Encryption et décryptage des données à l'aide de la clé publique et privée RSA générée par OpenSSL en Java
Qu'est-ce que RSA: l'algorithme de cryptage des clés publics RSA a été développé en 1977 par Ron Rivest, Adi Shamirh et Len Adleman à (Massachusetts Institute of Technology). La dénomination RSA provient des noms qui développent les trois. RSA est l'algorithme de cryptage des clés publics le plus influent à l'heure actuelle. Il est capable de résister à toutes les attaques cryptographiques connues jusqu'à présent et a été recommandée par l'ISO en tant que norme de cryptage des données de clés publiques. À l'heure actuelle, cette méthode de chiffrement est largement utilisée dans les services bancaires en ligne, les signatures numériques et autres occasions. L'algorithme RSA est basé sur une théorie des nombres très simple: il est très facile de multiplier deux grands nombres premiers, mais il était extrêmement difficile de factoriser le produit à ce moment-là, de sorte que le produit peut être divulgué comme clé de chiffrement.
Ce qui est OpenSSL: de nombreux algorithmes cryptographiques, des normes d'infrastructure de clé publique et des protocoles SSL, et peut-être que ces fonctionnalités intéressantes vous donneront l'idée de mettre en œuvre tous ces algorithmes et normes. Si c'est le cas, tout en exprimant votre admiration, je ne peux toujours pas m'empêcher de vous rappeler: c'est un processus intimidant. Ce travail n'est plus aussi simple que de lire quelques monographies et documents de protocole de cryptographie, mais plutôt comprendre chaque détail de tous ces algorithmes, normes et documents de protocole, et implémentant ces définitions et processus un par un avec des caractères C que vous connaissez peut-être. Nous ne savons pas combien de temps vous aurez besoin de faire ce travail amusant et terrible, mais ce n'est certainement pas un numéro ou deux. OpenSSL est une collection d'algorithmes qui combine de nombreux algorithmes de sécurité, écrits par deux grands hommes, Eric A. Young et Tim J. Hudson, depuis 1995. Grâce à des commandes ou à des bibliothèques de développement, nous pouvons facilement implémenter des applications d'algorithmes publics standard.
Un de mes antécédents de demande hypothétique:
Avec la popularité de l'Internet mobile, les applications développées pour les appareils mobiles émergent les unes après les autres. Ces applications sont souvent accompagnées de fonctions d'enregistrement des utilisateurs et de vérification du mot de passe. Il y a des dangers cachés dans la sécurité dans la "transmission du réseau" et "Accès du journal des applications". Les mots de passe sont des données sensibles pour les utilisateurs et les développeurs doivent prendre des précautions de sécurité avant le lancement de l'application. Une mauvaise manipulation peut entraîner des problèmes tels que des attaques malveillantes par des concurrents d'entreprise et des litiges par des partenaires tiers.
Bien que les algorithmes RSA aient tellement d'avantages, il n'y a pas d'exemple complet sur Internet pour illustrer comment les faire fonctionner. Permettez-moi de le présenter ci-dessous:
1. Utiliser OpenSSL pour générer des clés privées et publiques
J'utilise un système Linux et je fais installer le package OpenSSL. Veuillez vérifier que OpenSSL est installé sur votre machine. Les informations suivantes doivent apparaître lors de l'exécution de la commande:
[root @ chaijunkun ~] # OpenSSL Version -A OpenSSL 1.0.0-FIPS 29 mars 2010 Construit sur: Mer le 25 janvier 02:17:15 GMT 2012 Platform: Linux-X86_64 Options: BN (64,64) MD2 (int) RC4 (16x, int) DES (IDX, CISC, 16, int) Compiler (IDX) - GCC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC -FPIC - -DopenSSL_PIC -DZLIB -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -DKRB5_MIT -M64 -DL_ENDIAN -DERMIO -WALL -O2 -G -PIPE -WALT -WP, -D_FORTIFE_SOURCE = 2 -Fexppes -FSTACK --param = ssp-buffer-size = 4 -m64 -mtune = générique -wa, -noexecstack -dmd32_reg_t = int -DopenSSL_IA32_SSSE2 -DOPENSSL_BN_ASM_MONT -DSHA1_ASM -DSHA256_ASM -DSHA512_ASM -DMD5_ASM -DAESYM -Dwhirlpool_asm openssldir: "/ etc / pki / tls" moteurs: dynamique Aesni
Générez d'abord la clé privée:
[root @ chaijunkun ~] # openSSL Genrsa -out rsa_private_key.pem 1024 Génération de clé privée RSA, 1024 Bit Long Modulus .................. +++++++ .. ++++++++ E est 65537 (0x10001)
Cette commande permet à OpenSSL de générer de manière aléatoire une clé privée, et la longueur de chiffrement est de 1024 bits. La longueur cryptée fait référence à la limite théorique de la longueur maximale autorisée "d'informations cryptées", c'est-à-dire la limite de longueur du texte brut. À mesure que ce paramètre augmente (par exemple, 2048), la longueur de texte en clair autorisé augmentera également, mais elle entraînera également une augmentation rapide de la complexité informatique. La longueur recommandée est de 1024 bits (128 octets).
Jetons un coup d'œil au contenu de la clé privée:
[root @ chaijunkun ~] # Cat rsa_private_key.pem ----- Démarrer la clé privée RSA ----- miicwwibaakbgqchdzcjw / rwgfwnxunbkp7 / 4e8w / umxx2jk6qeen69t6n2r1i / l MCYDT1XR / T2AHGOIXNQ5V8W4ICAAENAWI7AJARHTVX1UOH / 2U378FSCEESEG8XDQ LL0GCFB1 / TJKI2AITVSZXOTRS8KYGUGU78F7VMDNGXILK3GDH Aogaaekk76cssp7k90mwywp18Ghlzru + Vehft9bpv67cglg1owfbntfyqspvstfm u2lwn5hd / icv + egaj4folxdm43kt4wyznoabszckkxs6urciu8nqafnuy4xveofx Phu2te7vi4ldkw9df1fya + dscslnadaUn3ohb5jqgl + ls5ecqqdufuxxn3uqgykk znrkj0j6py27hrfromehgxbjnapcq71szjqam77r3wilkfh935oiv0aqc4jqrb4 ihysll9lakeAwgh4jxxxEiafmsgjoi3qpjqgvumkx0w96mcpcwv3fsew7w1 / msi sutkjp5bbvjfvfwfmahyljdp7w + nebwkbwaybz / eb5naza4pxvr5vmcd8cikaj4 EgPLwsjI/mkhrb484xZ2VyuICIwYwNmfXpA3yDgQWsKqdgy3Rrl9lV8/AQJAcjLi IfigUr++nJxA8C4Xy0CZSoBJ76k710wdE1MPGr5WgQF1t+P+bCPjVAdYZm4Mkyv0 / ybxbd16qvixjvnt6qjabli6zx9gyrwnu6akpdahd8qjwonnnfnlqhue4wepevkm cysg + ibs2ggsxntrzlwjlfx7vhmpqnttc8ynmx1kfw == ------ End Rsa private key --------
Le contenu est tous des caractères ASCII standard, avec des marques évidentes au début et les lignes de fin, et les données privées réelles sont des caractères irréguliers au milieu.
Supplémentaire le 24 mars 2015: Le fichier clé stockera éventuellement les données via le codage Base64. Vous pouvez voir que la longueur de chaque ligne du contenu de fichier clé ci-dessus est très régulière. Cela est dû aux dispositions dans RFC2045: le flux de sortie codé doit être représenté en lignes de pas plus de 76 caractères chacun. C'est-à-dire que les données codées par Base64 ne dépasseront pas 76 caractères par ligne, et elles doivent être divisées par ligne pour des données ultra-longues.
Ensuite, générez la clé publique en fonction de la clé privée:
[root @ chaijunkun ~] # OpenSSL RSA -in RSA_PRIVATE_KEY.PEM -out RSA_PUBLIC_KEY.PEM -PUBOUT Écriture Rsa Key
Jetons un coup d'œil au contenu de la clé publique:
[root @ chaijunkun ~] # Cat rsa_public_ley.pem ----- Démarrer la clé publique ----- migfma0gcsqgsib3dqebaquaaa4gnadcbiqkbgqchdzcjw / rwgfwnxunbkp7 / 4e8w / Umxx2jk6qeen69t6n2r1i / lmcydt1xr / t2ahgoixnq5v8w4icaaenawi7ajarht vx1uoh / 2u378fsceeseg8xdqll0gcfb1 / tjKi2aitvszxotrs8kygu78f7vmdng Xilk3gdhnzh + uoeqywidaqab ---- terminer la clé publique ----
Pour le moment, la clé privée ne peut pas être utilisée directement, donc le codage PKCS # 8 est requis:
[root @ chaijunkun ~] # OpenSSL PKCS8 -TOPK8 -IN RSA_PRIVATE_KEY.PEM -out pkcs8_rsa_private_key.pem -Nocrypt
La commande indique que le fichier de clé privée d'entrée est rsa_private_key.pem, et le fichier de clé privée de sortie est pkcs8_rsa_private_key.pem, et aucun cryptage secondaire n'est utilisé (-Nocrypt)
Jetons un coup d'œil à savoir si le fichier de clés privés codé est différent du fichier de clé privée précédent:
[root @ chaijunkun ~] # cat pkcs8_rsa_private_key.pem
----- Démarrer la clé privée ----- miicdqibadanbgkqhkig9w0baqefaascal8wggjbageaogbakepnypd + taaxcfg 6dsqnv / h7zd9szfhaotqoqsfr23o3zhwl8uzzinpxgv9pyacy6jc1dlxxxbiijpp4 1rcltolpgg1xhw44f / ztfvx + xwqriqbxcoqwxqyj8hx9omojzqk1vlnc61gzyria ztvx / twym2bciwteb2gfoh66grdlagmbaaecgybp4qtvojkynut3sbdjy / xwaetm U768SF9P0GLXRTWYUDWJAVUE0VHBI9WXMWZTAVAFKCP8HXX4QZQPH84TD0ZJCQ3J DLOEGAFJKIORGZQ5FYK7YDBOU1TLJFV459C8DTZMTU + LGSOTD11 / V / JR4NJXI MBQ3C4CHMOOYV4UZKQJBANR + 7FC3E6OZGQTOOSQPSPQLJBSDF9E4X4EDFUOECCKJ DVVLOOOAZVTHFAIUP + H3FK4HXRPALINBEHIIDHIUX2UCQQDCCHFD4GC58YYCMMM 6leqkmoa + 6yPfrb3OXYKLBXCWX7DTBX + AYKY5OQMNKEG + MW8XB8WADIUL0 / TB6CQ FARVAKBHVP94HK0DMDINFVHLWYJ3XY4PONGSA8VCYMJ + ASGTVJZJZJFNZXK4GIJBJA 2Z9EKDFIOBBAWQP2DLDGUX2VXZ8BAKBYMUIH + KBSV76CNEDWLHFLQJLKGENVQTVX TB0TUW8AVLABAXW34 / 5SI + NUB1HMBGYTK / T / IFCEPXPBWLO + E3PAKAGWLPNH0ZH Fae7oaqkmad3xcny6ec180tae57hz6ks + sylkwb4ggzyacxc22vmtyksxhtueamo 1nmlzi2zfuox ----- End Private Key ----
À ce stade, les paires clés disponibles ont été générées. La clé privée utilise PKCS8_RSA_PRIVATE_KEY.PEM, et la clé publique utilise RSA_PUBLIC_KEY.PEM.
Ajouté le 20 mai 2014: Récemment, j'ai rencontré le besoin de cryptage RSA, et l'autre partie exigeait qu'ils ne pouvaient utiliser que le fichier de clé privé qui n'était pas codé par PKCS # 8 généré dans la première étape. Plus tard, j'ai vérifié les documents pertinents et j'ai appris que le fichier de clé privée généré dans la première étape est le format PKCS # 1. Ce format est en fait pris en charge par Java, mais j'écris simplement deux autres lignes de code:
RsaprivateKeystructure asn1privKey = new rsaprivateKeystructure ((asn1Sequence) asn1sence.frombytearray (prikeydata)); RsaprivateKeyspec rsaprivkeyspec = new rsaprivateKeyspec (asn1privkey.getModulus (), asn1privkey.getPrivateExponent ()); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); PrivateKey prikey = keyfactory.generateprivate (rsaprivkeyspec); Lisez d'abord le fichier de clé privée de PKCS # 1 (notez que vous supprimez le contenu de commentaire au début du signe moins), puis utilisez Base64 pour décoder la chaîne de lecture pour obtenir PrikeyData, qui est le paramètre dans la première ligne de code. La dernière ligne obtient la clé privée. Il n'y a pas de différence dans la prochaine utilisation.
Références: https://community.oracle.com/thread/1529240?start=0&tstart=0
2. Écrivez du code Java pour le tester
Supplémentaire 23 février 2012: Le JDK standard n'est spécifié que dans le JCE (JCE (JCE (Java Cryptographic Extension) est un ensemble de packages qui fournissent des cadres et des implémentations pour le chiffrement, la génération de clés et la négociation, et l'authentification des messages (Mac) Algorithmes. Il fournit également un support d'encryption pour les objets de scellage et les scellés, les flux d'asymétriques et les scellés. Interfaces, mais les implémentations internes doivent être fournies par elles-mêmes ou par un tiers. Versions JDK, vous pouvez trouver la version correspondante dans la page de téléchargement précédente.
Jetons un coup d'œil au code que j'ai implémenté:
Package net.csdn.blog.chaijunkun; Importer java.io.bufferedReader; Importer java.io.ioException; import java.io.inputStream; Importer java.io.inputStreamReader; Importer java.security.invalidkeyException; import java.security.keyfactory; Importer java.security.KeyPair; Importer java.security.KeyPairGenerator; importer java.security.nosuchalgorithMexception; Importer Java.Security.SeCurère et; Importer java.security.interfaces.rsaprivateKey; Importer java.security.interfaces.rsapublicKey; Importer java.security.spec.invalidKeyspecexception; Importer java.security.spe.pkcs8encodedKeyspec; Importer java.security.spec.x509encodedKeyspec; Importer javax.crypto.badpaddingException; import javax.crypto.cipher; Importer Javax.crypto.ILLEGALBLOCKSIZEException; Importer javax.crypto.nosuchpaddingException; import org.bouncycastle.jce.provider.bouncycastleprovider; IMPORT SUN.MISC.BASE64DECODER; classe publique rsaencrypt {private static final String default_public_key = "migfma0gcsqgsib3dqebaaa4gnadcbiqkbgqchdzcjw / rwgfwnxunbkp7 / 4e8w" + "/ r" + "/ Umxx2jk6qeen69t6n2r1i / lmcydt1xr / t2ahgoixnq5v8w4icaaenawi7ajarht" + "/ r" + "vx1uoh / 2u378fSceeseeseg8xdqll0gcfb1 / tjki2aitvszxoTrS8kyggu78f7vmdng" + "/ r" + "xilk3gdhnzh + uoeqywidaqab" + "/ r"; chaîne finale statique privée default_private_key = "miicdqibadanbgkqhkig9w0baqefaascal8wggjbageaaogbakepnypd + taaxcfg" + "/ r" + "6dsqnv / h7zd9szfhaotqoqsfr23o3zhwl8uzzinpxgv9pyacy6jc1dlxxbiijpp4" + "/ r" + "1rcltolpgg1xhw44f / ztfvx + xwqriqbxcoqwxqyj8hx9omojzqk1vlnc61gzyria" + "/ r" + "ZTVX / TWYM2BCIWTEB2GFOH66GRDLAGMBAACGYBP4QTVOJKYNUT3SBDJY / XWAETM" + "/ R" + "U768Sf9p0glxrtwyudwjavue0vhbi9wxmwztavafkcp8hxx4qzqph84td0zjcq3j" + "/ r" + "DloegafjKiorgzq5fyk7ydbou1tljfv459c8dtzmtu + lgsotd11 / v / jr4njxiudo" + "/ r" + "mbq3c4chmooyv4uzkqjbanr + 7fc3e6ozgqtoesqpspqljbsdf9e4x4edfuoc + "/ r" + "dvvloooazvthfaiup + h3fk4hxrpalinbehiidhiux2ucqqdcchiphfd4gc58yycm" + "/ r" + "6leqkmoa + 6yPfrb3Oxyklbxcwx7dtbx + ayky5oqmnkeg + mw8xb8wadiul0 / tb6cq" + "/ r" + "FARVAKBHVP94HK0DMDINFVHLWYJ3XY4PONGSA8VCYMJ + ASGTVJZJFNZXK4GIJBJA" + "/ R" + "2Z9EKDFIOBBAWQP2DLDGUX2VXZ8BAKBEVVX" + KBSV76CADEDWLLHFLIC "/ r" + "TB0TUW8AVLABAXW34 / 5SI + NUB1HMBGYTK / T / IFCEPXPBWLGO + E3PAKAGWLPNH0ZH" + "/ R" + "Fae7oaqkmad3xcny6ec180tae57hz6ks + sylkwb4ggzyacxc22vmtyksxhtueamo" + "/ r" + "1nmlzi2zfuox" + "/ r"; / ** * clé privée * / private rsaprivatekey privatekey; / ** * Public Key * / private rsapublickey publickey; / ** * SET privé sur String * / private static final char [] hex_char = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; / ** * Obtenez la clé privée * @return objet de clé privée actuelle * / public rsaprivateKey getPrivateKey () {return privateKey; } / ** * Obtenez la clé publique * @return objet de clé publique actuel * / public rsapublickey getPublickey () {return publicKey; } / ** * Paire de clés générée de manière aléatoire * / public void genkeypair () {keyPairGenerator keyPairgen = null; essayez {keypairgen = keypairgenerator.getInstance ("RSA"); } catch (NosuchalgorithMexception e) {e.printStackTrace (); } keyPairgen.Initialize (1024, new SecureRandom ()); Keypair keypair = keypairgen.generateKeyPair (); this.privateKey = (rsaprivateKey) keypair.getPrivate (); this.publicKey = (rsapublickey) keypair.getPublic (); } / ** * Chargez la touche publique à partir du flux d'entrée dans le fichier * @param dans la clé publique Stream d'entrée * @throws exception exception générée lors du chargement de la clé publique * / public void loadPublicKey (InputStream in) lève exception {try {buttereDader br = new BuffereDader (new InputStreamReader (in)); String readLine = null; StringBuilder sb = new StringBuilder (); while ((readLine = br.readline ())! = null) {if (readLine.Charat (0) == '-') {Continuer; } else {sb.append (readline); sb.append ('/ r'); }} loadPublicKey (sb.toString ()); } catch (ioException e) {lance une nouvelle exception ("Public Key Data Stream Read Error"); } catch (nullpointerException e) {Throw New Exception ("Le flux d'entrée de la clé publique est vide"); }} / ** * Chargez la clé publique à partir d'une chaîne * @param publicKeyStr Public Key Data String * @throws exception exception généré lors du chargement de la clé publique * / public void loadPublicKey (String publickeyStr) lève une exception {try {base64decoder Base64DecOder = new Base64DecOder (); octet [] buffer = base64decoder.decodeBuffer (publickeystr); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); X509EncodedKeyspec KeySpec = new x509encodedKeyspec (tampon); this.publicKey = (rsapublickey) keyfactory.generatePublic (keySpec); } catch (NosuchalgorithMexception e) {Throw New Exception ("Rien d'algorithme"); } catch (invalidKeyspeCException e) {lancer une nouvelle exception ("clé publique illégale"); } catch (ioException e) {lancez une nouvelle exception ("Public Key Data Content Read Error"); } catch (nullpointerException e) {lancer une nouvelle exception ("les données de clé publique sont vides"); }} / ** * Chargez la touche privée à partir du fichier * @param keyFileName Private Key Nom du fichier * @return si elle est réussie * @throws exception * / public void loadPrivateKey (InputStream in) lève exception {try {buttereDader br = new Bufferreader (new InputStreamReader (in)); String readLine = null; StringBuilder sb = new StringBuilder (); while ((readLine = br.readline ())! = null) {if (readLine.Charat (0) == '-') {Continuer; } else {sb.append (readline); sb.append ('/ r'); }} loadPrivateKey (sb.toString ()); } catch (ioException e) {lance une nouvelle exception ("Erreur de lecture des données de clé privée"); } catch (nullpointerException e) {Throw New Exception ("Le flux d'entrée de la clé privée est vide"); }} public void loadPrivateKey (String privateKeystr) lève une exception {try {base64decoder base64decoder = new base64decoder (); octet [] buffer = base64decoder.decodeBuffer (privateKeystr); Pkcs8EncodedKeyspec keySpec = new PKCS8EncodedKeyspec (tampon); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); this.privateKey = (rsaprivateKey) keyfactory.generatePrivate (keySpec); } catch (NoSuchalgorithMexception e) {Throw New Exception ("Rien cet algorithme"); } catch (invalidKeyspeCException e) {lancer une nouvelle exception ("clé privée illégale"); } catch (ioException e) {lancez une nouvelle exception ("Erreur de lecture de contenu de données de clé privée"); } catch (nullpointerException e) {Throw New Exception ("Les données de clé privée sont vides"); }} / ** * Processus de cryptage * @param publickey clé publique * @param PlainTextData Données PlainText * @return * @Throws Exception Informations Exception Pendant le processus de chiffrement * / public Byte [] Encrypt (rsapublicKey publicKey, Byte [] PlainTextData) lance une exception {si (PublicKey == Null) {Throw Exception ("Encryption Public Key est un pilier"); } Chiffre chiffre = null; essayez {cipher = cipher.getInstance ("RSA", nouveau BouncycastleProvider ()); Cipher.init (cipher.encrypt_mode, publicKey); octet [] output = cipher.dofinal (PlainTextData); sortie de retour; } catch (NoSuchalgorithMexception e) {Throw New Exception ("Nothis Encryption Algorithm"); } catch (nosuchpaddingException e) {e.printStackTrace (); retourner null; } catch (invalidkeyException e) {lancer une nouvelle exception ("La clé publique de cryptage est illégale, veuillez vérifier"); } catch (illégalblockSizeException e) {lancer une nouvelle exception ("la longueur de placktext est illégale"); } catch (badpaddingException e) {lancer une nouvelle exception ("Les données de placktext sont corrompues"); }} / ** * Processus de décryptage * @Param PrivateKey Key private * @Param Cipherdata CipherText Données * @return PlainText * @throws Exception Informations PrivateKey pendant le processus de décryptage * / CIPHERDATA) ensemble"); } Chiffre chiffre = null; essayez {cipher = cipher.getInstance ("RSA", nouveau BouncycastleProvider ()); cipher.init (cipher.decrypt_mode, privateKey); octet [] output = cipher.dofinal (cipherdata); sortie de retour; } catch (NosuchalgorithMexception e) {Throw New Exception ("Nothing Decryption Algorithm"); } catch (nosuchpaddingException e) {e.printStackTrace (); retourner null; } catch (invalidKeyException e) {lancer une nouvelle exception ("Decryption La clé privée est illégale, veuillez vérifier"); } catch (illégalblockSizeException e) {lancer une nouvelle exception ("la longueur cryptotext est illégale"); } catch (badpaddingException e) {lancer une nouvelle exception ("Les données cryptotext sont corrompues"); }} / ** * Données d'octet vers HexaDecimal String * @Param Data Input Data * @return HexaDecimal Content * / public static String bytearRayToString (byte [] data) {StringBuilder StringBuilder = new StringBuilder (); for (int i = 0; i <data.length; i ++) {// retirer les quatre chiffres élevés de l'octet en tant qu'index pour obtenir l'identifiant hexadécimal correspondant note que le shift de shift droit non signé à droite non signé (hex_char [(i i] & 0xf0) >>> 4]); // retirez les quatre bits inférieurs de l'octet en tant qu'index pour obtenir l'identifiant hexadécimal correspondant StringBuilder.Apend (hex_char [(data [i] & 0x0f)])); if (i <data.length-1) {stringBuilder.append (''); }} return stringBuilder.toString (); } public static void main (string [] args) {rsaencrypt rsaencrypt = new rsaencrypt (); //rsaencrypt.genkeypair (); // Chargez la clé publique essayez {rsaencrypt.loadPublicKey (rsaencrypt.default_public_key); System.out.println ("Chargement de la clé publique avec succès"); } catch (exception e) {System.err.println (e.getMessage ()); System.err.println ("Chargement de la clé publique a échoué"); } // Chargement de la touche privée try {rsaencrypt.loadPrivateKey (rsaencrypt.default_private_key); System.out.println ("Chargement de la clé privée avec succès"); } catch (exception e) {System.err.println (e.getMessage ()); System.err.println ("Chargement de la clé privée a échoué"); } // Test String String EncryptStr = "Test String chaijunkun"; essayez {// crypt byte [] cipher = rsaencrypt.encrypt (rsaencrypt.getPublicKey (), encryptstr.getBytes ()); // Decrypt byte [] PlainText = rsaencrypt.decrypt (rsaencrypt.getPrivateKey (), Cipher); System.out.println ("Longueur du texte chiffré:" + cipher.length); System.out.println (Rsaencrypt.ByteArrayToString (Cipher)); System.out.println ("Longueur en clair:" + PlainText.Length); System.out.println (Rsaencrypt.ByteArrayToString (PlainText)); System.out.println (nouvelle chaîne (PlainText)); } catch (exception e) {System.err.println (e.getMessage ()); }}} Dans le code, je fournis deux façons de charger des clés publiques et privées.
Lire par Stream: Convient à la méthode d'obtention de Ressources d'indexation ID InputStream par ID dans les applications Android;
Lire par String: Comme indiqué dans le code, stockez le contenu de la clé par ligne dans les constantes statiques et importez la clé par type de chaîne.
Exécutez le code ci-dessus et les informations suivantes seront affichées:
1 64 57 C8 E3 46 A7 CE 57 31 AC CD 21 89 89 8F C1 24 C1 22 0C CB 70 6A 0D FA C9 38 80 BA 2E E1 29 02 ED 45 9E 88 E9 23 09 87 AF AB AB CB 61 03 3C A1 81 56 A5 DE C4 79 AA 3E 3E 48 EE 30 3D BC 5B 47 505 79 AA 3E 3E 48 EE 30 3D BC 5B 47 505 79 AA 3E 3E 48 EE 30 3D BC 5B 47 50579 FD 22 87 9E DE B1 F4 E8 B2 Longueur du texte brut: 22 54 65 73 74 20 53 74 72 69 6e 67 20 63 68 61 69 6A 75 6E 6B 75 6E Test String Chaijunkun
Dans la fonction principale, j'ai commenté "rsaencrypt.genkeypair ()", qui est utilisé pour générer des paires clés aléatoirement (générer, utiliser, pas stocker). Lorsque la touche de fichier n'est pas utilisée, vous pouvez commenter le code qui charge la clé, activer cette méthode ou exécuter le code.
La différence entre le chargement d'une clé publique et le chargement d'une clé privée est que lorsque la clé publique est chargée, X509EncodedKeyspec (instruction de la clé en codés X509), et lorsque la clé privée est chargée, PKCS8EncodedKeyspec (PKCS # 8-Encoded Key Instruction).
Ajouté le 22 février 2012: lors du développement de logiciels Android, il a été constaté que le code ci-dessus ne fonctionnait pas correctement. La raison principale est que la classe Sun.Misc.base64Deccoder n'existe pas dans le package de développement Android. Par conséquent, vous devez rechercher le code source de Rt.jar sur Internet. Quant au code source de Src.zip de JDK, ce n'est qu'une partie du code source dans JDK, et les codes des classes ci-dessus n'existent pas. Après la recherche et l'ajout, le code ci-dessus fonctionne bien dans les applications Android. Cela contient le code correspondant pour cette classe. De plus, cette classe dépend également de CeFormatexception, de cestreamExhaUst, des classes de cocoter et de caractères et des définitions d'exception.
Ajouté le 23 février 2012: Au début, j'ai écrit cet article pour mettre en œuvre le cryptage et le décryptage RSA sans compter sur des packages tiers, mais j'ai rencontré des problèmes plus tard. Étant donné qu'un objet de chiffre doit être créé à la fois dans la méthode de cryptage Encrypt et la méthode Decrypt Decrypt, cet objet ne peut obtenir des instances que via GetInstance. Il existe deux types: la première consiste à spécifier uniquement l'algorithme et non le fournisseur; La seconde consiste à spécifier les deux. Au début, le code peut toujours s'exécuter, mais vous constaterez que le résultat de chaque cryptage est différent. Plus tard, il a été découvert que la clé publique et privée utilisée par l'objet Cipher avait été générée au hasard en interne, et non la clé publique et privée spécifiée dans le code. Étrangement, ce code qui ne spécifie pas un fournisseur peut exécuter les applications Android, et le résultat de chaque cryptage est le même. Je pense qu'en plus de certaines fonctions de développement du système dans le SDK Android, il implémente également les fonctions du JDK. Il peut avoir fourni des fournisseurs correspondants dans son propre JDK, ce qui rend le chiffrement le même à chaque fois. Lorsque j'ai ajouté le fournisseur de rebond comme l'exemple de code sur Internet, les résultats de chaque cryptage sont les mêmes.
Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!