Conceito de senha assimétrica
1. A principal diferença dos algoritmos de criptografia simétrica é que as chaves de criptografia e descriptografia são diferentes, uma é pública (chave pública) e a outra é confidencial (chave privada). Ele resolve principalmente o problema do gerenciamento de alocação -chave dos algoritmos de criptografia simétrica e melhora a segurança do algoritmo.
2. A eficiência de criptografia e descriptografia dos algoritmos de criptografia assimétrica é relativamente baixa. No design do algoritmo, os algoritmos de criptografia assimétrica têm requisitos rígidos no comprimento dos dados criptografados. Por exemplo, o algoritmo RSA exige que os dados sejam criptografados não devem ser maiores que 53 bytes.
3. Os algoritmos de criptografia assimétrica são usados principalmente para trocar chaves de algoritmos de criptografia simétrica, em vez de troca de dados.
4. O Java6 fornece dois algoritmos que implementam DH e RSA. O castelo saltitante fornece suporte ao algoritmo E1Gamal. Além dos três algoritmos acima, também há um algoritmo ECC e atualmente não existe um componente de código aberto relevante para fornecer suporte.
Duas chaves são necessárias para criptografia ou descriptografia, divididas em chaves públicas e privadas
Recursos: alta segurança, velocidade lenta
usar
【Troca de chaves (DH)】
Sem determinar a chave comum, ambas as partes geram a chave e não fornecem trabalho de criptografia. A criptografia e a descriptografia também requer outros algoritmos de criptografia simétrica para implementar.
Exemplo de algoritmo DH
importar javax.crypto.keyGreemement; importar javax.crypto.interfaces.dhprivateKey; importar javax.crypto.interfaces.dhpublickey; importar javax.crypto.spec.dParametersPec; java.kescurity. java.security.spec.x509encodedkeyspec; importar java.util.hashmap; importar java.util.map; // 1 gera chave de origem // 2 A chave pública da fonte é entregue ao alvo, e o alvo gera a chave pública e a chave privada através da fonte. // 3 A chave pública do alvo é entregue à fonte // 4 Ambas as partes usam a chave pública da outra parte e sua própria chave privada para gerar a chave local // 5 Se ambas as partes gerarem a chave local da mesma forma, preencha a classe Public Class Dhutil {public static string public_key = "dh_public_key"; public static final string private_key = "dh_private_key"; /** * Gere o par de teclas de origem * @return * @throws Exception */public estático mapa <string, object> initsourceKey () lança exceção {// Crie uma instância do KyyyGenerator, selecione o algoritmo DH KEYYPAIRGERGEREGEREGERGenerator = KEYYPERGenerator.getInStance ("dh"; // inicialize o comprimento da chave, padrão 1024, intervalo opcional 512-65536 e múltiplos de 64 keypairGenerator.initialize (1024); // gerar o teclado do teclado do par de chaves = keyyGenerator.geReReTeKeypair (); Dhpublickey dhpublickey = (dhpublickey) teclado.getpublic (); DHPrivateKey DHPrivateKey = (DHPrivateKey) KEYYPAIR.GETPRIVATE (); // Coloque o par de chaves no mapa mapa <string, object> keyMap = new hashmap <string, object> (); keymap.put (public_key, dhpublickey); keymap.put (private_key, dhprivateKey); retornar keymap; } / ** * Gere o par de teclas de destino através da chave pública de origem * @param sourcepublicKey * @return * @throws Exceção * / mapa estático público <string, objeto> inittargetKey (byte [] sourcepublicKey) lança exceção {keyFactory KeyFactory = KeyFactory.getInstance ("dh"); // Use a chave pública de origem, gera Keyspec e use KeyFactory para gerar informações de informações relacionadas à fonte do PublicKey X509ENCODEDKEYSPEC KEYSPEC = novo x509EncodedKeyspec (SourcepublicKey); DHPUBLICKEY SOURcepublic = (DHPUBLICKEY) keyFactory.GeneratePublic (Keyspec); Dhparameterspec dhpublickeyparams = sourcepublic.getparams (); KeypairGenerator keyypairGenerator = keypairGenerator.getInstance ("dh"); keypairGenerator.initialize (dhpublickeyparams); Teclado do teclado = keypairGenerator.GeraReKeypair (); Dhpublickey dhpublickey = (dhpublickey) teclado.getpublic (); DHPrivateKey DHPrivateKey = (DHPrivateKey) KEYYPAIR.GETPRIVATE (); // Coloque o par de chaves no mapa mapa <string, object> keyMap = new hashmap <string, object> (); keymap.put (public_key, dhpublickey); keymap.put (private_key, dhprivateKey); retornar keymap; } / *** Use a chave pública de uma parte e a chave privada da outra parte para gerar a chave local* @return* / public static byte [] generatelocalsecretkey (byte [] apublickey, byte [] bprivateKey) lança exceção {keyFactory KeyFactory = KeyFactory.GetInstance ("dh"); // Use uma chave pública, gerar keyspec e usar keyfactory para gerar uma informação relacionada ao público x509encodedkeyspec Keyspec = novo x509EncodedKeyspec (Apublickey); PublicKey PublicKey = keyFactory.GeneratePublic (KEYSPEC); // Use a chave privada B, gera informações relacionadas ao privateKey PKCS8EncodedKeyspec PKCS8ENCODEDKEYSPEC = novo PKCS8ENCODEDKEYSPEC (BPRIVATEKEY); PrivateKey privateKey = keyFactory.GeneratePrivate (PKCS8ENCODEDKEYSPEC); // criptografar a PublicKey de A e B'S PrivateKey de B por meio de keyagreement keyagreement keyAgreement = keyAgreement.getInstance ("dh"); keyagreement.init (privateKey); keyagreement.Dofase (PublicKey, True); return keyAgReement.GenerateSecret ("Aes"). getEncoded (); // O algoritmo usa o algoritmo de criptografia simétrica (desede, aes) // retorna keyagreement.GenereatesEcret (); // O algoritmo também pode ser usado para calcular o uso do método padrão sem selecionar o algoritmo} // Obter a chave pública Byte Array public static byte [] getPublicKey (map <string, object> map) {return (((dhpublickey) map.get (public_key)). Getscoded (); } // Obtenha a matriz de bytes privada Byte estático public [] getPrivateKey (map <string, object> map) {return ((dhprivateKey) map.get (private_key)). GetEncoded (); } public static void main (string [] args) lança exceção {byte [] fonte_public_key; byte [] fonte_private_key; byte [] fonte_local_key; byte [] Target_public_key; byte [] Target_private_key; byte [] Target_local_key; Mapa <string, objeto> fonteKey = initsourceKey (); fonte_public_key = getPublicKey (fonte de fonte); fonte_private_key = getPrivateKey (SourceKey); System.out.println ("Chave pública de origem:"+bytestohex.frombytestohex (fonte_public_key)); System.out.println ("Chave privada de origem:"+bytestohex.frombytestohex (fonte_private_key)); Mapa <string, object> TargetKey = inittargetKey (getPublicKey (SourceKey)); Target_public_key = getPublicKey (TargetKey); Target_private_key = getPrivateKey (TargetKey); System.out.println ("Target Public Key:"+bytestoHex.FromByTestoHex (Target_Public_Key)); System.out.println ("Target Private Key:"+bytestoHex.FromByTestoHex (Target_private_key)); fonte_local_key = generatelocalSecretKey (Target_public_key, fonte_private_key); Target_local_key = generatelocalSecretKey (fonte_public_key, Target_private_key); System.out.println ("Chave local de origem:"+bytestohex.frombytestohex (fonte_local_key)); System.out.println ("Target Local Key:"+bytestoHex.FromByTestoHex (Target_Local_Key)); }}【Criptografia/descriptografia (RSA) 】【 Signature Digital (RSA)】
O algoritmo RSA é posterior ao algoritmo DH, e todas essas cinco letras são as primeiras letras do nome humano. O algoritmo DH é o primeiro sistema criptográfico assimétrico.
O algoritmo RSA tem uma velocidade de computação lenta e não é adequada para criptografar grandes quantidades de dados. Uma solução é misturar métodos de criptografia RSA e simétrica, criptografar dados usando métodos de criptografia simétrica e as teclas de criptografia simétrica são criptografadas usando algoritmos RSA. Como a chave é muito curta, o tempo não é demais. De fato, a única desvantagem dos métodos de criptografia simétrica é que a chave é difícil de passar, e os métodos de criptografia simétrica também são difíceis de quebrar.
Cenários aplicáveis da RSA:
(1) O servidor gera uma chave pública e uma chave privada e divulga a chave pública.
(2) O cliente usa uma chave pública para criptografar os dados e entregá -los ao servidor. Outros não conseguem entender os dados criptografados.
(3) O servidor usa uma chave privada para descriptografar os dados e visualizar os dados enviados pelo usuário.
Nesse caso, a chave pública é como uma caixa de correio, e todos podem colocar uma mensagem nessa caixa de correio, mas apenas aqueles que têm as chaves da caixa de correio podem unir e visualizar as letras nesta caixa de correio.
RSA Cenário Aplicável 2:
(1) O imperador gera uma chave pública e uma chave secreta e divulga a chave pública.
(2) O imperador emitiu um decreto para informar o mundo. Existem duas cordas de números no canto inferior direito do decreto. A primeira sequência é uma string aleatória e a segunda sequência é o resultado de criptografar a primeira string com uma chave privada.
(3) Algumas pessoas não acreditam que o decreto tenha sido escrito pelo imperador, então descriptografaram a segunda série de números usando a chave pública. Depois de descriptografar, eles descobriram que era o mesmo que a primeira série de números, o que significa que foi realmente escrito pelo imperador. Como a maioria das pessoas não tem uma chave, elas não podem criptografar os dados que podem ser descriptografados com a chave pública.
Nesse caso, a chave pública é usada para descriptografia e a chave privada é usada para criptografia. Isso pode ser usado para provar que o anúncio foi realmente enviado por alguém. É equivalente a uma assinatura.
De fato, não há necessidade de ser particularmente longo para assinaturas. De um modo geral, as assinaturas são de comprimento fixo. Se você deseja ter um comprimento fixo, pode usar o algoritmo Messagedigest, como MD5 e SHA Series. Portanto, há uma variedade de algoritmos de assinatura, como MD5 withrsa, etc.
Exemplos de criptografia/descriptografia RSA
importar javax.crypto.cipher; importar java.security.keypair; importar java.security.KeypairGenerator; importar java.security.publickey; import java.security.interfaces.rsaprivateKey; import java.security.interfacts.rsApublic. java.util.map;/*** RSA Ferramenta de criptografia*/public classe rsautil {public static final string public_key = "rsa_public_key"; public static final string private_key = "rsa_private_key"; / ** * Chave de inicialização * @return * @throws Exception */ public static map <string, object> initKey () lança exceção {keyyairGenerator keyypairGenerator = keypairGenerator.getInstance ("rsa"); keypairGenerator.initialize (1024); // 512-65536 e múltiplos de 64 keypair Keypair = keyyairGenerator.GeraReKeypair (); RsapublicKey PublicKey = (RSAPublicKey) KeyyPair.getPublic (); RsaprivateKey privateKey Mapa <string, object> keyMap = new hashmap <string, object> (); keymap.put (public_key, publicKey); keymap.put (private_key, privateKey); retornar keymap; } public static rsapublickey getpublickey (map <string, object> keyMap) {return (rsapublickey) keymap.get (public_key); } public static rsaprivateKeyKey getPrivateKey (map <string, object> keyMap) {return (rsaprivateKey) keymap.get (private_key); } / ** * Criptografar dados usando a chave pública * @param dados * @param publicKey * @return * @throws Exceção * / public static byte [] Encrypt (byte [] dados, rsapublickey publicKey) lança exceção {cifra cifra = cipher.getInstance ("rsa"); cipher.init (cipher.encrypt_mode, publicKey); return cipher.dofinal (dados); } / ** * Use a chave privada para descriptografar * @param dados * @param privateKey * @return * @throws exceção * / public static byte [] descriptografar (byte [] dados, rsaprivatekey privateKey) lança exceção {cifra cipher = cipher.getinstance ("rsa"); cipher.init (cipher.decrypt_mode, privateKey); return cipher.dofinal (dados); } public static void main (string [] args) lança exceção {string data = "Jay chou-dongfeng break"; Mapa <string, objeto> keyMap = initKey (); byte [] miwen = Encrypt (data.getBytes (), getPublicKey (keyMap)); System.out.println ("Conteúdo criptografado:"+bytestohex.FrambyTestoHex (Miwen)); byte [] Plain = descriptografando (Miwen, getPrivateKey (keyMap)); System.out.println ("Conteúdo descriptografado:"+nova string (simples)); }}O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.