Este artigo descreve o método de implementar a autenticação bidirecional SSL em Java. Compartilhe -o para sua referência, como segue:
A verificação SSL comum é mais comum. Verifique apenas se nosso servidor é verdadeiro ou correto. Obviamente, se o URL que você está visitando estiver errado, ninguém poderá fazê -lo. Isso é chamado de autenticação unidirecional SSL.
Mas, na realidade, também podemos verificar se o cliente atende aos requisitos, ou seja, emitir um certificado para cada um de nossos usuários, e cada certificado digital é único e não público. Dessa forma, você pode garantir que o usuário acessando meu servidor atualmente seja reconhecido pelo servidor e não possa ser acessado por outras pessoas.
A autenticação bidirecional garante que o servidor e o cliente se reconheçam no primeiro nível. Então, se quiserem se comunicar, anexarão um protocolo SSL ao protocolo de comunicação para garantir que o conteúdo da comunicação seja criptografado. Até ferramentas de sniffer de rede como sniffer, consulte o código ilegal. No futuro, vou demonstrar a você o que você vê com Sniffer sem criptografia. Receio que você esteja mais vigilante dessa maneira.
O conteúdo a seguir é extraído da Internet e modificado após a verificação real.
Cenário de simulação:
Quando o lado do servidor se comunica com o lado do cliente, são necessárias autorização e verificação de identidade, ou seja, o cliente pode aceitar apenas mensagens do servidor e o servidor pode aceitar apenas mensagens do cliente.
Tecnologia de implementação:
JSSE (extensão do soquete de segurança Java)
É uma solução lançada pela Sun para resolver comunicações seguras na Internet. Ele implementa protocolos SSL e TSL (Segurança da Camada de Transporte). O JSSE inclui tecnologias como criptografia de dados, verificação do servidor, integridade de mensagens e verificação do cliente. Ao usar o JSSE, os desenvolvedores podem transferir dados com segurança entre o cliente e o servidor por meio do protocolo TCP/IP.
Para implementar a autenticação da mensagem.
O servidor requer:
1) Keystore: onde a chave privada do servidor é salva
2) Trust Keystore: salva o certificado de autorização do cliente
Da mesma forma, o cliente exige:
1) Keystore: onde a chave privada do cliente é salva
2) Trust Keystore: Aqui, recomendo o uso do comando keytool que vem com o Java para gerar esses arquivos de informação. Obviamente, o OpenSSL também é a geração de certificado SSL de código aberto mais popular. OpenSSL está escrito em C Language, System cruzado. No entanto, podemos considerar a conveniência do uso de programas Java para gerar certificados no futuro e usar o Keytool que vem com o JDK.
1) Gere a chave privada do servidor e importe -a para o arquivo de keystore do servidor
keytool -genkey -alias serverkey -keystore kserver.keystore
Durante o processo, você precisa preenchê -lo separadamente e configurá -lo de acordo com suas necessidades.
Keystore Senha: 123456
Primeiro e sobrenome: Jin
Nome da unidade organizacional: nenhum
Nome da organização: Nenhum
Nome da cidade ou região: BJ
Nome do estado ou da província: BJ
Código do país: CN
A senha da chave privada do Serverkey não está preenchida da mesma forma que a senha do keystore. Certifique -se de prestar atenção aqui, basta pressionar Enter sem alterar sua senha. Caso contrário, se essa chave privada não puder ser aplicada diretamente no programa subsequente, será relatado um erro.
Você pode gerar o arquivo kserver.keystore
Server.Keystore é usado para o servidor, que armazena sua própria chave privada.
2) Exportar o certificado do servidor com base na chave privada
keytool -export -alias serverkey -Keystore kserver.keystore -file server.crt
Server.crt é o certificado do lado do servidor
3) Importe o certificado do servidor para o Trust Keystore do cliente
keytool -import -Alias serverkey -File Server.crt -Keystore tclient.keystore
O TCLIENT.KEYSTORE é para clientes e possui um certificado confiável.
Da mesma maneira, gerar a chave privada do cliente e o certificado do cliente e importar -a para o keystore de confiança do servidor
1) KeyTool -GenKey -Alias ClientKey -Keystore kclient.keystore
2) Keytool -export -Alias ClientKey -Keystore kclient.keystore -File client.crt
3) Keytool -import -Alias ClientKey -File client.crt -Keystore tServer.keystore
Dessa forma, os arquivos gerados são divididos em dois grupos
Salvar servidor: kserver.keystore tserver.keystore
Salvar cliente: kclient.keystore tclient.kystore
O seguinte é verificar se o certificado que geramos está disponível no programa de comunicação do soquete Java.
Cliente:
pacote exemplos.ssl; importar java.io.bufferedInputStream; importar java.io.bufferedoutputStream; importar java.io.fileInputStream; importar java.io.ioException; import java.io.InUtStream; import java.io.outTream; import Java.io.io.io.io.IlutStream; importar; javax.net.ssl.keyManagerFactory; importar javax.net.ssl.ssslContext; importar javax.net.ssl.ssocket; importar javax.net.ssl.trustManagerFactory;/** * ssl client * */public class s.lclient {private final string; private estático final int default_port = 7777; String final estática privada client_key_store_password = "123456"; String final estática privada client_trust_key_store_password = "123456"; SSLSOCKET SSLSOCKET privado; / ** * Inicie o programa do cliente * * @param args */ public static void main (string [] args) {sslclient client = new sslclient (); client.init (); client.process (); } / *** conecte -se ao servidor através do soquete SSL e envie uma mensagem* / public void Process () {if (sslsocket == null) {System.out.println ("error"); retornar; } tente {inputStream input = sslsocket.getInputStream (); OutputStream Output = SSLSocket.getOutputStream (); BufferInputStream bis = new bufferInputStream (entrada); BufferOutputStream bos = new BufferoudOutputStream (saída); bos.write ("mensagem do cliente" .getBytes ()); bos.flush (); byte [] buffer = novo byte [20]; bis.read (buffer); System.out.println (new String (buffer)); sslsocket.close (); } catch (ioexception e) {System.out.println (e); }}/** * <ul> * <li> Os pontos -chave da conexão SSL: </li> * <li> Inicialize sslsocket </li> * <li> importar o cliente privado keystore, importar o cliente de confiança (certificado de servidor) </li> * </ul>/public void init () {TrySt {sslContext) KeyManagerFactory kmf = keyManagerFactory.getInstance ("SUNX509"); TrustManagerFactory TMF = TrustManagerFactory.GetInstance ("SUNX509"); Keystore ks = keystore.getInstance ("jks"); Keystore tks = keystore.getInstance ("jks"); ks.load (new FileInputStream ("e: //kclient.keystore"), client_key_store_password.toCharArray ()); tks.load (new FileInputStream ("e: //tclient.keystore"), client_trust_key_store_password.toCharArray ()); kmf.init (ks, client_key_store_password.toCharArray ()); tmf.init (tks); ctx.init (kmf.getKeymanagers (), tmf.gettrustmanagers (), nulo); sslsocket = (sslsocket) ctx.getSocketFactory (). } catch (Exceção e) {System.out.println (e); }}}Lado do servidor:
pacote exemplos.ssl; importar java.io.bufferedInputStream; importar java.io.bufferoudOutputStream; importar java.io.fileInputStream; importar java.io.inputStream; importSsTa.io.io.OutputStream; import java.net.selTeat; importSsTa.Security.Section.oStAlore; javax.net.ssl.ssslContext; importar javax.net.ssl.sslServersocket; importar javax.net.sssl.trustManagerFactory;/************************************************* ********************* ********************* ********************* ********************* ********************* ********************* ***************** serverkey -Keystore kserver.keystore -file server.crt </li> * <li> 3) Adicione o certificado à chave de confiança do cliente </li> * <li> keytool -import -alias serverKey -file server.crt -keystore tclient.keystore </li> * </ul> ***************************************** ***************************************** ***************************************** ***************************************** ***************************************** ***************************************** ***************************************** ***************************************** Servidor * */public class sslServer {private static final int default_port = 7777; private estático final String server_key_store_password = "123456"; private estático final String server_trust_key_store_password = "123456"; private SSLServersocket ServerSocket; / ** * Inicie o programa * * @param args */ public static void main (string [] args) {sslServer server = new sslServer (); server.init (); server.start (); }/** * <ul> * <li> Ouça o soquete do servidor SSL </li> * <li> Como este programa não é uma demonstração da escuta do soquete, ele simplesmente adota um formulário de thread único e aceita apenas as mensagens do cliente e retorna a mensagem especificada do cliente =; retornar; } while (true) {try {socket s = serversocket.accept (); InputStream input = s.getInputStream (); OutputStream saída = s.getOutputStream (); BufferInputStream bis = new bufferInputStream (entrada); BufferOutputStream bos = new BufferoudOutputStream (saída); byte [] buffer = novo byte [20]; bis.read (buffer); System.out.println (new String (buffer)); bos.write ("servidor echo" .getBytes ()); bos.flush (); S.Close (); } catch (Exceção e) {System.out.println (e); }}}}/** * <ul> * <li> Os pontos -chave da conexão SSL: </li> * <li> Inicialize sslServersocket </li> * <li> importar o servidor privado keystore e importar o servidor KeyStore (certificado do cliente) </li> * </xt */public ole in init () {Tryn {Trint (Try) {Trint (Trint) (Sonst) </li> * </xt */public e public {Trystore) SslContext.getInstance ("ssl"); KeyManagerFactory kmf = keyManagerFactory.getInstance ("SUNX509"); TrustManagerFactory TMF = TrustManagerFactory.GetInstance ("SUNX509"); Keystore ks = keystore.getInstance ("jks"); Keystore tks = keystore.getInstance ("jks"); ks.load (new FileInputStream ("e: //kserver.keystore"), server_key_store_password.toCharArray ()); tks.load (new FileInputStream ("e: //tserver.keystore"), server_trust_key_store_password.toCharArray ()); kmf.init (ks, server_key_store_password.toCharArray ()); tmf.init (tks); ctx.init (kmf.getKeymanagers (), tmf.gettrustmanagers (), nulo); serversocket = (sslServersocket) ctx.getServersocketFactory (). serversocket.setNeedClienteAuth (true); } catch (Exceção e) {e.printStackTrace (); }}}Para obter mais informações sobre o conteúdo relacionado ao Java, consulte os tópicos deste site: "Estrutura de dados Java e tutorial de algoritmo", "Resumo da operação Java Dom Node Tips", "Resumo das dicas de operação de arquivo e diretório de Java" e "Resumo das dicas de operação de cache de java"
Espero que este artigo seja útil para a programação Java de todos.