A criptografia é alterar os dados de informações originais usando um algoritmo especial, de modo que, mesmo que um usuário não autorizado obtenha as informações criptografadas, ele ainda não consegue entender o conteúdo das informações porque não conhece o método de descriptografia. Geralmente, é dividido em criptografia bidirecional e criptografia unidirecional, enquanto a criptografia bi-way é dividida em criptografia simétrica e criptografia assimétrica (alguns materiais dividem diretamente a criptografia em criptografia simétrica e criptografia asmétrica).
O significado geral da criptografia bidirecional é formar um texto cifrado após a criptografia de texto simples, que pode ser restaurado para o texto sem formatação através dos algoritmos. A criptografia unidirecional executa apenas um cálculo de digestão nas informações e não pode gerar texto simples através de algoritmos. Estritamente falando, a criptografia unidirecional não pode ser considerada como um tipo de criptografia, mas deve ser considerada um algoritmo de digestão.
Especificamente:
O sistema deve estar disponível e não pode ser decodificado não matematicamente.
O sistema não precisa ser mantido confidencial e pode facilmente cair nas mãos do inimigo.
A chave deve ser trocada e memorizada sem escrever, e ambas as partes podem alterar a chave.
O sistema pode ser usado para telecomunicações.
O sistema pode transferir posições e suas funções devem ser alcançadas sem passar por várias pessoas.
O sistema é fácil de usar e não exige que o usuário seja sobrecarregado ou tenha muitas regras.
1. O principal provedor de código do método de criptografia
JDK: O código está no pacote jre/lib/jce.jar no diretório de instalação Java;
CC: org.apache.commons.codec fornecido pela Apache
Página inicial: http://commons.apache.org/proper/commons-codec/
BC: org.bouncecastle
Página inicial: http://www.bouncycastle.org/java.html
Basicamente, o JDK comumente usado é suficiente.
2. Algoritmo base64
1. A julgar pela complexidade do algoritmo de criptografia agora, Base64 está envergonhado em dizer que é criptografado, mas é suficiente para pessoas que não entendem computadores. A codificação Base64 é ilegível, ou seja, os dados codificados não serão vistos diretamente pelos humanos a olho nu.
A codificação BASE64 é geralmente usada para o processamento de URL, ou qualquer coisa que você não queira saber que as pessoas comuns sabem rapidamente podem ser processadas com a codificação Base64 e depois publicadas na Internet.
pacote com.amuro.strategy.base64; importar java.util.base64; importar com.amuro.strategy.istrategy;/** * base64 o algoritmo é baseado em 64 caracteres básicos e apenas esses caracteres 64 são incluídos na string crotongina * @author amuro * */public base base codeBytes = base64.getEncoder (). Encode (src.getBytes ()); retornar nova string (codeBytes); } public string decodge (string src) {byte [] decodeBytes = base64.getDecoder (). decode (src.getBytes ()); retornar nova string (decodebytes); }}2. Tabela de correspondência de codificação base64
3. Algoritmo de digestão de mensagens (Digest Message)
O Digest de mensagens também é chamado de digestão digital. É um valor exclusivo correspondente a um comprimento fixo de uma mensagem ou texto e é gerado por uma função de criptografia de hash unidirecional que atua na mensagem. A resistência a conflitos da função de hash possibilita que um texto simples mude ligeiramente, mesmo que apenas uma letra do parágrafo seja alterada, valores diferentes serão gerados após o algoritmo de hash. A unidirecionalidade do algoritmo de hash torna impossível encontrar duas mensagens de entrada diferentes com o mesmo valor de hash computacionalmente. Portanto, o valor de hash dos dados, ou seja, o resumo da mensagem, pode verificar a integridade dos dados.
Em palavras claras, qualquer dados deve ser único como um humano. Qual é o identificador único? Para os seres humanos, atualmente são impressões digitais e qual é a impressão digital dos dados? É isso mesmo, é essa string gerada pelo algoritmo da Mensagem Digest. Por exemplo, quando registramos um site, o cliente transmite a senha que digitamos para o servidor, que deve ser o conteúdo após o processamento da mensagem. Mesmo que o servidor esteja quebrado, o hack não poderá saber qual é a senha real do usuário. No entanto, diz -se que o MD5 e o SHA foram comprometidos agora, para que você possa pesquisar no Google.
1. MD5
pacote com.amuro.strategy.message_digest; importar java.security.messagedigest; importar java.security.nosuchalgorithMexception; importar org.apache.commons.codec.binary.hex; import.amuro.strategy.istrategy;/** ** ** Digest All implementa o istrategy {public string cody (string src) {try {Messagedigest md = Messagedigest.getInstance ("md5"); byte [] codeBytes = md.digest (src.getBytes ()); return hex.encodehexstring (codeBytes); } catch (nosuchalgorithMexception e) {e.printStackTrace (); } retornar nulo; } public string decodge (string src) {lança nova runtimeException ("md5 no decodificar"); }}2. Sha
pacote com.amuro.strategy.message_digest; importar java.security.messagedigest; importar java.security.nosuchalgorithMexception; importação org.apache.commons.codec.binary.hex; importar comb.aMuroM.AtRategy.iMoMons.Codec.binary.Hex; Istrategy {public string cody (string src) {try {Messagedigest md = Messagedigest.getInstance ("sha"); md.update (src.getbytes ()); return hex.encodehexstring (md.digest ()); } catch (nosuchalgorithMexception e) {e.printStackTrace (); } retornar nulo; } public string decodge (string src) {lança nova runtimeException ("sha no decodificador"); }} 4. Criptografia simétrica <r /> Usando o método de criptografia de um sistema de criptografia de chave única, a mesma chave pode ser usada como a criptografia e descriptografia de informações ao mesmo tempo. Esse método de criptografia é chamado de criptografia simétrica, também conhecida como criptografia de chave única. Como a criptografia e a descriptografia usam a mesma chave, como passar a chave com segurança para o descriptor se torna um problema que deve ser resolvido. Obviamente, as vantagens de baixa segurança são pequenos volume de cálculo, velocidade de criptografia rápida e alta eficiência de criptografia.
No entanto, os computadores modernos há muito tempo pararam de se importar com esse nível de computação, e a segurança é a coisa mais importante.
1. Des
Des, nome completo é "padrão de criptografia de dados" e seu nome chinês é "padrão de criptografia de dados", é um algoritmo de bloco que usa a criptografia de chave. O algoritmo DES é um sistema criptográfico simétrico no sistema criptográfico, também conhecido como padrão de criptografia de dados americano. É um algoritmo de criptografia de sistema criptográfico simétrico desenvolvido pela IBM nos Estados Unidos em 1972. O texto sem formatação é agrupado por 64 bits, e a chave é na verdade um método de criptografia de 56 bits que participa da operação (8th, 16, 24, 42, 48, 56, 64 bits são verificados (16, 24, 42, 48, 48, 56, 64 bits são verificados. são substituídos ou trocados para formar o método de criptografia do grupo de texto cifrado.
pacote com.amuro.strategy.des; importar javax.crypto.cipher; importar javax.crypto.keygenerator; importar javax.crypto.secretkey; import javax.crypto.secretkeyfactory; import javax.crypto.pec.deskeyspec; com.amuro.strategy.istrategy;/** * * @author amuro * */classe pública Desstrategy implementa a istrategy {private cifra cifra; SecretKey privado GenerateKey; public string cody (string src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("DES"); keyGenerator.init (56); // tamanho secretKey SecretKey = keyGenerator.GenerateKey (); byte [] keybytes = secretKey.getEncoded (); Deskeyspec DESKEYSPEC = new Deskeyspec (KeyBytes); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.getInstance ("DES"); generateKey = secretKeyFactory.GenerateSecret (DESKEYSPEC); cifra = cipher.getInstance ("DES/ECB/PKCS5Padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultbytes = cipher.dofinal (src.getbytes ()); return hex.encodehexstring (resultadobytes); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; } public string decodge (string src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] resultado = hex.decodeHex (src.toCharArray ()); return new string (cipher.dofinal (resultado)); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; }}2. 3DES3DES, também conhecido como "Triple des", é chamado de "algoritmo de criptografia de dados triplos", que equivale a aplicar o algoritmo de criptografia DES três vezes em cada bloco de dados. Devido ao poder de computação de computador aprimorado, o comprimento da chave da senha original do DES tornou-se facilmente forçado; O 3DES foi projetado para fornecer um método relativamente simples para evitar ataques semelhantes, aumentando o comprimento chave do DES, em vez de projetar um novo algoritmo de cifra em bloco.
pacote com.amuro.strategy.des; importar javax.crypto.cipher; importar javax.crypto.keygenerator; importar javax.crypto.secretkey; import javax.crypto.secretkeyfactory; import javax.crypto.pec.desedekeyspec; com.amuro.strategy.istrategy; classe pública _3desstrategy implementa a istrategy {private cifra cifra; SecretKey privado GenerateKey; public string cody (string src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("desede"); keyGenerator.init (168); // tamanho secretKey SecretKey = keyGenerator.GenerateKey (); byte [] keybytes = secretKey.getEncoded (); DEEDEKESPEC DESKEYSPEC = new Desedekeyspec (Keybytes); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.getInstance ("Desede"); generateKey = secretKeyFactory.GenerateSecret (DESKEYSPEC); cipher = cipher.getInstance ("DEEDE/ECB/PKCS5Padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultbytes = cipher.dofinal (src.getbytes ()); return hex.encodehexstring (resultadobytes); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; } public string decodge (string src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] resultado = hex.decodeHex (src.toCharArray ()); return new string (cipher.dofinal (resultado)); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; }}3. AESAES, o nome completo é "padrão avançado de criptografia", o nome chinês é "padrão avançado de criptografia". Também é conhecido como método de criptografia de Rijndael em criptografia. É um padrão de criptografia de bloco adotado pelo governo federal dos EUA. Como uma nova geração de padrões de criptografia de dados, o algoritmo de criptografia AES reúne as vantagens de forte segurança, alto desempenho, alta eficiência, facilidade de uso e flexibilidade. O design da AES possui três comprimentos -chave: 128, 192, 256 bits. Relativamente falando, a chave 128 do AES é 1021 vezes mais forte que a chave 56 do DES.
pacote com.amuro.strategy.des; importar javax.crypto.cipher; importar javax.crypto.keygenerator; importar javax.crypto.secretKey; importamAmStrax.codectho.spec.seckiny a; implementa a istrategy {private cifra cifra; SecretKey privado GenerateKey; public string cody (string src) {try {keyGenerator keyGenerator = keyGenerator.getInstance ("aes"); keyGenerator.init (128); // tamanho secretKey SecretKey = keyGenerator.GenerateKey (); byte [] keybytes = secretKey.getEncoded (); generateKey = new SecretKeyspec (KeyBytes, "Aes"); cipher = cipher.getInstance ("AES/ECB/PKCS5Padding"); cipher.init (cipher.encrypt_mode, generateKey); byte [] resultbytes = cipher.dofinal (src.getbytes ()); return hex.encodehexstring (resultadobytes); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; } public string decodge (string src) {try {cipher.init (cipher.decrypt_mode, generateKey); byte [] resultado = hex.decodeHex (src.toCharArray ()); return new string (cipher.dofinal (resultado)); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; }} 4. PBE
PBE, nome completo "Criptografia base de senha", é um algoritmo de criptografia baseado em senha. Sua característica é que as senhas são usadas em vez de teclas, e a senha é gerenciada pelo próprio usuário. Número aleatório hashed múltiplo criptografia e outros métodos para garantir a segurança dos dados.
O algoritmo PBE não possui o conceito de chave e trata a senha como uma chave. Como o comprimento da chave afeta a segurança do algoritmo e não é conveniente para a memória, é muito diferente usarmos diretamente a senha que usamos aqui, o que é conveniente para a nossa memória. No entanto, as senhas simples são facilmente esgotadas pelos métodos de dicionário, por isso adicionamos algum "sal" à senha aqui. Essa combinação de sal e senhas é difícil de quebrar. Ao mesmo tempo, mesclamos o sal e a senha e iteramos muitas vezes com o algoritmo Digest Message para criar o material básico do principal vetor de inicialização, dificultando a decifração.
pacote com.amuro.strategy.pbe; importar java.security.SecureRandom; importar javax.crypto.cipher; importar javax.crypto.secretKey; import javax.crypto.secretKey; import javox.crypto.secretkeyFactory; javax.crypto.spec.pbeparameterspec; importar org.apache.commons.codec.binary.hex; importar com.amuro.strategy.istrategy;/** * criptografia baseada em senha (senha), symmetry + message digert * @author amuro * */public Class PBSTRAYMGRAYM), Symmetry + Message Digest * @author @aiTo * */public Class PBSMENTRAGEMS; SecretKey privado GenerateKey; privado pbeparameterspec pbeparameterspec; public string cody (string src) {try {secureRandom secureRandom = new SecureRandom (); byte [] sal = securendom.generateseed (8); String senha = "amuro"; Pbekeyspec pbekeyspec = new pbekeyspec (senha.toCharArray ()); SecretKeyFactory SecretKeyFactory = SecretKeyFactory.GetInstance ("PBewithMd5anddes"); generateKey = secretKeyFactory.GenerateSecret (pbekeyspec); pbeparameterspec = novo pbepparameterspec (sal, 100); cipher = cipher.getInstance ("pbewithmd5anddes"); cipher.init (cipher.encrypt_mode, generateKey, pbeparameterspec); byte [] resultbytes = cipher.dofinal (src.getbytes ()); return hex.encodehexstring (resultadobytes); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; } public string decodge (string src) {try {cipher.init (cipher.decrypt_mode, generateKey, pbeparameterspec); byte [] resultado = hex.decodeHex (src.toCharArray ()); return new string (cipher.dofinal (resultado)); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; }} 5. Criptografia assimétrica <Br /> O algoritmo de criptografia assimétrica requer duas teclas para criptografar e descriptografar, a saber, a chave pública e a chave privada. Uma coisa a observar é que a chave pública e a chave privada devem ser um par. Se os dados forem criptografados com a chave pública, apenas a chave privada correspondente poderá ser descriptografada e vice -versa. Como a criptografia e descriptografia usam duas teclas diferentes, esse algoritmo é chamado de algoritmo de criptografia assimétrica.
1. RSA
De fato, a RSA apareceu já em 1978, e foi o primeiro algoritmo que pode ser usado para criptografia de dados e assinaturas digitais. É fácil de entender e operar e também é muito popular. O princípio é como descrito no processo de trabalho acima. O algoritmo RSA é baseado em um fato muito simples da teoria do número: é fácil multiplicar dois grandes números primários, mas é extremamente difícil fatorar seus produtos, para que o produto possa ser divulgado como uma chave de criptografia.
pacote com.amuro.strategy.asymmétrico; importar java.security.keyFactory; importar java.security.Keypair; importar java.security.KeypairGenerator; importar java.Security.PrivateKey; import Java.Security.PublicKey; Java.Security.Interfaces.rsapublicKey; importar java.security.spec.pkcs8encodedkeyspec; importar java.security.spec.x509encodedKeyspec; import javax.crypto.cipher; import.apache.Comns.COMONS.COMONS.CODECC.COMING.CROPTO.CIPHER; RSASTRATÉGIA IMPLEMENTO ISTRATÉGIA {Private RsapublicKey RsapublicKey; private rsaprivatekey rsaprivatekey; public string cody (string src) {try {// Initialize KeyyPairGenerator KyyyPairGenerator = keypairGenerator.getInstance ("rsa"); keypairGenerator.initialize (512); Teclado do teclado = keypairGenerator.GeraReKeypair (); rsapublicKey = (rsapublickey) teclado.getpublic (); rsaprivateKey = (rsaprivateKey) keypair.getprivate (); // CHAVE DE CHAVE PRIVADO CHAVE PÚBLICA DECRIPTION PKCS8ENCODEDKEYSPEC PKCS8ENCODEDKEYSPEC = novo PKCS8ENCODEDKEYSPEC (rsaprivateKey.getEncoded ()); KeyFactory keyFactory = keyFactory.getInstance ("rsa"); PrivateKey privateKey = keyFactory.GeneratePrivate (PKCS8ENCODEDKEYSPEC); Cifra cifra = cipher.getInstance ("rsa"); cipher.init (cipher.encrypt_mode, privateKey); byte [] resultbytes = cipher.dofinal (src.getbytes ()); // Chave privada Decripção Public Key Criptografia // x509EncodedKeyspec x509EncodedKeyspec = // new X509EncodedKeyspec (rsapublicKey.getEncoded ()); // keyFactory KeyFactory = KeyFactory.getinstance ("rsa"); keyFactory.GeneratePublic (x509EncodedKeyspec); // cifra cifra = cipher.getInstance ("rsa"); // cipher.init (cipher.encrypt_mode, publicKey); // byte [] resultado = cipher.dofinal; return hex.encodehexstring (resultadobytes); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; } public string decodge (string src) {try {// Chave privada Cripção pública Chave Decripção x509encodedKeyspec x509EncodedKeyspec = novo x509encodedkeyspec (rsapublickey.getEncoded ()); KeyFactory keyFactory = keyFactory.getInstance ("rsa"); PublicKey PublicKey = keyFactory.GeneratePublic (x509EncodedKeyspec); Cifra cifra = cipher.getInstance ("rsa"); cipher.init (cipher.decrypt_mode, publicKey); byte [] resultbytes = cipher.dofinal (hex.decodeHex (src.toCharArray ())); // Chave privada Decripção Public Key Criptografia // PKCS8EncodedKeyspec PKCS8ENCODEDKEYSPEC // = new PKCS8ENCODKEYSPEC (RsaPrivateKey.getEncoded (); keyFactory.GeneratePrivate (PKCS8ENCODEDKEYSPEC); // cifra cifra = cifra.getInstance ("rsa"); // cipher.init (cipher.decrypt_mode, privateKey); // byte [] resultbytes = cipher.dofinal (hex.decey); return new string (resultadobytes); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; }} 2. Algoritmo DH
DH, nome completo "Diffie-Hellman", é um método para garantir que a chave compartilhada atravesse as redes inseguras, que geralmente são chamadas de protocolo de consenso-chave. Uma idéia proposta por Diffie e Hellman, os fundadores do sistema de criptografia de chave pública. Simplificando, é para permitir que dois usuários trocem informações sobre mídia pública para gerar chaves "consistentes" e compartilháveis. Ou seja, a parte A produz um par de chaves (chave pública, chave privada) e o Party B gera o par do Party B (chave pública, chave privada) com base na chave pública do Partido A.
Tomando isso como a linha de base como base para a confidencialidade da transmissão de dados, ambas as partes usam o mesmo algoritmo de criptografia simétrica para construir uma chave local (SecretKey) para criptografar os dados. Dessa maneira, após o algoritmo local (SecretKey) é interoperável, o Partido A e o Partido B divulgam suas chaves públicas, criptografando os dados usando a chave pública da outra parte e a chave privada que acabamos de gerar e, ao mesmo tempo, eles podem usar a chave pública da outra parte e sua própria chave privada para descriptografar os dados. Não apenas as duas partes A e B, elas podem ser expandidas para a comunicação de dados compartilhados de várias partes, que completa a comunicação segura de dados interativos de rede!
pacote com.amuro.strategy.asymmetric; importar java.security.keyfactory; importar java.security.Keypair; importar java.security.keypairgenerator; import java.security.privateKey; import java.security.publicKey; java.util.Objects; importar javax.crypto.cipher; importar javax.crypto.keyGreement; importar javax.crypto.secretkey; importar javax.crypto.interfaces.dhpublickey; import javax.crypto.cec.dhparers. org.apache.commons.codec.binary.hex; import com.amuro.strategy.istrategy; public class Dhstrategy implementa a istrategy {private cifra cifra; Private SecretKey ReceiverSecretKey; public string cody (string src) {try {// Inicialize o remetente keyypairGenerator senderKeypairGenerator = keypairGenerator.getInstance ("dh"); severKeypairGenerator.initialize (512); Keypair remetKeypair = senderkeypairGenerator.GeReReKeyypair (); PrivateKey senderPrivateKey = severKeyypair.getPrivate (); byte [] senderPublicKeyBytes = severKeypair.getpublic (). getSencoded (); // Public Key do remetente // Inicialize a chave do receptor, use a chave pública do remetente ReceiverKeyFactory = KeyFactory.getInstance ("dh"); X509ENCODEDKEYSPEC X509ENCODEDKEYSPEC = new X509EncodedKeyspec (SenderPublickeyBytes); PublicKey ReceiverPublicKey = receptorKeyFactory.GeReRePublic (x509EncodedKeyspec); DHPARAMETERSPEC DHPARAMETERSPEC = ((DHPUBLICKEY) RECEBERPUBLICKEY) .getParams (); KeyyGairGenerator RECIVERKEYYPAIRGERERATER = KEYYPAIRGENERATOR.GETINSTANCE ("DH"); receptorkeypairGenerator.initialize (dhparameterspec); Keypair ReceiverKeypair = ReceiverKeypairGenerator.GeraReTeKeypair (); PrivateKey ReceiverPrivateKey = Receiverkeypair.getPrivate (); byte [] receiverpublicKeyBytes = receiverkeypair.getpublic (). getEncoded (); KeyAgreement ReceiverKeyGreement = KeyAgreement.GetInstance ("DH"); receiverkeyagreement.init (receptorprivateKey); ReceiverKeyagreement.Dofase (ReceiverpublicKey, True); ReceiverCretKey = ReceiverKeyAGREEMENT.GenerateSecret ("DES"); // O remetente pode criptografá -lo recebendo a chave pública do receptor. Keyfactory senderKeyFactory = keyFactory.getInstance ("dh"); x509EncodedKeyspec = new X509EncodedKeyspec (ReceiverpublicKeyBytes); PublicKey senderPublicKey = senderKeyFactory.GeraRatePublic (x509EncodedKeyspec); KeyAgreement senderKeyGreement = keyagreement.getInstance ("dh"); sesteykeyagreement.init (senderprivateKey); senderKeyAgreement.Dofase (SenderPublicKey, True); SecretKey senderSecretKey = senderKeyAGReement.GenerateSecret ("DES"); if (objects.Equals (receptoresCretKey, severSecretKey)) {cipher = cipher.getInstance ("des"); cipher.init (cipher.encrypt_mode, sendesecretkey); byte [] resultado = cipher.dofinal (src.getbytes ()); return hex.encodehexstring (resultado); }} catch (Exceção e) {e.printStackTrace (); } retornar nulo; } public string decode (string src) {try {cipher.init (cipher.decrypt_mode, receptorSecretKey); byte [] resultado = hex.decodeHex (src.toCharArray ()); return new string (cipher.dofinal (resultado)); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; }} 6. A criptografia assimétrica de certificados de assinatura digital já é muito segura, mas há outra falha:
Servidor A publicou sua chave pública. Meu computador criptografou os dados com a chave pública do servidor A e o enviou ao servidor A. Nesse momento, o servidor B invadiu meu computador e substituiu a chave pública que eu usava para criptografá -lo com sua chave pública, para que os dados que enviei seriam quebrados pela chave privada do servidor B. Como impedir que a chave pública seja adulterada?
Sim, pensamos no resumo da mensagem anterior. Quando o servidor A jogou a chave pública para mim, ele também foi à CA para solicitar um certificado digital. De fato, é principalmente o resumo da mensagem da chave pública. Com este certificado, quando eu o criptografar com a chave pública, posso primeiro verificar se a chave pública atual foi confirmada como me enviada pelo servidor A.
Aqui está uma espécie de RSA:
pacote com.amuro.strategy.signature; importar java.security.KeyFactory; importar java.security.Keypair; importar java.security.KeypairGenerator; importar java.Security.PrivateKey; importação java.Security.publicKey; importação java.security.signture; Java.Security.Interfaces.rsaprivateKey; importar java.security.interfaces.rsapublicKey; importar java.security.spec.pkcs8encodedKeyspec; importCratic {TrySecury.Spec.x509EncodedKeysPec; publicySig; KeypairGenerator keyyPairGenerator = keypairGenerator.getInstance ("rsa"); keypairGenerator.initialize (512); Teclado do teclado = keypairGenerator.GeraReKeypair (); PublicKey rsapublicKey = (Rsapublickey) Keypair.getPublic (); PrivateKey RsaprivateKey PKCS8ENCODEDKEYSPEC PKCS8ENCODEDKEYSPEC = novo PKCS8ENCODEDKEYSPEC (rsaprivateKey.getEncoded ()); KeyFactory keyFactory = keyFactory.getInstance ("rsa"); PrivateKey privateKey = keyFactory.GeneratePrivate (PKCS8ENCODEDKEYSPEC); Assinatura assinatura = assinatura.getInstance ("md5withrsa"); assinatura.initsign (privateKey); Signature.Update (src.getBytes ()); // gerar bytes de assinatura bytes byte [] signbytes = assinatura.sign (); X509ENCODEDKEYSPEC X509ENCODEDKEYSPEC = new X509EncodedKeyspec (rsapublickey.getEncoded ()); keyFactory = keyFactory.getInstance ("rsa"); PublicKey PublicKey = keyFactory.GeneratePublic (x509EncodedKeyspec); assinatura = assinatura.getInstance ("md5withrsa"); Signature.initVerify (PublicKey); Signature.Update (src.getBytes ()); boolean isVerified = Signature.Verify (SignBytes); retornar isverificado; } catch (Exceção e) {e.printStackTrace (); } retornar false; }} Em relação ao uso de assinaturas digitais e algoritmos de criptografia assimétrica, também vi um ótimo exemplo e o compartilharei com você:
Infelizmente, comprei muitos livros este mês e não consigo sair até o final do mês. Por acaso eu encontrei Clark no QQ:
1-2-3: "Clark, eu preciso de 200 Tael Silver, posso me emprestar?"
Clark: "Não há problema. Vou transferir o dinheiro para você agora. Por favor, me dê uma IOU."
1-2-3: "Muito obrigado. Vou escrever uma IOU na palavra para você."
Então, criei um novo documento do Word, escrevi o IOU e o salvei. Então, o que devo fazer? Não posso enviar IOU diretamente para Clark por razões:
1. Não posso garantir que Clark não mudará "200 taels de prata" para "2000 Taels of Silver" depois de receber o IOU.
2. Se eu perder a dívida, Clark não pode provar que escrevi a IOU.
3. Documentos comuns de palavras não podem ser usados como evidência de ações judiciais.
Felizmente, solicitei um certificado digital. Primeiro, criptografi o IOU com minha chave privada e depois envio o CipherText criptografado para Clark no QQ. Depois que Clark recebeu o texto cifrado da IOU, ele baixou minha chave pública no site do Centro de Certificação de Certificação Digital e, em seguida, usou minha chave pública para descriptografar o texto cifrado. Ele descobriu que era realmente escrito como "200 taels de prata emprestada", para que Clark pudesse me emprestar o dinheiro com confiança. Eu não me preocuparia que Clark adulterasse com o meu IOU, porque:
1. Desde o texto cifrado que enviei para Clark, Clark não pode modificá -lo. Clark pode modificar o IOU descriptografado, mas Clark não tem minha chave privada, para que não possa me imitar criptografando o IOU. Isso é chamado de violação à prova de adulteração.
2. Desde que o IOU criptografou com minha chave privada, existem e apenas minhas chaves públicas que podem ser descriptografadas. Por outro lado, o IOU que pode ser descriptografado com minha chave pública deve ser criptografada com minha chave privada, e só eu possuo minha chave privada, para que Clark possa provar que este IOU foi escrito por mim. Isso é chamado de anti-dívida.
3. Se eu continuasse pagando o dinheiro, Clark me processou no tribunal, e este documento do Word criptografado com minha chave privada poderia ser usado como certificado de Cheng Tang. Porque nosso país emitiu a "Lei de Assinatura Eletrônica da República Popular da China", o que torna as assinaturas digitais legalmente eficazes.
Você deve ter notado que este IOU que foi criptografado com minha chave privada tem as características de adulteração e anti-débito, e pode ser usado como um certificado de Chengtang, que é o mesmo que o efeito de "assinar" este IOU. A propósito, o processo de "criptografar IOUs com minha chave privada" é chamado de assinatura digital.
Este é um artigo de resumo, que escreve algumas tecnologias de criptografia Java comumente usadas e código central aqui para referência de amigos.