Le chiffrement consiste à modifier les données d'information d'origine à l'aide d'un algorithme spécial, de sorte que même si un utilisateur non autorisé obtient les informations chiffrées, il ne peut toujours pas comprendre le contenu des informations car il ne connaît pas la méthode de décryptage. Il est généralement divisé en cryptage bidirectionnel et en cryptage unidirectionnel, tandis que le cryptage bifurtif est divisé en cryptage symétrique et en cryptage asymétrique (certains matériaux divisent directement le cryptage en cryptage symétrique et en cryptage asymétrique).
La signification générale du chiffrement bidirectionnel est de former un texte chiffré après le cryptage en texte clair, qui peut être restauré en texte en clair via des algorithmes. Le chiffrement unidirectionnel effectue uniquement un calcul de digestion sur les informations et ne peut pas générer du texte brut via des algorithmes. À strictement parler, le cryptage à sens unique ne peut pas être considéré comme un type de chiffrement, mais doit être considéré comme un algorithme de digest.
Spécifiquement:
Le système doit être disponible et ne peut pas être décodé de manière non mathématique.
Le système n'a pas à rester confidentiel et peut facilement tomber entre les mains de l'ennemi.
La clé doit être échangée et mémorisée sans écrire, et les deux parties peuvent modifier la clé.
Le système peut être utilisé pour les télécommunications.
Le système peut transférer des positions et ses fonctions doivent être obtenues sans passer par plusieurs personnes.
Le système est facile à utiliser et ne nécessite pas que l'utilisateur soit surmené ou dispose de nombreuses règles.
1. Le principal fournisseur de code de méthode de chiffrement
JDK: Le code est dans le package JRE / LIB / JCE.JAR dans le répertoire d'installation Java;
CC: org.apache.commons.codec fourni par Apache
Page d'accueil: http://commons.apache.org/proper/comons-codec/
BC: org.bouncecastle
Page d'accueil: http://www.bouncycastle.org/java.html
Fondamentalement, le JDK couramment utilisé est suffisant.
2. Algorithme de base64
1. À en juger par la complexité de l'algorithme de cryptage maintenant, la base64 est gênée de dire qu'elle est cryptée, mais cela suffit pour les personnes qui ne comprennent pas du tout les ordinateurs. Le codage de la base64 est illisible, c'est-à-dire que les données codées ne seront pas directement vues par les humains à l'œil nu.
Le codage de la base64 est généralement utilisé pour le traitement de l'URL, ou tout ce que vous ne voulez pas que les gens ordinaires sachent en un coup d'œil peuvent être traités avec le codage de la base64, puis affiché sur Internet.
Package com.amuro.strategy.base64; import java.util.base64; import com.amuro.strategy.istrategy; / ** * Base64 Algorithm est basé sur 64 caractères de base, et seuls ces 64 caractères sont inclus dans la chaîne encrypted * @author Amuro * * / Stratage) {la chaîne publique Src) BYTE [] EncodeBytes = Base64.GetEncoder (). Encode (src.getBytes ()); return new String (EncodeBytes); } public String Decode (String src) {byte [] decodeBytes = base64.getDeccoder (). Decode (src.getBytes ()); return new String (decodeBytes); }}2. Tableau de correspondance de codage Base64
3. Algorithme de digestion de message (DIMEST MESSAGES)
Message Digest est également appelé Digital Digest. Il s'agit d'une valeur unique correspondant à une longueur fixe d'un message ou d'un texte, et il est généré par une fonction de chiffrement de hachage à sens unique qui agit sur le message. La résistance aux conflits de la fonction de hachage permet à un texte brut de changer légèrement, même si une seule lettre du paragraphe est modifiée, différentes valeurs seront générées après l'algorithme de hachage. L'unidirectionnalité de l'algorithme de hachage rend impossible de trouver deux messages d'entrée différents avec la même valeur de hachage par calcul. Par conséquent, la valeur de hachage des données, c'est-à-dire le Message Digest, peut vérifier l'intégrité des données.
En mots clairs, toute pièce de données doit être unique comme un humain. Quel est l'identifiant unique? Pour les humains, ce sont actuellement les empreintes digitales, et quelle est l'empreinte digitale des données? C'est vrai, c'est cette chaîne générée par l'algorithme de digestion du message. Par exemple, lorsque nous enregistrons un site Web, le client transmet le mot de passe que nous avons entré au serveur, qui devrait être le contenu après le traitement du message DIMEST. Même si le serveur est rompu, Hack ne pourra pas savoir quel est le véritable mot de passe de l'utilisateur. Cependant, il est dit que MD5 et SHA ont été compromis maintenant, vous pouvez donc le rechercher sur Google.
1. MD5
Package com.amuro.strategy.message_digest; import java.security.messagedigest; import java.security.nosuchalgorithmexception; import org.apache.commons.codec.binary.hex; import com.amuro.strategy.istragy; / ** * Message digest algorithm * @author amuro * / Md5Strategy implémente istrategy {public String Encode (String src) {try {messagediGest md = MessagediGest.getInstance ("md5"); BYTE [] EncodeBytes = md.digest (src.getBytes ()); return hex.encodehexstring (EncodeBytes); } catch (NosuchalgorithMexception e) {e.printStackTrace (); } return null; } public String Decode (String src) {Throw New RuntimeException ("MD5 no Decode"); }}2. Sha
Package com.amuro.strategy.message_digest; import java.security.messagedigest; import java.security.nosuchalgorithmexception; importer org.apache.commons.codec.binary.hex; import com.amuro.strategy.istegy; / ** * hah algorithme sécurisé Shastrategy implémente Istrategy {public String Encode (String Src) {try {MessagediGest md = MessagediGest.getInstance ("sha"); md.update (src.getBytes ()); return hex.ecodehexstring (md.digest ()); } catch (NosuchalgorithMexception e) {e.printStackTrace (); } return null; } public String Decode (String src) {Throw New RuntimeException ("Sha no Decode"); }} 4. Encryption symétrique <Br /> En utilisant la méthode de chiffrement d'un système de cryptographie à clé unique, la même clé peut être utilisée que le chiffrement et le déchiffrement des informations en même temps. Cette méthode de cryptage est appelée cryptage symétrique, également connu sous le nom de cryptage à clé unique. Étant donné que le cryptage et le déchiffrement utilisent la même clé, comment passer la clé en toute sécurité au décrypteur devient un problème qui doit être résolu. Bien sûr, les avantages de la faible sécurité sont un petit volume de calcul, une vitesse de chiffrement rapide et une efficacité de cryptage élevée.
Cependant, les ordinateurs modernes ont longtemps cessé de se soucier de ce niveau d'informatique, et la sécurité est la chose la plus importante.
1. DES
DES, le nom complet est "Standard de chiffrement des données", et son nom chinois est "Standard de chiffrement des données", est un algorithme de bloc qui utilise le cryptage clé. L'algorithme DES est un système cryptographique symétrique dans le système cryptographique, également connu sous le nom de norme de chiffrement américaine. Il s'agit d'un algorithme de chiffrement symétrique du système cryptographique développé par IBM aux États-Unis en 1972. Le texte en clair est regroupé par 64 bits, et la clé est en fait une méthode de chiffrement 56 bits qui participe à l'opération DES (8e, 16, 24, 32, 40, 48, 56, 64 bits sont des bits de contrôle, de sorte que chaque clé a un nombre impaire de 1S) et le groupe 56 après le groupe est le bit de la clé a un nombre impaissant de 1S) et le 56 bits après le groupe est le bit de la clé a un nombre impaissant de 1S) et le 56 bits après le groupe est le bit de la clé a un numéro impaire de 1S) et le 56 bits après le groupe est le bic substitution ou échangée pour former la méthode de cryptage du groupe de texte chiffré.
package com.amuro.strategy.des; import javax.crypto.cipher; import javax.crypto.keygenerator; import javax.crypto.secretkey; import javax.crypto.secretkeyfactory; import javax.crypto.spe.dexpecc; importation org.apache.commons.codec.binary.hex; com.amuro.strategy.istrategy; / ** * * @author amuro * * / public class DesStrategy implémente istrategy {private Cipher Cipher; SecretKey privé Generatekey; Public String Encode (String src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("DES"); keyGenerator.init (56); // size SecretKey SecretKey = keyGenerator.GenerateKey (); Byte [] keyBytes = SecretKey.getEncoded (); DeskeySpec dekeyspec = new DeskeySpec (keyBytes); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.getInstance ("DES"); generateKey = SecretKeyFactory.GeneraSECret (Deskeyspec); cipher = cipher.getInstance ("DES / ECB / PKCS5PADDING"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.ecodehexstring (resultBytes); } catch (exception e) {e.printStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); BYTE [] result = hex.decodehex (src.tocharArray ()); return new String (cipher.dofinal (résultat)); } catch (exception e) {e.printStackTrace (); } return null; }}2. 3DES3DES, également connu sous le nom de "Triple DES", est appelé "Algorithme de cryptage Triple Data", qui équivaut à l'application de l'algorithme de cryptage DES trois fois à chaque bloc de données. En raison de la puissance de calcul informatique améliorée, la longueur de clé du mot de passe d'origine est devenu facilement forcé par brutalité; 3DES est conçu pour fournir une méthode relativement simple pour éviter des attaques similaires en augmentant la longueur clé du DES, plutôt que de concevoir un tout nouvel algorithme de chiffre d'affaires.
package com.amuro.strategy.des; importer javax.crypto.cipher; importer javax.crypto.keygenerator; import javax.crypto.secretkey; import javax.crypto.secretkeyfactory; import javax.crypto.spe.desedeypec; org.apache.commons.codec.binary.hex; import com.amuro.strategy.istrategy; classe publique _3DesStrategy implémente istrategy {Cipher privé Cipher; SecretKey privé Generatekey; Public String Encode (String src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("Deede"); keyGenerator.init (168); // taille secrète SecretKey = keyGenerator.GenerateKey (); Byte [] keyBytes = SecretKey.getEncoded (); Dedekeyspec dekeyspec = new Deedekeyspec (keyBytes); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.getInstance ("Deede"); generateKey = SecretKeyFactory.GeneraSECret (Deskeyspec); cipher = cipher.getInstance ("Deede / ecb / pkcs5padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.ecodehexstring (resultBytes); } catch (exception e) {e.printStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); BYTE [] result = hex.decodehex (src.tocharArray ()); return new String (cipher.dofinal (résultat)); } catch (exception e) {e.printStackTrace (); } return null; }}3. Aesaes, le nom complet est "Advanced Encryption Standard", le nom chinois est "Advanced Encryption Standard". Il est également connu sous le nom de méthode de cryptage Rijndael en cryptographie. Il s'agit d'une norme de chiffrement en bloc adoptée par le gouvernement fédéral américain. En tant que nouvelle génération de normes de chiffrement des données, l'algorithme de cryptage AES rassemble les avantages d'une forte sécurité, d'une haute performance, d'une grande efficacité, d'une facilité d'utilisation et d'une flexibilité. La conception AES a trois longueurs clés: 128, 192, 256 bits. Relativement parlant, la clé 128 des AES est 1021 fois plus forte que la clé 56 de DES.
Package com.amuro.strategy.des; import javax.crypto.cipher; import javax.crypto.keygenerator; import javax.crypto.secretkey; import javax.crypto.spec.secretKeyspec; import org.apache.comons.codec.binary.hex; import com.amuro.strategy. AesStrategy implémente Istrategy {Cipher privé Cipher; SecretKey privé Generatekey; Public String Encode (String src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("aes"); KeyGenerator.Init (128); // Size SecretKey SecretKey = KeyGenerator.GenerateKey (); Byte [] keyBytes = SecretKey.getEncoded (); generateKey = new SecretKeyspec (KeyBytes, "AES"); cipher = cipher.getInstance ("aes / ecb / pkcs5padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.ecodehexstring (resultBytes); } catch (exception e) {e.printStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); BYTE [] result = hex.decodehex (src.tocharArray ()); return new String (cipher.dofinal (résultat)); } catch (exception e) {e.printStackTrace (); } return null; }} 4. PBE
PBE, nom complet "Encryption de base de mot de passe", est un algorithme de cryptage basé sur un mot de passe. Sa caractéristique est que les mots de passe sont utilisés à la place des clés, et le mot de passe est géré par l'utilisateur lui-même. Le nombre aléatoire a hachait le chiffrement multiple et d'autres méthodes pour assurer la sécurité des données.
L'algorithme PBE n'a pas le concept d'une clé et traite le mot de passe comme une clé. Étant donné que la longueur de la clé affecte la sécurité de l'algorithme et n'est pas pratique pour la mémoire, il est très différent pour nous d'utiliser directement le mot de passe que nous utilisons ici, ce qui est pratique pour notre mémoire. Cependant, les mots de passe simples sont facilement épuisés par les méthodes de dictionnaire, nous avons donc ajouté du "sel" au mot de passe ici. Cette combinaison de sel et de mots de passe est difficile à casser. Dans le même temps, nous fusions le sel et le mot de passe et itérons à plusieurs reprises avec l'algorithme de digestion de message pour créer le matériel de base du vecteur d'initialisation clé, ce qui rend le déchiffrement encore plus difficile.
Package com.amuro.strategy.pbe; import java.security.securerAndom; import javax.crypto.cipher; import javax.crypto.secretkey; import javax.crypto.secretkey; import javax.crypto.secrekeyfactory; importer javax.crypto.Spec.pbekeyspec; javax.crypto.spe.pbeparameterspec; import org.apache.commons.codec.binary.hex; import com.amuro.strategy.istrategy; / ** * Encryption basé sur le mot de passe (mot de passe), symétrie + digest de message * @author AMURO * * / Classe publique Pbestrategy implémente isTrategy {privily Cipher; SecretKey privé Generatekey; PBEPARAMETERSPEC privé PBEPARAMETERSPEC; Encode de chaîne publique (String Src) {try {SecureRandom SecureRandom = new SecureRandom (); octet [] Salt = SecureRandom.Generateseed (8); Chaîne mot de passe = "amuro"; PBekeyspec pBekeyspec = new pbekeyspec (mot de passe.toCharArray ()); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.getInstance ("PBEWITHMD5andDES"); generateKey = SecretKeyFactory.GeneraSECret (pBekeySpec); PBEPARAMETERSPEC = NOUVEAU PBEPPARAMETERSPEC (SALT, 100); cipher = cipher.getInstance ("pBewithmd5anddes"); cipher.init (cipher.encrypt_mode, generatekey, pbeParameterspec); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.ecodehexstring (resultBytes); } catch (exception e) {e.printStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey, pbeParametersPec); BYTE [] result = hex.decodehex (src.tocharArray ()); return new String (cipher.dofinal (résultat)); } catch (exception e) {e.printStackTrace (); } return null; }} 5. Encryption asymétrique <Br /> 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.
1. 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.
package com.amuro.strategy.asymmetric; import java.security.keyfactory; import java.security.keypair; import java.security.keypairgenerator; import java.security.privatekey; import java.security.publickey; import java.security.interfaces.rsaprivatekey; java.security.interfaces.rsapublickey; import java.security.spe.pkcs8encodedkeypec; import java.security.spec.x509encodedKeyspec; import javax.crypto.cipher; import org.apache.commons.codec.binary.hex; import com.amuro.straty. La classe RSastrategy implémente Istrategy {private rsapublickey rsapublickey; RSAPRivatekey privé RSAPRivatekey; Public String Encode (String src) {try {// Initialize Key KeyPAirGenerator KeyPArGenerator = KeyPairGenerator.getInstance ("RSA"); KeyPairGenerator.Initialize (512); Keypair keypair = keypairgenerator.generateKeypair (); rsapublicKey = (rsapublickey) keypair.getPublic (); rsaprivateKey = (rsaprivateKey) keypair.getPrivate (); // Clé privé Encryption Décryptage de clé publique PKCS8EncodedKeyspec PKCS8EncodedKeyspec = new PKCS8EncodedKeyspec (rsaprivateKey.getencoded ()); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); PrivateKey privateKey = keyfactory.generatePrivate (pkcs8encodedKeyspec); Cipher Cipher = Cipher.getInstance ("RSA"); cipher.init (cipher.encrypt_mode, privateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); // Décryption de clé privée Encryption de clé publique // x509EncodedKeyspec X509EncodedKeyspec = // new x509EncodedKeyspec (rsapublickey.getEncoded ()); // keyFactory KeyFactory = KeyFactory.getInstance ("RSA"); // public publicKey = keyfactory.generatePublic (x509encodedKeyspec); // cipher cipher = cipher.getInstance ("rsa"); // cipher.init (cipher.encrypt_mode, publicKey); // by [] resultBytes = cipher.dofinal (src.getbytes ()); return hex.ecodehexstring (resultBytes); } catch (exception e) {e.printStackTrace (); } return null; } public String Decode (String src) {try {// Clé privé Encryption de clé de clé publique x509EncodedKeyspec x509EncodedKeyspec = new x509encodedkeyspec (rsapublickey.getEncoded ()); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); PublicKey publicKey = keyFactory.GenateRedPublic (x509encodedKeyspec); Cipher Cipher = Cipher.getInstance ("RSA"); cipher.init (cipher.decrypt_mode, publicKey); octet [] resultBytes = cipher.dofinal (hex.decodehex (src.tocharArray ())); // Décryption de clé privée Encryption de clé publique // pkcs8encodedkeyspec pkcs8encodedkeyspec // = new pkcs8encodedkeyspec (rsaprivatekey.getEncoded ()); // keyfactory keyfactory = keyfactory.getinstance ("rsa"); // privateKey = privateKey = keyfactory.generateprivate (pkcs8encodedKeyspec); // cipher cipher = cipher.getinstance ("rsa"); // cipher.init (cipher.decrypt_mode, privateKey); // byte [] resultBytes = cipher.Dofinal (hex.deCodeHex (src.tocarray); return new String (resultBytes); } catch (exception e) {e.printStackTrace (); } return null; }} 2. Algorithme DH
DH, nom complet "Diffie-Hellman", est une méthode pour garantir que la clé partagée traverse en toute sécurité les réseaux dangereux, qui est souvent appelé le protocole de consensus clé. Une idée proposée par Diffie et Hellman, les fondateurs du Public Key Cryptography System. En termes simples, il s'agit de permettre à deux utilisateurs d'échanger des informations sur les médias publics pour générer des clés "cohérentes" et partageables. Autrement dit, Party A produit une paire de clés (clé publique, clé privée), et la fête B génère la paire de clés de la fête B (clé publique, clé privée) basée sur la clé publique de la fête A.
En prenant cela comme référence comme base de la confidentialité de la transmission des données, les deux parties utilisent le même algorithme de chiffrement symétrique pour construire une clé locale (SecretKey) pour crypter les données. De cette façon, après que l'algorithme de clé locale (SecretKey) soit interopérable, la fête A et le parti B divulguent leurs clés publiques, cryptent les données utilisant la clé publique de l'autre partie et la clé privée qui vient d'être générée, et en même temps, ils peuvent utiliser la clé publique de l'autre partie et leur propre clé privée pour décrypter les données. Non seulement les deux parties A et B, elles peuvent être étendues à la communication de données partagées multipartites, qui complète la communication sécurisée des données interactives du réseau!
Package com.amuro.strategy.asymmetric; import java.security.keyfactory; import java.security.keypair; import java.security.keypairgenerator; import java.security.privatekey; import java.security.publickey; import java.security.pec.x509enducedkeyedkey java.util.objects; importer javax.crypto.cipher; import javax.crypto.keyagrement; import javax.crypto.secretkey; importer javax.crypto.interfaces.dhpublickey; importer javax.crypto.spe.dhparameterspec; org.apache.commons.codec.binary.hex; import com.amuro.strategy.istrategy; public class dhstrategy implémente istrategy {Cipher privé Cipher; Private SecretKey Receiversecretkey; Public String Encode (String Src) {try {// Initialize Key KeyPAirGenerator SenderKeyPairGenerator = KeyPairGenerator.getInstance ("DH"); SenderKeyPairGenerator.Initialize (512); KeyPair SenderKeyPair = SenderKeyPairGenerator.GenerateKeyPair (); PrivateKey SenderPrivateKey = SenderKeyPair.getPrivate (); BYTE [] SENDERPUBLICKEYBYTES = SENDERKEYPAIR.GETPUBLIC (). GetEncoded (); // Sender's Public Key // Initialisez la clé du récepteur, utilisez la clé publique de l'expéditeur KeyFactory ReceiverKeyFactory = KeyFactory.getInstance ("DH"); X509EncodedKeyspec X509EncodedKeyspec = new x509EncodedKeyspec (SenderPublicKeyBytes); PublicKey ReceiverPublicKey = ReceiverKeyFactory.generatePublic (x509EncodedKeyspec); DhParameterspec dhParameterspec = ((dhpublickey) receiverPublicKey) .getParams (); KeyPairGenerator ReceiverKeyPairGenerator = KeyPairGenerator.getInstance ("DH"); ReceiverKeyPairGenerator.Initialize (dhParameterspec); KeyPair ReceiverKeyPair = ReceiverKeyPairGenerator.GenerateKeyPair (); Privatekey receiverPrivateKey = receiverKeypair.getPrivate (); octet [] receiverPublicKeyBytes = receiverKeyPair.getPublic (). getEncoded (); KeyAgrement ReceiverKeyAgrement = keyAgrement.getInstance ("DH"); ReceiverKeyAgrement.Init (ReceiverPrivateKey); ReceiverKeyAgrement.dophase (ReceiverPublicKey, True); receiversECretKey = receiverKeyAgrement.GenerateSecret ("DES"); // l'expéditeur peut le crypter en obtenant la clé publique du récepteur. KeyFactory SenderKeyFactory = keyFactory.getInstance ("dh"); x509EncodedKeyspec = new x509encodedKeyspec (receverPublicKeyBytes); PublicKey SenderPublicKey = SenderKeyFactory.GenateRedPublic (x509EncodedKeyspec); KeyAgrement SenderKeyAgrement = keyagrement.getInstance ("dh"); SenderKeyAgrement.Init (SenderPrivateKey); SenderKeyAgrement.dophase (SenderPublicKey, true); SecretKey SendersECretKey = SenderKeyAgrement.GenerateSecret ("DES"); if (objets.equals (receiversECRETKEY, SENDERSECRETKEY)) {cipher = cipher.getInstance ("DES"); cipher.init (cipher.encrypt_mode, SendersecretKey); BYTE [] result = cipher.dofinal (src.getBytes ()); return hex.encodehexstring (résultat); }} catch (exception e) {e.printStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, receiversecretKey); BYTE [] result = hex.decodehex (src.tocharArray ()); return new String (cipher.dofinal (résultat)); } catch (exception e) {e.printStackTrace (); } return null; }} 6. Le cryptage asymétrique des certificats de signature numérique est déjà très sûr, mais il y a un autre défaut:
Serveur A a publié sa clé publique. Mon ordinateur a chiffré les données avec la clé publique du serveur A, puis l'a envoyée au serveur A. Pour le moment, le serveur B a envahi mon ordinateur et a remplacé la clé publique que j'ai utilisée pour la crypter avec sa clé publique, de sorte que les données que j'ai envoyées seraient craquées par la clé privée du serveur B. Comment empêcher la clé publique d'être falsifiée?
Oui, nous avons pensé au résumé du message précédent. Lorsque le serveur a jeté la clé publique pour moi, il est également allé en Californie pour demander un certificat numérique. En fait, c'est principalement le résumé du message de la clé publique. Avec ce certificat, lorsque je le crypte avec la clé publique, je peux d'abord vérifier si la clé publique actuelle a été confirmée pour m'avoir été envoyée par le serveur A.
Voici une sorte de RSA:
package com.amuro.strategy.signature; import java.security.keyfactory; import java.security.keypair; import java.security.keypairgenerator; import java.security.privatekey; import java.securit java.security.interfaces.rsaprivateKey; import java.security.interfaces.rsapublickey; import java.security.spec.pkcs8encodedkeypec; import java.security KeyPAirGenerator KeyPAirGenerator = KeyPainerator.getInstance ("RSA"); KeyPairGenerator.Initialize (512); Keypair keypair = keypairgenerator.generateKeypair (); Publickey rsapublickey = (rsapublickey) keypair.getPublic (); PrivateKey rsaprivateKey = (rsaprivateKey) keypair.getPrivate (); Pkcs8EncodedKeyspec pkcs8encodedKeyspec = new pkcs8encodedKeyspec (rsaprivateKey.getEncoded ()); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); PrivateKey privateKey = keyfactory.generatePrivate (pkcs8encodedKeyspec); Signature signature = signature.getInstance ("md5withrsa"); Signature.InitSign (PrivateKey); Signature.update (src.getBytes ()); // générer des octets de signature octets byte [] signytes = signature.sign (); X509EncodedKeyspec X509EncodedKeyspec = new x509EncodedKeyspec (rsapublicKey.GetEncoded ()); keyFactory = keyFactory.getInstance ("RSA"); PublicKey publicKey = keyFactory.GenateRedPublic (x509encodedKeyspec); signature = signature.getInstance ("md5withrsa"); Signature.Initverify (publicKey); Signature.update (src.getBytes ()); booléen isverified = signature.verify (signytes); retour isverified; } catch (exception e) {e.printStackTrace (); } return false; }} En ce qui concerne l'utilisation des signatures numériques et des algorithmes de chiffrement asymétriques, j'ai également vu un excellent exemple, et je le partagerai avec vous:
Hélas, j'ai acheté trop de livres ce mois-ci et je ne peux pas le sortir jusqu'à la fin du mois. J'ai rencontré Clark sur QQ:
1-2-3: "Clark, j'ai besoin de 200 Tael Silver, puis-je me le prêter?"
CLARK: "Pas de problème. Je vais vous transférer l'argent maintenant. S'il vous plaît, donnez-moi un iou."
1-2-3: "Merci beaucoup. Je vais vous écrire un iou en parole."
Ensuite, j'ai créé un nouveau document Word, écrit l'IOU et l'ai enregistré. Alors, que dois-je faire? Je ne peux pas envoyer IOU directement à Clark pour des raisons:
1. Je ne peux pas garantir que Clark ne changera pas "200 Taels of Silver" à "2000 Taels of Silver" après avoir reçu l'IOU.
2. Si la dette me manque, Clark ne peut pas prouver que j'ai écrit l'IOU.
3. Les documents de mots ordinaires ne peuvent pas être utilisés comme preuve de poursuites.
Heureusement, j'ai demandé un certificat numérique. Je crypte d'abord l'IOU avec ma clé privée, puis envoie le texte chiffré chiffré à Clark en qq. Après que Clark ait reçu le texte chiffré de l'IOU, il a téléchargé ma clé publique sur le site Web du Digital Certificate Certification Center, puis a utilisé ma clé publique pour décrypter le texte chiffré. Il a constaté qu'il était en effet écrit comme "200 Taels of Emprunted Silver", afin que Clark puisse me donner l'argent avec confiance. Je ne m'inquiéterais pas que Clark falsifie mon iou, parce que:
1. Depuis le texte chiffré que j'ai envoyé à Clark, Clark ne peut pas le modifier. Clark peut modifier le IOU décrypté, mais Clark n'a pas ma clé privée, donc elle ne peut pas m'imiter en cryptage de l'IOU. C'est ce qu'on appelle le sabotage.
2. Depuis que l'IOU a crypté avec ma clé privée, il y a et seulement mes clés publiques qui peuvent être décryptées. À l'inverse, l'IOU qui peut être décryptée avec ma clé publique doit être cryptée avec ma clé privée, et seulement je possède ma clé privée, afin que Clark puisse prouver que ce iou a été écrit par moi. C'est ce qu'on appelle l'anti-dette.
3. Si je n'arrêtais pas de rembourser l'argent, Clark m'a poursuivi devant le tribunal, et ce document de mots crypté avec ma clé privée pourrait être utilisé comme certificat de Cheng Tang. Parce que notre pays a publié la «loi sur la signature électronique de la République populaire de Chine», ce qui rend les signatures numériques légalement efficaces.
Vous devez avoir remarqué que cet IOU qui a été crypté avec ma clé privée a les caractéristiques de la falsification et de l'anti-dette, et peut être utilisé comme certificat de Chengtang, qui est le même que l'effet de "signature" ce iou. Soit dit en passant, le processus de «crypter Ious avec ma clé privée» est appelé signature numérique.
Il s'agit d'un article sommaire, qui écrit certaines technologies de cryptage Java couramment utilisées ici pour référence par des amis.