对称加密算法对比

Posted 2021-04-25 码农吴先生

对称加密算法

• 1、DES（Data Encryption Standard）：对称算法，数据加密标准，速度较快，适用于加密大量数据的场合；

• 2、3DES（Triple DES）：是基于DES的对称算法，对一块数据用三个不同的密钥进行三次加密，强度更高；

• 3、RC4：对称算法，用变长密钥对大量数据进行加密，比 DES 快；

• 4、AES（Advanced Encryption Standard）：高级加密标准，对称算法，是下一代的加密算法标准，速度快，安全级别高，在21世纪AES 标准的一个实现是 Rijndael 算法；

非对称加密算法

• 5、IDEA（International Data Encryption Algorithm）国际数据加密算法，使用 128 位密钥提供非常强的安全性；

• 6、RSA：由 RSA 公司发明，是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的，非对称算法；

• 7、DSA（Digital Signature Algorithm）：数字签名算法，是一种标准的 DSS（数字签名标准），严格来说不算加密算法；

• 8、ECC（Elliptic Curves Cryptography）：椭圆曲线密码编码学，属于公开密钥算法。

• 9、MD5：严格来说不算加密算法，只能说是摘要算法，不可逆

• 10、SHA-N：是一种密码散列函数，现使用SHA-2，标准包括了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256

对称加密算法

名称	密钥长度	运算速度	安全性	资源消耗
DES	56位	较快	低	中
3DES	112位或168	慢	低	高
AES	128位,192位,256位	快	高	低

非对称加密算法

加密密钥和解密密钥不同

名称	运算速度	安全性	资源消耗
RSA	慢	高	高
DSA	慢	高	数字签名
ECC	快	高	低

散列加密算法

SHA-N，MD5

JAVA-对称加密算法

 public static String jdkDES(String str) {
        try {
            // 生成 KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
            System.out.println(keyGenerator.getProvider());
            keyGenerator.init(new SecureRandom());
            Key secretKey = keyGenerator.generateKey();
            byte[] keyBytes = secretKey.getEncoded();

            // KEY 转换
            DESKeySpec desKeySpec = new DESKeySpec(keyBytes);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
            Key convertSecretKey = factory.generateSecret(desKeySpec);

            // 加密
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
            byte[] result = cipher.doFinal(str.getBytes());
            System.out.println("DES加密后：" + Hex.encodeHexString(result));

            // 解密
            cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
            System.out.println("DES解密后: " + new String(cipher.doFinal(result)));

            return Hex.encodeHexString(result);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    
    public static String jdk3DES(String str) {
        try {
            // 生成 KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
            System.out.println(keyGenerator.getProvider());
            keyGenerator.init(new SecureRandom());
            Key secretKey = keyGenerator.generateKey();
            byte[] keyBytes = secretKey.getEncoded();

            // KEY 转换
            DESedeKeySpec desKeySpec = new DESedeKeySpec(keyBytes);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
            Key convertSecretKey = factory.generateSecret(desKeySpec);

            // 加密
            Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
            byte[] result = cipher.doFinal(str.getBytes());

            // 解密
            cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
            System.out.println("JDK 3DES Decrypt: " + new String(cipher.doFinal(result)));

            return Hex.encodeHexString(result);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    public static String rC4(String aInput,String aKey){
        int[] iS = new int[256];
        byte[] iK = new byte[256];

        for (int i=0;i<256;i++){
            iS[i]=i;
        }

        int j = 1;

        for (short i= 0;i<256;i++){
            iK[i]=(byte)aKey.charAt((i % aKey.length()));
        }

        j=0;

        for (int i=0;i<255;i++){
            j=(j+iS[i]+iK[i]) % 256;
            int temp = iS[i];
            iS[i]=iS[j];
            iS[j]=temp;
        }


        int i=0;
        j=0;
        char[] iInputChar = aInput.toCharArray();
        char[] iOutputChar = new char[iInputChar.length];
        for(short x = 0;x<iInputChar.length;x++)
        {
            i = (i+1) % 256;
            j = (j+iS[i]) % 256;
            int temp = iS[i];
            iS[i]=iS[j];
            iS[j]=temp;
            int t = (iS[i]+(iS[j] % 256)) % 256;
            int iY = iS[t];
            char iCY = (char)iY;
            iOutputChar[x] =(char)( iInputChar[x] ^ iCY) ;
        }
        return new String(iOutputChar);

    }
    
    public static void jdkAES(String str) {
        try {
            //1.生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(new SecureRandom());
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] byteKey = secretKey.getEncoded();

            //2.转换KEY
            Key key = new SecretKeySpec(byteKey,"AES");

            //3.加密
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] result = cipher.doFinal(str.getBytes());
            System.out.println("AES加密后：" + Hex.encodeHexString(result));

            //4.解密
            cipher.init(Cipher.DECRYPT_MODE, key);
            result = cipher.doFinal(result);
            System.out.println("AES解密后：" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }