Datenverschlüsselung und Entschlüsselung mit RSA -öffentlichen und privaten Schlüssel, die von OpenSSL in Java generiert wurden
Was ist RSA: Der RSA Public Key -Verschlüsselungsalgorithmus wurde 1977 von Ron Rivest, Adi Shamirh und Len Adleman unter (Massachusetts Institute of Technology) entwickelt. RSA -Benennung kommt von den Namen, die die drei entwickeln. RSA ist derzeit der einflussreichste öffentliche Schlüsselverschlüsselungsalgorithmus. Es ist in der Lage, allen bisher bekannten kryptografischen Angriffen zu widerstehen, und wurde von ISO als öffentliche Schlüsselverschlüsselungsstandard für Daten empfohlen. Gegenwärtig wird diese Verschlüsselungsmethode häufig für Online -Banking, digitale Signaturen und andere Anlässe verwendet. Der RSA -Algorithmus basiert auf einer sehr einfachen Zahlen -Theorie -Tatsache: Es ist sehr einfach, zwei große Primzahlen zu multiplizieren, aber es war zu diesem Zeitpunkt äußerst schwierig, das Produkt zu faktorisieren, sodass das Produkt als Verschlüsselungsschlüssel bekannt gegeben werden kann.
Was ist OpenSSL: zahlreiche kryptografische Algorithmen, öffentliche Schlüsselinfrastrukturstandards und SSL -Protokolle und möglicherweise diese interessanten Merkmale geben Ihnen die Idee, all diese Algorithmen und Standards implementieren. Wenn ja, kann ich bei der Ausdruck Ihrer Bewunderung immer noch nicht anders, als Sie daran zu erinnern: Dies ist ein entmutigender Prozess. Diese Arbeit ist nicht mehr so einfach wie das Lesen einiger Kryptographie -Monographien und Protokolldokumente, sondern das Verständnis jedes Details all dieser Algorithmen, Standards und Protokolldokumente sowie die Implementierung dieser Definitionen und Prozesse einzeln mit C -Zeichen, mit denen Sie vertraut sind. Wir wissen nicht, wie viel Zeit Sie für diesen lustigen und schrecklichen Job müssen, aber es ist sicherlich kein oder zwei Jahre. OpenSSL ist eine Algorithmussammlung, die seit 1995 viele Sicherheitsalgorithmen kombiniert, die von zwei großen Männern, Eric A. Young und Tim J. Hudson, verfasst wurden. Durch Befehle oder Entwicklungsbibliotheken können wir problemlos Standard -Anwendungen für öffentliche Algorithmus implementieren.
Einer meiner hypothetischen Anwendungshintergrund:
Mit der Popularität des mobilen Internets entstehen Anwendungen, die für mobile Geräte entwickelt wurden, nacheinander. Diese Anwendungen werden häufig von den Funktionen für Benutzerregistrierung und Kennwortüberprüfung begleitet. Die Sicherheit in Bezug auf "Netzwerkübertragung" und "Anwendungsprotokollzugriff" besteht versteckte Gefahren. Passwörter sind sensible Daten für Benutzer, und Entwickler müssen Sicherheitsvorkehrungen treffen, bevor die Anwendung gestartet wird. Eine unsachgemäße Handhabung kann zu Problemen wie böswilligen Angriffen durch Unternehmensbewerber und Rechtsstreitigkeiten durch Partner von Drittanbietern führen.
Obwohl RSA -Algorithmen so viele Vorteile haben, gibt es im Internet kein vollständiges Beispiel, um zu veranschaulichen, wie man sie betreibt. Lassen Sie es mich unten vorstellen:
1. Verwenden Sie OpenSSL, um private und öffentliche Schlüssel zu generieren
Ich verwende ein Linux -System und lasse das OpenSSL -Paket installieren. Bitte überprüfen Sie, dass OpenSL auf Ihrem Computer installiert ist. Die folgenden Informationen sollten beim Ausführen des Befehls angezeigt werden:
[root@chaijunkun ~]# openssl version -a OpenSSL 1.0.0-fips 29 Mar 2010 built on: Wed Jan 25 02:17:15 GMT 2012 platform: linux-x86_64 options: bn(64,64) md2(int) rc4(16x,int) des(idx,cisc,16,int) blowfish(idx) compiler: gcc -fPIC -Dopensl_pic -dzlib -dopensl_threads -d_reentrant -ddso_dlfcn -dhave_dlfcn_h -dkrb5_Mit -m64 -dl_endian -dtermio -Wall -o2 -pip -Wall -Wall -Wall -Wall -Wall -wp, --Dl_endian -Dtermio = 2 -fexces -Fexces -Fexces -Fexces -Fexces -Fexces -Fexcectoction -Fexcectoction -Fexcectocr. --param=ssp-buffer-size=4 -m64 -mtune=generic -Wa,-noexecstack -DMD32_REG_T=int -DOPENSSL_IA32_SSE2 -DOPENSSL_BN_ASM_MONT -DSHA1_ASM -DSHA256_ASM -DSHA512_ASM -DMD5_ASM -DAES_ASM -Dwhirlpool_asm OpenSSLDIR: "/etc/pki/tls" Motoren: Aesni Dynamic
Generieren Sie zuerst den privaten Schlüssel:
[root@chaijunkun ~]# OpenSSL Genrsa -out rsa_private_key.pem 1024 Generierung von RSA Private Key, 1024 Bit -Long Modulus .................. ++++++ .. +++++++ I ist 65537 (0x10001).
Dieser Befehl ermöglicht es OpenSSL, zufällig einen privaten Schlüssel zu generieren, und die Verschlüsselungslänge beträgt 1024 Bit. Die verschlüsselte Länge bezieht sich auf die theoretische Grenze der maximal zulässigen "verschlüsselten Informationslänge", dh die Längengrenze des einfachen Textes. Mit zunehmender Parameter (z. B. 2048) erhöht sich auch die erlaubte Klartextlänge, führt jedoch auch zu einer raschen Zunahme der Complexität. Die empfohlene Länge beträgt 1024 Bit (128 Bytes).
Schauen wir uns den Inhalt des privaten Schlüssels an:
[root@chaijunkun ~]# cat rsa_private_key.pem ----- starten rsa private key ----- MCYDT1XR/T2AHGOIXNQ5V8W4icaaaenawi7ajarhtvx1uoh/2U378fSceseg8XDQ LL0GCFB1/TJKI2AITVSZXOTRS8KYGU78F7VMDNGXILK3GDHNZH+UUEQYWIDAQAB AoGAaeKk76CSsp7k90mwyWP18GhLZru+vEhfT9BpV67cGLg1owFbntFYQSPVsTFm U2lWn5HD/IcV+EGaj4fOLXdM43Kt4wyznoABSZCKKxs6uRciu8nQaFNUy4xVeOfX PHU2TE7VI4LDKW9DF1FYA+DSCSLNADAUN3OHB5JQGL+LS5ECQQQDUFUXXN3UQGYKK ZNRKJ0J6PY27HRFROMEHGXBJNNAPCQ71SZJQAM77R3WILKFH935OIV0AQC4JQAM7R3W935OIV0AQC4JQAM7R3W935OIV0AQC4JQRB4 IHYSll9LAKEAWGH4JXXXXEIAUFMSGJOI3QPJQGVUMKX0W96MCPCWV3FSEW7W1/MSI SUTKJP5BBVJFVFWFMAHYLJDP7W+NebwkbwjayBz/EBVFW5NAZA4PXVXVR5VMCD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8CD8Cd8CD8Cd8CD8Cd8CD8Cd8Cd8Cd8cd8cd8c EGPLWSJI/MKHRB484XZ2VYUICIWYWNMFXPA3YDGQWSKQDGY3RRL9LV8/AQJACJLI IFIGUR ++ NJXA8C4XY0CZSOBJ710WDE1MPGR5WGQF1TR5WGQF1T+P+BCPJK4K4WGMPGR5WGQF1T+P+BCPJK4K4WGMPGGR5WGQF1T+P+P+BCPJK4WDE1MPGR5WGQF1TR5WGQF1TR5WGQF1TR5WGQF1TREI /ybxbd16qvixjvnt6qjabli6zx9gyrwnu6akpdahd8qjwonnnfnlqhue4Wepevkm cysg+ibs2ggSxntrzlwjlfx7vHmpqntc8ynmx1kfw == ------- endrsa ------ ----- ------Fell-enden
Die Inhalte sind alle Standard -ASCII -Zeichen mit offensichtlichen Markierungen am Anfang und den Endzeilen, und die realen privaten Schlüsseldaten sind unregelmäßige Zeichen in der Mitte.
Ergänzung am 24. März 2015: Die Schlüsseldatei speichert die Daten schließlich über die Base64 -Codierung. Sie können sehen, dass die Länge jeder Zeile des obigen Schlüsseldateiinhalts sehr regelmäßig ist. Dies ist auf die Bestimmungen in RFC2045 zurückzuführen: Der codierte Ausgangsstrom muss in Zeilen von jeweils nicht mehr als 76 Zeichen dargestellt werden. Das heißt, die von Base64 codierten Daten werden 76 Zeichen pro Zeile nicht überschreiten und müssen durch Zeile für ultra-lange Daten geteilt werden.
Generieren Sie als nächstes den öffentlichen Schlüssel basierend auf dem privaten Schlüssel:
[root@chaijunkun ~]# openssl rsa -in rsa_private_key.pem -out rsa_public_key.pem -pubout RSA Key schreiben
Schauen wir uns den Inhalt des öffentlichen Schlüssels an:
[root@chaijunkun ~]# cat rsa_public_ley.pem ----- public key beginnen /Umxx2jk6qeen69t6n2r1i/lmcydt1xr/t2ahgoixnq5v8w4icaaenawi7ajarht vx1uoh/2U378FSCEENG8XDQLL0GCFB1/TJKI2AITVSZXOTRS8KYGRS8KYGRS8KYGRS8KYGRS8KU78F7VMDNGS8KYGRS8KYGRS8KYGRS8KYGRS8KEGRS8KU78F7VMDNGS8KYGRS8KEGRS8KEGRS8KE Xilk3gdhnzh+uoeqywidaqab ---- Ende öffentlicher Schlüssel ----
Zu diesem Zeitpunkt kann der private Schlüssel nicht direkt verwendet werden, sodass PKCS#8 -Codierung erforderlich ist:
[root@chaijunkun ~]# openssl pkcs8 -topk8 -in rsa_private_key.pem -out pkcs8_rsa_private_key.pem -nocrypt
Der Befehl zeigt an, dass die private Schlüsseldatei in der Eingabe rsa_private_key.pem und die private Schlüsseldatei aus der Ausgabe von PKCS8_RSA_PRIVATE_KEE.PEM ist und keine sekundäre Verschlüsselung verwendet wird (-Nocrypt)
Schauen wir uns an, ob sich die codierte private Schlüsseldatei von der vorherigen privaten Schlüsseldatei unterscheidet:
[root@chaijunkun ~]# cat pkcs8_rsa_private_key.pem
------ private Schlüssel beginnen ----- 1RCLTOLPGG1XHW44F/ZTFVX+XWQRIQBXCOQWXQYJ8HX9OMOJZQK1VLNC61GZYRIA ZTVX/TWYM2BCIWTEB2GFOH66GRDLAGMBAACYBP4QTVOJKYNUTVOJKYNUT3SBDJYBP4QTVOJKYNUT3SBDJY/· XwaaaCGyB4QTvojkynut3Sbdjybp4qTvojkynut3Sbdjy/teufe u768Sf9p0glxrtwyudwjavue0VHBI9WXMWZTAVAFKCP8HXX4QZQPH84TD0ZJCQ3J DLOEGAFJKiRGQ5FYK7YDBOU1TLJFV4C8DTZQUM MBQ3C4ChMOOYV4UZKQJBANR+7FC3E6OZGQTOSQPSPQLJBSDF9E4X4EDFUOCCKJ DVVLOOAAZVHFAIUP+H3FK4HXRPALINBEHIIDHIUCQQDCCHFD4GCC58YYCMM 6LEQKMOA+6YPFRB3OXYKLBXCWX7DTBX+AYKY5OQMNKEG+MW8XB8WADIUL0/TB6CQ FARVAKBHVP94HK0DMDINFVHLWYJ3XYPONGSA8VCYMJ+ASGTVJZJABJABJABJABJABJABJAGIGJBJAJFJFJFJFJFJFJFJFJFJBJBJAJBJAJABJABJBJBJABJABJABHK 2Z9EKDFIobBAWQP2DLDGUX2VXZ8BAKBYMUIH+KBSV76CNEDWLHFLQJLKGENVQTVX TB0TUW8AVLABAXW34/5SI+NUB1HMBGYTK/IFCEPXPXPBWWLGO+E3PAKAGAGAGWLPNH0ZH FAE7OAQKMAD3XCNY6EC180TAE57HZ6KS+SYLKWB4GGZYACXC22VMTYKSXHTUEAMO 1NMLZI2ZFUOX ----- END Privatschlüssel -----
Zu diesem Zeitpunkt wurden die verfügbaren Schlüsselpaare generiert. Der Privatschlüssel verwendet PKCS8_RSA_PRIVATE_KEY.PEM, und der öffentliche Schlüssel verwendet rsa_public_key.pem.
Am 20. Mai 2014 hinzugefügt: Kürzlich habe ich die Notwendigkeit einer RSA -Verschlüsselung gestoßen, und die andere Partei verlangte, dass sie nur die private Schlüsseldatei verwenden konnten, die nicht von PKCS#8 codiert wurde, die im ersten Schritt generiert wurden. Später überprüfte ich die entsprechenden Dokumente und erfuhr, dass die im erste Schritt generierte private Tastendatei das PKCS#1 -Format ist. Dieses Format wird tatsächlich von Java unterstützt, aber ich schreibe nur zwei weitere Codezeilen:
RsaprivateKeystructure Asn1privkey = new rsaprivateKeyStructure ((Asn1sequence) Asn1sequence.FromByTearray (prikeydata)); RsaprivateKeyspec rsaprivkeyspec = new rsaprivateKeyspec (Asn1privkey.getModulus (), Asn1privkey.getPrivateExponent ()); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); Privatekey priikey = keyFactory.generatePrivate (rsaprivkeyspec); Lesen Sie zuerst die private Schlüsseldatei von PKCS#1 vor (beachten Sie, dass Sie den Kommentarinhalt zu Beginn des Minus -Zeichens entfernen) und verwenden Sie dann Base64, um die Lesezeichenfolge zu dekodieren, um PrikeyData zu erhalten, der Parameter in der ersten Codezeile. Die letzte Zeile erhält den privaten Schlüssel. Es gibt keinen Unterschied in der nächsten Verwendung.
Referenzen: https://community.oracle.com/thread/1529240?start=0&tstart=0
2. Schreiben Sie Java -Code, um ihn zu testen
Ergänzende 23. Februar 2012: Der Standard -JDK ist nur im JCE (JCE (JCE (JAVA Cryptography Extension)) ein Satz von Paketen, die Frameworks und Implementierungen für Verschlüsselung, Schlüsselgenerierung und Verhandlungen sowie Verhandlungen und Messyauthentifizierungscode (MAC) -Angorithmen und -störungen und -Symmetrie- und Streams und Streams und Streams und Streams, Sochetricy, Asymmetry, Asymmetry, Asymmetry, Asymmetry, Block- und Block- und -stream- und -Symmetrie- und -block- und -block- und -block- und -block- und -block- und -block- und -block- und -Symmetrie- und -block- und -Symmetrie- und -Symmetrie- und -störungen bereitstellen. Schnittstellen, aber interne Implementierungen müssen von sich selbst oder von Dritten bereitgestellt werden. Mit Versionen finden Sie die entsprechende Version auf der vorherigen Download -Seite.
Schauen wir uns den Code an, den ich implementiert habe:
Paket net.csdn.blog.chaijunkun; Import Java.io.BufferedReader; importieren java.io.ioException; importieren java.io.inputstream; importieren java.io.inputStreamReader; Import Java.security.inValidkeyException; Java.Security.KeyFactory importieren; Java.security.keypair; Import Java.Security.Keypairgenerator; Java.security.NoSuchalgorithmException; Java.security.securerandom importieren; Java.security.interfaces.rsaprivateKey; import Java.security.interfaces.rsapublickey; importieren java.security.spec.invalidkeyspecexception; importieren java.security.spec.pkcs8EnencodedKeyspec; import Java.security.spec.x509EncodedKeyspec; importieren javax.crypto.badpaddingException; importieren javax.crypto.cipher; Import Javax.Crypto.IilleGalBlocksizeexception; importieren javax.crypto.nosuchpaddingException; import org.bouncycastle.jce.provider.bouncycastleProvider; import sun.misc.base64Decoder; public class rSaencrypt {private statische endgültige String default_public_key = "migfma0gcsqgsib3dqebaquaa4gnadcbiqkbgqchdzcjw/rwgfwnxUnbkp7/4e8w" + "/r" + + + + + + + + "/Umxx2jk6qeen69T6N2R1i/lmcydt1xr/t2ahgoixnq5v8w4icaaenawi7ajarht" + "/r" + "vx1uoH/2U378fSEG8XDQLL0GCFB1/TJKi2U2SZSZSZS8KYGCFBB1/TJKI2SZSZSZS8KYGCFBB1/TJKi2SZSZSZS8KYGCFBB1/TJKI2SZSZS8KYGUS8F7VSGUFBB1/TJKi2U2U2SZSZS8KYGUS8FUFFBB1: "/r" + "xilk3gdhnzh + uoeqywidaqab" + "/r"; private statische endgültige String default_private_key = "miicdqibadanbgkqhkig9w0baqefaascal8wggjbagebagaaaGbakepnypd + Taaxcfg" + "/r" + + + "6DSQNV/H7ZD9SZFHAOTQOQSFR23O3ZHWL8UZZINPXGV9PYACY6JC1DLXXBIIJPP4" + "/R" + + + + "1RCLTOLPGG1XHW44F/ZTFVX + XWQRIQBXCOQWXQYJ8HX9OMOJZQK1VLNC61GZYRIA" + "/R" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "Ztvx/twym2bciwteb2gfoh66grdlagmbaaecgyBp4qTvojkynut3Sbdjy/xwaetm" + "/r" + + + "U768SF9P0GLXRTWYUDWJAVUE0VHBI9WXMWZTAVAFKCP8HXX4QZQPH84TD0ZJCQ3J" + "/R" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "Dloegafjkiorgzq5fyk7ydbou1tljfv459c8dtzmtu + lgsotd11/v/jr4njxiudo" + "/r" + + + + + + "MBQ3C4ChMOOYV4UZKQJBANR + 7FC3E6OZGQTOESQPSPQLJBSDF9E4X4EDFUOECKJ" + "/R" + "DVVLOOAZVHFAIUP + H3FK4HXRPALINBEHIIDHIIX2UCQQQQQQQQQQQQQQQQQQQQQQQQICQQQQQQQQQQQQQQQQUCQQQQQQQQQQQQUCQQQQQQQQQQUCQQQQUCQQQQQQUCQQQQQUCQQQQUCQQQUCQQQUCQQUCQQUCQQQUCQSHFD4GC58YGC58YGC58YGC58YGC58YGC58YGC58YGC5. "/r" +"6leqkmoa +6YPFRB3OXYKLBXCWX7DTBX +AYKY5OQMNKEG +MW8XB8WADIUL0/TB6CQ" +"/R" + + + + + "Farvakbhvp94hk0dmdinfvhlwyj3xy4pongSa8vcymj + Asgtvjzjfnzxk4gijbja" + "/r" + "2Z9EKDFIBBAWQP2DLDGUX2VXZ8BAKBYMUiH + KBSV76CNEDWLHFLK8BAKMUIH + KBSV76CNEDWLHFLKMUIHULIHUH + KBSV76CNEDWLHFLSHFLSHFLSHLHFLSWLHFLSHLHFLSHFLQUFLHFLSHFLK. "/r" + "tb0TUW8AVLABAXW34/5SI + NUB1HMBGYTK/T/IFCEPXPBWLGO + E3PAKAGWLPNH0ZH" + "/R" + + + + + "Fae7oaqkmad3xcny6ec180Tae57Hz6ks + Sylkwb4ggzyacxc22vmtykSxhtueAMO" + "/r" + "1nmlzi2zfuox" + "/r"; / *** Privatschlüssel*/ privat rsaprivateKey privateKey; / *** public key*/ privat rsapublickey publicKey; / *** privat auf String*/ private statische endgültige char [] hex_char = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', ',', ',', 'f'}; / *** Holen Sie sich den privaten Schlüssel* @return aktuelles privates Schlüsselobjekt*/ public rsaprivateKey getPrivateKey () {return privateKey; } / *** Holen Sie sich den öffentlichen Schlüssel* @return aktuelles öffentliches Schlüsselobjekt* / public rsapublickey getPublickey () {return publicKey; } / *** zufällig generiertes Schlüsselpaar* / public void genkeypair () {keypairgenerator keypairgen = null; try {keypairgen = keypairgenerator.getInstance ("rSA"); } catch (nosuchalgorithmException e) {e.printstacktrace (); } keypairgen.initialize (1024, new Securerandom ()); Tastair tastepair = keypairgen.generateKeypair (); this.PrivateKey = (rsaprivateKey) tastypair.getPrivate (); this.publickey = (rsapublickey) keypair.getPublic (); } / *** Laden Sie den öffentlichen Schlüssel aus dem Eingabestream in der Datei* @Param im öffentlichen Schlüsseleingabestream* @throws -Ausnahme -Ausnahme generiert beim Laden des öffentlichen Schlüssels* / public void loadPublicke (InputStream in) Ausnahme von Ausnahme {try {bufferedReader broster buferedReader (neuer InputStreamReader (in)); String readline = null; StringBuilder sb = new StringBuilder (); while ((readline = br.readline ())! = null) {if (readline.charat (0) == '-') {Fortsetzung; } else {sb.append (readline); sb.Append ('/r'); }} LoadPublickey (sb.toString ()); } catch (ioException e) {Neue Ausnahme werfen ("öffentlicher Schlüsseldatenstromlesen -Fehler"); } catch (nullPointerexception e) {Neue Ausnahme werfen ("öffentlicher Schlüsseleingangsstrom ist leer"); }} / *** Laden Sie den öffentlichen Schlüssel aus einer String* @param publicKeyStr public Schlüsseldaten String* @throws Exception generiert beim Laden des öffentlichen Schlüssels* / public void loadPublicke (String publicKeyStr) löst eine Ausnahme aus {try {Base64DeCoder Base64DeCoder = new Base64DeCoder (); byte [] buffer = base64DeCoder.decodeBuffer (PublicKeyStr); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); X509EncodedKeySpec keyspec = new x509EncodedKeySpec (Puffer); this.publickey = (rsapublickey) keyFactory.generatePublic (keyspec); } catch (NoSuchalgorithmException e) {neue Ausnahme werfen ("nichts Algorithmus"); } catch (InvalyKeySpeCexception e) {Neue Ausnahme werfen ("public key illegal"); } catch (ioException e) {Neue Ausnahme werfen ("öffentlicher Schlüsseldateninhalte lesen"); } catch (nullPointerexception e) {Neue Ausnahme werfen ("öffentliche Schlüsseldaten ist leer"); }} / *** Laden Sie den privaten Schlüssel aus der Datei* @param keyFileName Private Taste -Dateinamen* @return, ob es erfolgreich ist. String readline = null; StringBuilder sb = new StringBuilder (); while ((readline = br.readline ())! = null) {if (readline.charat (0) == '-') {Fortsetzung; } else {sb.append (readline); sb.Append ('/r'); }} LoadPrivateKey (sb.toString ()); } catch (ioException e) {Neue Ausnahme werfen ("private Schlüsseldaten -Lesen -Fehler"); } catch (nullPointerexception e) {Neue Ausnahme werfen ("privater Schlüsseleingabestream ist leer"); }} public void loadPrivateKey (String privateKeyStr) löst eine Ausnahme aus {try {Base64DeCoder Base64DeCoder = new Base64DeCoder (); byte [] buffer = base64DeCoder.decodeBuffer (privateKeyStr); PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec (Puffer); KeyFactory keyFactory = keyFactory.getInstance ("RSA"); this.privateKey = (rsaprivateKey) keyFactory.generatePrivate (keyspec); } catch (NoSuchalgorithmException e) {Neue Ausnahme werfen ("nichts, dieser Algorithmus"); } catch (InvalyKeySpeCecception e) {Neue Ausnahme werfen ("privater Schlüssel illegal"); } catch (ioException e) {Neue Ausnahme werfen ("private Schlüsseldateninhalte lesen"); } catch (nullPointerexception e) {Neue Ausnahme werfen ("private Schlüsseldaten ist leer"); }} / *** Verschlüsselungsprozess* @param publicKey key* @param plainTextData PlainText -Daten* @return* @Throws Ausnahmeinformationen während des Verschlüsselungsprozesses* / public byte [] Verschlüsselung (rsapublickey publicKey, byte [] plattelldata) löst Ausnahme aus (publicKey == null). } Cipher cipher = null; try {cipher = cipher.getInstance ("RSA", New BouncycastleProvider ()); cipher.init (cipher.encrypt_mode, publicKey); byte [] output = cipher.dofinal (PlainTextData); Rückgabeausgabe; } catch (NoSuchalgorithmException e) {Neue Ausnahme werfen ("Nothis -Verschlüsselungsalgorithmus"); } catch (nosuchpaddingException e) {e.printstacktrace (); null zurückkehren; } catch (InvalyKeyException e) {Neue Ausnahme werfen ("Verschlüsselung öffentlicher Schlüssel ist illegal, bitte überprüfen"); } catch (illegalblocksizeexception e) {Neue Ausnahme werfen ("PlackText -Länge ist illegal"); } catch (badpaddingException e) {Neue Ausnahme werfen ("PlackText -Daten sind beschädigt"); }} / *** Decryption -Prozess* @param privateKey private Key* @param cipherdata cipherText Data* @return plelligtext* @Throws Ausnahmeinformationen während des Entschlüsselungsprozesses* / public byte [] decrypt (rsaprivateKey, byte [] cipherdata). Satz"); } Cipher cipher = null; try {cipher = cipher.getInstance ("RSA", New BouncycastleProvider ()); cipher.init (cipher.decrypt_mode, privateKey); byte [] output = cipher.dofinal (cipherdata); Rückgabeausgabe; } catch (NoSuchalgorithmException e) {Neue Ausnahme werfen ("Nichts Entschlüsselungsalgorithmus"); } catch (nosuchpaddingException e) {e.printstacktrace (); null zurückkehren; } catch (InvalyKeyException E) {Neue Ausnahme werfen ("Entschlüsselung privatschlüssel ist illegal, bitte überprüfen"); } catch (illegalblocksizeexception e) {Neue Ausnahme werfen ("Cryptotext Länge ist illegal"); } catch (badpaddingException e) {Neue Ausnahme werfen ("Cryptotext -Daten sind beschädigt"); }} / *** Byte -Daten zu hexadezimaler String* @param -Dateneingabedaten* @return hexadezimaler Inhalt* / public static String bytearrayToString (byte [] data) {StringBuilder StringBuilder = new StringBuilder (); für (int i = 0; i <data.length; i ++) {// Die hohen vier Ziffern des Byte als Index herausnehmen, um die entsprechende hexadezimale Bezeichnung zu erhalten, beachten Sie, dass der nicht signierte rechte Schicht StringBuilder.Append (hex_char [(Daten [i] & 0xf0) >>> 4]); // Nehmen Sie die unteren vier Bits des Byte als Index heraus, um den entsprechenden hexadezimalen Identifikator StringBuilder.Append (hex_char [(Daten [i] & 0x0f)]) zu erhalten; if (i <data.length-1) {stringBuilder.Append (''); }} return stringBuilder.toString (); } public static void main (String [] args) {rSaencrypt rSaencrypt = new rSaencrypt (); //rsaencrypt.genKeypair (); // laden Sie den öffentlichen Schlüssel aus {rSaencrypt.loadPublickey (rSaencrypt.default_public_key); System.out.println ("erfolgreich den öffentlichen Schlüssel laden"); } catch (Ausnahme e) {System.err.println (e.getMessage ()); System.err.println ("Laden des öffentlichen Schlüssels fehlgeschlagen"); } // Laden des privaten Schlüssels try {rSaencrypt.loadPrivateKey (rSaencrypt.default_private_key); System.out.println ("erfolgreich des privaten Schlüssels laden"); } catch (Ausnahme e) {System.err.println (e.getMessage ()); System.err.println ("Lade privater Schlüssel fehlgeschlagen"); } // String String String Encryptstr = "Testen von String chaijunkun"; try {// Encrypt byte [] cipher = rSaencrypt.encrypt (rSaencrypt.getPublickey (), encryptstr.getBytes ()); // byte entschlüsseln [] plaintext = rSaencrypt.decrypt (rSaencrypt.getPrivateKey (), Cipher); System.out.println ("Ciphertext Länge:"+ cipher.length); System.out.println (rSaencrypt.BytearrayToString (cipher)); System.out.println ("PlainText Länge:"+ plainText.length); System.out.println (rSaencrypt.BytearrayToString (Plaintext)); System.out.println (neuer String (PlainText)); } catch (Ausnahme e) {System.err.println (e.getMessage ()); }}} Im Code gebe ich zwei Möglichkeiten, öffentliche und private Schlüssel zu laden.
Lesen nach Stream: Geeignet für die Methode zum Erhalten von InputStream durch ID -Indexierungsressourcen in Android -Anwendungen;
Lesen Sie nach String: Speichern Sie wie im Code gezeigt den Schlüsselinhalt durch Zeile in statische Konstanten und importieren Sie den Schlüssel mit dem String -Typ.
Führen Sie den obigen Code aus und die folgenden Informationen werden angezeigt:
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 AC CB 61 03 3c A1 81 56 A5 DE C4 79 AA 3 FD 22 87 9E DE B1 F4 E8 B2 NIME Textlänge: 22 54 65 73 74 20 53 74 72 69 6e 67 20 63 68 61 69a 75 6e 6b 75 6e Test String Chaijunkun
In der Hauptfunktion kommentierte ich "rSaencrypt.GenKeypair ()", mit der zufällig Schlüsselpaare generiert werden (nur generieren, verwenden, nicht speichern). Wenn der Dateischlüssel nicht verwendet wird, können Sie den Code, der den Schlüssel lädt, diese Methode aktiviert oder den Code ausführen.
Der Unterschied zwischen dem Laden eines öffentlichen Schlüssels und dem Laden eines privaten Schlüssels besteht darin, dass bei der Erlastung der öffentlichen Taste x509EncodedKeyspec (x509-kodierter Schlüsselanweis) und wenn der private Schlüssel geladen wird, pkcs8CodedKeyspec (PKCS#8-kodierte Schlüsselanweisung).
Hinzugefügt am 22. Februar 2012: Während der Entwicklung der Android -Software wurde festgestellt, dass der obige Code nicht ordnungsgemäß funktioniert hat. Der Hauptgrund ist, dass die Sun.misc.Base64Decoder -Klasse im Android -Entwicklungspaket nicht existiert. Daher müssen Sie im Internet nach dem Quellcode von Rt.jar suchen. Was den Quellcode in JDKs src.zip betrifft, so ist dies nur ein Teil des Quellcodes in JDK, und die Codes der oben genannten Klassen existieren nicht. Nach der Suche und dem Hinzufügen funktioniert der obige Code in Android -Anwendungen gut. Dies enthält den entsprechenden Code für diese Klasse. Darüber hinaus hängt diese Klasse auch von CESTREAMEXHAUTED, CharakterDecoder- und Charaktercoder -Klassen und Ausnahmendefinitionen ab.
Am 23. Februar 2012 hinzugefügt: Zunächst schrieb ich diesen Artikel, um die RSA-Verschlüsselung und Entschlüsselung zu implementieren, ohne mich auf Pakete von Drittanbietern zu verlassen, aber ich habe später auf Probleme gestoßen. Da ein Verschlüsselungsobjekt sowohl in der Verschlüsselungsmethode als auch in der Entschlüsselungsmethode erstellt werden muss, kann dieses Objekt nur durch GetInstance Instanzen erhalten. Es gibt zwei Arten davon: Die erste besteht darin, nur den Algorithmus und nicht den Anbieter anzugeben; Die zweite ist, beides anzugeben. Zunächst kann der Code weiterhin ausgeführt werden, aber Sie werden feststellen, dass das Ergebnis jeder Verschlüsselung unterschiedlich ist. Später wurde festgestellt, dass der vom Verschlüsselungsobjekt verwendete öffentliche und private Schlüssel zufällig intern generiert wurde, nicht der im Code angegebene öffentliche und private Schlüssel. Seltsamerweise kann dieser Code, der keinen Anbieter angibt, durch Android -Anwendungen ausgeführt werden, und das Ergebnis jeder Verschlüsselung ist gleich. Ich denke, dass zusätzlich zu einigen Systementwicklungsfunktionen im Android SDK auch die Funktionen des JDK implementiert werden. Möglicherweise hat es entsprechende Anbieter in seinem eigenen JDK bereitgestellt, was das Verschlüsselungsergebnis jedes Mal gleich macht. Wenn ich den Bouncycastle -Anbieter wie den Beispielcode im Internet hinzufügte, sind die Ergebnisse jeder Verschlüsselung gleich.
Danke fürs Lesen, ich hoffe, es kann Ihnen helfen. Vielen Dank für Ihre Unterstützung für diese Seite!