El cifrado es cambiar los datos de información original utilizando un algoritmo especial, de modo que incluso si un usuario no autorizado obtiene la información cifrada, aún no puede entender el contenido de la información porque no conoce el método de descifrado. Generalmente se divide en cifrado bidireccional y cifrado unidireccional, mientras que el cifrado bi-vía se divide en cifrado simétrico y cifrado asimétrico (algunos materiales dividen directamente el cifrado en cifrado simétrico y cifrado asimétrico).
El significado general del cifrado bidireccional es formar un texto cifrado después del cifrado de texto sin formato, que puede restaurarse al texto sin formato a través de algoritmos. El cifrado unidireccional solo realiza un cálculo de resumen en la información y no puede generar texto plano a través de algoritmos. Estrictamente hablando, el cifrado unidireccional no puede considerarse como un tipo de cifrado, pero debe considerarse un algoritmo de resumen.
Específicamente:
El sistema debe estar disponible y no se puede decodificar de manera no matemática.
El sistema no tiene que mantenerse confidencial y puede caer fácilmente en manos del enemigo.
La clave debe intercambiarse y memorizarse sin escribir, y ambas partes pueden cambiar la clave.
El sistema se puede utilizar para telecomunicaciones.
El sistema puede transferir posiciones, y sus funciones deben lograrse sin pasar por varias personas.
El sistema es fácil de usar y no requiere que el usuario esté exagerado o tenga muchas reglas.
1. El principal proveedor de código de método de cifrado
JDK: El código está en el paquete jre/lib/jce.jar en el directorio de instalación de Java;
CC: org.apache.commons.codec proporcionado por Apache
Página de inicio: http://commons.apache.org/proper/commons-codec/
BC: org.bouncecastle
Página de inicio: http://www.bouncycastle.org/java.html
Básicamente, JDK de uso común es suficiente.
2. Algoritmo Base64
1. A juzgar por la complejidad del algoritmo de cifrado ahora, Base64 se avergüenza de decir que está encriptado, pero es suficiente para las personas que no entienden las computadoras en absoluto. La codificación BASE64 es ilegible, es decir, los datos codificados no serán vistos directamente por humanos a simple vista.
La codificación BASE64 generalmente se usa para el procesamiento de URL, o cualquier cosa que no desee que la gente común sepa de un vistazo puede procesarse con la codificación de Base64 y luego publicado en Internet.
paquete com.amuro.strategy.base64; import java.util.base64; import com.amuro.strategy.istrategy;/** * algoritmo base64 se basa en 64 caracteres básicos, y solo estos 64 caracteres están incluidos en la cadena cifrada * @author amuro * */public class Base64 Implements IStrateGygygygygygy (String String String String String String String String String String String String Code String Code String Code String String Code String Engine byte [] encodebytes = base64.getEncoder (). Code (src.getBytes ()); return new String (CodeBytes); } public String Decode (String src) {byte [] decodebytes = base64.getDecoder (). decode (src.getBytes ()); devolver nueva cadena (decodeBytes); }}2. Base64 Tabla de correspondencia de codificación
3. Algoritmo de digestión de mensajes (digest de mensajes)
Message Digest también se llama Digital Digest. Es un valor único correspondiente a una longitud fija de un mensaje o texto, y es generado por una función de cifrado hash unidireccional que actúa sobre el mensaje. La resistencia al conflicto de la función hash permite que un texto sin formato cambie ligeramente, incluso si solo se cambia una letra del párrafo, se generarán diferentes valores después del algoritmo de hash. La unidireccionalidad del algoritmo hash hace que sea imposible encontrar dos mensajes de entrada diferentes con el mismo valor hash computacionalmente. Por lo tanto, el valor hash de los datos, es decir, el resumen del mensaje, puede verificar la integridad de los datos.
En palabras simples, cualquier dato debe ser único como un humano. ¿Cuál es el identificador único? Para los humanos, actualmente son huellas digitales, y ¿cuál es la huella digital de los datos? Así es, es esta cadena generada por el algoritmo de digestión de mensajes. Por ejemplo, cuando registramos un sitio web, el cliente transmite la contraseña que ingresamos al servidor, que debería ser el contenido después del procesamiento de digestos de mensajes. Incluso si el servidor está roto, Hack no podrá saber cuál es la contraseña real del usuario. Sin embargo, se dice que MD5 y SHA se han visto comprometidos ahora, por lo que puede buscarlo en Google.
1. MD5
paquete com.amuro.strategy.message_digest; import java.security.messageGest; import java.security.nosuchalgorithmexception; importar org.apache.commons.codec.binary.hex; import com.amuro.strategy.istratey;/** * Message Digest algorithm * @@autorhor MD5Strategy implementa iStrategy {public String codeD (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 sin decodificación"); }}2. Sha
paquete com.amuro.strategy.message_digest; import java.security.messageTigest; import java.security.nosuchalgorithmexception; importar org.apache.commons.codec.binary.hex; import com.amuro.strategy.istegy;/** * Secure Hash Algorithm * @@author Shastrategy implementa iStrategy {public String codeD (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) {Throw New RuntimeException ("Sha no decode"); }} 4. Cifrado simétrico <Br /> Utilizando el método de cifrado de un sistema de criptografía de una sola clave, se puede usar la misma clave que el cifrado y el descifrado de información al mismo tiempo. Este método de cifrado se llama cifrado simétrico, también conocido como cifrado de clave única. Dado que tanto el cifrado como el descifrado usan la misma clave, cómo pasar de manera segura la clave al descifrador se convierte en un problema que debe resolverse. Por supuesto, las ventajas de baja seguridad son un pequeño volumen de cálculo, velocidad de cifrado rápido y alta eficiencia de cifrado.
Sin embargo, las computadoras modernas han dejado de preocuparse por este nivel de informática, y la seguridad es lo más importante.
1.
Des, el nombre completo es "Estándar de cifrado de datos", y su nombre chino es "Estándar de cifrado de datos", es un algoritmo de bloque que utiliza el cifrado clave. El algoritmo DES es un sistema criptográfico simétrico en el sistema criptográfico, también conocido como el estándar de cifrado de datos estadounidense. Es un algoritmo de cifrado de sistema criptográfico simétrico desarrollado por IBM en los Estados Unidos en 1972. El texto sin formato está agrupado por 64 bits, y la clave es en realidad un método de cifrado de 56 bits que participa en la operación des (8, 16, 24, 32, 40, 48, 56, 64 bits son bits de verificación, por lo que cada clave tiene un número impar de 1S) y el 1 de los 56) y el 56 bits) y los 56 bits) y los 56-bits de los 56) y el número 56) y los 56 bits de los 56) y el número 56) y los 56 bits de los 56) y los 56 bits) y el número 56) y los 56 bits de los 56) y los 56 bits) y los 56 bits) y los 56-bits de los 5. sustitución o intercambiado para formar el método de cifrado del grupo de texto cifrado.
paquete com.amuro.strategy.des; import javax.crrypto.cipher; import javax.crypto.keyGenerator; import javax.crypto.secretkey; import javax.crypto.secretkeyFactory; import javax.cryptox.spec.deskeyspec; import com.amuro.strategy.istrategy;/** * * @author amuro * */public class delstrategy implementa istrategy {private cifrado de cifrado; Secretkey privado GenerateKey; public String coden (string src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("des"); keyGenerator.init (56); // size SecretKey SecretKey = KeyGenerator.GenerateKey (); byte [] keyBytes = SecretKey.getEncoded (); Deskeyspec deskeyspec = new DeskeySpec (keyBytes); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.getInstance ("des"); GenerateKey = SecretKeyFactory.GeneratesECret (deskeyspec); cifrado = cipher.getInstance ("des/ecb/pkcs5padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.EncodeHexString (resultBytes); } catch (Exception e) {E.PrintStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] resultado = hex.decodeHex (src.toCarArray ()); devolver nueva cadena (cipher.dofinal (resultado)); } catch (Exception e) {E.PrintStackTrace (); } return null; }}2. 3DES3DES, también conocido como "Triple DES", se llama "Algoritmo de cifrado de datos triples", que es equivalente a aplicar el algoritmo de cifrado DES tres veces a cada bloque de datos. Debido a la potencia informática de la computadora mejorada, la longitud clave de la contraseña de DES original se ha vuelto fácilmente forzada; 3DES está diseñado para proporcionar un método relativamente simple para evitar ataques similares al aumentar la longitud clave del DES, en lugar de diseñar un algoritmo de cifrado de bloque nuevo.
paquete com.amuro.strategy.des; import javax.crrypto.cipher; import javax.crypto.keyGenerator; import javax.crypto.secretkey; import javax.crypto.secretkeyFactory; import javax.crypto.spec.DesedeKeyspec; importar orgache.commons.commons. com.amuro.strategy.istrategy; clase pública _3Destrategy implementa iStrategy {CIPHER CIPHER PRIVADO; Secretkey privado GenerateKey; public String coden (String src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("desede"); keyGenerator.init (168); // size SecretKey SecretKey = KeyGenerator.GenerateKey (); byte [] keyBytes = SecretKey.getEncoded (); Desedekeyspec deskeyspec = new desedeKeySpec (keyBytes); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.getInstance ("desede"); GenerateKey = SecretKeyFactory.GeneratesECret (deskeyspec); cifrado = cipher.getInstance ("desede/ecb/pkcs5padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.EncodeHexString (resultBytes); } catch (Exception e) {E.PrintStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] resultado = hex.decodeHex (src.toCarArray ()); devolver nueva cadena (cipher.dofinal (resultado)); } catch (Exception e) {E.PrintStackTrace (); } return null; }}3. AESAES, el nombre completo es "Estándar de cifrado avanzado", el nombre chino es "Estándar de cifrado avanzado". También se conoce como método de cifrado Rijndael en criptografía. Es un estándar de cifrado de bloque adoptado por el gobierno federal de los Estados Unidos. Como una nueva generación de estándares de cifrado de datos, el algoritmo de cifrado AES reúne las ventajas de una fuerte seguridad, alto rendimiento, alta eficiencia, facilidad de uso y flexibilidad. El diseño de AES tiene tres longitudes clave: 128, 192, 256 bits. Hablando relativamente, la clave 128 de AES es 1021 veces más fuerte que la clave 56 de DES.
paquete com.amuro.strategy.des; import javax.crrypto.cipher; import javax.crypto.keyGenerator; import javax.crypto.secretkey; import javax.crypto.spec.secretkeyspec; import org.apache.commons.codec.binary.hex; import.amuro.muro.Strate.Strate.Strate.Strate.Strate.Strate.Strate.Stratate.Strate.Strate Aestrategy implementa iStrategy {Cifrado privado de cifrado; Secretkey privado GenerateKey; public String coden (string src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("AES"); keyGenerator.init (128); // size SecretKey SecretKey = KeyGenerator.GenerateKey (); byte [] keyBytes = SecretKey.getEncoded (); generateKey = new SecretKeSpec (KeyBytes, "AES"); cifrado = cipher.getInstance ("AES/ECB/PKCS5PADDING"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.EncodeHexString (resultBytes); } catch (Exception e) {E.PrintStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] resultado = hex.decodeHex (src.toCarArray ()); devolver nueva cadena (cipher.dofinal (resultado)); } catch (Exception e) {E.PrintStackTrace (); } return null; }} 4. PBE
PBE, nombre completo "Cifrado base de contraseña", es un algoritmo de cifrado basado en contraseña. Su característica es que se usan contraseñas en lugar de claves, y la contraseña es administrada por el propio usuario. Número aleatorio de cifrado múltiple y otros métodos para garantizar la seguridad de los datos.
El algoritmo PBE no tiene el concepto de una clave y trata la contraseña como una clave. Debido a que la longitud de la clave afecta la seguridad del algoritmo y no es conveniente para la memoria, es muy diferente para nosotros usar directamente la contraseña que usamos aquí, lo cual es conveniente para nuestra memoria. Sin embargo, las contraseñas simples se agotan fácilmente por los métodos de diccionario, por lo que hemos agregado algo de "sal" a la contraseña aquí. Esta combinación de sal y contraseñas es difícil de descifrar. Al mismo tiempo, fusionamos la sal y la contraseña e iteramos muchas veces con el algoritmo de digestión de mensajes para construir el material básico del vector de inicialización clave, lo que dificulta aún más el descifrado.
paquete com.amuro.strategy.pbe; import java.security.secureerAndom; import javax.crypto.cipher; import javax.crypto.secretkey; import javax.crypto.secretkey; import javax.crypto.secretKeyFactory; import javax.crypto.peC.pbekey javax.crypto.spec.pbeParametersPec; import org.apache.commons.codec.binary.hex; import Secretkey privado GenerateKey; PBEPARAMETERSPEC PRIVADO PBEPARAMETERSPEC; public string coden (string src) {try {SecureRandom SecureRandom = new SecureRandom (); byte [] sal = SecureRandom.Generateseed (8); String Password = "Amuro"; PBEKEYSPEC PBEKEYSPEC = new PBeKeySpec (Password.ToCarArray ()); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.getInstance ("PBewithMd5anddes"); GenerateKey = SecretKeyFactory.GeneratesECret (PBEKEYSPEC); pBeParameterspec = new PBepParameterspec (sal, 100); cifrado = cipher.getInstance ("pbewithmd5anddes"); cipher.init (cipher.encrypt_mode, generatekey, pbeParameterspec); byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.EncodeHexString (resultBytes); } catch (Exception e) {E.PrintStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, generateKey, pBeParameterspec); byte [] resultado = hex.decodeHex (src.toCarArray ()); devolver nueva cadena (cipher.dofinal (resultado)); } catch (Exception e) {E.PrintStackTrace (); } return null; }} 5. Cifrado asimétrico <Br /> El algoritmo de cifrado asimétrico requiere dos claves para encriptar y descifrar, a saber, la clave pública y la clave privada. Una cosa a tener en cuenta es que la clave pública y la clave privada deben ser un par. Si los datos están encriptados con la clave pública, solo la clave privada correspondiente se puede descifrar y viceversa. Dado que el cifrado y el descifrado usan dos claves diferentes, este algoritmo se llama algoritmo de cifrado asimétrico.
1. RSA
De hecho, RSA apareció ya en 1978, y fue el primer algoritmo el que se puede utilizar tanto para el cifrado de datos como para las firmas digitales. Es fácil de entender y operar y también es muy popular. El principio es el descrito en el proceso de trabajo anterior. El algoritmo RSA se basa en un hecho de teoría de números muy simple: es fácil multiplicar dos grandes números primos, pero es extremadamente difícil factorizar sus productos, por lo que el producto puede revelarse como una clave de cifrado.
paquete com.amuro.strategy.asymmetric; import java.security.keyFactory; import java.security.keypair; import java.security.keypairGenerator; import java.security.privatekey; import java.ssecurity.publickey; import java.security.interfaces.RsapRiMaRes; java.security.interfaces.rsapublickey; import java.security.spec.pkcs8encodedkeyspec; import java.security.spec.x509CodedKeySpec; import javax.crypto.ciPher; import com.amuro.strategy.istrategy; clase pública rsastrategy implementa iStrategy {private rsapublickey rsapublickey; RSAPRIVATEKE PRIVADO RSAPRIVATEKEY; public String codeN (String src) {try {// Inicializar clave KeyPairGenerator KeyPairGenerator = KeyPairGenerator.GetInstance ("RSA"); KeyPairGenerator.initialize (512); KeyPair KeyPair = KeyPairGenerator.GenerateKePAir (); rsapublickey = (rsapublickey) keypair.getPublic (); rsaprivateKey = (rsaprivatekey) keypair.getPrivate (); // Cifrado de clave privada Clave pública Decryación PKCS8CodedKeySpec PKCS8EncodedKeySpec = new PKCS8EncodedKeySpec (rsaprivateKey.getEncoded ()); KeyFactory KeyFactory = KeyFactory.GetInstance ("RSA"); PrivateKey privateKey = keyFactory.GeneratePrivate (PKCS8EncodedKeySpec); Cifrado cifrado = cifrado.getInstance ("rsa"); cipher.init (cipher.encrypt_mode, privateKey); byte [] resultBytes = cipher.dofinal (src.getBytes ()); // Cifrado de clave pública de descifrado de clave privada // x509CodedkeySpec x509EncodedKeySpec = // new x509EncodedKeySpec (rsapublickey.getEncoded ()); // keyFactory KeyFactory = KeyFactory.getInStance ("RSA"); // PublicKey PublicKey = KeyFactory.Generse (x509999 Cipher cipher = cipher.getInstance ("rsa"); // cipher.init (cipher.encrypt_mode, public keyk); // byte [] resultBytes = cipher.dofinal (src.getBytes ()); return hex.EncodeHexString (resultBytes); } catch (Exception e) {E.PrintStackTrace (); } return null; } public String Decode (String Src) {try {// Private Cifrado de clave Public Key Decryption x509CodedKeySpec x509EncodedKeySpec = new x509EncodeDKeySpec (rsapublickey.getEncoded ()); KeyFactory KeyFactory = KeyFactory.GetInstance ("RSA"); PublicKey PublicKey = KeyFactory.GeneratePublic (x509EncodedKeySpec); Cifrado cifrado = cifrado.getInstance ("rsa"); cipher.init (cipher.decrypt_mode, public key); byte [] resultBytes = cipher.dofinal (hex.decodeHex (src.toCarArray ())); // Cifrado público de descifrado de clave privada // PKCS8EncodedKeySpec PKCS8EncodedKeySpec // = new PKCS8EncodedKeySpec (rsaprivateKey.getEdeded ()); // keyFactory = keyFactory.getInstance ("RSA"); // privado privado Keyk keyFactory.GeneratePrivate (PKCS8EncodedKeSpec); // cipher cipher = cipher.getInstance ("rsa"); // cipher.init (cipher.decrypt_mode, privatekey); // byte [] resultBytes = cipher.dofinal (hex.DecodeHex (sRC.TO1); devolver una nueva cadena (resultBytes); } catch (Exception e) {E.PrintStackTrace (); } return null; }} 2. Algoritmo DH
DH, el nombre completo "Diffie-Hellman", es un método para garantizar que la clave compartida cruza de forma segura redes inseguras, que a menudo se denomina protocolo de consenso clave. Una idea propuesta por Diffie e Hellman, los fundadores del sistema de criptografía de clave pública. En pocas palabras, es permitir que dos usuarios intercambien información en los medios públicos para generar claves "consistentes" y compartibles. Es decir, Party A produce un par de claves (clave pública, clave privada), y el Partido B genera el par de claves del Partido B (clave pública, clave privada) basada en la clave pública del Partido A.
Tomando esto como la línea de base como base para la confidencialidad de la transmisión de datos, ambas partes usan el mismo algoritmo de cifrado simétrico para construir una clave local (SecretKey) para cifrar los datos. De esta manera, después de que el algoritmo de la clave local (SecretKey) sea interoperable, el Partido A y el Partido B revelan sus claves públicas, cifre los datos utilizando la clave pública de la otra parte y la clave privada que acaba de generar, y al mismo tiempo, pueden usar la clave pública de la otra parte y su propia clave privada para descifrar los datos. ¡No solo las dos partes A y B, pueden ampliarse a la comunicación de datos compartidos de varias partes, lo que completa la comunicación segura de los datos interactivos de la red!
paquete com.amuro.strategy.asymmetric; import java.security.keyFactory; import java.security.keypair; import java.security.keypairGenerator; import java.security.privatekey; import java.sssuprickey; import java.security.spec.X50999 java.util.objects; import javax.crrypto.cipher; import javax.crypto.keyagreement; import javax.crypto.secretkey; import javax.crypto.interfaces.dhpublickey; import javax.crypto.spec.dhparameterspec; importar; importación org.apache.commons.codec.binary.hex; import com.amuro.strategy.istrategy; clase pública dhstrategy implementa istrategy {private cifrado de cifrado; Private SecretKey receptsecretkey; public string coden (string src) {try {// Inicializar la tecla de remitente KeyPairGenerator SenderKeyPairGenerator = KeyPairGenerator.GetInstance ("Dh"); SenderkypairGenerator.initialize (512); KeyPair Senderkypair = SenderkyPairGenerator.GenerateKepair (); PrivateKey senderPrivateKey = SenderKeypair.getPrivate (); byte [] stenderPublicKeyBytes = SenderKeypair.getPublic (). X509CodedKeySpec x509CodedKeSpec = new X509EncodedKeySpec (SenderPublicKeyByBytes); PublicKey receperPublicKey = receperkeyFactory.GeneratePublic (x509EncodedKeySpec); Dhparameterspec dhparameterspec = ((dhpublickey) receperPublicKey) .getParams (); KeyPairGenerator receperKePairGenerator = keyPairGenerator.getInstance ("dh"); receptorkypairGenerator.initialize (dhparameterspec); KeyPair receperketair = receperKePairGenerator.GenerateKeypair (); PrivateKey receperRivateKey = receperkepair.getPrivate (); byte [] receperPublicKeyBytes = receperkingEpair.getPublic (). getEncoded (); KeyAgreement recoiverkeyAgreement = keyAgreement.getInStance ("dh"); receperkeyAgreement.init (receperPrivateKey); receperkeyAgreement.dophase (receperPublicKey, verdadero); receptiveSecretKey = receperkeyAgreement.GeneratesECret ("DES"); // El remitente puede encriptarlo obteniendo la clave pública del receptor. KeyFactory SenderKeyFactory = KeyFactory.GetInstance ("Dh"); x509EncodedKeySpec = new X509EncodedKeySpec (receperPublicKeyBytes); PublicKey SenderPublicKey = SenderKeyFactory.GeneratePublic (x509EncodedKeySpec); KeyAgreement SenderKeyAgreement = KeyAgreement.GetInStance ("DH"); senceKeyAgreement.init (SenderPrivateKey); senderKeyAgreement.dophase (SenderPublicKey, verdadero); SecretKey Sendersecretkey = SenderKeyAgreement.GeneratesECret ("DES"); if (objects.equals (receptiveRetKey, senceersecretkey)) {cipher = cipher.getInstance ("des"); cipher.init (cipher.encrypt_mode, stenderersecretkey); byte [] resultado = cipher.dofinal (src.getBytes ()); return hex.encodeHexString (resultado); }} catch (Exception e) {E.PrintStackTrace (); } return null; } public String Decode (String src) {try {cipher.init (cipher.decrypt_mode, receptiveSecretkey); byte [] resultado = hex.decodeHex (src.toCarArray ()); devolver nueva cadena (cipher.dofinal (resultado)); } catch (Exception e) {E.PrintStackTrace (); } return null; }} 6. El cifrado asimétrico de los certificados de firma digital ya es muy seguro, pero hay otro defecto:
Servidor A publicó su clave pública. Mi computadora encriptó los datos con la clave pública del servidor A y luego los envió al servidor A. En este momento, el servidor B invadió mi computadora y reemplazó la clave pública que usé para cifrarlo con su clave pública, por lo que los datos que envié serían agrietados por la clave privada del servidor B. ¿Cómo evitar que la clave pública sea manipulada?
Sí, pensamos en el resumen del mensaje anterior. Cuando Server A me arrojó la clave pública, también fue a CA para solicitar un certificado digital. De hecho, es principalmente el resumen del mensaje de la clave pública. Con este certificado, cuando lo cifro con la clave pública, primero puedo verificar si la clave pública actual fue confirmada por ser enviada por el servidor A.
Aquí hay una especie de RSA:
paquete com.amuro.strategy.signature; import java.security.keyFactory; import java.security.keypair; import java.security.keypairGenerator; import java.security.privatekey; import java.security.publickey; import java.security.signature; importar; importación; importación; importación; importación; importación; java.security.interfaces.rsaprivatekey; import java.security.interfaces.rsapublickey; import java.security.spec.pkcs8encodeSpec; import java.security.spec.x509CodedKeySpec; clase pública RSASIGN {Public static versign (string strc) {KeyPairGenerator KeyPairGenerator = KeyPairGenerator.GetInstance ("RSA"); KeyPairGenerator.initialize (512); KeyPair KeyPair = KeyPairGenerator.GenerateKePAir (); 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 ()); // Generar bytes de firma bytes byte [] signbytes = firature.sign (); X509CodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec (rsapublickey.getEncoded ()); keyFactory = keyFactory.getInstance ("RSA"); PublicKey PublicKey = KeyFactory.GeneratePublic (x509EncodedKeySpec); firma = firma.getInstance ("md5withrsa"); Signature.initverify (PublicKey); Signature.Update (src.getBytes ()); boolean isverified = firature.verify (signbytes); regresar isverificado; } catch (Exception e) {E.PrintStackTrace (); } return false; }} Con respecto al uso de firmas digitales y algoritmos de cifrado asimétricos, también vi un gran ejemplo, y lo compartiré con usted:
Por desgracia, compré demasiados libros este mes y no puedo sacarlo hasta fin de mes. Me encontré con Clark en QQ:
1-2-3: "Clark, necesito 200 Tael Silver, ¿puedo prestarme a mí?"
Clark: "No hay problema. Te transferiré el dinero ahora. Por favor, dame un iou".
1-2-3: "Muchas gracias. Te escribiré un IOU en palabra".
Luego, creé un nuevo documento de Word, escribí el IOU y lo guardé. Entonces, ¿qué debo hacer? No puedo enviarlo directamente a Clark por razones:
1. No puedo garantizar que Clark no cambie "200 Taels of Silver" a "2000 Taels of Silver" después de recibir el IOU.
2. Si pierdo la deuda, Clark no puede probar que escribí el IOU.
3. Los documentos de palabras ordinarias no pueden usarse como evidencia de demandas.
Afortunadamente, he solicitado un certificado digital. Primero encripté el IOU con mi clave privada, y luego envío el texto cifrado en Clark en QQ. Después de que Clark recibió el texto cifrado del IOU, descargó mi clave pública en el sitio web del Centro de Certificación de Certificado Digital, y luego usó mi clave pública para descifrar el texto cifrado. Descubrió que de hecho estaba escrito como "200 Taels de plata prestada", para que Clark pudiera prestarme el dinero con confianza. No me preocuparía que Clark manipule con mi iou, porque:
1. Dado que el texto cifrado que envié a Clark, Clark no puede modificarlo. Clark puede modificar el iou descifrado, pero Clark no tiene mi clave privada, por lo que no puede imitarme cifrar el iou. Esto se llama a prueba de manipulación.
2. Dado que el IOU encriptó con mi clave privada, hay y solo mis claves públicas que se pueden descifrar. Por el contrario, el IOU que se puede descifrado con mi clave pública debe estar encriptada con mi clave privada, y solo soy dueño de mi clave privada, para que Clark pueda probar que este IOU fue escrito por mí. Esto se llama anti-deuda.
3. Si seguía no pagando el dinero, Clark me demandó en la corte, y este documento de palabra encriptado con mi clave privada podría usarse como certificado de Cheng Tang. Debido a que nuestro país ha emitido la "Ley de firma electrónica de la República Popular de China", que hace que las firmas digitales sean legalmente efectivas.
Debe haber notado que este IOU que estaba encriptado con mi clave privada tiene las características de manipulación y anti-deuda, y puede usarse como un certificado de Chengtang, que es el mismo que el efecto de "firmar" este iou. Por cierto, el proceso de "encriptar IOUS con mi clave privada" se llama firma digital.
Este es un artículo resumido, que escribe algunas tecnologías de cifrado Java de uso común y código central aquí para referencia de amigos.