非对称加密算法的使用

🕗 发布于 2024-10-07 22:06 python 开发语言

1. JAVA中的使用

1.1.原生使用

package asymmetric_encryption;  
  
import java.security.*;  
import java.util.Base64;  
import javax.crypto.Cipher;  
import javax.crypto.NoSuchPaddingException;  
  
public class RSAExample {  
    public static void RSADemo() throws Exception {  
        // Generate a key pair  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");  
        keyPairGen.initialize(2048, new SecureRandom());  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
  
        PublicKey publicKey = keyPair.getPublic();  
        PrivateKey privateKey = keyPair.getPrivate();  
        // 输出公钥和私钥  
        System.out.println("publicKey: " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));  
        System.out.println("privateKey: " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));  
  
  
        // Encrypt the message  
        String message = "Hello, World!";  
        Cipher cipher = Cipher.getInstance("RSA");  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
        byte[] encryptedMessage = cipher.doFinal(message.getBytes());  
  
        System.out.println("Encrypted Message: " + bytesToHex(encryptedMessage));  
  
        // Decrypt the message  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);  
        byte[] decryptedMessage = cipher.doFinal(encryptedMessage);  
  
        System.out.println("Decrypted Message: " + new String(decryptedMessage));  
    }  
  
    private static String bytesToHex(byte[] bytes) {  
        StringBuilder sb = new StringBuilder();  
        for (byte b : bytes) {  
            sb.append(String.format("%02x", b));  
        }  
        return sb.toString();  
    }  
}

package asymmetric_encryption;  
import org.bouncycastle.jce.provider.BouncyCastleProvider;  
import org.bouncycastle.jce.spec.ECParameterSpec;  
import org.bouncycastle.jce.spec.ECPrivateKeySpec;  
import org.bouncycastle.jce.spec.ECPublicKeySpec;  
import org.bouncycastle.math.ec.ECPoint;  
  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.Security;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.Signature;  
import java.util.Base64;  
  
public class ECCExample {  
    public static void ECCDemo() throws Exception {  
        Security.addProvider(new BouncyCastleProvider());  
  
        // 生成 ECC 密钥对  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("ECDSA");  
        keyPairGen.initialize(256);  // 使用 256 位的曲线  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
  
        PrivateKey privateKey = keyPair.getPrivate();  
        PublicKey publicKey = keyPair.getPublic();  
  
        System.out.println("ECC 公钥: " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));  
        System.out.println("ECC 私钥: " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));  
  
        // 签名  
        Signature signature = Signature.getInstance("SHA256withECDSA");  
        signature.initSign(privateKey);  
        String message = "Hello, World!";  
        signature.update(message.getBytes());  
        byte[] signatureBytes = signature.sign();  
  
        System.out.println("签名: " + Base64.getEncoder().encodeToString(signatureBytes));  
    }  
}

package asymmetric_encryption;  
  
import javax.crypto.KeyAgreement;  
import javax.crypto.KeyGenerator;  
import javax.crypto.spec.DHParameterSpec;  
import javax.crypto.spec.DHPublicKeySpec;  
import java.math.BigInteger;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.SecureRandom;  
  
public class DiffieHellmanExample {  
    public static void DiffieHellmanDemo() throws Exception {  
        // 生成 Diffie-Hellman 密钥对  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DH");  
        keyPairGen.initialize(2048);  
        KeyPair keyPairA = keyPairGen.generateKeyPair();  
        KeyPair keyPairB = keyPairGen.generateKeyPair();  
  
        // 获取公钥和私钥  
        PublicKey publicKeyA = keyPairA.getPublic();  
        PrivateKey privateKeyA = keyPairA.getPrivate();  
        PublicKey publicKeyB = keyPairB.getPublic();  
        PrivateKey privateKeyB = keyPairB.getPrivate();  
  
        // 进行密钥交换  
        KeyAgreement keyAgreementA = KeyAgreement.getInstance("DH");  
        keyAgreementA.init(privateKeyA);  
        keyAgreementA.doPhase(publicKeyB, true);  
        byte[] secretA = keyAgreementA.generateSecret();  
  
        KeyAgreement keyAgreementB = KeyAgreement.getInstance("DH");  
        keyAgreementB.init(privateKeyB);  
        keyAgreementB.doPhase(publicKeyA, true);  
        byte[] secretB = keyAgreementB.generateSecret();  
  
        System.out.println("A 生成的共享密钥: " + bytesToHex(secretA));  
        System.out.println("B 生成的共享密钥: " + bytesToHex(secretB));  
    }  
  
    private static String bytesToHex(byte[] bytes) {  
        StringBuilder sb = new StringBuilder();  
        for (byte b : bytes) {  
            sb.append(String.format("%02x", b));  
        }  
        return sb.toString();  
    }  
}

publicKey: MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr61PJJoDjoPp6naH64hTuEqa3hgY+7tcdadPye1GbhQpSAyyeKzkLDxrUreuR8DImjutY+d9rNDLdFJVN074hoAJMzYKUR2zTBrwcdmY0uij3IHe3XzV7tQdVZTHWjCLWYXqouYKkIIm8Dw52XbCSPbPNMuL1/7W1weitTLCZX239caI1blOYagklTPGAj40Gb5aWUdxuwCRwzqgAwR7LM+Oee7GwEs7vSb0cEc9b3uRZjKm7sIfIbBAbSeEer0ALAC5EJ1nCH5MBxQNeiCAIiMsnO6yADEV+AUQcY5lrYs2DvLZCWnnpSnl9biASLGgCQiOWDeQe84JDDVBY5YrbwIDAQAB
privateKey: MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCvrU8kmgOOg+nqdofriFO4SpreGBj7u1x1p0/J7UZuFClIDLJ4rOQsPGtSt65HwMiaO61j532s0Mt0UlU3TviGgAkzNgpRHbNMGvBx2ZjS6KPcgd7dfNXu1B1VlMdaMItZheqi5gqQgibwPDnZdsJI9s80y4vX/tbXB6K1MsJlfbf1xojVuU5hqCSVM8YCPjQZvlpZR3G7AJHDOqADBHssz4557sbASzu9JvRwRz1ve5FmMqbuwh8hsEBtJ4R6vQAsALkQnWcIfkwHFA16IIAiIyyc7rIAMRX4BRBxjmWtizYO8tkJaeelKeX1uIBIsaAJCI5YN5B7zgkMNUFjlitvAgMBAAECggEAE/yDpIZhITWgxyv1CrbXz3+tXtcfAISwYDJIwZBdEuj4SVooc9I3o1C8ZQzApyknqWRgtZ0Aj0ix3OoBB+nUHHk0kr7zLYdTfrUR5eH7oQMWoV+lG024iRNYwwPKKlibgfPaXe4OBaLJC0vOyQ7Zy7NIn5kIr+ouRwh3WmYL97/FXhm7+MhfJS42279/kxeQNc74CHVO0WVYD67+xojzZFfM5Nq8VWG42m/FuBFXTO1nmMvuHzdtFw2158b4Emqry55LrV960PD9YILLNmFf9/c5bTi1u7h79DC47KTfY59hLxKWIZnE1AkFXKSfXNlF2NH0XaKZfLNyyJDxnzHwAQKBgQDnYTzFLx3QxjzliLX4R9leNdIeXt8Xze3chpgA44fOFsxSm2vkQVWEzUvYyWMjdLIbGNywANvC2ocQJ25GWYPS1CP4z5rVF/BgMOvVbsQWry2ZLIYWyc8wDgxiD7IwYWhNBG+Uuw8HFl7sF4kop/KgaP6pG52C+fTgvXedawfgQQKBgQDCXrto661Y4mBlKWOYWgLvzODFnI8bEbyvBXUT8iytum9qIUVQ6ZoIX6De9Bubr+m4Aw02RZs5uIG9RLtx/xGvUx74/IG9Uwh8RAXBnigBTM6GGhYZ9is/krzmgcxpvnHaQveNOghAxUDD1iawkrc3CcvqMezC0ZwyVTSAQgwfrwKBgEL/rBoo74hBruaENLUFERMvoH082XrKHYNK0f8H444wmc+dw5sftAS1ca3/ep6Mrvobs+OfDAObRZrO4Casyvgkh5oHe30S5n7kC5YM8ejjpt+Avf8hRsZSexF2HBHYUtxiWXEGzW4u8yOIGSZVo3MBlCQho/WGLXtaQaWqlWhBAoGAR5p8cd94gakLl9jSftqSAGM6XrIZKgCzwMpC4jEx8mIfDzrofTFBdFo+OkQ1M3pvoEFHibnEwFPPP7llUE6F5k+5tkHXTbacBqNMd5Ja7HeuEUrk33WHYykce9JPSplE+gH3jkhVp/7CqCJpKF00L4tlWoY/0VlEsGohKCqsqrMCgYAnLCTZwbhGJyk881x7eQqOSwPgzdMe0CYYIFGzBGKfzaR2viOpTcT7EH+/Jx+jALtlFVlWzC7in290XYydluZkhfEm5VVdn8pdmXg88iiR5lqkDOcW9pPnEEnxFcbpCNUgJDTgmNzc5euahulFoTRdlnchKs0WEMST2oKPak0VZA==
Encrypted Message: 12ff35876ec5f6f3668ecbed834b7b253618efadbc0b4aa379fc51085e16bbd28e34bf432646dc0d7e4f4087009d52c9bdec56133a99f6714d6c6874ffb08695123985695a923d76993636b971effaaa14f854cda273861476ca740f71afc74946c6c8f4462cf0c3eb9c690351942d776d0ac6061368100a9080c7ca929a781f8498a40ae24e6156142635be1ec5dd97472ca9dac1c7b68c2c87b8fe1cdebe14c10a5059fac8c5df838ba4164a775d80f41acea363c5fd313780163462621db449f1e393823f7a180e76b53cca6e9b6e292e6aa17e1607ac7a835de845b95c1efb7811cb9842d75dfbe5b377cad65971c210735ae7c10cee1b5d196c657e5c71
Decrypted Message: Hello, World!
ECC 公钥: MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEKHo2k1n8tAjfc0SoaY0DxYdCi6/37xFkJi5r1Bnv/OYK6jJP5DOcYgnwk3rwQ50OS+SFr+FnlXfPO5R5LaA0Q==
ECC 私钥: MIGTAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBHkwdwIBAQQgWwYN6xMEIk6thUld36jFO4ajuNYPV9QI1lWrEX47lgqgCgYIKoZIzj0DAQehRANCAAQQoejaTWfy0CN9zRKhpjQPFh0KLr/fvEWQmLmvUGe/85grqMk/kM5xiCfCTevBDnQ5L5IWv4WeVd887lHktoDR
签名: MEQCIFdO2y8Gcmi8CFa/D6VQ3TG/DhSx0hnkJ593MdEMEshTAiA0L+R83QpWgAW7NsFLrdXSvrpVhnVryfkeu8eAN9ebIA==
A 生成的共享密钥: 8e37c3fd8136e231328ea910d413dc91bb9537a3dd39582461deb88fe68df0ea75dd2b0673c79dc223e367f0d373fdd75413865db5970114e4dfbe57790ab607d0fcdcdf72aaeed3324433ff8c6be08b202c9f99031bbacb0c5cc0446cb86c24b82a6f9e6da35d682d75fae55123ca0594ef197be9229999332ad0115c79ac43314d6e32a2d42f33f8bd58c53c4821abf2498adbb72714c14f7ef7b3adccce1a4a3a8fc81b88e49a6a784dc3c2e28bfc4d51cedad728e32e1360004cbdfd5bc60b50526fa6bb5f7ebb860dc6a604d174f94a2b6e7ac8ea843c88151471a56d54fa517113bd710c07735fb15b3ec91f669bf4ea647fa09cc4e6b30f679a1aff3d
B 生成的共享密钥: 8e37c3fd8136e231328ea910d413dc91bb9537a3dd39582461deb88fe68df0ea75dd2b0673c79dc223e367f0d373fdd75413865db5970114e4dfbe57790ab607d0fcdcdf72aaeed3324433ff8c6be08b202c9f99031bbacb0c5cc0446cb86c24b82a6f9e6da35d682d75fae55123ca0594ef197be9229999332ad0115c79ac43314d6e32a2d42f33f8bd58c53c4821abf2498adbb72714c14f7ef7b3adccce1a4a3a8fc81b88e49a6a784dc3c2e28bfc4d51cedad728e32e1360004cbdfd5bc60b50526fa6bb5f7ebb860dc6a604d174f94a2b6e7ac8ea843c88151471a56d54fa517113bd710c07735fb15b3ec91f669bf4ea647fa09cc4e6b30f679a1aff3d

1.2.Hutool包使用

package asymmetric_encryption.hutool;  
  
import cn.hutool.crypto.asymmetric.KeyType;  
import cn.hutool.crypto.asymmetric.RSA;  
import cn.hutool.core.codec.Base64;  
  
public class RSAExample {  
  
    public static void RSADemo() {  
        // 创建 RSA 非对称加密对象，生成 2048 位密钥  
        RSA rsa = new RSA();  
  
        // 获取公钥和私钥  
        String publicKey = rsa.getPublicKeyBase64();  
        String privateKey = rsa.getPrivateKeyBase64();  
  
        System.out.println("RSA 公钥: " + publicKey);  
        System.out.println("RSA 私钥: " + privateKey);  
  
        // 要加密的消息  
        String message = "Hello, World!";  
  
        // 使用公钥加密  
        byte[] encryptedMessage = rsa.encrypt(message, KeyType.PublicKey);  
        System.out.println("加密后的消息: " + Base64.encode(encryptedMessage));  
  
        // 使用私钥解密  
        byte[] decryptedMessage = rsa.decrypt(encryptedMessage, KeyType.PrivateKey);  
        System.out.println("解密后的消息: " + new String(decryptedMessage));  
    }  
}

package asymmetric_encryption.hutool;  
  
import cn.hutool.crypto.asymmetric.ECIES;  
import cn.hutool.crypto.SecureUtil;  
import cn.hutool.crypto.asymmetric.KeyType;  
  
public class ECCExample {  
    public static void ECCDemo() {  
        // 创建 ECC 非对称加密对象  
        ECIES ecies = new ECIES();  
  
        // 生成密钥对  
        byte[] publicKey = ecies.getPublicKey().getEncoded();  
        byte[] privateKey = ecies.getPrivateKey().getEncoded();  
  
        System.out.println("ECC 公钥: " + cn.hutool.core.codec.Base64.encode(publicKey));  
        System.out.println("ECC 私钥: " + cn.hutool.core.codec.Base64.encode(privateKey));  
  
        // 要加密的消息  
        String message = "Hello, World!";  
  
        // 使用公钥加密  
        byte[] encryptedMessage = ecies.encrypt(message, KeyType.PublicKey);  
        System.out.println("加密后的消息: " + cn.hutool.core.codec.Base64.encode(encryptedMessage));  
  
        // 使用私钥解密  
        byte[] decryptedMessage = ecies.decrypt(encryptedMessage,KeyType.PrivateKey);  
        System.out.println("解密后的消息: " + new String(decryptedMessage));  
    }  
}

ECC 公钥: MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+NuRU/SRoc5kVMn1c+ZuG9VtX8AWzaD1KNPiKvTtiOQXqLZbEfKO1YsKqXUg4sqW6MnlOcBHqdedG53A6McObA==
ECC 私钥: MIGTAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBHkwdwIBAQQgRCjKPEiVHls4VU4pm4abcV2xQw9oT5Qmo/9gHOKkgZagCgYIKoZIzj0DAQehRANCAAT425FT9JGhzmRUyfVz5m4b1W1fwBbNoPUo0+Iq9O2I5BeotlsR8o7ViwqpdSDiypboyeU5wEep150bncDoxw5s
加密后的消息: BM3b94CHhQQdvsTXnll43ARpkT6Uf2K2wOunGBdtGsF9uetI08PeDA+l3Fqd7X1cTBC3M8K9R8aZPMI0O28/kGGXeBzI67n1pt4rPgrp44yzhFZYmSuqVEtwYExyekFiEPA=
解密后的消息: Hello, World!
RSA 公钥: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDWH4XMCsuIgb80/cHdp94kcmOuWo4O2v/Kdk3hT7AnmdBLQZavQAfwZgZFyDSBVpFJcTo2ec4XOp2WIfTbj0TywsAvgrFbpV/BlOrK/vZU6Rg8Qr7lKxLXzuNtZTqEjMl/zhBVxjoQESn/1PerBETRqJMzUOo9IN1nRQBwUGnJMwIDAQAB
RSA 私钥: MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBANYfhcwKy4iBvzT9wd2n3iRyY65ajg7a/8p2TeFPsCeZ0EtBlq9AB/BmBkXINIFWkUlxOjZ5zhc6nZYh9NuPRPLCwC+CsVulX8GU6sr+9lTpGDxCvuUrEtfO421lOoSMyX/OEFXGOhARKf/U96sERNGokzNQ6j0g3WdFAHBQackzAgMBAAECgYApWSH9snH2VNPHGF+I/aMkl6BPKXZ4QOsXPjwwz7IdG5NBDRPbmLpPvmvkqtIUzdI1g/NxVJkrHCsVNE5z3Zk7CzZxBJBHixqymaelEgOBnVYjsVAMsKwmastetoIPwyMr9JMMe5QAC1zgFC7LjiGEFADaVISpWyUPIdXLGE3G3QJBAPewuefWBnh6+YJJWbe5FSurqjen8nwn18jadcsNIxMsreX37DTdANFXTQgwryDqHz8pzpd9hBlmJbIe5GG/g28CQQDdToGryCoH1y8Ws6Ii/Q07n6qus6rJhYCi+I/VTy/e/5pve9LQO806ChMi5Fcwt1lD1sLuLjB4r4k0Wv0txSR9AkAwW32AKMXsob2y1RVCDE140DQUV6K84J59ZUFYGkF9zdxJqKSiEX/GXy/36GFYoLzm/QeLhgLTXqD/bI6UEurbAkB8CZBsM5g7JMRjuPLbIXHVRTxpBpJmuMjMjvwu1l9CYYixi3kw9ROlwBfRqqGj0F/bwfcngAPy4I/KJGVazfARAkApvWDTzBog7f4bnzJ8CzDVmaBiNE3kgiHsuIrzqiB5VQg7mB1TQNRcNcCUTflqd2KcaBoVHUhwUoUHLSqYFonx
加密后的消息: NfizGbtj7xEGDWjysZwSLdjvxSC3bZkeLCuHgdJVShUL6lkY+XxJC5LT17GKWzT565MLE1wmTaUQ+siOQ8NWN3SBKYNaJgNK+LdG0DxvslNdFpqiZDSLlSe420A1YEuZsqMOHENl8M9MUxZZUrxoQBvN/dxgJO/qJdGvR28O9v8=
解密后的消息: Hello, World!

1.3.库Bouncy Castle实现

package asymmetric_encryption.bouncy_castle;  
  
import org.bouncycastle.jce.provider.BouncyCastleProvider;  
import org.bouncycastle.util.encoders.Base64;  
  
import javax.crypto.Cipher;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.Security;  
  
public class BouncyCastleECCExample {  
    public static void ECCDemo() throws Exception {  
        // 添加 Bouncy Castle 提供者  
        Security.addProvider(new BouncyCastleProvider());  
  
        // 生成 ECC 密钥对  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("EC", "BC");  
        keyPairGen.initialize(256);  // 使用 256 位的椭圆曲线  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
  
        PublicKey publicKey = keyPair.getPublic();  
        PrivateKey privateKey = keyPair.getPrivate();  
  
        System.out.println("ECC 公钥: " + Base64.toBase64String(publicKey.getEncoded()));  
        System.out.println("ECC 私钥: " + Base64.toBase64String(privateKey.getEncoded()));  
  
        // 使用公钥加密  
        Cipher cipher = Cipher.getInstance("ECIES", "BC");  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
        byte[] encryptedMessage = cipher.doFinal("Hello, this is a secret message!".getBytes());  
  
        System.out.println("加密消息: " + Base64.toBase64String(encryptedMessage));  
  
        // 使用私钥解密  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);  
        byte[] decryptedMessage = cipher.doFinal(encryptedMessage);  
  
        System.out.println("解密消息: " + new String(decryptedMessage));  
    }  
}

package asymmetric_encryption.bouncy_castle;  
  
import org.bouncycastle.jce.provider.BouncyCastleProvider;  
import org.bouncycastle.util.encoders.Base64;  
  
import javax.crypto.Cipher;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.Security;  
  
public class BouncyCastleRSAExample {  
    public static void RSADemo() throws Exception {  
        // 添加 Bouncy Castle 提供者  
        Security.addProvider(new BouncyCastleProvider());  
  
        // 生成 RSA 密钥对  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", "BC");  
        keyPairGen.initialize(2048);  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
  
        PublicKey publicKey = keyPair.getPublic();  
        PrivateKey privateKey = keyPair.getPrivate();  
  
        System.out.println("RSA 公钥: " + Base64.toBase64String(publicKey.getEncoded()));  
        System.out.println("RSA 私钥: " + Base64.toBase64String(privateKey.getEncoded()));  
  
        // 使用公钥加密  
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
        byte[] encryptedMessage = cipher.doFinal("Hello, this is a secret message!".getBytes());  
  
        System.out.println("加密消息: " + Base64.toBase64String(encryptedMessage));  
  
        // 使用私钥解密  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);  
        byte[] decryptedMessage = cipher.doFinal(encryptedMessage);  
  
        System.out.println("解密消息: " + new String(decryptedMessage));  
    }  
}

RSA 公钥: MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwZvqUXbY3/s/7kXSFaq6o7S1W4X5ErnZqZzcYGdPVnX1/E6q7pMdMx8ps2gwoQhK0gtj/AgM6V1H2344WCa0TkPKX2UuLi3vjEGOWzE7B+G8bpcEl8vA4Fx/sGixTlzlDD8E01MLGKk4Da91KxlowS16/bmkRl6WKNMgNn+iwY5bzDyiwCaSKaslTo2YwQxij4vgpZBB17fTTO++6Vw8ktTxsMLiTYcJt5ScYMg60pahdYiLqm/omK+KT70ycnAL5HEcHf3qWKZllYcCZ40daw96VjRxQoAZPy6iSJyxvnt7HbcqfYiDLYYx9d3TH40sQ9+tgmJwUFq8wTZo+pYDewIDAQAB
RSA 私钥: MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDBm+pRdtjf+z/uRdIVqrqjtLVbhfkSudmpnNxgZ09WdfX8Tqrukx0zHymzaDChCErSC2P8CAzpXUfbfjhYJrROQ8pfZS4uLe+MQY5bMTsH4bxulwSXy8DgXH+waLFOXOUMPwTTUwsYqTgNr3UrGWjBLXr9uaRGXpYo0yA2f6LBjlvMPKLAJpIpqyVOjZjBDGKPi+ClkEHXt9NM777pXDyS1PGwwuJNhwm3lJxgyDrSlqF1iIuqb+iYr4pPvTJycAvkcRwd/epYpmWVhwJnjR1rD3pWNHFCgBk/LqJInLG+e3sdtyp9iIMthjH13dMfjSxD362CYnBQWrzBNmj6lgN7AgMBAAECggEAWs33ML0Wi7qJ6gWaOmpIPjanpqTnxGYhVcFJxPc/STRrKip1Vg7ur4bqpofz4tsCSJBqFQ9ritoitSn2YDXK9DgsRuCsL6GAzB4FF/U3lANGPvIah91a+X+4rbL0keXU0ZEPANRejHL1ZMnJoOy6anwbxruWdiCvubcH0Te8zJ1YvIEICDPT7fih42e/Q2DqrpMBUXbNuVhbgXWxV7KPwvKFCaaujrFy+B/hkqJucAUioUuaJtT7tacHe9QsRsFM9ocCNCoVHxbwE8nxtqACtZz7S305s6e6i4LdfVIh9dj6s8EwafQ/lmNhX7ivPKe1eto2iAQ7friiBGEqQbTVuQKBgQDkvsLL3cWixTih68+8Q8xaOm7L939sFY8i980Ajiiywpc9ltigkah/L8wCcwN2awTzGOwP72yt8VKkRxOcWZoC+QW7wxfVqyNjRzUoN0/EV16ZJ1Ie6dbLJg/5RK2k7USJHfGfmeGMBmaPLY0lu2K7MYv7gvXu/q7t8n4ptzPFwwKBgQDYrWyb789GfHED52LDA+Wc2zTcG7b8D3S1kH7/MOno57AVlgA50Y6Qg43N0NXHGnqieBf65nlnMrXvKLODW7jqkUeEBmT+XCHzTeQAmn1gF7yul2QavuQlFx8krTx/2yWgJvEg+TFYN5w7yUBqhKkEuXakna+HhSHlnG8xF9uX6QKBgQClityk95GhU8PBg0wqvpI0tlca67neudeGAfntrfQMMsGLhBCwW9mqeifVmfDmkVrap62ndqmbVKtvUjUCEOJhxmB82xrzuk/4+D6jJSxoNqayhf9reeXFzXz/89ELK99OsEn+LDpLwRIWCmw841j3ikr5MXTUiqKEd9sQS5J/SwKBgQCeINJmavjF5ANGahL1Z16mvoMxLzi3c0AlUTKdYkESrCMhXbsEdx6n8JoIXiPljjl5YFN/07s9yRBlXTrE3qdw6F1cyJ3j07EjMvD2T8i33Bri/7Eao700JE+iIJtKY9BttH29Jp8QVmU6bIEKO45t2DvxnvJ+4HYAb83l8hdcIQKBgQCSJj4ZXSYxuea5H8oP0Oi0FbVKPcTcFHsNm484A5JSCgow9aExtI73k0cdQsOCgRxiGWTl4wWsB1JwpSI3ibq5l1jblMeqAeLxLLFpSWWXYWyXfA+6knbF1qhEeRYPmQWPUEE8l3SjZasRHshYk+ukehlSzywptydZVKbIuIviTA==
加密消息: SUTCZ70ICxPJW+G5G+kw8vqHqegxk6kBvuP1TCn3Ga7hlGjfC9I0u5paO86M0vpd1bMdPWX0khOlgPe8C+cNxn7K7lYlbwjzrqrr5tODKIZwUg33wM/LGpUV6XhWv1qMjBcAzBSHqO0Koso6xrLzrN42/b32oLxmFOwEWAcfDlJ6sEWT0KS/X0FSY/SHbrBZVVwB43gN7QNGvnh22Dek3LicawxYEwvTTjfdbf9K0b/iiLtQoVRfaC7nwm4bBGc1xSImo4upaXN+jLXtw3aK9/JBC2azZncSv+4NJWNSYlSHC4uk36PZqCKl6zly/MS4dPwSJbcovAGd24TQiKRXbw==
解密消息: Hello, this is a secret message!
ECC 公钥: MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvB5M2an/YkzomTxEA1uZcy696O7xk3u/Dz0i7IrcB+1B12WrHtqJrRgKeePHVeg94Y+dxkJ3PrdcLKn51/qJaw==
ECC 私钥: MIGTAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBHkwdwIBAQQgx3KL5Xiv+/ZQZNWwhLYeEw6Tp5r/mYI6msI/j1vnvQmgCgYIKoZIzj0DAQehRANCAAS8HkzZqf9iTOiZPEQDW5lzLr3o7vGTe78PPSLsitwH7UHXZase2omtGAp548dV6D3hj53GQnc+t1wsqfnX+olr
加密消息: BP0dLeL78X41WQU1McMSvqxmZBRkVSPitHW1/jkMx5mVb5p3DNBqd17KP4HRjGDCOq4JB2bavyp6vTm+3czbXw3aVzTNMCGcSnlzgHGXVUP0b14wNCZotTfNlwB88Oh0KlK19Bk4ShElHONH5Ah8zW9efU3O
解密消息: Hello, this is a secret message!

2.C#中的使用

2.1. 原生使用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;

namespace ConsoleSymmetricEncryption
{
    public class RSAExample
    {
        public static void RSADemo()
        {
            using (RSA rsa = RSA.Create())
            {
                // 导出公钥和私钥
                var publicKey = rsa.ExportRSAPublicKey();
                var privateKey = rsa.ExportRSAPrivateKey();

                string originalMessage = "Hello, RSA! 小菜";
                byte[] messageBytes = Encoding.UTF8.GetBytes(originalMessage);

                // 加密
                byte[] encryptedMessage = rsa.Encrypt(messageBytes, RSAEncryptionPadding.Pkcs1);
                string encryptedText = Convert.ToBase64String(encryptedMessage);

                // 解密
                byte[] decryptedMessage = rsa.Decrypt(encryptedMessage, RSAEncryptionPadding.Pkcs1);
                string decryptedText = Encoding.UTF8.GetString(decryptedMessage);

                Console.WriteLine($"encryptedText: {encryptedText}");
                Console.WriteLine($"decryptedText: {decryptedText}");
            }
        }
    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;

namespace ConsoleSymmetricEncryption
{
    public class ECCExample
    {
        public static void ECCSignDemo()
        {
            using (ECDsa ecdsa = ECDsa.Create())
            {
                // 生成密钥对
                byte[] publicKey = ecdsa.ExportSubjectPublicKeyInfo();
                byte[] privateKey = ecdsa.ExportECPrivateKey();

                string originalMessage = "Hello, ECC!";
                byte[] messageBytes = Encoding.UTF8.GetBytes(originalMessage);

                // 签名
                byte[] signature = ecdsa.SignHash(SHA256.HashData(messageBytes));

                // 验证签名
                bool isValid = ecdsa.VerifyHash(SHA256.HashData(messageBytes), signature);

                Console.WriteLine($"Original Message: {originalMessage}");
                Console.WriteLine($"Is Signature Valid: {isValid}");
            }
        }

        public static void ECCDemo()
        {
            // Alice 和 Bob 各自生成 ECC 密钥对
            using (ECDiffieHellmanCng bob = new ECDiffieHellmanCng())
            {
                ECDiffieHellmanCng alice = new ECDiffieHellmanCng();
                alice.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
                alice.HashAlgorithm = CngAlgorithm.Sha256;

                bob.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
                bob.HashAlgorithm = CngAlgorithm.Sha256;

                // Alice 获取 Bob 的公钥，生成共享密钥
                byte[] alicePublicKey = bob.PublicKey.ToByteArray();
                byte[] aliceSharedKey = alice.DeriveKeyMaterial(CngKey.Import(alicePublicKey, CngKeyBlobFormat.EccPublicBlob));

                // Bob 获取 Alice 的公钥，生成共享密钥
                byte[] bobPublicKey = alice.PublicKey.ToByteArray();
                byte[] bobSharedKey = bob.DeriveKeyMaterial(CngKey.Import(bobPublicKey, CngKeyBlobFormat.EccPublicBlob));

                // 确保 Alice 和 Bob 生成的共享密钥是相同的
                Console.WriteLine($"Alice's Shared Key: {Convert.ToBase64String(aliceSharedKey)}");
                Console.WriteLine($"Bob's Shared Key: {Convert.ToBase64String(bobSharedKey)}");
                Console.WriteLine($"Keys are equal: {Convert.ToBase64String(aliceSharedKey) == Convert.ToBase64String(bobSharedKey)}");

                // 使用共享密钥进行 AES 加密和解密
                string originalMessage = "Hello, ECC with AES!";
                byte[] encryptedMessage = AESEncrypt(originalMessage, aliceSharedKey);
                string decryptedMessage = AESDecrypt(encryptedMessage, bobSharedKey);

                Console.WriteLine($"Original Message: {originalMessage}");
                Console.WriteLine($"Decrypted Message: {decryptedMessage}");
            }
        }

        // AES 加密方法
        private static byte[] AESEncrypt(string plainText, byte[] key)
        {
            using (Aes aes = Aes.Create())
            {
                aes.Key = key;
                aes.GenerateIV(); // 随机生成 IV

                using (ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
                {
                    byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);
                    byte[] encryptedBytes = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length);

                    // 返回 IV 和加密的数据
                    byte[] result = new byte[aes.IV.Length + encryptedBytes.Length];
                    Array.Copy(aes.IV, 0, result, 0, aes.IV.Length);
                    Array.Copy(encryptedBytes, 0, result, aes.IV.Length, encryptedBytes.Length);

                    return result;
                }
            }
        }

        // AES 解密方法
        private static string AESDecrypt(byte[] encryptedData, byte[] key)
        {
            using (Aes aes = Aes.Create())
            {
                aes.Key = key;

                // 提取 IV
                byte[] iv = new byte[aes.BlockSize / 8];
                byte[] cipherText = new byte[encryptedData.Length - iv.Length];
                Array.Copy(encryptedData, iv, iv.Length);
                Array.Copy(encryptedData, iv.Length, cipherText, 0, cipherText.Length);

                aes.IV = iv;

                using (ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV))
                {
                    byte[] decryptedBytes = decryptor.TransformFinalBlock(cipherText, 0, cipherText.Length);
                    return Encoding.UTF8.GetString(decryptedBytes);
                }
            }
        }
    }
}

encryptedText: Q8TCZh5f6u8dOSRYigreS2DIUy4fLV8pQlaklqi3pcz5zm7ZYX4p2d3fHYE7hKMmyvqYiZxSL+q4MyMJX8rKxgF94Q0Ba25Sa3RxHSbgAM3fkREnn9eS5cK+xk2kCX/tqsHl4ZT/6zTBoiHugec9eta7J+1zEblyEbprHbCe2SXLJDd64TbqqZTF7qo6OSyMcwP5v9PJHb1zSdLuDeHvfP7Uwydvrq9TdPZH3Bc0LnJElb8oEdCaFYRlMYCcRfs1gu0rnUpCl7ELUvZ+jxgcb4Xnup/jzoZfRamvvEM3f4tEHLiOCVkyAw729RavXJhsgWrj55liqgOP0dnbDqn0kA==
decryptedText: Hello, RSA! 小菜
Original Message: Hello, ECC!
Is Signature Valid: True
Alice's Shared Key: FEmE+ZdiM68D/XRMquoNzWWBjcorVYannZ+xoVXTh5U=
Bob's Shared Key: FEmE+ZdiM68D/XRMquoNzWWBjcorVYannZ+xoVXTh5U=
Keys are equal: True
Original Message: Hello, ECC with AES!
Decrypted Message: Hello, ECC with AES!

2.2.库Bouncy Castle实现

using System;
using System.Text;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Security;

public class RSAWithBouncyCastleExample
{
    public static void RSAWithBouncyCastleDemo()
    {
        // 生成 RSA 密钥对
        AsymmetricCipherKeyPair keyPair = GenerateRSAKeyPair();

        var publicKey = (RsaKeyParameters)keyPair.Public;
        var privateKey = (RsaKeyParameters)keyPair.Private;

        // 要加密的原始信息
        string originalMessage = "Hello, RSA with Bouncy Castle!";
        byte[] messageBytes = Encoding.UTF8.GetBytes(originalMessage);

        // 使用公钥加密
        byte[] encryptedData = Encrypt(messageBytes, publicKey);
        Console.WriteLine($"Encrypted Data: {Convert.ToBase64String(encryptedData)}");

        // 使用私钥解密
        byte[] decryptedData = Decrypt(encryptedData, privateKey);
        string decryptedMessage = Encoding.UTF8.GetString(decryptedData);
        Console.WriteLine($"Decrypted Message: {decryptedMessage}");
    }

    // 生成 RSA 密钥对
    public static AsymmetricCipherKeyPair GenerateRSAKeyPair()
    {
        var keyGenerationParameters = new KeyGenerationParameters(new SecureRandom(), 2048); // 2048位密钥
        var keyPairGenerator = new RsaKeyPairGenerator();
        keyPairGenerator.Init(keyGenerationParameters);
        return keyPairGenerator.GenerateKeyPair();
    }

    // 使用公钥加密
    public static byte[] Encrypt(byte[] plainText, RsaKeyParameters publicKey)
    {
        var engine = new RsaEngine();
        engine.Init(true, publicKey); // true表示加密
        return engine.ProcessBlock(plainText, 0, plainText.Length);
    }

    // 使用私钥解密
    public static byte[] Decrypt(byte[] cipherText, RsaKeyParameters privateKey)
    {
        var engine = new RsaEngine();
        engine.Init(false, privateKey); // false表示解密
        return engine.ProcessBlock(cipherText, 0, cipherText.Length);
    }
}

using System;
using System.Text;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Crypto.Agreement;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Paddings;
using Org.BouncyCastle.Crypto.Modes;

public class ECCWithAESExample
{
    public static void ECCWithBouncyCastleDemo()
    {
        // 生成 Alice 和 Bob 的 ECC 密钥对
        var keyPairGenerator = new ECKeyPairGenerator();
        var keyGenParams = new KeyGenerationParameters(new SecureRandom(), 256);
        keyPairGenerator.Init(keyGenParams);

        // Alice 和 Bob 各自生成密钥对
        AsymmetricCipherKeyPair aliceKeyPair = keyPairGenerator.GenerateKeyPair();
        AsymmetricCipherKeyPair bobKeyPair = keyPairGenerator.GenerateKeyPair();

        var alicePublicKey = (ECPublicKeyParameters)aliceKeyPair.Public;
        var alicePrivateKey = (ECPrivateKeyParameters)aliceKeyPair.Private;
        var bobPublicKey = (ECPublicKeyParameters)bobKeyPair.Public;
        var bobPrivateKey = (ECPrivateKeyParameters)bobKeyPair.Private;

        // 通过密钥交换生成共享密钥
        byte[] aliceSharedKey = GenerateSharedSecret(alicePrivateKey, bobPublicKey);
        byte[] bobSharedKey = GenerateSharedSecret(bobPrivateKey, alicePublicKey);

        // 确保共享密钥相同
        Console.WriteLine($"Alice Shared Key: {Convert.ToBase64String(aliceSharedKey)}");
        Console.WriteLine($"Bob Shared Key: {Convert.ToBase64String(bobSharedKey)}");
        Console.WriteLine($"Keys are equal: {Convert.ToBase64String(aliceSharedKey) == Convert.ToBase64String(bobSharedKey)}");

        // 使用共享密钥进行 AES 加密和解密
        string originalMessage = "Hello, ECC with AES!";
        byte[] encryptedMessage = AESEncrypt(originalMessage, aliceSharedKey);
        string decryptedMessage = AESDecrypt(encryptedMessage, bobSharedKey);

        Console.WriteLine($"Original Message: {originalMessage}");
        Console.WriteLine($"Decrypted Message: {decryptedMessage}");
    }

    // 生成共享密钥（ECC 密钥交换）
    private static byte[] GenerateSharedSecret(ECPrivateKeyParameters privateKey, ECPublicKeyParameters publicKey)
    {
        var agreement = new ECDHBasicAgreement();
        agreement.Init(privateKey);
        var sharedSecret = agreement.CalculateAgreement(publicKey);
        return sharedSecret.ToByteArray();
    }

    // AES 加密方法
    private static byte[] AESEncrypt(string plainText, byte[] key)
    {
        // 截取共享密钥的一部分用于 AES 密钥
        byte[] aesKey = new byte[16];
        Array.Copy(key, 0, aesKey, 0, 16);

        var aesEngine = new AesEngine();
        var cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(aesEngine));
        cipher.Init(true, new KeyParameter(aesKey));

        byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);
        byte[] encryptedBytes = new byte[cipher.GetOutputSize(plainBytes.Length)];
        int length = cipher.ProcessBytes(plainBytes, 0, plainBytes.Length, encryptedBytes, 0);
        cipher.DoFinal(encryptedBytes, length);

        return encryptedBytes;
    }

    // AES 解密方法
    private static string AESDecrypt(byte[] cipherText, byte[] key)
    {
        byte[] aesKey = new byte[16];
        Array.Copy(key, 0, aesKey, 0, 16);

        var aesEngine = new AesEngine();
        var cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(aesEngine));
        cipher.Init(false, new KeyParameter(aesKey));

        byte[] decryptedBytes = new byte[cipher.GetOutputSize(cipherText.Length)];
        int length = cipher.ProcessBytes(cipherText, 0, cipherText.Length, decryptedBytes, 0);
        cipher.DoFinal(decryptedBytes, length);

        return Encoding.UTF8.GetString(decryptedBytes).TrimEnd('\0');
    }
}

Alice Shared Key: AMKHXIMVFLpUalPjkgKJrGtfH2/x9dU47Ls3Ci7Xst15
Bob Shared Key: AMKHXIMVFLpUalPjkgKJrGtfH2/x9dU47Ls3Ci7Xst15
Keys are equal: True
Original Message: Hello, ECC with AES!
Decrypted Message: Hello, ECC with AES!
Encrypted Data: HFZyDohNGBXmx5SXRXc8eHUfd9iw/18AHJRGkgRlANxMGFHX6K4sg3c+6XuYkhiA7tZABl79xhkqW9FPM1Mgkjc2IhYlNMUpdCmvplsvTCtmNnsArc/S2KfZOb7uNqXrw24tNJaFVsbEbgX00FZ94A0ix47PPt2pUTxeqfEfFGMmZaN0Iwe2M8e+os44iY1cHCOiKidKxByOwanrkTvTLEciOyncW0iBkzJR6DcCM8fSaaL1pvkaeVSdoPKIOjANrKLt594DZAGt2xEejR+/KOtNl7W8HDn2qSUGmACrTR9wfMzT67zW67Pz2Kb4UiOjekBYANnmSenHZOgWsrjVHQ==
Decrypted Message: Hello, RSA with Bouncy Castle!

原文地址：https://blog.csdn.net/a13407142317/article/details/142743124

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：vue3常用组件通信方法
下一篇：Python字符串操作详解

Qt源码-Qt多媒体音频框架
这里记录一下在Linux下Qt 的 Qt Multimedia 模块的设计，我目前先记录与音频相关的库的设计。不同Qt版本的设计有些不一样，需要看对应版本的源码设计。
阅读更多2024-10-08
数据库概述（1）
查询接口层：假设你要开发一款转账的应用，这时候就需要用到数据库驱动程序，驱动程序会实现API接口的功能【API接口是指实现各种软件之间交互的工具】，通过驱动程序可以让转账的应用接入数据库，进行查询、存
阅读更多2024-10-08
OpenCV视频I/O(20）视频写入类VideoWriter之用于将图像帧写入视频文件函数write()的使用
cv::VideoWriter::write() 函数用于将图像帧写入视频文件。
阅读更多2024-10-08
测试用例的进阶二
本文主要写了软件测试的分类；
阅读更多2024-10-08
keras yolo8目标检测
labels=['car','bus','train','truck']来做目标检测,用的backbone = keras_cv.models.YOLOV8Backbone.from_preset()
阅读更多2024-10-08
Mysql锁机制解读(敲详细)
主要是对未提交事务，修改表结构造成表结构混乱，进行控制。主要是避免加锁前的行级遍历(行级锁)，提高性能。
阅读更多2024-10-08
如何使用ssm实现基于BS的超市商品管理系统的设计与实现+vue
【代码】ssm基于BS的超市商品管理系统的设计与实现+vue
阅读更多2024-10-08
掌握 ASP.NET Web 开发：从基础到身份验证
是微软开发的一个功能强大的框架，广泛用于构建现代化的 Web 应用程序。它支持 MVC 架构、Web API、Razor 语法，并提供完善的身份验证与授权机制。本文将介绍的基础知识、MVC 模式、We
阅读更多2024-10-08
APISIX 联动雷池 WAF 实现 Web 安全防护
Apache APISIX 是一个动态、实时、高性能的云原生 API 网关，提供了负载均衡、动态上游、灰度发布、服务熔断、身份认证、可观测性等丰富的流量管理功能。
阅读更多2024-10-08
eNodeB User Manual - Troubleshooting
RF条件可能受到所使用的天线的影响，我们建议使用Ettus的Vert2450天线（或类似的）。可以使用实验室设备或开源工具（如Kalibrate-RTL）来估计您的射频前端的CFO，并手动通过在eNo
阅读更多2024-10-08

非对称加密算法的使用

1. JAVA中的使用

1.1.原生使用

1.2.Hutool包使用

1.3.库Bouncy Castle实现

2.C#中的使用

2.1. 原生使用

2.2.库Bouncy Castle实现

相关文章