Die Verschlüsselung soll die ursprünglichen Informationsdaten mit einem speziellen Algorithmus ändern, sodass ein nicht autorisierter Benutzer die verschlüsselten Informationen immer noch nicht verstehen kann, da er die Entschlüsselungsmethode nicht kennt. Es ist im Allgemeinen in eine Zwei-Wege-Verschlüsselung und eine Einwegverschlüsselung unterteilt, während die Bi-Way-Verschlüsselung in symmetrische Verschlüsselung und asymmetrische Verschlüsselung unterteilt ist (einige Materialien teilen die Verschlüsselung direkt in symmetrische Verschlüsselung und asymmetrische Verschlüsselung).
Die allgemeine Bedeutung der bidirektionalen Verschlüsselung besteht darin, nach der Klartextverschlüsselung einen Chiffretext zu bilden, der durch Algorithmen in Klartext wiederhergestellt werden kann. Die Einwegverschlüsselung führt nur eine Verdauung der Informationen durch und kann keinen einfachen Text über Algorithmen generieren. Streng genommen kann die Einwegverschlüsselung nicht als Verschlüsselungstyp angesehen werden, sondern sollte als Digest-Algorithmus angesehen werden.
Speziell:
Das System muss verfügbar sein und kann nicht nicht mathematisch dekodiert werden.
Das System muss nicht vertraulich gehalten werden und kann leicht in die Hände des Feindes fallen.
Der Schlüssel muss ohne Schreiben ausgetauscht und auswendig gelernt werden, und beide Parteien können den Schlüssel ändern.
Das System kann für Telekommunikation verwendet werden.
Das System kann Positionen übertragen, und seine Funktionen müssen erreicht werden, ohne mehrere Personen zu durchlaufen.
Das System ist einfach zu bedienen und verlangt nicht, dass der Benutzer überarbeitet wird oder viele Regeln hat.
1. Der Anbieter der Hauptverschlüsselungsmethodencode -Anbieter
JDK: Der Code befindet sich im Java -Installationsverzeichnis im Java -Installationsverzeichnis.
CC: org.apache.commons.Codec von Apache bereitgestellt
Homepage: http://commons.apache.org/proper/commons-codec/
BC: org.bouncecastle
Homepage: http://www.bouncycastle.org/java.html
Grundsätzlich ist häufig JDK ausreichend.
2. Base64 -Algorithmus
1. Nach der Komplexität des Verschlüsselungsalgorithmus nun ist Base64 peinlich zu sagen, dass es verschlüsselt ist, aber es reicht für Menschen, die Computer überhaupt nicht verstehen. Base64 -Codierung ist unlesbar, dh die codierten Daten werden von Menschen mit bloßem Auge nicht direkt gesehen.
Die Basis64 -Codierung wird im Allgemeinen für die URL -Verarbeitung verwendet oder alles, was gewöhnliche Personen auf einen Blick wissen sollen, kann mit Base64 -Codierung verarbeitet und dann im Internet veröffentlicht werden.
Paket com.amuro.strategy.base64; import Java.util.base64; Import Com.amuro.Strategy.Iistrategy; byte [] codebytes = base64.GetEnCoder (). codode (src.getBytes ()); Neue String zurückgeben (EncodeBytes); } public String decode (String src) {byte [] decodeBytes = base64.getDeCoder (). Decode (src.getBytes ()); Neue Zeichenfolge zurückgeben (DecoDebytes); }}2. Base64 Codierungstabelle
3. Message Digest Algorithmus (Message Digest)
Message Digest wird auch als Digital Digest bezeichnet. Es ist ein eindeutiger Wert, der einer festen Länge einer Nachricht oder eines Textes entspricht, und wird durch eine Einweg-Hash-Verschlüsselungsfunktion erzeugt, die auf die Nachricht wirkt. Der Konfliktresistenz der Hash -Funktion ermöglicht es einem einfachen Text, sich geringfügig zu ändern, auch wenn nur ein Buchstaben des Absatzes geändert wird, werden nach dem Hashing -Algorithmus unterschiedliche Werte generiert. Die Unidirektionalität des Hash -Algorithmus macht es unmöglich, zwei verschiedene Eingabenachrichten mit demselben Hash -Wert zu finden, das rechnerisch ist. Daher kann der Hash -Wert der Daten, dh der Nachrichtenverdauung, die Integrität der Daten überprüfen.
In einfachen Worten sollten alle Daten wie ein Mensch eindeutig sein. Was ist die eindeutige Kennung? Für Menschen sind es derzeit Fingerabdrücke und wie hoch ist der Fingerabdruck der Daten? Das ist richtig, es ist diese Zeichenfolge, die durch den Message Digest -Algorithmus generiert wird. Wenn wir beispielsweise eine Website registrieren, überträgt der Client das Kennwort, das wir an den Server eingegeben haben. Dies sollte der Inhalt nach der Verarbeitung von Message Digest sein. Auch wenn der Server unterbrochen ist, kann Hack nicht wissen, was das wahre Passwort des Benutzers ist. Es wird jedoch gesagt, dass MD5 und SHA jetzt kompromittiert wurden, sodass Sie es googeln können.
1. Md5
Paket com.amuro.strategy.message_Digest; Import Java.Security.Messagedigest; Import Java.Security.NoSuchalgorithmException; import org.apache.commons.codec.binary.hex; Md5Strategy implementiert iStrategy {public String code (String src) {try {MessagedIGest md = MessagedIGest.getInstance ("md5"); byte [] codebytes = md.Digest (src.getBytes ()); return hex.encodEhexstring (encodeBytes); } catch (nosuchalgorithmException e) {e.printstacktrace (); } return null; } public String decode (String src) {neue runTimeexception ("md5 no decode"); }}2. Sha
Paket com.amuro.strategy.message_Digest; Import Java.Security.Messagedigest; Import Java.security.NoSuchalgorithmException; Shastrategy implementiert iStrategy {public String codem (String src) {try {MessagedIGest md = MessagedIGest.getInstance ("SHA"); md.update (src.getBytes ()); return hex.encodEhexstring (md.Digest ()); } catch (nosuchalgorithmException e) {e.printstacktrace (); } return null; } public String decode (String src) {neue runTimeException ("Sha no decode"); }} 4. Symmetrische Verschlüsselung <br /> Mit der Verschlüsselungsmethode eines Kryptographiesystems mit einem Key kann derselbe Schlüssel gleichzeitig als Verschlüsselung und Entschlüsselung von Informationen verwendet werden. Diese Verschlüsselungsmethode wird als symmetrische Verschlüsselung bezeichnet, die auch als Einzelschlüsselverschlüsselung bezeichnet wird. Da sowohl Verschlüsselung als auch Entschlüsselung denselben Schlüssel verwenden, wird die Lösung des Schlüssels zum Entschlüssor ein Problem, das gelöst werden muss. Natürlich sind die Vorteile der niedrigen Sicherheit ein kleines Berechnungsvolumen, eine schnelle Verschlüsselungsgeschwindigkeit und eine hohe Verschlüsselungseffizienz.
Moderne Computer haben jedoch lange aufgehört, sich um dieses Computerniveau zu kümmern, und Sicherheit ist das Wichtigste.
1.. Des
DES, Vollständiger Name ist "Datenverschlüsselungsstandard", und sein chinesischer Name ist "Datenverschlüsselungsstandard", ein Blockalgorithmus, der die Schlüsselverschlüsselung verwendet. Der DES -Algorithmus ist ein symmetrisches kryptografisches System im kryptografischen System, das auch als amerikanischer Datenverschlüsselungsstandard bezeichnet wird. Es handelt sich um einen symmetrischen kryptografischen Systemverschlüsselungsalgorithmus, der 1972 von IBM in den USA entwickelt wurde. Der Klartext ist mit 64 Bit gruppiert, und der Schlüssel ist tatsächlich eine 56-Bit-Verschlüsselungsmethode, die am DES-Operation beteiligt ist Substitution oder ausgetauscht, um die Verschlüsselungsmethode der Ciphertext -Gruppe zu bilden.
Paket com.amuro.strategy.des; import javax.crypto.cipher; import Javax.crypto.KeyGenerator; import Javax.Crypto.secretkey; importieren javax.crypto.secretkeyfactory; com.amuro.strategy.ISTRATEGY;/** * * @Author Amuro * */Public Class Desstrategy implementiert iStrategy {private chiffher cipher; Private SecretKey GenerateKey; public String encodes (String src) {try {keyGenerator keygenerator = keygenerator.getInstance ("des"); KeyGenerator.init (56); // Größe SecretKey SecretKey = KeyGenerator.generateKey (); byte [] keyBytes = secryKey.getEncoded (); Deskeyspec Deskeyspec = new Deskeyspec (KeyBytes); SecretKeyFactory SecretKeyFactory = secryKeyFactory.getInstance ("Des"); generateKey = secryKeyFactory.generatecret (Deskeyspec); cipher = cipher.getInstance ("DES/ECB/PKCS5Padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.encodEhexstring (resultBytes); } catch (Ausnahme e) {e.printstacktrace (); } return null; } public String decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] result = hex.decodeHex (src.toarArray ()); Neue Zeichenfolge zurückgeben (cipher.dofinal (Ergebnis)); } catch (Ausnahme e) {e.printstacktrace (); } return null; }}2. 3DES3DES, auch als "Triple DES" bezeichnet, wird als "Triple Data Encryption Algorithmus" bezeichnet, was der Anwendung des DES -Verschlüsselungsalgorithmus dreimal auf jeden Datenblock entspricht. Aufgrund der erweiterten Computer-Computing-Leistung ist die Schlüssellänge des ursprünglichen DES-Kennworts leicht gezwungen geworden. 3DES ist so konzipiert, dass sie eine relativ einfache Methode bietet, um ähnliche Angriffe zu vermeiden, indem die Schlüssellänge der DES erhöht wird, anstatt einen brandneuen Block -Cipher -Algorithmus zu entwerfen.
Paket com.amuro.strategy.des; import javax.crypto.cipher; import javax.crypto.keygenerator; import Javax.crypto.secretkey; Import Javax.crypto.secretkeyfactory; org.apache.commons.codec.bary.hex; import com.amuro.strategy.Istrategy; öffentliche Klasse _3desstrategy implementiert istrategy {private chiffher chiffre; Private SecretKey GenerateKey; public String encodes (String src) {try {keyGenerator keygenerator = keygenerator.getInstance ("Desede"); KeyGenerator.init (168); // Größe SecretKey SecretKey = KeyGenerator.generateKey (); byte [] keyBytes = secryKey.getEncoded (); Desedekeyspec Deskeyspec = new Desedekeyspec (KeyBytes); SecretKeyFactory SecretKeyFactory = secryKeyFactory.getInstance ("Desede"); generateKey = secryKeyFactory.generatecret (Deskeyspec); cipher = cipher.getInstance ("Desede/ECB/PKCS5Padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.encodEhexstring (resultBytes); } catch (Ausnahme e) {e.printstacktrace (); } return null; } public String decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] result = hex.decodeHex (src.toarArray ()); Neue Zeichenfolge zurückgeben (cipher.dofinal (Ergebnis)); } catch (Ausnahme e) {e.printstacktrace (); } return null; }}3. AESAES, Vollständiger Name ist "Advanced Encryption Standard", der chinesische Name ist "Advanced Encryption Standard". Es ist auch als Rijndael -Verschlüsselungsmethode in der Kryptographie bekannt. Es handelt sich um einen Blockverschlüsselungsstandard, der von der US -Bundesregierung angenommen wurde. Als neue Generation von Datenverschlüsselungsstandards vereint der AES -Verschlüsselungsalgorithmus die Vorteile starker Sicherheit, hoher Leistung, hoher Effizienz, Benutzerfreundlichkeit und Flexibilität. Das AES -Design hat drei wichtige Längen: 128, 192, 256 Bit. Relativ gesehen ist der 128 -Schlüssel der AES 1021 -mal stärker als der 56 -Taste von DES.
Paket com.amuro.strategy.des; import javax.crypto.cipher; import Javax.crypto.KeyGenerator; Import Javax.Crypto.secretkey; Import Javax.Crypto.Spec.SecretkeScyspec; Aestrategy implementiert IStrategy {private Chiffre -Chiffre; Private SecretKey GenerateKey; public String encodes (String src) {try {keyGenerator keygenerator = keygenerator.getInstance ("aes"); KeyGenerator.init (128); // Größe SecretKey SecretKey = KeyGenerator.generateKey (); byte [] keyBytes = secryKey.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.encodEhexstring (resultBytes); } catch (Ausnahme e) {e.printstacktrace (); } return null; } public String decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] result = hex.decodeHex (src.toarArray ()); Neue Zeichenfolge zurückgeben (cipher.dofinal (Ergebnis)); } catch (Ausnahme e) {e.printstacktrace (); } return null; }} 4. PBE
PBE, der vollständige Name "Kennwortbasisverschlüsselung", ist ein kennwortbasierter Verschlüsselungsalgorithmus. Seine Eigenschaft ist, dass Kennwörter anstelle von Schlüssel verwendet werden und das Passwort vom Benutzer selbst verwaltet wird. Zufällige Zahl hasste mehrere Verschlüsselung und andere Methoden, um die Sicherheit der Daten sicherzustellen.
Der PBE -Algorithmus hat nicht das Konzept eines Schlüssels und behandelt das Kennwort als Schlüssel. Da sich die Länge des Schlüssels auf die Sicherheit des Algorithmus auswirkt und für den Speicher nicht bequem ist, ist es für uns sehr unterschiedlich, das hier verwendete Kennwort direkt zu verwenden, was für unseren Speicher geeignet ist. Einfache Passwörter sind jedoch leicht durch Wörterbuchmethoden erschöpft, sodass wir dem Passwort hier etwas "Salz" hinzugefügt haben. Diese Kombination aus Salz und Passwörtern ist schwer zu knacken. Gleichzeitig verschmelzen wir das Salz und das Passwort und iterieren mehrmals mit dem Message Digest -Algorithmus, um das Grundmaterial des Schlüsselinitialisierungsvektors zu erstellen, wodurch die Entschlüsselung noch schwieriger wird.
Paket com.amuro.strategy.pbe; import Java.Security.securerandom; Import Javax.crypto.Cipher; javax.crypto.spec.pbeparameterspec; import org.apache.commons.codec.bary.hex; import com.amuro.strategy.istrategy; Private SecretKey GenerateKey; private pbeparameterspec pbeparameterspec; public string codode (string src) {try {Securerandom Securerandom = new SecurerAndom (); byte [] salt = Securerandom.generateseed (8); String password = "Amuro"; PBekeySpec pBekeySpec = new pBekeySpec (password.therarArray ()); SecretKeyFactory SecretKeyFactory = secryKeyFactory.getInstance ("pBewithmd5anddes"); generateKey = secryKeyFactory.generateSecret (pBekeySpec); pbeparameterspec = neuer pBepparameterspec (Salz, 100); cipher = cipher.getInstance ("pBewithmd5anddes"); cipher.init (cipher.encrypt_mode, generateKey, pbeparameterspec); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.encodEhexstring (resultBytes); } catch (Ausnahme e) {e.printstacktrace (); } return null; } public String decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey, pbeparameterspec); byte [] result = hex.decodeHex (src.toarArray ()); Neue Zeichenfolge zurückgeben (cipher.dofinal (Ergebnis)); } catch (Ausnahme e) {e.printstacktrace (); } return null; }} 5. Asymmetrische Verschlüsselung <br /> Der asymmetrische Verschlüsselungsalgorithmus erfordert zwei Schlüssel zum Verschlingen und Entschlüsseln, nämlich der öffentliche Schlüssel und den privaten Schlüssel. Eine Sache zu beachten ist, dass der öffentliche Schlüssel und der private Schlüssel ein Paar sein müssen. Wenn die Daten mit dem öffentlichen Schlüssel verschlüsselt sind, kann nur der entsprechende private Schlüssel entschlüsselt und umgekehrt. Da Verschlüsselung und Entschlüsselung zwei verschiedene Schlüssel verwenden, wird dieser Algorithmus als asymmetrischer Verschlüsselungsalgorithmus bezeichnet.
1. RSA
Tatsächlich trat RSA bereits 1978 auf und war der erste Algorithmus, der sowohl für die Datenverschlüsselung als auch für digitale Signaturen verwendet werden kann. Es ist leicht zu verstehen und zu arbeiten und ist auch sehr beliebt. Das Prinzip ist wie im obigen Arbeitsprozess beschrieben. Der RSA -Algorithmus basiert auf einer sehr einfachen Zahlen -Theorie -Tatsache: Es ist einfach, zwei große Primzahlen zu multiplizieren, aber es ist äußerst schwierig, ihre Produkte zu faktorisieren, sodass das Produkt als Verschlüsselungsschlüssel offenbart werden kann.
Paket com.amuro.strategy.asymmetrisch; Import Java.security.KeyFactory; Import Java.Security.Keypair; java.security.interfaces.rsapublickey; import Java.security.spec.pkcs8EnencodedKeyspec; Import Java.Security.spec.x509EncodedkeSpec; Javax.crypto.cipher; com.amuro.strategy.Istrategy; öffentliche Klasse Rsastrategy implementiert IStrategy {private rsapublickey rsapublickey; Privat RsaprivateKey RsaprivateKey; public String encodes (String src) {try {// Key KeypairGenerator KeypairGenerator = KeypairGenerator.getInstance ("RSA"); tastypairgenerator.initialize (512); Tastatur Tastatur = Keypairgenerator.generateKeypair (); rsapublickey = (rsapublickey) keypair.getPublic (); rsaprivateKey = (rsaprivateKey) keypair.getPrivate (); // private Schlüsselverschlüsselung Public Key Decryption PKCS8EncodedKeySpec PKCS8EncodedKeySpec = NEU PKCS8ECODEDKEYSPEC (RSAPRIVATEKEY.GETECODED ()); 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 ()); // private Key Decryption Public Schlüsselverschlüsselung // x509EncodedKeySpec x509EncodedKeyspec = // Neue x509Codedkeyspec (rsapublickey.getEnoded ()); // keyfactory keyFactory keyFactory.generatePublic (x509EncodedKeyspec); // Cipher Cipher = Cipher.getInstance ("rsa"); // cipher.init (Cipher.encrypt_mode, publicKey); // byte [] resultBytes = Cipher.dofinal (src.getBytes (); return hex.encodEhexstring (resultBytes); } catch (Ausnahme e) {e.printstacktrace (); } return null; } public String decode (String src) {try {// private Schlüsselverschlüsselung public Key Decryption x509CodedKeyspec x509CodedKeySpec = new x509CodedKeyspec (rsapublickey.getEnoded ()); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); PublicKey publicKey = keyFactory.generatePublic (x509CodedKeyspec); Cipher cipher = cipher.getInstance ("rsa"); cipher.init (cipher.decrypt_mode, PublicKey); byte [] resultBytes = cipher.dofinal (hex.decodeHex (src.tocharArray ())); // Private Key Decryption Public Schlüsselverschlüsselung // PKCS8EncodedKeySpec PKCS8EncodedKeyspec // = Neue PKCS8EncodedKeySpec (rsaprivateKey.GetetEnCoded ()); // Keyfactory Keyfactory = Keyfactory keyFactory.generatePrivate(pkcs8EncodedKeySpec);// Cipher cipher = Cipher.getInstance("RSA");// cipher.init(Cipher.DECRYPT_MODE, privateKey);// byte[] resultBytes = cipher.doFinal(Hex.decodeHex(src.toCharArray())); neue Zeichenfolge zurückgeben (resultBytes); } catch (Ausnahme e) {e.printstacktrace (); } return null; }} 2. DH -Algorithmus
DH, der vollständige Name "Diffie-Hellman", ist eine Methode, um sicherzustellen, dass gemeinsame Schlüssel sicher unsichere Netzwerke überschreitet, die häufig als Schlüsselkonsensprotokoll bezeichnet wird. Eine Idee von Diffie und Hellman, den Gründern des öffentlichen Schlüsselkryptographiesystems. Einfach ausgedrückt werden zwei Benutzern ermöglicht, Informationen über öffentliche Medien auszutauschen, um "konsistente" und gemeinsam genutzbare Schlüssel zu generieren. Das heißt, Party A produziert ein Paar Schlüssel (öffentlicher Schlüssel, privater Schlüssel), und Party B generiert das Schlüsselpaar von Partei B (öffentlicher Schlüssel, privater Schlüssel) basierend auf dem öffentlichen Schlüssel der Partei A.
Wenn Sie dies als Grundlage als Grundlage für die Vertraulichkeit der Datenübertragung betrachten, verwenden beide Parteien denselben symmetrischen Verschlüsselungsalgorithmus, um einen lokalen Schlüssel (SecretKey) zu erstellen, um die Daten zu verschlüsseln. Nach dem lokalen Key (SecretKey) -Algorithmus ist interoperabel, Partei A und Party B ihre öffentlichen Schlüssel offenlegen, die Daten mit dem öffentlichen Schlüssel der anderen Partei und dem gerade generierten privaten Schlüssel verschlüsseln. Gleichzeitig können sie den öffentlichen Schlüssel der anderen Partei und ihren eigenen privaten Schlüssel verwenden, um die Daten zu entschlüsseln. Nicht nur die beiden Parteien A und B, sondern auch auf die gemeinsame Datenkommunikation mit mehreren Parteien, die die sichere Kommunikation von interaktiven Netzwerkdaten vervollständigen!
Paket com.amuro.strategy.asymmetrisch; Import Java.security.Keyfactory; Import Java.Security.Keypair; java.util.objects; import javax.crypto.cipher; import javax.crypto.keyagreement; import javax.crypto.secretkey; import javax.crypto.interfaces.dhpublicke; import Javax.crypto.spec.dhparameterspecerSpecerSpec; org.apache.commons.codec.bary.hex; import com.amuro.strategy.Istrategy; öffentliche Klasse dhstrategy implementiert istrategy {private chiffher cipher; Private SecretKey Receversecretkey; public String encodes (String src) {try {// Absender Schlüssel KeyypairGenerator SENTERKEYPAIRGENERATOR = KeypairGenerator.getInstance ("dh"); SENTERKEYPAIRGENERATOR.initialize (512); TasteTair senerkeypair = senderkeypairgenerator.generateKeypair (); PrivateschlüsselabsenderPrivateKey = senderKeypair.getPrivate (); BYTE [] SENTERPUBLICKEYBYTES = SENTERKEYPAIR.getPublic (). getCoded (); // Absenderer öffentlicher Schlüssel // Initialisieren Sie den Schlüssel des Empfängers, verwenden Sie den öffentlichen Schlüsselfaktor des Absenders. X509EncodedKeySpec x509EncodedKeySpec = new x509EncodedKeyspec (SenderpublickeyBytes); PublicKey receiverpublickey = reciverKeyFactory.generatePublic (x509EncodedKeyspec); Dhparameterspec dhparameterspec = ((dhpublickey) receiverpublickey) .getParams (); Keypairgenerator receiverKeypairgenerator = keypairgenerator.getInstance ("dh"); ReceiverKeypairGenerator.initialize (dhparameterspec); Tastirair receiverkeypair = receiverkeypairgenerator.generateKeypair (); Privateschlüsselempfänger receiverPrivateKey = receiverKeypair.getPrivate (); byte [] receiverpublickeyBytes = receiverKeypair.getPublic (). getCoded (); KeyAgreement receiverkeyAgreement = keyAgreement.getInstance ("dh"); ReceiverKeAgreement.init (ReceiverPrivateKey); receiverKeagreement.dophase (receiverpublickey, true); receiversecretkey = receiverKeyAgreement.generateSecret ("Des"); // Der Absender kann ihn verschlüsseln, indem der öffentliche Schlüssel des Empfängers erhältlich ist. KeyFactory SenderKeyFactory = KeyFactory.getInstance ("DH"); x509EncodedKeySpec = neuer x509CodedKeySpec (receiverpublickeyBytes); PublicKey SenderPublickey = SenderKeyFactory.generatePublic (x509CodedKeyspec); KEYAGREENTS SENTERKEYAGREENTION = KEYAGREENement.getInstance ("DH"); SENTERKEYAGREENTION.INIT (SENTERPRIVATEKEY); SENTERKEYAGREEMENT.DOPHASE (SENTERPUBLICKEY, TRUE); SecretKey Senderecretkey = SenderkeyAgreement if (Objects.equals (receiversecretkey, sengerecretkey)) {cipher = cipher.getInstance ("Des"); cipher.init (cipher.encrypt_mode, sengerecretkey); byte [] result = cipher.dofinal (src.getBytes ()); return hex.encodEhexstring (Ergebnis); }} catch (Ausnahme e) {e.printstacktrace (); } return null; } public String decode (String src) {try {cipher.init (cipher.decrypt_mode, receiversecretkey); byte [] result = hex.decodeHex (src.toarArray ()); Neue Zeichenfolge zurückgeben (cipher.dofinal (Ergebnis)); } catch (Ausnahme e) {e.printstacktrace (); } return null; }} 6. Asymmetrische Verschlüsselung digitaler Signaturzertifikate ist bereits sehr sicher, aber es gibt einen weiteren Fehler:
Server A veröffentlicht seinen öffentlichen Schlüssel. Mein Computer verschlüsselt die Daten mit dem öffentlichen Schlüssel von Server A und schickte sie dann an Server A. Der Server B hat in meinen Computer in meinen Computer eingedrungen und den öffentlichen Schlüssel ersetzt, mit dem ich sie mit seinem öffentlichen Schlüssel verschlüsselt habe. Wie kann man verhindern, dass der öffentliche Schlüssel manipuliert wird?
Ja, wir haben an die frühere Nachrichtenübersicht gedacht. Als Server A den öffentlichen Schlüssel zu mir warf, ging er auch zu CA, um ein digitales Zertifikat zu beantragen. Tatsächlich ist es hauptsächlich die Nachrichtenübersicht des öffentlichen Schlüssels. Wenn ich es mit dem öffentlichen Schlüssel verschlüsselt, kann ich zuerst überprüfen, ob der aktuelle öffentliche Schlüssel von Server A an mich gesendet wird.
Hier ist eine Art RSA:
Paket com.amuro.strategy.Signature; Import Java.security.KeyFactory; Import Java.Security.Keypair; Import Java.Security.Keypairgenerator; java.security.interfaces.rsaprivateKey; import Java.security.interfaces.rsapublickey; Import Java.Security.Spec.Pkcs8EncodedKeyspec; Java.Security.spec.x509EnifydecedKeysPec; try {keypairGenerator keypairgenerator = keypairgenerator.getInstance ("RSA"); tastypairgenerator.initialize (512); Tastatur Tastatur = Keypairgenerator.generateKeypair (); PublicKey rsapublickey = (rsapublickey) keypair.getPublic (); Privatekey rsaprivateKey = (rsaprivateKey) keypair.getPrivate (); PKCS8EncodedKeySpec PKCS8EnencodedKeySpec = New PKCS8EncodedKeyspec (rsaprivateKey.getEncoded ()); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); Privatekey privateKey = keyFactory.generatePrivate (PKCS8EncodedKeySpec); Signature Signatur = Signature.getInstance ("Md5Withrsa"); Signature.initsign (privatkey); Signature.Update (src.getBytes ()); // Signatur Bytes Byte Byte [] SignBytes = Signature.Sign () erzeugen; X509EncodedKeySpec x509EncodedKeySpec = new x509EncodedKeyspec (rsapublickey.getEnoDed ()); KeyFactory = KeyFactory.getInstance ("RSA"); PublicKey publicKey = keyFactory.generatePublic (x509CodedKeyspec); Signature = Signature.getInstance ("md5withrsa"); Signature.initverify (PublicKey); Signature.Update (src.getBytes ()); boolean isverified = Signature.Verify (SignBytes); Rückgabe isverified; } catch (Ausnahme e) {e.printstacktrace (); } return false; }} In Bezug auf die Verwendung von digitalen Signaturen und asymmetrischen Verschlüsselungsalgorithmen habe ich auch ein großartiges Beispiel gesehen, und ich werde es mit Ihnen teilen:
Leider habe ich diesen Monat zu viele Bücher gekauft und ich kann es erst Ende des Monats herausholen. Ich habe Clark auf QQ getroffen:
1-2-3: "Clark, ich brauche 200 Tael Silber, kann ich es mir leihen?"
Clark: "Kein Problem. Ich werde das Geld jetzt an Sie überweisen. Bitte gib mir eine IOU."
1-2-3: "Vielen Dank. Ich werde Ihnen ein IOU in Wort schreiben."
Dann habe ich ein neues Word -Dokument erstellt, die IOU geschrieben und es gespeichert. Was soll ich dann tun? Ich kann IOU aus Gründen nicht direkt an Clark senden:
1. Ich kann nicht garantieren, dass Clark nach Erhalt der IOU nicht "200 Taels Silber" in "2000 Taels Silber" wechseln wird.
2. Wenn ich die Schulden vermisse, kann Clark nicht beweisen, dass ich die IOU geschrieben habe.
3. Gewöhnliche Wortdokumente können nicht als Beweis für Klagen verwendet werden.
Glücklicherweise habe ich ein digitales Zertifikat beworben. Ich verschlüsse zuerst die IOU mit meinem privaten Schlüssel und sende dann den verschlüsselten Chiffrettext an Clark in QQ. Nachdem Clark den Chiffretext der IOU erhalten hatte, lud er meinen öffentlichen Schlüssel auf der Website des Digital Certificate Certification Center herunter und verwendete dann meinen öffentlichen Schlüssel, um den Ciphertext zu entschlüsseln. Er stellte fest, dass es tatsächlich als "200 Taels ausgeliehenes Silber" geschrieben wurde, damit Clark mir das Geld mit Zuversicht leihen konnte. Ich würde mir keine Sorgen machen, dass Clark meine IOU manipuliert würde, weil:
1. Seit dem Chiffrikett, den ich an Clark gesendet habe, kann Clark es nicht ändern. Clark kann das entschlüsselte IOU ändern, aber Clark hat meinen privaten Schlüssel nicht, sodass es mich nicht imitieren kann, die IOU zu verschlüsseln. Dies wird manipulationssicher genannt.
2. Da die IOU mit meinem privaten Schlüssel verschlüsselt sind, gibt es und nur meine öffentlichen Schlüssel, die entschlüsselt werden können. Umgekehrt muss die IOU, die mit meinem öffentlichen Schlüssel entschlüsselt werden kann, mit meinem privaten Schlüssel verschlüsselt werden, und nur ich besitze meinen privaten Schlüssel, damit Clark beweisen kann, dass dies von mir geschrieben wurde. Dies nennt man Anti-Debbt.
3. Wenn ich das Geld nicht zurückzahlen würde, verklagte mich Clark vor Gericht, und dieses mit meinem private Schlüssel verschlüsselte Wortdokument könnte als Cheng Tangs Zertifikat verwendet werden. Weil unser Land das "elektronische Unterschriftengesetz der Volksrepublik China" herausgegeben hat, das digitale Unterschriften rechtlich effektiv macht.
Sie müssen bemerkt haben, dass diese IOU, die mit meinem privaten Schlüssel verschlüsselt wurde, die Eigenschaften von Manipulationen und Anti-Debet hat und als Zertifikat von Chengtang verwendet werden kann, was die gleiche ist wie die Wirkung der "Signatur" dieser IOU. Übrigens wird der Prozess des "Verschlüsselung von IOUs mit meinem privaten Schlüssel" als digitale Signatur bezeichnet.
Dies ist ein zusammenfassender Artikel, in dem einige häufig verwendete Java -Verschlüsselungstechnologien und Core -Code hier als Referenz durch Freunde geschrieben werden.