Introdução
Quaisquer informações transmitidas em redes de computadores, ou na Internet, está suscetível à intercepção por outros não autorizados. Algumas informações podem ser sensíveis, como número de cartão de crédito e outras informações pessoais. Para tornar a Internet mais útil para empresas e mais segura para o comércio eletrônico, aplicações devem proteger as informações de seus usuários, utilizando encriptação, autenticação e protocolos seguros de comunicação. O secure Hypertext Transfer Protocol (HTTPs), que é o HTTP sobre o Secure Socket Layer (SSL), é usado com sucesso em aplicações de comércio eletrônico.
O protocolo SSL
O protocolo SSL, que foi desenvolvido pela Netscape em 1994, permite aos clientes (normalmente os navegadores Web) e servidores HTTP comunicarem-se sobre uma conexão segura. O SSL oferece encriptação, autenticação e integridade dos dados no intuito de proteger a informação trocada em redes públicas inseguras. Há várias versões do SSL: SSL 2.0 possui algumas fraquezas de segurança, não sendo muito utilizado atualmente; já o SSL 3.0 é universalmente suportado; e finalmente o Tranport Layer Security (TLS), que é um melhoramento do SSL 3.0, tem sido adotado como um padrão na Internet e amplamente suportado por quase todos os softwares recentes.
A encriptação protege dados contra uso não autorizado, utilizando algoritmos criptográficos, antes da transmissão. O dado é criptografado em um lado (cliente ou servidor), transmitido, decifrado pelo outro lado e, então, processado.
A autenticação é um método para verificar a indentidade do remetente. A primeira vez que um navegador Web ou outro cliente tenta se comunicar com um servidor Web sobre uma conexão segura, o servidor apresenta ao cliente um conjunto de credenciais na forma de um certificado.
Certificados são emitidos e validados por autoridades confiáveis conhecidas como Autoridades Certificadoras (CAs). Um certificado representa a identidade da chave pública de uma pessoa. É um documento assinado que tem por finalidade dizer: "Eu certifico que a cheve pública presente neste documento pertence a entidade nomeada neste documento. Assinado CA". Algumas CAs bastante conhecidas são a Verisign e Entrust. Vale ressaltar que os certificados utilizados com SSL/TLS são certificados X.509.
A integridade de dados refere-se a uma maneira de assegurar que os dados não foram modificados durante a tranmissão
SSL e a pilha de protocolos TCP/IP
Como o próprio nome indica (Camada de Socket Seguro), conexões SSL agem como sockets conectados por TCP. Portanto, podemos pensar as conexões SSL como conexões TCP seguras desde que o lugar do SSL na pilha de protocolos é imediatamente acima do TCP e logo abaixo da camada de aplicação, como mostra a figura 1. Deve-se ressaltar, entretanto, que o SSL não suporta algumas das habilidades do TCP como dados out-of-band.
Figura 1 - SSL e a pilha de protocolos TCP/IP
O protocolo SSL possui duas camadas: "SSL Record Protocol", que é responsável por encapsular outros protocolos de alto nível e a "SSL Handshake Protocol", que recebe os dados a serem codificados/decodificados. Esta segunda camada é responsável pela autenticação do cliente e/ou servidor, negociação do algoritmo criptográfico e suas chaves antes da aplicação receber ou enviar qualquer dado.
Negociação da Encriptação (Handshake)
Dentre as "facilidades" do SSL que o tornaram o veículo padrão para trnasações seguras de comércio eletrônico é o seu suporte para a negociação da encriptação e dos algoritmos de autenticação. Os projetistas do SSL pereceberma que nem todas as partes envolvidas usam o mesmo software cliente e que, conseqüentemente, nem todos os clientes incluem um algortimo criptográfico em particular. O mesmo vale para os servidores. O cliente e os servidores dos dois lados de uma conexão devem, então, ser capazes de negociar os algoritmos de encriptação e decriptação ("cipher suites") durante o handshake inicial. Se eles não tiverem algoritmos suficientes em comum, o handshake deve ser interrompido e a tentativa de conexão irá falhar.
O protocolo SSL permite que tanto o cliente quanto o servidor autentiquem um ao outro, mas, tipicamente, somente o servidor é autenticado na camada SSL. Clientes são, costumeiramente, autenticados na camada de aplicação, por meio de uso de passwords enviados sobre um canal protegido por SSL. Esse padrão é comum em transações bancárias, dentre outras aplicações Web seguras.
Os parâmetros criptográficos do estado de uma sessão são produzidos pelo Handshake do protocolo SSL, que opera no topo da camada Record Layer do SSL. Quando um cliente SSL e um servidor SSL iniciam a comunicação, eles concordam em uma versão do protocolo, escolhem os algortimos criptográficos, autenticam um ao outro (opcionalmente) e usam criptografia de chave pública para gerar os segredos que compartilham. Esses passos são realizados pelo protocolo handshake, que pode ser resumido como segue:
O cliente envia uma hello message para a qual o servidor deve responder com uma outra hello message, caso contrário um erro fatal ocorrerá e a conexão falhará. O hello do cliente e o do servidor são usados para estabelecer capacidades de segurança entre o cliente e o servidor.
Esses hello's estabelecem os seguintes atributos: versão do protocolo, identificação da sessão, suite de cifras e métodos de compressão. Adicionalmente, dois valores randômicos são gerados e trocados: ClentHello.random e ServerHello.random.
A seguir, o servidor enviará o seu certificado, se este for autenticado. Adicionalmente, uma mensagem de trocas de chave do servidor pode ser enviada, se necessário (por exemplo, se o servidor não possuir certificado ou se o seu certificado for apenas para assinatura). Se o servidor está autenticado, ele pode solicitar um certificado do cliente.
Agora o servidor enviará uma mensagem hello done, indicando que a fase hello message do handshake está completa. O servidor irá, então, esperar por uma resposta do cliente.
Se o servidor tiver enviado uma mensagem de solicitação de certificado, o cliente deve o seu certificado ou uma mensagem de alerta de que não há certificado (no_certificate alert). A mensagem de troca de chaves do cliente é, então, enviada, e o conteúdo desta mensagem dependerá do algortimo assimétrico escolhido durante o hello do cliente e o hello do servidor. Se o cliente enviou um certificado com possibilidade de assinatura, uma mensagem de verificação digital do certificado (digitally-signed cerfiticate verify message) é enviada para verificar, explicitamente, o certificado.
Nesse momento, uma mensagem de mudança de especificação da cifra é enviada pelo cliente, e o cliente copia a Especificação de Cifra (Cipher Spec) da cifra pendente na Especificação atual. O cliente envia, então, imediatamente a mensagem de finalização, juntamente com os novos algoritmos, chaves e segredos.
Em resposta, o servidor enviará sua mensagem de mudança de Cipher Spec, tranferindo a cifra pendente para a Especificação atual e envia sua mensagem de finalização juntamente com a nova Cipher Spec.
Nesse momento, o handshake está completo e o cliente e o servidor podem começar a trocar dados na camada de aplicação (veja a figura abaixo).
Figura 2 - Handshake SSL
JSSE
O Java Secure Socket Extension (JSSE), um conjunto de pacotes que habilita comunicação segura na Internet, é um framework que implementa, totalmente em Java, o Secure Soket Layer. Esses pacotes habilitam a construção de aplicações de rede seguras; isso possibilita a passagem, de forma segura e confiável, de dados entre um cliente e um servidor executando qualquer protocolo, como HTTP, FTP, Telnet, entre outros.
Além disso, o JSSE abstrai a complexidade inerente a certos algortimos criptográficos e, portanto, minimiza o risco de criação de vulnerabilidades. Como veremos, o JSSE torna o desenvolvimento de aplicações habilitadas com SSL bastante simples, nos permitindo integrar o SSL de forma fácil. O framework JSSE é capaz de suportar muitos protocolos de comunicação segura como SSL 2.0 e 3.0 e TLS 1.0.
Programando com JSSE
As APIS JSSE complementam os pacotes java.security e java.net, provendo classes que implementam
sockets de rede, gerenciadores de chaves e um framework que funciona como uma fábrica para o encapsulamento do comportamento
de sockets. Essas classes estão incluídas nos pacotes javax.net e
javax.net.ssl.
O principal pacote para a criação de sockets seguros baseados em SSL é o javax.net.ssl. A seguir,
há uma breve descrição de algumas das classes e interfaces desse pacote.
Interface KeyManager
Essa interface é a base para os gerenciadores de chave JSSE. Os gerenciadores de chave são responsáveis pelo material (as chaves) que é usado para autenticar o socket SSL junto ao seu par (isto é, autenticar o servidor junto ao cliente e/ou autenticar o cliente junto ao servidor). Se nenhuma chave estiver disponível o socket não terá a capacidade de se autenticar. KeyManagers são criados ou usando um KeyManagerFactory ou por meio de uma de suas subclasses.Interface SSLSession
Essa interface implementa as sessões SSL, que são usadas para descrever a relação atual entre duas entidades. Cada conexão SSL envolve uma sessão por vez. Sessões são criadas como parte do protocolo de handshake do SSL. Esta interface permite que sejam conhecidas as cifras que estão sendo utilizadas na sessão (por meio do método getCipherSuite()), o ID da sessão (getId()), o protocolo em uso (getProtocol()), os certificados que foram definidos como parte da definição da sessão (getPeerCertificates()), dentre outras características.Classe HandshakeCompletedEvent
Essa classe implementa um evento que indica que o handshake SSL está completo para uma dada conexão SSL. Todas as informações do resultado do handshake são capturadas por meio de um objeto do tipo SSLSession.Classe KeyManagerFactory
Essa classe funciona como uma "fábrica" de gerenciadores de chaves, baseada em uma fonte das chaves. Cada gerenciador de chaves gerencia um tipo específico de material para as chaves que serão usadas por um socket seguro. O material da chave é baseado em um KeyStore e/ou em um provedor específico. Os métodos comumente utilizados são o init(KeyStore ks, char[] password), onde é inicializado um KeyManagerFactory para trabalhar com um KeyStore específico e o método getKeyManagers() que retorna um gerenciador para cada tipo de material de chave.Classe SSLContext
Instâncias dessa classe representam uma implementação segura de sockets que age como uma fábrica para a construção de sockets seguros. Em outras palavras, um SSLContext é um ambiente para a implementação do JSSE. Podem ser criados por meio do seu método estático getInstance(String protocol), onde se informa um protocolo (por exemplo, SSLv3) para que se obtenha um SSLContext. Essa classe é inicializada por meio do método init(KeyManager[] km, TrustManager[] tm, SecureRandom random) .Classe SSLSocket
Essa classe estende a classe Socket do pacote javax.net e provê sockets seguros por meio de uso de protocolos como o SSL ou o TLS. Alguns métodos importantes são: getEnabledCipherSuites() que retorna o nome das cifras SSL que estão habilitadas para uso na conexão atual, getSession() que retorna a sessão SSL em uso na conexão atual, setWantClientAuth(boolean auth) que configura o socket para solicitar a autenticação do cliente, startHandshake() que inicia um handshake SSL para a conexão atual, dentre outros.Classe SSLServerSocket
Essa classe estende a classe ServerSocket do pacote javax.net e provê sockets de servidores seguros por meio de uso de protocolos como o SSL ou o TLS. Intâncias dessas classes podem ser criadas por meio de um SSLServerSocketFactory. A função primária de um SSLServerSocket é criar sockets SSL aceitando conexões (por meio do método accept()). Alguns métodos importantes são: getEnabledCipherSuites() que retorna o nome das cifras SSL que estão habilitadas para uso na conexão atual, getSession() que retorna a sessão SSL em uso na conexão atual, setNeedClientAuth(boolean auth) que controla se as conexões aceitas pelo servidor devem incluir autenticação por parte do cliente, dentre outros.Classe TrustManagerFactory
Esta classe age como uma fábrica para a criação de gerenciadores confiáveis (TrustManagers). Um gerenciador confiável gerencia um tipo específico de material para serem usados por sockets seguros. Esse material é baseado em fonte de Keystores e/ou provedores específicos. Alguns métodos importantes são getTrustManager() que retorna objetos do tipo TrustManager e init(KeyStore ks) que inicializa um TrustManagerFactory por meio de um KeyStore.
Lidando com os Certificados
Conforme mostrado na seção Negociação da Encriptação (Handshake), a troca de certificados
entre cliente e servidor, embora seja opcional, é uma das partes mais importantes do protocolo SSL. Normalmente, o servidor
apresenta o seu certificado como forma de autenticar-se perante o cliente; procedimento comum em transações comerciais na
Web. A autenticação por parte do cliente, isto é, o cliente ter que apresentar o seu certificado é mais raro, embora seja possível.
Criando os certificados
Para a criação dos certificados do cliente e do servidor foi utilizada a ferramenta Keytool, que
já vem instalada na versão 1.4 do Java 2 Second Edition (J2SE). O Keytool é um
utilitário de gerenciamento de certificados e chaves. Possibilita ao usuário administrar seus pares de chaves públicas e privadas
e os certificados associados para uso de auto-autenticação ou para uso de integridade e autenticação usando assinaturas
digitais.
O Keytool fica na pasta bin do diretório do j2sdk.
Keytool armazena as chaves e os certificados em um local chamado keystore. O
keystore é normalmente implementado na forma de arquivos, protegendo as chaves privadas com passwords.
Para a criação do certificado do servidor, foi utilizado o comando abaixo.
>keytool -genkey -keystore kservidor -keyalg rsa -alias servidorsimples
Enter keystore password: password
What is your first and last name?
[Unknown]: localhost
What is the name of your organizational unit?
[Unknown]: CIC
What is the name of your organization?
[Unknown]: UnB
What is the name of your City or Locality?
[Unknown]: Brasilia
What is the name of your State or Province?
[Unknown]: DF
What is the two-letter country code for this unit?
[Unknown]: BR
Is CN=localhost, OU=CIC, O=UnB, L=Brasilia, ST=DF, C=BR correct?
[no]: yes
Enter key password for <servidorsimples>
(RETURN if same as keystore password):
|
Esse comando (a primeira linha acima) gera um certificado referenciado pelo alias servidorsimples e que será armazenado em um arquivo chamado kservidor. O certificado foi gerado utilizando o algoritmo RSA e foi pedido um password para o armazenamento da chave no keystore e um password para o alias; optei por informar o valor password para os dois valores.
Criando o certificado do Cliente
>keytool -genkey -keystore kcliente -keyalg rsa -alias clientesimples
Enter keystore password: password
What is your first and last name?
[Unknown]: Cliente
What is the name of your organizational unit?
[Unknown]: Desenvolvimento
What is the name of your organization?
[Unknown]: Sistemas de Seguranca
What is the name of your City or Locality?
[Unknown]: Brasilia
What is the name of your State or Province?
[Unknown]: DF
What is the two-letter country code for this unit?
[Unknown]: BR
Is CN=Cliente, OU=Desenvolvimento, O=Sistemas de Seguranca, L=Brasilia, ST=DF, C
=BR correct?
[no]: yes
Enter key password for <clientesimples>
(RETURN if same as keystore password):
|
Implementando o servidor : ServidorSimplesSSL
Agora vamos mostrar como construir um servidor simples SSL baseado em Java. Nessa seção serão mostrados os aspectos mais
relevantes da criação do servidor, enfocando as etapas de configuração do socket para a criação de um socket seguro. Para
uma referência completa ao código, veja o Apêndice A.
O método main() de ServidorSimplesSSL inicia pedindo o password do keystore do servidor. Em seguida, chama o construtor
de ServidorSimplesSSL para criar uma instância desse objeto. Como argumentos são passados o nome do servidor, o password
informado e um valor booleano, que serve para indicar se o servidor vai ou não requerer a autenticação por parte do cliente. A seguir
é chamado o método run do ServidorSimplesSSL.
Dentro do método run(), é chamado o método criaSSLServerSocket(), que como o seu nome diz, cria um socket do tipo
SSLServerSocket. Este método é o mais importante da classe ServidorSimplesSSL, pois,
é ele quem configura todas as propriedades para que a conexão seja segura e baseada em SSL. Como vai ser exigido que o
servidor se autentique para o cliente, a primeira coisa que o método faz é carregar o keystore do servidor kservidor, que foi criado
previamente (veja Criando o certificado do Servidor). As quatro linhas seguintes fazem isso.
KeyStore ks = Utils.getKeyStore("JKS");
ks.load(new FileInputStream(keystore), keystorepass);
KeyManagerFactory kmf = Utils.getKMFactory("SunX509");
kmf.init(ks, keypassword);
|
A primeira linha chama o método getKeyStore("JKS") da classe Utils; esse método retorna um KeyStore por meio de uma chamada à KeyStore.getInstance(tipo), que cria um keystore utilizando o provedor JKS da Sun. A segunda linha carrega o arquivo kservidor (o keystore do servidor), informando o seu password. A terceira linha chama o método getKMFactory() para criar um KeyManagerFactory que, conforme explcado anteriormente, é uma fábrica de gerenciadores de chaves. O método getKMFactory("X509") realiza a sua ação por meio da chamada KeyManagerFactory.getInstance(algoritmo), que cria um caminho de certificação baseado em X509. Por fim, a quarta linha inicializa o KeyManagerFactory para trabalhar com o keystore do servidor.
A seguir, precisamos criar um objeto do tipo SSLContext. Conforme explicado anteriormente, é a partir do SSLContext que poderemos criar sockets seguros SSL. As duas linhas a seguir mostram como o SSLContext foi criado.
SSLContext contextoSSL = Utils.criaSSLContext("SSLv3");
contextoSSL.init(kmf.getKeyManagers(), null, null);
|
A primeira linha chama o método estático criaSSLContext() da classe Utils para criar um objeto SSLContext, onde é informado que se deve utilizar o protocolo SSL versão 3 para a criação do contexto. O método criaSSLContext() faz isso por meio de uma chamada à SSLContext.getInstance(protocolo). A segunda linha inicializa o objeto para trabalhar com o gerenciador de chaves criado previamente. O segundo e terceiros parâmetros marcados como null indicam que serão utilizados os valores default para o TrustManager e para o SecureRandom, respectivamente.
Agora, estabelecido o objeto SSLContext, podemos criar o socket seguro SSL. O procedimento é feito em dois passos: primeiro obtemos um ServerSocketFactory a partir de SSLContext e, em seguida, a partir do ServerSocketFactory, criamos um SSLSocketServer. As duas linhas a seguir mostram essas operações.
ServerSocketFactory ssf = contextoSSL.getServerSocketFactory(); SSLServerSocket servidorSSL = (SSLServerSocket) ssf.createServerSocket(HTTPS_PORT); |
O método createServerSocket() utiliza a variável de instância HTTPS_PORT definida como 443 (a porta padrão para conexões SSL) para a criação do Socket.
O método criaSSLServerSocket(), antes de devolver o SSLServerSocket criado, verifica se é requerida autenticação do cliente; se for ele executa o método setNeedClientAuth() para requerer essa autenticação. O trecho a seguir mostra isso:
if (autCliente){
servidorSSL.setNeedClientAuth(autCliente);
} |
Implementando o cliente: ClienteSimplesSSL
A implementação do ClienteSimplesSSL é bastante similar a do servidor. A função básica do cliente
é se conectar ao servidor, lê um arquivo e exibi-lo na tela.
Assim como no servidor, o método main() de ClienteSimplesSSL chama o construtor da classe, passando como argumentos o nome
do cliente, o password do seu keystore (lido via linha de comando) e o host no qual o cliente deve se conectar (um argumento
passado via linha de comando). Em seguida é chamado o método run() de ClienteSimplesSSL.
O método run() chama o método criaSSLSocket(); esse método é bastante parecido com o método criaSSLServerSocket de
ServidorSimplesSSL, mas, ao invés de criar um SSLServerSocket, ele cria um SSLSocket. No mais, os passos são praticamente
os mesmos para a criação do socket do servidor: criação de um KeyStore; criação de um KeyManagerFactory; isso permite que
trabalhemos com o keystore do cliente. Em seguida criamos um objeto do tipo SSLContext, o qual nos irá permitir criar um
SSLSocketFactory (veja que não é um SSLServerSocketFactory), que por sua vez nos
permitirá construir o objeto SSLSocket.
O trecho a seguir mostra a criação do SSLSocket para o cliente.
KeyStore ks = Utils.getKeyStore("JKS");
ks.load(new FileInputStream(keystore), password);
KeyManagerFactory kmf = Utils.getKMFactory("SunX509");
kmf.init(ks, password);
SSLContext sslcontext = Utils.criaSSLContext("SSLv3");
sslcontext.init(kmf.getKeyManagers(), null, null);
SSLSocketFactory ssf = sslcontext.getSocketFactory();
SSLSocket socket = (SSLSocket) ssf.createSocket(host,HTTPS_PORT);
|
Veja que a implementação é realmente bastante similar àquela do servidor.
Testando o ServidorSimplesSSL e o ClienteSimplesSSL
Vamos, a seguir, mostrar alguns testes de execução do servidor e do cliente. Os testes foram realizados utilizando o J2SDK
1.4.1, executando em ambiente MS Windows 98. Contudo, não deve haver problemas para a execução dos testes em outros Sistemas
Operacionais.
Estabelecendo uma conexão SSL com ServidorSimplesSSL por meio de um navegador Web
Neste primeiro teste, vamos nos conectar ao ServidorSimplesSSL utilizando o navegador Mozilla. Primeiramente, devemos compilar
o arquivo ServidorSimplesSSL.java, por meio do comando javac, conforme mostrado a seguir.
>javac ServidorSimplesSSL.java |
A seguir, executamos o ServidorSimplesSSL. Para isso abrimos uma janela de comando e no prompt digitamos
>java ServidorSimplesSSL |
Temos então que informar qual o password do keystore do servidor (kservidor). Quando criamos o keystore e o certificado, informamos o valor password. Então, entramos com esse valor. A janela abaixo mostra o servidor em execução e aguardando por uma conexão. Vale ressaltar, que nesse exemplo, o arquivo kservidor está na mesma pasta que o ServidorSimplesSSL.
Figura 3 - ServidorSimplesSSL em execução
Agora, na janela do Mozilla e com o servidor em execução, entramos com o endereço https://localhost. Ao fazermos, o navegador mostra uma informação alertando que o servidor é certificado por um Autoridade de Certificação desconhecida. Veja abaixo.
Figura 4 - Alerta do navegador Mozilla
Figura 5 - Visualizando o certificado do servidor
Figura 6 - Conexão estabelecida
Fazendo a comunicação cliente-servidor entre ClienteSimplesSSL e ServidorSimplesSSL
Agoras vamos fazer a conexão entre o servidor e o cliente. Em uma janela de comando, colocamos o servidor para executar, conforme fizemos anteriormente. Em outra janela de comando, executamos o cliente. Para isso devemos compilar o cliente por meio do comando javac e em seguida executá-lo informando o host em que ele deve se conectar (no caso, localhost). Quando da execução do cliente, assim como no servidor, nos é solicitado um password para o keystore kcliente do cliente, onde devemos informar password. Contudo, se executarmos da forma normal, isto é, fazendo java ClienteSimplesSSL localhost, algo de interessante acontece. Vejamos a seguir.
Figura 7 - Conexão cliente-servidor recusada: cliente não reconhece certificado
A janela da esquerda representa a execução do cliente e a da direita a do servidor. Observemos a última linha de execução de cada um dos componentes; no lado do servidor, vemos que uma exceção foi lançada e o servidor recebeu a seguinte mensagem: Received fatal alert: certificate_unknown. Do lado do cliente uma exceção também foi lançada, que informa: Couldn't find trusted certificate. Isso ocorreu porque o cliente espera que o servidor se autentique perante ele; contudo, o certificado que o servidor apresenta não é confiável pelo cliente; logo este envia uma mensagem que não encontrou um certificado confiável, o servidor recebe esta notificação e a conexão é abortada.
Para resolver este problema, devemos informar ao cliente em que certificado ele deve confiar, ou seja, qual é a fonte confiável. Isso pode ser feito da seguinte forma:
>java -Djavax.net.ssl.trustStore=kservidor ClienteSimplesSSL localhost |
Assim estamos informando, por meio do parâmetro -Djavax.net.ssl.trustStore, que o cliente deve confiar em kservidor. Dessa forma, a conexão se estabelece normalmente, e o cliente imprime a página index.html enviada pelo servidor (figura a seguir).
Figura 8 - Conexão cliente-servidor estabelecida com sucesso
Conforme vimos na seção Negociação de Encriptação (Handshake), o servidor também pode requerer autenticação por parte do cliente. Este último teste enfoca essa questão. Para isso, no método main() de ServidorSimplesSSL, devemos alterar o segundo parâmetro do construtor de false para true. Assim, no método criaSSLServerSocket() será requerida a autenticação do cliente por meio da chamada à setNeedClientAuth(autCliente). Agora, depois de recompilarmos o servidor, executamo-lo e em seguida solicitamos uma conexão por parte do cliente. Se fizermos a execução do servidor da forma normal (somente java ServidorSimplesSSL), o mesmo erro que aconteceu anteriormente na parte do cliente se repetirá, pois, como o servidor requer a autenticação do cliente, este apresenta o seu certificado. Contudo, este certificado não é conhecido pelo servidor, que aborta a conexão. Esta execução é mostrada a seguir.
Figura 9 - Conexão cliente-servidor recusada: servidor não reconheceu certificado
Veja que o servidor enviou a mensagem null cert chain, significando que não encontrou um certificado confiável. O cliente recebeu uma mensagem informando que a conexão foi reiniciada. Para resolver isso, fazemos da mesma forma que fizemos quando queríamos que o cliente reconhecesse o certificado do servidor: devemos informar ao servidor, por meio de -Djavax.net.ssl.trustStore=kcliente, qual é o gerenciador confiável para ele. Dessa forma, a conexão se estabelece corretamente, e o cliente exibe a página enviada pelo servidor.
Figura 10 - Conexão cliente-servidor estabelecida com sucesso: servidor reconheceu certificado do cliente
Apendice A: Código Completo
Aqui são mostrados os códigos completos dos arquivos necessários para o funcionamento do servidor e do cliente. São eles:
ServidorSimplesSSL.java, ClienteSimplesSSL.java e Utils.java. Ao final há um arquivo compactado,
contendo os arquivos .java, os arquivos .class, os keystore kservidor e kcliente e o arquivo index.html que é utilizado para
o servidor enviar dados ao cliente.
ServidorSimplesSSL.java
Nota: Essa versão não exige autenticação por parte do cliente.
import java.io.*;
import java.net.*;
import javax.net.*;
import javax.net.ssl.*;
import java.security.*;
import java.util.*;
public class ServidorSimplesSSL{
String keystore = "kservidor";
char keystorepass[];
char keypassword[] ;
public static final int HTTPS_PORT = 443;
boolean autCliente;
String nome;
ObjectOutputStream out;
ObjectInputStream in;
//construtor
public ServidorSimplesSSL(String nome, boolean autCliente, String password){
this.nome = nome;
this.autCliente = autCliente;
keystorepass = password.toCharArray();
keypassword = password.toCharArray();
}
public ServerSocket criaSSLServerSocket() throws Exception{
KeyStore ks = Utils.getKeyStore("JKS");
ks.load(new FileInputStream(keystore), keystorepass);
KeyManagerFactory kmf = Utils.getKMFactory("SunX509");
kmf.init(ks, keypassword);
SSLContext contextoSSL = Utils.criaSSLContext("SSLv3");
contextoSSL.init(kmf.getKeyManagers(), null, null);
showPropSSLContext(contextoSSL);
ServerSocketFactory ssf = contextoSSL.getServerSocketFactory();
SSLServerSocket servidorSSL = (SSLServerSocket) ssf.createServerSocket(HTTPS_PORT);
//Se necessário, autentica o cliente
if (autCliente){
servidorSSL.setNeedClientAuth(autCliente);
}
return servidorSSL;
}
public void run(){
ServerSocket listen;
try{
//vai criar um SSLServerSocket
listen = criaSSLServerSocket();
System.out.println(this.nome+" executando na porta "+HTTPS_PORT);
System.out.println("Aguardando conexao...");
//espera por uma conexão do cliente
Socket cliente = listen.accept();
Conexao con = new Conexao(cliente);
}catch(Exception e){
System.out.println("Exception "+e.getMessage());
e.printStackTrace();
}
}
private void showPropSSLContext(SSLContext contextoSSL){
System.out.println("-------Informaçoes de contexto SSL-------");
String protocol = contextoSSL.getProtocol();
System.out.println("Protocolo : "+protocol);
Provider provider = contextoSSL.getProvider();
System.out.println("Nome do provedor : "+provider.getName());
System.out.println("Versao do provedor : "+provider.getVersion());
SSLSessionContext sslsessioncontext = contextoSSL.getServerSessionContext();
}
//main
public static void main(String[] args) throws Exception{
System.out.print("Informe o password para o keystore do servidor:");
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String password = in.readLine();
ServidorSimplesSSL servidor = new ServidorSimplesSSL("Servidor HTTPs", false, password);
servidor.run();
}
//classe interna
class Conexao extends Thread {
Socket cliente;
BufferedReader in;
DataOutputStream out;
public Conexao(Socket s) {
cliente = s;
try {
in = new BufferedReader(new InputStreamReader (cliente.getInputStream()));
out = new DataOutputStream(cliente.getOutputStream());
}catch (IOException e) {
System.out.println("Excecao lancada: "+e.getMessage());
}
this.start(); // chama o método run
}
public void run(){
try {
String request = in.readLine();
System.out.println( "Request: "+request );
StringTokenizer st = new StringTokenizer(request);
if ((st.countTokens() >= 2) && st.nextToken().equals("GET")) {
if ((request = st.nextToken()).startsWith("/"))
request = request.substring( 1 );
if (request.equals(""))
request = request + "index.html";
File arq = new File(request);
leDocumento(out, arq);
}
else{
out.writeBytes( "Erro 400: arquivo nao encontrado.");
}
cliente.close();
}catch (Exception e) {
System.out.println("Excecao lancada: " + e.getMessage());
}
}
// Lê o arquivo e o envia para o cliente
public void leDocumento(DataOutputStream out, File arq) throws Exception {
try {
DataInputStream in = new DataInputStream(new FileInputStream(arq));
int tam = (int) arq.length();
byte[] buffer = new byte[tam];
in.readFully(buffer);
in.close();
out.writeBytes("HTTP/1.0 200 OK\r\n");
out.writeBytes("Tamanho do conteúdo: " + tam +"\r\n");
out.writeBytes("Tipo do conteúdo: text/html\r\n\r\n");
out.write(buffer);
out.flush();
}catch (Exception e) {
out.writeBytes("<html><head><title>Erro</title></head><body>\r\n\r\n");
out.writeBytes("HTTP/1.0 400 " + e.getMessage() + "\r\n");
out.writeBytes("Tipo do conteúdo: text/html\r\n\r\n");
out.writeBytes("</body></html>");
out.flush();
}finally {
out.close();
}
}
}
}
|
ClienteSimplesSSL.java
import java.io.*;
import java.net.*;
import java.security.*;
import javax.net.ssl.*;
public class ClienteSimplesSSL{
private static final int HTTPS_PORT = 443;
private static SSLSocket socket;
private String keystore = "kcliente";
private char[]password;
private String nome;
private String host;
public ClienteSimplesSSL(String nome, String password, String host){
this.nome = nome;
this.password = password.toCharArray();
this.host = host;
}
private SSLSocket criaSSLSocket(String host) throws Exception{
KeyStore ks = Utils.getKeyStore("JKS");
ks.load(new FileInputStream(keystore), password);
KeyManagerFactory kmf = Utils.getKMFactory("SunX509");
kmf.init(ks, password);
SSLContext sslcontext = Utils.criaSSLContext("SSLv3");
sslcontext.init(kmf.getKeyManagers(), null, null);
SSLSocketFactory ssf = sslcontext.getSocketFactory();
SSLSocket socket = (SSLSocket) ssf.createSocket(host,HTTPS_PORT);
return socket;
}
public void run(){
try{
socket = criaSSLSocket(host); //cria o socket SSL que o cliente utilizará
}catch(Exception e){
System.out.println("Excecao 1 lancada : "+e.getMessage());
}
try{
BufferedWriter out = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out.write("GET / HTTP/1.0\n\n");
out.flush();
//o trecho a seguir pega o arquivo do servidor, lê esse arquivo e imprime na tela
String linha;
StringBuffer sb = new StringBuffer();
while((linha = in.readLine()) != null) {
sb.append(linha);
sb.append("\n");
}
out.close();
in.close();
System.out.println(sb.toString());
}catch(Exception e){
System.out.println("Excecao 2 lancada: "+e.getMessage());
}
}
public static void main(String argv[]) throws IOException{
if (argv.length != 1) {
System.out.println("Deve ser informado o host em que o cliente deve se conectar.");
System.exit(0);
}
System.out.print("Informe o password para o keystore do cliente:");
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String password = in.readLine();
ClienteSimplesSSL cliente = new ClienteSimplesSSL("Cliente 1", password, argv[0]);
cliente.run();
}
}
|
Utils.java
import javax.net.ssl.*;
import java.security.*;
public class Utils{
protected static KeyStore getKeyStore(String tipo) throws KeyStoreException{
//utiliza a implementação do keystore provido pela Sun
return KeyStore.getInstance(tipo);
}
protected static KeyManagerFactory getKMFactory(String algoritmo) throws NoSuchAlgorithmException{
//cria um caminho de certificação baseado em X509
return KeyManagerFactory.getInstance(algoritmo);
}
protected static SSLContext criaSSLContext(String protocolo) throws NoSuchAlgorithmException{
//cria um SSLContext segundo o protocolo informado
return SSLContext.getInstance(protocolo);
}
} |
Clique aqui para pegar todos os arquivos.
Nota: esse arquivo contém uma pasta chamada classes, que contém as classes compiladas, os keystores e o arquivo index.html, e a pasta fontes, que contém os arquivos .java.
Apendice B: Referências
-
Usando OpenSSL - Uma implementação livre do protocolo SSL: http://www.pedro.jmrezende.com.br/trabs/hammurabi.htm
-
Autenticação de Usuários e Controle de Acesso com Certificação Digital - Uma Implementação com OpenSSL http://www.pedro.jmrezende.com.br/trabs/gelson.html
Documentação Oficial da API J2SE http://java.sun.com/docs
JavaTM Secure Socket Extension (JSSE) Reference Guide for the JavaTM 2 SDK, Standard Edition, v 1.4.2 http://java.sun.com/j2se/1.4.2/docs/guide/security/jsse/JSSERefGuide.html
SSL 3.0 Especification http://wp.netscape.com/eng/ssl3/draft302.txt