Artigos Java Trabalhando com Applet auto-assinado em Java

Para começar, é preciso entender a diferença entre um Applet e aplicação do ponto de vista de segurança. Máquina virtual Java (JVM) controla Applets dentro de uma região de segurança diferente em comparação com aplicações. As aplicações Java são por padrão considerado como confiáveis. A especificação JVM pressupõe que um aplicativo é controlado pelo desenvolvedor, por isso é de responsabilidade do usuário verificar o aspecto da segurança. Assim, o código do aplicativo Java é considerado como confiável e não é de responsabilidade da JVM para cuidar da segurança. Por outro lado, Applets são controlados pelo navegador e começa automaticamente pelo navegador após o download. Portanto, não se espera que os usuários tomem a responsabilidade do comportamento do Applet, porque eles não estão cientes das atividades do Applet baixado. Então, um Applet é considerado como intruso pela natureza e há uma série de restrições no lado da applet. Como resultado, os Applets são assinados pelo seu criador para torná-lo confiável e que o usuário deve ter o certificado necessário instalado durante o download do Applet.

Necessidade de Applet de auto-assinado

Como sabemos que os Applets são assinados por padrão e, sendo assim, não são de confiança. Portanto, há algumas restrições que um Applet assinado não pode executar. Segue abaixo as restrições:

  • Acessar o sistema de arquivos local do usuário e realizar operações de E/S.
  • Ler as propriedades do sistema do sistema como usuário local.
  • Abrir uma conexão via socket para um servidor diferente do servidor web que hospeda o Applet.

As restrições acima são impostas a um Applet assinado. Então, se o Applet precisa realizar operação I/O ou precisa acessar algum servidor, então ele precisa ser assinado com um certificado. Seguem-se os dois tipos de Applets assinados:

  • Applets auto-assinados: assinado pelos próprios desenvolvedores.
  • Applets assinados por autoridade certificadora: Este é um Applet assinado por uma autoridade certificadora. A assinatura é verificada pelo navegador através da ligação a um servidor independente executando remotamente pela autoridade de certificação.

Uma vez que o Applet é assinado por qualquer um dos procedimentos acima, em seguida, torna-se Applet confiável. Agora, o navegador pode baixar e iniciar um Applet assinado (auto-assinado ou usar a autoridade de segurança). O Applet automaticamente solicita permissão para executar fora do security sandbox (http://en.wikipedia.org/wiki/Sandbox_(computer_security)). Se o usuário concede permissão ao clicar no pop-up, o Applet é considerado como Applet de confiança e a responsabilidade vai para o usuário. O Applet assinado também é chamado de um Applet privilegiado que pode ser executado fora do security sandbox.

Agora vamos criar uma classe Applet e assiná-lo usando a auto assinatura.

Listagem 1: Applet para a entrada do usuário e criação de arquivo de saída


import java.awt.*; 
import java.applet.*; 
import java.awt.event.*; 
import java.io.BufferedWriter; 
import java.io.FileWriter; 
  
public class UserInput extends Applet implements ActionListener{ 
      // Create components 
    TextField key_text1,key_text2,key_output; 
      Label key_label1,key_label2,key_label3; 
      Button key_button; 
  
      public void init(){ 
        // Create layout   
        setLayout(null); 
        // Add different components to the layout. 
        key_label1 = new Label("Enter Keyword1: "); 
        key_label1.setBounds(20,20,100,20); 
        add(key_label1); 
  
        key_text1 = new TextField(5); 
        key_text1.setBounds(150,20,100,20); 
        add(key_text1); 
  
        key_label2 = new Label("Enter Keyword2: "); 
        key_label2.setBounds(20,50,100,20); 
        add(key_label2); 
  
        key_text2 = new TextField(5); 
        key_text2.setBounds(150,50,100,20); 
        add(key_text2); 
  
        key_label3 = new Label("Keywords are: "); 
        key_label3.setBounds(20,80,130,20); 
        add(key_label3); 
  
        key_output = new TextField(5); 
        key_output.setBounds(150,80,100,20); 
        add(key_output); 
  
        key_button = new Button("Get keywords"); 
        key_button.setBounds(150,110,100,20); 
        add(key_button); 
        // Add action listener 
        key_button.addActionListener(this); 
        } 
        
      public void actionPerformed(ActionEvent ae){ 
            Test t = new Test(); 
            t.print(); 
            // String to get the user input texts 
            String str1= key_text1.getText(); 
            String str2= key_text2.getText(); 
            // Show output on the third text box 
            key_output.setText(str1+"--"+str2); 
              
            try{                
                // Create out put file 
                FileWriter fstream = new FileWriter("output.txt",true); 
                BufferedWriter out = new BufferedWriter(fstream); 
                // Write to the file 
                out.write("\n"+str1+","); 
                out.write("\t"+str1+",");            
                out.write("\t"+str1+",");  
                // Flush the out put to the file 
                out.flush(); 
            } 
            catch (Exception e) 
            { 
                e.printStackTrace(); 
            } 
        } 
    }

Agora vamos criar um arquivo html para exibir o Applet através do navegador.

Listagem 2: O arquivo html contendo o Applet


<html> 
    <head> 
<title>Signed Applet Example</title>  
    </head> 
    <body> 
        <applet 
            code="UserInput.class"
     archive="SignedApplet.jar"
            width="640"
            height="480">            
        </applet> 
    </body> 
</html>

Criando Applet auto-assinado

Agora vamos discutir o processo de criação de um auto-certificado e assinar o Applet criado acima.

A seguir estão os três passos para criar um Applet auto-assinado.

  • Primeiro: Criando um par de chaves pública e privada.
  • Segundo: Crie um certificado para o par de chaves criado no passo acima.
  • Terceiro: associar o certificado com o arquivo JAR que contém o Applet.

Vamos ver agora um utilitário conhecido como "keytool" fornecido pelo JDK. Ele é usado para criar pares de chaves públicas e privadas. Durante a criação, a ferramenta solicitará a senha e muitos outros parâmetros que são armazenados na assinatura digital. Após a criação deste, um arquivo conhecido como key-store é criado no diretório atual. O arquivo de key-store contém o par de chaves pública e privada. A key-store como o nome sugere, pode conter mais de um par de chaves, e cada par de chaves é dado um nome (alias) que o identifica de forma única.

A seguir estão os comandos para criar pares de chaves usando 'keytool'. Se o usuário está criando o arquivo de key-store, pela primeira vez, em seguida, um novo arquivo será criado caso contrário, apenas um novo par de chaves com o nome do alias é adicionada a este ficheiro.

Primeiro: Crie uma key-store

Listagem 3: Criação de uma key-store

$ keytool -genkey -keystore newkeystore -alias newalias 
Enter keystore password:  password123 
What is your first and last name? 
  [Unknown]:  kaushik 
What is the name of your organizational unit? 
  [Unknown]:  software 
What is the name of your organization? 
  [Unknown]:  testorg 
What is the name of your City or Locality? 
  [Unknown]:  kolkata 
What is the name of your State or Province? 
  [Unknown]:  WB 
What is the two-letter country code for this unit? 
  [Unknown]:  IN 
Is CN=kaushik, OU=software, O=testorg , L=kolkata, ST=WB, C=IN correct? 
  [no]:  yes 
Enter key password for <newalias> 
        (RETURN if same as keystore password):

Segundo

O segundo passo é criar um certificado digital para assinar o Applet. Isso também é feito por meio do "keytool". O certificado é armazenado no mesmo arquivo de armazenamento de chaves criado no primeiro passo. O código a seguir demonstra a criação do certificado.

Listagem 4: Exemplo de criação de certificado de exibição

$ keytool -selfcert -keystore newkeystore -alias newalias 
Enter keystore password:  password123

Terceiro

O terceiro passo na auto-assinatura do Applet, usando o certificado digital criado na segunda etapa. Mas, antes de assinar o Applet, ele tem de ser incluído em um arquivo .jar. Lembre-se, apenas Applets contidos em um arquivo jar pode ser assinado. Segue-se o comando para certificar o jar do Applet.

Listagem 5: Exemplo de código para assinar o arquivo jar do Applet

$ jarsigner -keystore newkeystore SignedApplet.jar newalias 
Enter keystore password:  password123 
  
Warning: The signer certificate will expire within six months.

Esse processo cria um hash para cada classe Applet em um jar e os assina com a chave privada criada na primeira etapa. O hashs, chave pública e certificado estão incluídos no diretório META-INF do arquivo jar.

Depois de assinar um jar, o seu conteúdo não pode ser modificado. Se o usuário altera alguma coisa, então os hashes calculados pela ferramenta jar signer (assinador de jar) se tornará inválido. Uma vez que todas as etapas forem concluídas, o jar assinado pode ser incluído no arquivo html. Lembre-se, todos os arquivos como jar, html e classe deve ser mantido na mesma pasta. Caso contrário caminho correto deve ser mencionado no html. Agora quando as cargas de Applet no navegador o usuário receberá um pop-up, uma vez que o pop-up é aceito, o Applet vai começar a trabalhar como um Applet confiável.

Conclusão

Para concluir esse artigo, podemos dizer que um Applet é um componente útil em Java e é amplamente utilizado em diferentes aplicações críticas. Assim, a segurança do Applet deve ser assegurada para proteger o interesse do usuário. Auto-applets assinados podem ser usados durante a fase de desenvolvimento, mas na produção, o Applet deve ser assinado por uma autoridade de segurança adequada.

Artigo traduzido e originalmente publicado em: http://mrbool.com/what-is-self-signed-applet/28604