J'ai l'impression que cela fait longtemps que je n'ai pas écrit un blog pour la dernière fois. Permettez-moi de me plaindre en premier. Ce mois-ci, la société a travaillé des heures supplémentaires, publié et lancé la publication, et les nouveaux projets sont trop serrés, donc je ne dirai pas grand-chose sur les spécifiques. Aujourd'hui, il est vraiment important de parler du cryptage asymétrique. Le chiffrement asymétrique est indispensable dans notre vie quotidienne.
concept
Avant de parler de RSA, parlons d'abord de ce qu'est le cryptage asymétrique. Lorsque vous parlez de chiffrement symétrique, il a été dit une fois que les algorithmes de cryptage symétrique utilisent la même clé secrète lors du chiffrement et du décryptage, et les deux parties pour crypter et décrypter doivent utiliser la même clé pour communiquer normalement. Le cryptage asymétrique n'est pas le cas. L'algorithme de cryptage asymétrique nécessite deux clés pour crypter et décrypter, à savoir la clé publique et la clé privée.
Une chose à noter est que la clé publique et la clé privée doivent être une paire. Si les données sont cryptées avec la clé publique, seule la clé privée correspondante peut être déchiffrée, et vice versa. Étant donné que le cryptage et le déchiffrement utilisent deux clés différentes, cet algorithme est appelé algorithme de cryptage asymétrique.
Processus de travail
Comme le montre la figure ci-dessous, les données sont transmises à l'aide du cryptage asymétrique.
Les principaux algorithmes utilisés dans le chiffrement asymétrique comprennent: RSA, Elgamal, Algorithme de sac à dos, Rabin, DH, ECC (algorithme de chiffrement de la courbe elliptique), etc. Aujourd'hui, nous présenterons principalement RSA. Quant aux autres algorithmes, nous en choisirons quelques-uns pour les présenter plus tard.
RSA
En fait, RSA est apparu dès 1978, et c'était le premier algorithme qui peut être utilisé à la fois pour le chiffrement des données et les signatures numériques. Il est facile à comprendre et à opérer et est également très populaire. Le principe est tel que décrit dans le processus de travail ci-dessus.
L'algorithme RSA est basé sur une théorie des nombres très simple: il est facile de multiplier deux grands nombres premiers, mais il est extrêmement difficile de factoriser leurs produits, de sorte que le produit peut être divulgué comme clé de chiffrement.
Implémentation de code
Jetons un coup d'œil à l'implémentation de code spécifique ci-dessous.
import com.google.common.collect.maps; IMPORT SUN.MISC.BASE64DECODER; Import Sun.Misc.Base64Encoder; import javax.crypto.cipher; importer java.security. *; Importer java.security.interfaces.rsaprivateKey; Importer java.security.interfaces.rsapublicKey; Importer java.security.spe.pkcs8encodedKeyspec; Importer java.security.spec.x509encodedKeyspec; importation java.util.map; / ** * Créé par Xiang.Li le 2015/3/3. * Classe d'outils de chiffrement et de décryptage RSA * / classe publique RSA {/ ** * Définir la méthode de chiffrement * / chaîne statique finale privée key_rsa = "RSA"; / ** * Définir l'algorithme de signature * / chaîne statique finale privée key_rsa_signature = "md5withrsa"; / ** * Définir l'algorithme de clé publique * / chaîne statique finale privée key_rsa_publickey = "rsapublicKey"; / ** * Définir l'algorithme de clé privée * / chaîne statique finale privée key_rsa_privateKey = "rsaprivateKey"; / ** * Key d'initialisation * @return * / public static map <String, object> init () {map <string, object> map = null; Try {KeyPairGenerator Generator Generator = keyPairGenerator.getInstance (key_rsa); générateur.Initialize (1024); Keypair keypair = generator.generateKeyPair (); // Public Key RsapublicKey PublicKey = (Rsapublickey) keyPair.getPublic (); // Clé privé RSAPRivateKey privateKey = (rsaprivateKey) keypair.getPrivate (); // encapsuler la clé comme map map = maps.newhashmap (); map.put (key_rsa_publickey, publicKey); map.put (key_rsa_privateKey, privateKey); } catch (NosuchalgorithMexception e) {e.printStackTrace (); } retour de la carte; } / ** * Utilisez la touche privée pour générer une signature numérique pour les informations * @param datacypted data * @param privateKey key private * @return * / public static String signe (byte [] data, string privateKey) {String str = ""; essayez {// décrypter la clé privée octet codé [] octets = decryptBase64 (privateKey); Cette // L'algorithme de chiffrement spécifié KeyFactory Factory = keyFactory.getInstance (Key_rsa); // obtient l'objet de clé privée PrivateKey Key = factory.GeneteReatePrivate (PKCS); // Utilisez la clé privée pour générer une signature numérique pour l'information signature Signature = Signature.getInstance (KEY_RSA_SIGNATURE); Signature.InitSign (clé); Signature.Update (données); str = encryptBase64 (signature.sign ()); } catch (exception e) {e.printStackTrace (); } return str; } / ** * Vérifier la signature numérique * @param Données données cryptées * @param publicKey clé publique * @param signe Signature numérique * @return vérifiez revert return true, échoué return false * / public static boolean vérifie (byte [] data, String publicKey, string signe) {booléen drapeau = false; essayez {// décrypter la clé publique octet codé [] octets = decryptBase64 (publicKey); // Construisez l'objet X509EncodedKeySpec X509EncodedKeyspec KeySpec = new x509encodedKeyspec (octets); // L'algorithme de chiffrement spécifié KeyFactory Factory = keyFactory.getInstance (Key_rsa); // Obtenez l'objet de clé publique PublicKey Key = factory.generatePublic (keySpec); // Vérifiez la signature numérique avec la signature de clé publique Signature = signature.getInstance (key_rsa_signature); Signature.Initverify (clé); Signature.Update (données); Flag = Signature.Verify (deCryptBase64 (signe)); } catch (exception e) {e.printStackTrace (); } drapeau de retour; } / ** * Clé privée Decrypt * @param Données Données chiffrées * @param clé Clé privée * @return * / public static byte [] decryptbyprivateKey (byte [] data, string key) {byte [] result = null; essayez {// décrypter l'octet de clé privée [] bytes = decryptBase64 (key); // Obtenez la clé privée PKCS8EncodedKeySpec KeySpec = new PKCS8EncodedKeyspec (octets); KeyFactory factory = keyfactory.getInstance (key_rsa); PrivateKey privateKey = factory.generateprivate (keyspec); // décryptez le chiffrement de données de données = cipher.getInstance (factory.getalgorithm ()); cipher.init (cipher.decrypt_mode, privateKey); résultat = cipher.dofinal (données); } catch (exception e) {e.printStackTrace (); } Retour Résultat; } / ** * Décription de clé privée * @Param Données Données cryptées * @param Key Clé publique * @return * / public static byte [] decryptByPublicKey (byte [] data, string key) {byte [] result = null; essayez {// décrypter l'octet de clé publique [] bytes = decryptBase64 (key); // Obtenez la clé publique x509EncodedKeySpec KeySpec = new x509encodedKeyspec (octets); KeyFactory factory = keyfactory.getInstance (key_rsa); PublicKey publicKey = factory.generatePublic (keyspec); // décryptez le chiffrement de données de données = cipher.getInstance (factory.getalgorithm ()); cipher.init (cipher.decrypt_mode, publicKey); résultat = cipher.dofinal (données); } catch (exception e) {e.printStackTrace (); } Retour Résultat; } / ** * Encryption de clé publique * @Param Données Données à crypter * @Param Key Key Public * @return * / public static octet [] EncryptByPublicKey (byte [] data, string key) {byte [] result = null; essayez {byte [] bytes = decryptBase64 (key); // Obtenez la clé publique x509EncodedKeySpec KeySpec = new x509encodedKeyspec (octets); KeyFactory factory = keyfactory.getInstance (key_rsa); PublicKey publicKey = factory.generatePublic (keyspec); // Crypt Data Cipher Cipher = Cipher.getInstance (factory.getalgorithm ()); Cipher.init (cipher.encrypt_mode, publicKey); résultat = cipher.dofinal (données); } catch (exception e) {e.printStackTrace (); } Retour Résultat; } / ** * Encryption de clé privée * @param Données à crypter * @param clé Private Key * @return * / public static byte [] EncryptByprivateKey (byte [] data, string key) {byte [] result = null; essayez {byte [] bytes = decryptBase64 (key); // Obtenez la clé privée PKCS8EncodedKeySpec KeySpec = new PKCS8EncodedKeyspec (octets); KeyFactory factory = keyfactory.getInstance (key_rsa); PrivateKey privateKey = factory.generateprivate (keyspec); // Crypt Data Cipher Cipher = Cipher.getInstance (factory.getalgorithm ()); cipher.init (cipher.encrypt_mode, privateKey); résultat = cipher.dofinal (données); } catch (exception e) {e.printStackTrace (); } Retour Résultat; } / ** * Obtenez la clé publique * @param map * @return * / public static String getPublicKey (map <string, object> map) {String str = ""; essayez {key key = (key) map.get (key_rsa_publicKey); str = encryptBase64 (key.getEncoded ()); } catch (exception e) {e.printStackTrace (); } return str; } / ** * Obtenez la clé privée * @param map * @return * / public static String getPrivateKey (map <string, object> map) {String str = ""; essayez {key key = (key) map.get (key_rsa_privateKey); str = encryptBase64 (key.getEncoded ()); } catch (exception e) {e.printStackTrace (); } return str; } / ** * Base64 Decrypt * @param key string qui doit être décrypté * @return byte array * @throws exception * / public static byte [] decryptBase64 (string key) lève exception {return (new base64decoder ()). DecodeBuffer (key); } / ** * Base64 Encryption * @Param Key Byte Array qui doit être chiffré * @return String * @throws exception * / public static String EncryptBase64 (byte [] key) lève une exception {return (new base64encoder ()). EncodeBuffer (key); } / ** * Méthode de test * @param args * / public static void main (String [] args) {String privateKey = ""; String publicKey = ""; // Générer la clé privée de la clé privée <String, objet> map = init (); publicKey = getPublicKey (carte); privateKey = getPrivateKey (map); System.out.println ("clé publique: / n / r" + publicKey); System.out.println ("clé privée: / n / r" + privateKey); System.out.println ("Encryption de clé publique -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------; EncryptByPublicKey (word.getBytes (), PublicKey); String Decword = New String (decryptByPrivate (ENCORD, PrivateKey); Cryptage ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- EncryptByPrivateKey (English.getBytes (), PrivateKey); String Denenglish = new String (decryptBypublicKey (encenglish, publicKey)); System.out.println ("Avant le chiffrement:" + anglais + "/ n / r" + "après le décryptage:" + Decsenglish); System.out.println ("Signature de clé de clé de clé privée-clé de la clé"); // Générer Signature String Sign = Sign (encenglish, privateKey); System.out.println ("signature: / r" + signe); // Vérifiez le statut booléen de signature = Vérifier (encenglish, publicKey, signe); System.out.println ("status: / r" + statut); }} Crypter et décrypter les résultats
Conclusion
En fait, un processus apparemment complexe peut être décrit dans une phrase: l'utilisation du chiffrement des clés publiques et du décryptage des clés privées, un transfert de données de la fête B à la fête A est terminé, via un cryptage de clés privés et un décryptage de clés publics, et en même temps, via la signature privée de la clé et la signature de la clé publique, un transfert de données et une vérification des données de la fête A est terminé, et deux transferts de données complètent un ensemble complet d'interactions de données.
L'émergence d'algorithmes de cryptage asymétriques est de résoudre le problème du chiffrement et du décryport d'une seule clé. Tant que cette clé est perdue ou divulguée, les données cryptées seront facilement attaquées. Dans le même temps, c'est précisément en raison de l'émergence d'algorithmes de chiffrement asymétriques que les signatures numériques, les certificats numériques, etc. ultérieurs sont obtenus.
D'accord, arrêtons ici aujourd'hui. L'article suivant poursuit le cryptage asymétrique. Quant à laquelle, je le saurai à ce moment-là. Gardez-le secret ici d'abord