\documentclass[a4paper]{article}
\usepackage[utf8]{inputenc}
\usepackage[brazilian]{babel}
\usepackage{hyperref}
\usepackage{fullpage}
\renewcommand{\familydefault}{\sfdefault}
\usepackage{ifpdf}
\usepackage{graphicx}

\title{Applet Java Assinador Digital}
\author{Daniel Ricardo dos Santos \\
João Paulo Pizani Flor}
\date{\today}
\ifpdf
	\pdfinfo {
		/Author (Daniel Ricardo dos Santos e João Paulo Pizani Flor)
		/Title (Applet Java Assinador Digital)
		/Subject (SUBJECT)
		/Keywords (KEYWORDS)
		/CreationDate (D:20100704123417)
	}
\fi

\begin{document}
	\maketitle
	
	\section{Introdução}
        O trabalho final da disciplina de Segurança em Computação, no semestre 2010/1,
        consiste na implementação de um Applet Java® capaz de realizar as operações de
        assinatura digital de documentos e verificação da assinatura de tais documentos.
        O aluno tinha liberdade na escolha dos formatos de chave e algoritmos a serem
        usados, e também na maneira como seriam armazenadas no computador do cliente as
        chaves a serem utilizadas.
        
        O Applet deve estar disponível em uma página web publicada pelo aluno, e no
        carregamento dessa página o Applet deve ser exibido. O Applet deve ser capaz
        de acessar, no computador do usuário, os arquivos a serem assinados e/ou
        verificados, e também o(s) arquivo(s) contendo as chaves públicas e privadas
        utilizadas na operação.
        
        Como requisito adicional, o Applet produzido deve ser assinado digitalmente,
        isso para permitir que o computador cliente confie no Applet e conceda a ele
        permissão de acesso aos arquivos locais. Esse requisito também permitiu aos
        alunos a revisão dos conceitos de certificação digital e infra-estrutura de
        chaves púlbicas.
	    
	    
	\section{Solução adotada}
	    O trabalho exigia alguma forma de gerenciador de certificados digitais, onde
	    ficariam armazenados os certificados e chaves a serem utilizados pelo Applet.
	    Nosso grupo decidiu-se pelo uso do Keytool\cite{keytool}. O Keytool é uma
	    ferramenta padrão Java®, incluso na distribuição J2SE da Sun Microsystems.
	    
	    Utilizamos o Keytool para um objetivo duplo no trabalho. Primeiramente, era
	    necessário assinar o arquivo .jar contendo nosso Applet. Para tal tarefa, é
	    necessário utilizar um par de chaves do autor do Applet \emph{já importados}
        para o Keytool.
        
        Em segundo lugar utilizamos o Keytool como gerenciador do certificados e chaves
        a serem usados pelo \emph{usuário}, quando assinando ou verificando assinaturas
        de documentos usando nosso programa. Isto é, para utilizar nosso Applet, o
        usuário deve escolher um banco de dados (uma Keystore\cite{keystore}) contendo
        chaves e certificados, e então escolher um item desse banco de dados para
        realizar a operação desejada (assinar ou verificar).
        
        \begin{figure}[h]
            \begin{center}
                \includegraphics[scale=0.32]{ss.png}
            \end{center}
            \caption{Interface do Applet}
            \label{fig:applet}
        \end{figure}
        
        A figura \ref{fig:applet} demonstra a interface gráfica com o usuário (GUI) do
        Applet desenvolvido. 
        Para assinar um documento, o usuário deve escolher o arquivo a ser
        assinado, assim como a chave privada que vai utilizar (dentre as disponíveis
        no Keystore). Ao comandar a assinatura, é gerado um arquivo no mesmo diretório
        do documento original, com o sufixo ``.sign'' no nome. Tal arquivo contém a
        assinatura, em formato binário. Já para verificar uma assinatura, além de
        escolher o arquivo a ser verificado e a chave pública a utilizar, o usuário
        deve também escolher o arquivo que contém a assinatura.
	    
	\section{Ferramentas utilizadas}
	    \subsection{Keytool e Jarsigner}
	        O Jarsigner\cite{jarsigner} é a ferramenta da distribuição Java® que serve
	        ao propósito de assinar digitalmente pacotes .jar. Utilizando o Jarsigner,
	        um autor de software Java® pode assinar suas obras, fazendo com que seus
	        programas possam rodar de forma confiável em todos os clientes que possuam
	        sua chave pública. Para assinar um .jar, utiliza-se o seguinte comando:
	        
\begin{verbatim}
    jarsigner [opções] arquivo-jar alias
\end{verbatim}

            Tal comando utiliza a chave privada armazenada sob o nome ``alias'' no
            keystore especificado para assinar o ``arquivo-jar'', e gera o .jar
            assinado com o mesmo nome, sobrescrevendo o original.
	    
	        Já o Keytool é o programa de gerenciamento de certificados da distribuição
	        Java®. Ele permite importar/exportar/criar pares de chaves e certificados
	        correspondentes, que poderão então ser usados para várias tarefas, dentre
	        elas a de assinar um JAR usando o Jarsigner. Mais detalhes sobre o uso
	        do Keytool no escopo desse trabalho estão nas próximas seções.
	        
	    \subsection{API Java Keystore}
	        A biblioteca padrão da linguagem Java® possui um amplo framework de
	        segurança, e uma parte importante desse framework é a
	        API Keystore\cite{keystore-api}. Essa API permite a utilização de bases de
	        dados de chaves e certificados (Keystores) que foram criados e gerenciados
	        pelo utilitário Keytool.
	        
	        Através do uso dessa API foi possível acessar facilmente as chaves e
	        certificados do keystore no computador do cliente, mostrando no Applet
	        e permitindo ao usuário escolher a chave para realizar a assinatura e/ou
	        verificação.
	        
	        De particular importância foi a classe \emph{java.security.KeyStore}, e em
	        especial seus métodos \emph{aliases()}, \emph{getCertificate(String alias)}
	        e \emph{getKey(String alias, char[] password)}.
	        
	\section{Uso do Keytool}
        Para assinar o Applet foi usada uma Infra-estrutura de Chaves Públicas de dois
        níveis, onde meu certificado (do autor) é assinado diretamente por uma AC Raiz
        que pertence a meu colega de grupo, Daniel Ricardo dos Santos.
        O diagrama\ref{fig:pki} representa essa infra-estrutura.

        \begin{figure}[h]
            \begin{center}
                \includegraphics[scale=0.25]{pki.png}
            \end{center}
            \caption{Infra-estrutura de chaves}
            \label{fig:pki}
        \end{figure}
        
        Inicialmente foi necessário importar no Keytool o certificado auto-assinado da
        AC Raiz. Para isso foi utilizado o comando:
        
\begin{verbatim}
    keytool -importcert -alias "AC Raiz" -file rootca.pem -keystore javaKeys
\end{verbatim}
        
        O comando importou o certificado presente no arquivo ``rootca.pem'' para o
        keystore ``javaKeys'', sob o nome (alias) ``AC Raiz''. Foram exibidos os
        detalhes do certificado para que o USUÁRIO pudesse confirmar a confiança,
        já que ele é auto-assinado e sua confiança não pode ser verificada
        automaticamente. O próximo passo foi a geração dos pares de chaves, tanto o
        que vai servir a assinatura do pacote .jar, quanto o que vai ser utilizado
        pelo usuário na operação do Applet. Ambos foram gerados da seguinte forma:
        
\begin{verbatim}
    keytool -genkeypair -alias <"jarsign"|"Joao Paulo"> -keystore javaKeys
\end{verbatim}

        Tendo gerado os pares de chaves, necessitamos agora exportar uma
        \emph{requisição de certificado} para cada chave pública de cada par, essa
        requisição será então assinada pela AC Raiz e então reimportadas no keytool,
        já devidamente assinadas e com a cadeia de confiança estabelecida. Os comandos
        que exportam a requisição de certificado e importam os certificados devidamente
        assinados são os seguintes:
        
\begin{verbatim}
    keytool -certreq -alias <"jarsign"|"Joao Paulo"> -file <jarreq.pem|joaoreq.pem> -rfc
    keytool -importcert -alias <"jarsign"|"Joao Paulo"> -file <jarcert.pem|joaocert.pem>\end{verbatim}

    
    \section{Operação do Applet}
	    O Applet possui basicamente dois modos de operação: Assinar e Verificar
	    assinatura. Cada um desses modos é descrito em mais detalhes a seguir. Todas
	    as informações sobre a operação do Applet, incluindo possíveis mensagens de
	    erro, são exibidas na \emph{barra de status}, na parte inferior do Applet, logo
	    abaixo do botão ``Realizar operação''.
	    
	    \subsection{Assinar}
	        Para assinar um documento digital em seu computador, o usuário do Applet
	        deve seguir o seguinte procedimento:
	        
	        \begin{itemize}
	            \item Clicar no botão \emph{Escolher arquivo a assinar / verificar} e
	            selecionar o arquivo a ser assinado
	            
	            \item Clicar no botão \emph{Escolher Keystore} e selecionar o arquivo
	            contendo o banco de dados de chaves que deseja utilizar
	            
	            \item Selecionar a opção \emph{Assinar}, logo abaixo \emph{Operações}.
	            
	            \item Finalmente, clicar em \emph{Realizar operação}
	        \end{itemize}
	        
	        O resultado do processo será mostrado na barra de status. Caso a assinatura
	        tenha sido bem-sucedida, será exibida a mensagem \emph{Arquivo assinado
	        com sucesso}. Caso contrário a mensagem do erro ocorrido será mostrada.
	        
	    \subsection{Verificar assinatura}
	        Os passos a seguir devem ser realizados para fazer a verificação de uma
	        assinatura digital utilizando nosso Applet. O usuário precisa ter em mãos,
	        além do arquivo cuja assinatura deseja verificar, também a ASSINATURA em si.
	        
	        \begin{itemize}
	            \item Clicar no botão \emph{Escolher arquivo a assinar / verificar} e
	            selecionar o arquivo cuja assinatura deve ser verificada
	            
	            \item Clicar em \emph{Escolher Keystore} e selecionar o arquivo contendo
	            o banco de dados de chaves e certificados a serem utilizados
	            
	            \item Selecionar o opção \emph{Verificar assinatura}, logo abaixo
	            \emph{Operações}. Será então exibida uma tela de seleção de arquivo,
	            pedindo que se escolha o arquivo contendo a ASSINATURA.
	            
	            \item Por fim, clicar em \emph{Realizar operação}
	        \end{itemize}
	        
	        Caso a assinatura corresponda de fato ao arquivo e ao suposto dono, será
	        exibida na barra de status a mensagem \emph{Assinatura verificada com
	        sucesso}. Caso a assinatura não seja condizente (não confira), a mensagem
	        será \emph{Assinatura não condiz com o conteúdo do arquivo}. Eventuais erros
	        na execução do processo também são reportados na barra de status.



	\bibliographystyle{plain}    
	\bibliography{referencias}

\end{document}
