对称加密

于 2016-07-06 15:48:39 发布
阅读量295 收藏
点赞数
分类专栏： 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/share_free/article/details/51839705
版权 
package 对称加密;

import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class AES {

    private static String src="imooc";
    public static void main(String[] args) {
        jdkAES();
    }
    public static void jdkAES(){
        //生成密钥
        try {

            KeyGenerator keyGenerator =KeyGenerator.getInstance("AES");
            keyGenerator.init(new SecureRandom());
            SecretKey secretKey=keyGenerator.generateKey();
            System.out.println("编码格式"+secretKey.getFormat());
            byte[] keyBytes=secretKey.getEncoded();


            //key转换
            Key key=new SecretKeySpec(keyBytes,"AES");



            //加密
            /**
             * 初始化cipher
             * 调用cipher的doFinal()方法生成字符数组形式的密文
             */
            Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] result=cipher.doFinal(src.getBytes());
            //result 变十六进制
            System.out.println(byteHexStr(result));

            //解密
            //密钥++密文
            cipher.init(Cipher.DECRYPT_MODE, key);
            result=cipher.doFinal(result);
            //result变成字符串
            System.out.println("jdkAES:  "+new String(result));




        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }






    }

     public static String byteHexStr(byte[] b) {
            String stmp = "";
            StringBuilder sb = new StringBuilder("");
            for (int n = 0; n < b.length; n++) {
              stmp = Integer.toHexString(b[n] & 0xFF);
              sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
            }
            return sb.toString().toUpperCase().trim();
          }



}

package 对称加密;

import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Provider;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

/**
 * 
 * 明文 密钥+算法 密文 密钥是如何来的？？？
 * 
 * 
 * @author idea
 * 
 */

public class DES {
    private static String src = "imooc";

    // 明文
    public static void main(String[] args) {
        try {
            jdkDES();
        } catch (InvalidKeyException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (BadPaddingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void bcDES() throws InvalidKeyException,
            NoSuchAlgorithmException, InvalidKeySpecException,
            NoSuchPaddingException, IllegalBlockSizeException,
            BadPaddingException, NoSuchProviderException {

        //添加实现方
        //Security.addProvider(new Provider());


        // 生成密钥
        // 初始化(对称)密钥生成器
        KeyGenerator keyGenerator = KeyGenerator.getInstance("DES","BC");//这一点与jdk不同
        keyGenerator.init(56);
        // ===生成密钥并编码，使用字节数组接受
        SecretKey secretKey = keyGenerator.generateKey();
        byte[] byteKey = secretKey.getEncoded();

        // 密钥转换
        DESKeySpec desKeySpec = new DESKeySpec(byteKey);
        SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
        Key convertSecretKey = factory.generateSecret(desKeySpec);

        // 加密
        // result是密文
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
        byte[] result = cipher.doFinal(src.getBytes());
        System.out.println(byteHexStr(result));

        // 解密
        // 把cipher初始化解密码 
        // converSecretKey是密钥
        // 形参result是密文，返回结果是byte[]

        cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
        result = cipher.doFinal(result);
        System.out.println(new String(result));

    }

    public static void jdkDES() throws InvalidKeyException,
    NoSuchAlgorithmException, InvalidKeySpecException,
    NoSuchPaddingException, IllegalBlockSizeException,
    BadPaddingException {

// 生成密钥
// 初始化(对称)密钥生成器
KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
keyGenerator.init(56);
// ===生成密钥并编码，使用字节数组接受
SecretKey secretKey = keyGenerator.generateKey();
byte[] byteKey = secretKey.getEncoded();

// 密钥转换
DESKeySpec desKeySpec = new DESKeySpec(byteKey);
SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
Key convertSecretKey = factory.generateSecret(desKeySpec);

// 加密
// result是密文
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println(byteHexStr(result));

// 解密
// 把cipher初始化解密码 
// converSecretKey是密钥
// 形参result是密文，返回结果是byte[]

cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
result = cipher.doFinal(result);
System.out.println(new String(result));

}




    /**
     * 
     * 字节数组按照16进制转为字符串
     * @param b
     * @return
     */
     public static String byteHexStr(byte[] b) {
            String stmp = "";
            StringBuilder sb = new StringBuilder("");
            for (int n = 0; n < b.length; n++) {
              stmp = Integer.toHexString(b[n] & 0xFF);
              sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
            }
            return sb.toString().toUpperCase().trim();
          }



}

package 对称加密;

import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;

public class PBE {
    private static String src = "imooc";

    public static void main(String[] args) {
        jdkPBE();
    }

    private static void jdkPBE() {
        // 初始化盐
        SecureRandom random = new SecureRandom();
        byte[] salt = random.generateSeed(8);
        // 口令和密钥
        String password = "imooc";
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());
        SecretKeyFactory factory;
        try {
            factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
            // 工厂生产密钥需要告诉规范，就是pbeKeySpec
            Key key = factory.generateSecret(pbeKeySpec);
            // 加密
            PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt, 100);// 100???
            Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
            cipher.init(Cipher.ENCRYPT_MODE, key, pbeParameterSpec);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println(byteHexStr(result));
            // 解密
            cipher.init(Cipher.DECRYPT_MODE, key, pbeParameterSpec);
            result = cipher.doFinal(result);
            System.out.println(new String(result));

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public static String byteHexStr(byte[] b) {
        String stmp = "";
        StringBuilder sb = new StringBuilder("");
        for (int n = 0; n < b.length; n++) {
            stmp = Integer.toHexString(b[n] & 0xFF);
            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
        }
        return sb.toString().toUpperCase().trim();
    }

}

package 对称加密;

import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec;

public class ThreeDES {
    private static String src = "imooc";
    public static void main(String[] args) {
        try {
            jdk3DES();
        } catch (InvalidKeyException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (BadPaddingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void jdk3DES() throws InvalidKeyException,
    NoSuchAlgorithmException, InvalidKeySpecException,
    NoSuchPaddingException, IllegalBlockSizeException,
    BadPaddingException {

// 生成密钥
// 初始化(对称)密钥生成器
KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
keyGenerator.init(168);
// ===生成密钥并编码，使用字节数组接受

SecretKey secretKey = keyGenerator.generateKey();
byte[] byteKey = secretKey.getEncoded();

// 密钥转换
DESedeKeySpec desKeySpec = new DESedeKeySpec(byteKey);
SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
Key convertSecretKey = factory.generateSecret(desKeySpec);

// 加密
// result是密文
Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println(byteHexStr(result));

// 解密
// 把cipher初始化解密码 
// converSecretKey是密钥
// 形参result是密文，返回结果是byte[]

cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
result = cipher.doFinal(result);
System.out.println(new String(result));

}




    /**
     * 
     * 字节数组按照16进制转为字符串
     * @param b
     * @return
     */
     public static String byteHexStr(byte[] b) {
            String stmp = "";
            StringBuilder sb = new StringBuilder("");
            for (int n = 0; n < b.length; n++) {
              stmp = Integer.toHexString(b[n] & 0xFF);
              sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
            }
            return sb.toString().toUpperCase().trim();
          }


}
share_free
关注
专栏目录
非对称加密JAVA实现
08-06
非对称加密JAVA实现，实现对超长内容进行加密
RSA非对称加密算法
02-14
RSA 非对称加密算法 RSA 非对称加密算法是一种经典的非对称加密算法，由罗纳德·李维斯特、阿迪·萨莫尔和伦纳德·阿德曼三人于 1977 年共同提出的。该算法的主要思想是基于大素数的乘积和因式分解之间的关系，通过...
密码学实验_对称加密算法DES_非对称加密算法RSA.pdf
02-20
本实验报告主要涉及两种加密算法：对称加密算法DES（Data Encryption Standard）和非对称加密算法RSA。实验旨在帮助学生深入理解这两种算法的基本原理，并通过Python编程实现加密和解密过程。 ### **对称加密算法...
AES对称加密算法-C语言
11-22
C语言实现AES-128对称加解密算法。编译环境：VS2010。请参考我的博客https://blog.csdn.net/u013073067/article/details/86529111 分析代码
自定义对称加密解密算法
03-17
在信息安全领域，对称加密是一种常见的数据保护方法。它的核心思想是使用相同的密钥进行数据的加密和解密。自定义对称加密解密算法，正如标题所提及，是指设计和实现一种特定的加密机制，以提高加密速度并增强安全性...
常见加密算法方式(对称加密和非对称加密)
03-26
在实际操作中，经常采用混合加密模式：利用非对称加密算法交换对称加密算法的密钥，再利用对称加密算法加密实际数据，从而结合两种加密算法的优点。 总之，加密算法是信息安全领域的基石，合理选择和使用加密算法...
C#对称加密与非对称加密实例
09-04
在C#编程中，加密是保护数据安全的重要手段，分为对称加密和非对称加密两种类型。这两种加密方法在应用场景和安全性上有所不同。 一、对称加密（Symmetric Cryptography） 对称加密是最常见的加密方式，其特点是...
Android对称加密与非对称加密
09-01
在Android开发中，数据安全是至关重要的，对称加密和非对称加密是两种常见的加密技术，用于保护敏感信息不被未经授权的用户访问。本文将详细介绍这两种加密方式，并以凯撒密码为例，演示对称加密的基本原理和实现。 ...
ThinkPHP实现的rsa非对称加密类示例
10-18
ThinkPHP框架实现RSA非对称加密涉及到密钥的生成、公钥和私钥的存储、加密和解密操作。RSA加密是非对称加密的一种，它使用一对密钥——公钥和私钥。公钥可以公开给所有人使用，用于加密数据；私钥必须保密，用于解密...
浅析Node.js非对称加密方法
12-23
在Node.js中，非对称加密是一种用于保护数据安全的重要技术。它涉及到两个密钥：公钥和私钥。公钥可以公开分享，用于加密数据，而私钥必须保密，用于解密数据。这种机制使得只有拥有私钥的接收者才能读取由公钥加密...
C# 对称加密算法加密字段
03-30
在IT行业中，尤其是在网络安全和数据保护领域，对称加密算法是一种常见的数据加密技术。C#作为.NET框架的主要编程语言，提供了丰富的加密库来支持开发者实现安全的数据加解密。本篇将详细介绍C#中对称加密算法的应用...
php中简单的对称加密算法实现
12-19
在网上找到了一个不错的PHP方面的对称加密算法；在PHP的语法环境里，有urlencode与urldecode,base64_encode和base64_decode自带的对称算法，不过这些自带的算法不能称之为加密算法，只能说是编码方式而已。可是我们...
.NET中的DES对称加密详解
10-26
DES是一种对称加密(Data Encryption Standard)算法,于1977年得到美国政府的正式许可，是一种用56位密钥来加密64位数据的方法。一般密码长度为8个字节，其中56位加密密钥，每个第8位都用作奇偶校验
C# 非对称加密 私钥加密 公钥解密实现
11-18
C# RSA非对称加密 实现私钥加密 公钥解密；可以用于生成授权码。 RSA生成一下随机值，然后都是用BigInteger类字符串跟字节数组互转
C#实现简单的RSA非对称加密算法示例
08-29
C#实现简单的RSA非对称加密算法示例 本文主要介绍了C#实现简单的RSA非对称加密算法，结合实例形式分析了C#实现RSA加密的具体步骤与相关操作技巧。 RSA非对称加密算法是公钥密码体制中的一种，使用了一对密钥，一个...
非对称加密
12-20
### 非对称加密概述 #### 一、非对称加密的概念 非对称加密是一种基于两个不同但数学上相关的密钥来进行加密和解密的技术。这两个密钥分别是公开密钥(public key)和私有密钥(private key)。与传统的对称加密不同，...
chazhi.zip_对称加密
09-24
在IT领域，对称加密是一种常见的数据保护技术，它基于同一密钥进行数据加密和解密，因此称为“对称加密”。本主题聚焦于“chazhi.zip”压缩包中的内容，该包包含了一个关于经典对称加密算法——DES（Data Encryption...
更新上市公司企业机构投资者实地调研数据（2013-2023年）.txt
最新发布
10-11
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。样例数据及详细介绍参见文章：https://blog.csdn.net/samLi0620/article/details/142865262
一次性叉子压成型机_三维3D设计图纸.zip
10-11
一次性叉子压成型机_三维3D设计图纸.zip
Android加密技术：对称加密与非对称加密解析
"本文主要介绍了Android平台上的对称加密与非对称加密技术，包括对称加密中的凯撒密码作为示例进行详细讲解，并提供了简单的Java代码实现。" 在Android应用开发中，数据的安全性至关重要，加密技术是保护数据安全的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值