+非対称暗号化対称暗号化、データのセキュリティ伝送

一般的な金融商品、それはフロントとリアの相互作用が来る、私たちは厳格なデータセキュリティを持っています。改ざんを防止するハッカーの攻撃、情報。

対称および非対称の2つの種類に分けられ、一般的に多くの暗号化は、あります。これら2つの暗号化方式で見てみましょうは何ですか？その違いは何ですか？

対称暗号化：

対称暗号化、すなわち対称暗号符号化技術は、彼は同じ暗号化および復号化キーを使用して、特徴としています。

DES、3DES、Blowfishの、IDEA、RC4、RC5、RC6とAESアルゴリズム共通の対称暗号化。対称暗号化アルゴリズムは、簡単かつ迅速に使用するには、キー短く、解読することは困難です。

しかし、対称秘密鍵使用時に以下のような問題点：

1、対称暗号化アルゴリズムは、通常、認証情報の整合性を提供していません。これは、送信者と受信者の身元を確認することはできません。

図2は、対称キー管理及び配布作業は、潜在的に危険で面倒なプロセスです。秘密鍵の漏洩を防止する方法が困難であることです。

非対称暗号化：

非対称暗号、二つの鍵、公開鍵と秘密鍵。公開鍵と秘密鍵のペア。

のみ対応する秘密鍵を使って暗号化データへの公開鍵は、復号化することができる場合は、秘密鍵はデータを暗号化するために使用される場合は、できるだけで対応する公開鍵で復号。暗号化と復号化は、2つの異なるキーを使用しているので、ので、このアルゴリズムは、非対称暗号化アルゴリズムと呼ばれています。

機密情報の鍵Bを用いて、公開鍵を取得するステップと、一方の当事者が鍵のペアを生成し、他の当事者が公開鍵として開示されている前記非対称暗号化アルゴリズムの機密情報を交換するの基本的なプロセス暗号化され、その後、所有者に送信され、その後、自分自身の相手が暗号化された情報を解読するための秘密鍵を保存します。パーティAは、公開鍵暗号化によって情報を復号化するためにその秘密鍵を使用することができます。

非対称暗号化の典型的なアプリケーションは、デジタル署名です。

一般的な非対称暗号化アルゴリズム：RSA、ECC（モバイル機器）、ディフィー・ヘルマン、エルガマル、DSA（デジタル署名）。

+非対称対称の組み合わせ：

今、私たちは、対称および非対称暗号化のいくつかを理解しています。対称+非対称：次に、私がプロジェクトで使用される方法の暗号化についてのあなたを教えてあげましょう。

フロー・チャートを見て：

差出人を見てください：

ここでは、主に2段階の操作です。

1、报文原文使用对称加密技术。对称加密的秘钥（避免混淆，这里称对称密码）。根据随机数生成。每次发起请求时，会重新产生一个随机数，进一步降低被破解的风险。

2、对称密码通过非对称加密方式进行加密。公钥由后台产生，匹配的私钥由后台保管。这样产生一个加密后的对称密码。前端在发送给后端之后，后端需要用匹配的私钥才能解开。

再看接收方：

接收方在接收到数据包之后，同样有两步操作：

1、会使用匹配的私钥解密加密的对称密码，获取到真实的对称密码。

2、使用对称密码，解密加密报文，获取原报文内容。

这样做的好处是：

1、因为我们的对称密码是使用非对称加密的，因此，想要破解，需要找到相应的公钥才行。

2、每次请求会重新生成一个对称密码，这就加大了破解的难度。

代码实现：

工具类：

非对称加密：

public class RSA1 {
    /**
     * 随机生成公钥和私钥
     */
 
    public static final String publicKeyString  = "publicKeyString";
    public static final String privateKeyString = "privateKeyString";
 
 
    public static HashMap<String, String> getRandomKey() throws NoSuchAlgorithmException, InvalidKeySpecException {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        keyPairGen.initialize(1024);//生成大小 1024
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();//获取公钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();//获取私钥
        HashMap<String, String> keyMap = new HashMap<String, String>();
        keyMap.put(publicKeyString, new String(Base64.encode(publicKey.getEncoded(), Base64.DEFAULT)));//获取公钥Base64编码
        keyMap.put(privateKeyString, new String(Base64.encode(privateKey.getEncoded(), Base64.DEFAULT)));//获取密钥Base64编码
        return keyMap;
    }
 
    /**
     * 通过字符串生成私钥
     */
    public static PrivateKey getPrivateKey(String privateKeyData) {
        PrivateKey privateKey = null;
        try {
            byte[] decodeKey = Base64.decode(privateKeyData, Base64.DEFAULT); //将字符串Base64解码
            PKCS8EncodedKeySpec x509 = new PKCS8EncodedKeySpec(decodeKey);//创建x509证书封装类
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");//指定RSA
            privateKey = keyFactory.generatePrivate(x509);//生成私钥
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return privateKey;
    }
 
 
    /**
     * 通过字符串生成公钥
     */
    public static PublicKey getPublicKey(String publicKeyData) {
        PublicKey publicKey = null;
        try {
            byte[] decodeKey = Base64.decode(publicKeyData, Base64.DEFAULT);
            X509EncodedKeySpec x509 = new X509EncodedKeySpec(decodeKey);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            publicKey = keyFactory.generatePublic(x509);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return publicKey;
    }
 
    /**
     * 加密
     */
    public static byte[] encrypt(String data, Key key) {
        try {
            //取公钥
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm(),"BC");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            return cipher.doFinal(data.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    /**
     * 解密
     */
    public static byte[] decrypt(byte[] data, Key key) {
        try {
            Cipher cipher = Cipher.getInstance("RSA","BC");
            cipher.init(Cipher.DECRYPT_MODE, key);
            return cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

对称加密:

public class AES_2 {
 
    public static byte[] genPrivateKey(String password) throws NoSuchAlgorithmException {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        byte[] bytes = tohash256Deal(password);
        SecureRandom securerandom = new SecureRandom(bytes);
        kgen.init(128, securerandom);
        SecretKey secretKey = kgen.generateKey();
        byte[] enCodeFormat = secretKey.getEncoded();
        SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
        return key.getEncoded();
    }
 
    public static byte[] encrypt(String content, SecretKeySpec key) {
        try {
            //创建一个实现指定转换的 Cipher对象，该转换由指定的提供程序提供。
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] byteContent = content.getBytes("utf-8");
            byte[] cryptograph = cipher.doFinal(byteContent);
            return Base64.encode(cryptograph, Base64.DEFAULT);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public static String decrypt(byte[] cryptograph, SecretKeySpec key) {
        try {
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] content = cipher.doFinal(Base64.decode(cryptograph, Base64.DEFAULT));
            return new String(content);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public static byte[] encrypt(String content, String password) {
        try {
            //"AES"：请求的密钥算法的标准名称
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            //256：密钥生成参数；securerandom：密钥生成器的随机源
            SecureRandom securerandom = new SecureRandom(tohash256Deal(password));
            kgen.init(128, securerandom);
            //生成秘密（对称）密钥
            SecretKey secretKey = kgen.generateKey();
            //返回基本编码格式的密钥
            byte[] enCodeFormat = secretKey.getEncoded();
            //根据给定的字节数组构造一个密钥。enCodeFormat：密钥内容；"AES"：与给定的密钥内容相关联的密钥算法的名称
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
            //将提供程序添加到下一个可用位置
            Security.addProvider(new BouncyCastleProvider());
            //创建一个实现指定转换的 Cipher对象，该转换由指定的提供程序提供。
            //"AES/ECB/PKCS7Padding"：转换的名称；"BC"：提供程序的名称
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] byteContent = content.getBytes("utf-8");
            byte[] cryptograph = cipher.doFinal(byteContent);
            return Base64.encode(cryptograph, Base64.DEFAULT);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public static String decrypt(byte[] cryptograph, String password) {
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            SecureRandom securerandom = new SecureRandom(tohash256Deal(password));
            kgen.init(128, securerandom);
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
            Security.addProvider(new BouncyCastleProvider());
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] content = cipher.doFinal(Base64.decode(cryptograph, Base64.DEFAULT));
            return new String(content);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public static String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }
 
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }
 
    public static byte[] tohash256Deal(String datastr) {
        try {
            MessageDigest digester = MessageDigest.getInstance("SHA-256");
            digester.update(datastr.getBytes());
            byte[] hex = digester.digest();
            return hex;
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
 
}

发送方和接收方的实现：

String content = "000";
JSONObject jsonObject = new JSONObject();
try {
    LogT.i("++++++++++++++++++++++发送方+++++++++++++++++++++++++=");
    //产生私钥
    int random = (int) ((Math.random() * 9 + 1) * 100000);
    //私钥字节
    byte[] bytes = AES_2.genPrivateKey(String.valueOf(random));
    //传输报文加密
    SecretKeySpec key1 = new SecretKeySpec(bytes, "AES");
    byte[] content_encrypt = AES_2.encrypt(content, key1);
    //公钥对私钥加密
    PublicKey publicKey = RSA1.getPublicKey(public_key);
    sKey_encrypt = RSA1.encrypt(Base64.encodeToString(bytes, Base64.DEFAULT), publicKey);
    //数据组装
    jsonObject.put("key", Base64.encodeToString(sKey_encrypt, Base64.DEFAULT));
    jsonObject.put("content", AES_2.parseByte2HexStr(content_encrypt));

    LogT.i("+++++++++++++++++++++++接收方++++++++++++++++++++++++=");

    //解析获取私钥
    PrivateKey privateKey = RSA1.getPrivateKey(private_key);
    //解析接收到的key数据
    byte[] decode = Base64.decode(Base64.encodeToString(sKey_encrypt, Base64.DEFAULT), Base64.DEFAULT);
    //私钥解密
    byte[] decrypt = RSA1.decrypt(decode, privateKey);
    //解码私钥字节
    byte[] decode_orig = Base64.decode(new String(decrypt), Base64.DEFAULT);
    //加密的报文
    byte[] HexStrByte = AES_2.parseHexStr2Byte(AES_2.parseByte2HexStr(content_encrypt));
    SecretKeySpec key2 = new SecretKeySpec(decode_orig, "AES");
    //解密后的报文
    String decrypt1 = AES_2.decrypt(HexStrByte, key2);
    LogT.i(decrypt1);//000
} catch (Exception e) {
        e.printStackTrace();
}

参考:

原文：https://blog.csdn.net/Aminy123/article/details/81871092