Como assinar um applet

Como assinar um applet

Fonte: http://insonix.blogspot.com/2009/04/como-assinar-um-applet.html

Se você estiver se perguntando, para que precisa assinar meu applet, ai vai a resposta.
Existem várias questões de segurança envolvendo a chamada de arquivos e aplicações externas de dentro do navegador, e para executar alguma função mais específica, ou até mesmo rodar executáveis do sistema operacional a partir do seu applet, você precisa criar uma assinatura digital para ele.
Até mesmo para identificar que este applet é assinado pela empresa ou site cujo ele está sendo executado.

Vamos ao que interessa.

Como exemplo, eu criei um applet Exemplo.java que gerou o binário Exemplo.class.

1 – Criar um JAR
Criar um JAR com a classe envolvida, pois a assinatura será feita em cima do jar.
Na linha de comando, vá até a pasta em que o .class de sua classe está e digite:

jar cvf Exemplo.jar Exemplo.class

Neste momento foi criado um jar chamado Exemplo.jar.

2 – Criar o par de chaves (chave pública e privada)
Na linha de comando digite:

keytool -genkey -dname “cn=Exemplo, ou=Laboratorio, o=Empresa, c=BR” -alias exemplo -storepass 123456 -validity 3655

Detalhes do comando

-dname = dados da organização/empresa/site
-alias = nome da chave criada, no caso “exemplo”
-storepass = pass da chave, quando for assinar um jar com esta chave por exemplo, será necessário digitar este pass
– validity = quantidade de dias de validade da assinatura digital

Esta chave fica guardada na pasta home do usuário, e você poderá utilizar apenas o alias dela quando for assinar o JAR.

3 – Assinar o JAR do applet
Assinar o JAR do applet, criado no passo 1.

Na linha de comando digite:

jarsigner -storepass 123456 Exemplo.jar exemplo

Detalhes do comando

-storepass = pass da chave, conforme explicado no passo 2
Exemplo.jar = arquivo jar criado no passo 1
exemplo = alias da chave, criada no passo 2.

Pronto, é só jogar o seu JAR para sua aplicação, e agora caso você em seu applet, chamava um .class, é só chamar o .JAR.

Seu applet já está assinado.

Anúncios

Criando arquivos .jar

//
// Olá a todos, em primeiro lugar gostaria mais uma vez agradecer o apoio, comentários e críticas de todos vocês.
Nem sempre consigo responder todos os emails e comentários, mas quero que saibam que todos são lidos e são de grande importância para mim, por tanto muito obrigado.

Muitas pessoas tem me perguntado sobre como trabalhar com arquivos compactados .jar, pois na maior parte das vezes a nossa aplicação java não se resume apenas a um arquivo .java, e sim, são compostas de vários arquivos, então como fazer para tornar a vida mais fácil na hora de um “deploy” ou mesmo no manuseio dos mesmo? A forma mais fácil é criar um arquivo .jar contendo todos os arquivos do nosso projeto, hoje veremos como fazer isso utilizando o comando “jar” para criar um pacote “executável” com os arquivos da nossa aplicação.

Gostaria de dedicar esse artigo ao meus amigos que tem me perguntado sobre arquivos .jar em especial ao Adriano, foi por causa de suas perguntas que escrevi esse artigo.

Agora sem mais demora vamos ao que interessa. Para esse artigo iremos precisar de alguns códigos .java para que possamos gerar o pacote da nossa aplicação, como o intuito é explicar como gerar o arquivo .jar, os códigos não serão comentados, são apenas dois códigos simples que escrevi para esta demonstração.

Vamos criar um diretório qualquer para o nosso projeto, eu criei um diretorio chamado “jarfiles”, (que de agora em diante será chamado de diretório RAIZ) e dentro dele criaremos mais alguns diretórios:
src – diretório onde colocaremos nossos arquivos fonte
bin – diretório onde colocaremos os arquivos compilados

E dentro do diretorio “src” criaremos mais um diretório chamado “init”, é um nome qualquer apenas para mostrar como fazer para rodar um arquivo que estará dentro dele, e para demostrar que é possível criar diversos diretórios e colocá-los todos no nosso .jar.

Agora que já temos os diretórios iremos criar duas classes dentro do diretório “src/init”, são elas:

OlaMundo.java

package init;

/**
* @author Dayvid Lima
*/

public class OlaMundo {
public void falaOla(){
System.out.println(“Olá mundo cruel!”);
}
}

UsaOlaMundo.java

package init;

/**
* @author Dayvid Lima
*/

public class UsaOlaMundo {

public static void main(String[] args){
OlaMundo om = new OlaMundo();
om.falaOla();
}
}

Prontinho, agora vamos compilar nossos códigos java para dentro do diretório bin, para isso uma vez estando dentro do diretório RAIZ no prompt do DOS ou em um terminal qualquer, vamos digitar:
javac src/init/*.java -d bin/

Isso fará com que os arquivos .java que estão em /src/init/ sejam compilados e colocados em /bin/init/.

Para ver se está tudo ok iremos rodar nossa aplicação, primeiro entramos no diretório “bin”, e então executamos nossa aplicação com o comando:
java init.UsaOlaMundo

Se tudo der certo veremos a mensagem “Olá mundo cruel!” na tela.

Bom agora que tudo está ok chegou a hora do que realmente interessa, compactar todos esses arquivos em um único arquivo .jar e rodar a aplicação a partir dele.

Para criar o arquivo .jar iremos fazer uso do comando “jar”, existem diversas opções que podemos passar para o comando jar, iremos nesse artigo fazer uso das seguintes:
c – cria um novo arquivo
v – modo “verbose”, mostra na tela o que está acontecendo
f ARQUIVO_JAR – especifica o nome que queremos para o arquivo .jar
m ARQUIVO_DE_MANIFESTO – inclue o arquivo informado como arquivo de manifesto (veremos isso na segunda parte da explicação)

Ainda dentro do diretório bin, tudo que temos que fazer para criar nosso .jar é executar o comando:
jar cvf Ola.jar init/*

Pronto, com isso temos nossa aplicação agora dentro do arquivo Ola.jar, vamos então executá-la, para fazer isso devemos informar no classpath onde está nossa aplicação (no caso a classe init.UsaOlaMundo),
Podemos tanto colocar o arquivo Ola.jar no nosso classpath quanto informar esse parâmetro no momento da execução como no comando abaixo:
java -classpath Ola.jar init.UsaOlaMundo

Muito bom, meus parabéns, agora você tem a sua aplicação toda em um arquivo só, pois bem, vamos facilitar um pouco mais as coisas.

Se olharem dentro do arquivo Ola.jar (abram ele com um compactador qualquer como Winzip ou Winrar, pois ele é apenas um arquivo compactado sem utilizar compressão, isso mesmo, você poderia ter simplesmente criado um arquivo .zip ou .rar com o seu compactador preferido informando a ele para não utilizar compactação, apenas adicionar os arquivos e depois renomear o mesmo para .jar que ainda assim funcionaria.

Enfim, voltando a aplicação, veja que dentro dele temos um diretório META-INF contendo o arquivo MANIFEST.MF, pois bem, esse arquivo contém informações sobre a nossa aplicação, como não criamos esse arquivo, ele tem apenas algumas informações básica, vamos então criar o nosso MANIFEST.MF e ver em que ele pode nos ajudar.

Quando executamos nossa aplicação vocês se lembram que tivemos que infomar no classpath o arquivo Ola.jar para que fosse possível rodar a classe “init.UsaOlaMundo”, agora iremos criar um arquivo de manifesto para que seja possível rodar nossa aplicação informando apenas o arquivo Ola.jar e não mais o nome da classe e pacote (init.UsaOlaMundo).

Para isso criaremos o nosso próprio MANIFEST.MF, salvem o código abaixo em um arquivo chamado MANIFEST.MT dentro do diretório “bin”.

Manifest-Version: 1.0
Created-By: Dayvid Lima
Main-Class: init.UsaOlaMundo

O mais importante aqui é a última linha “Main-Class: init.OlaMundo”, aqui eu digo qual classe será chamada quando o arquivo Ola.jar for executado.

Arquivo salvo, estamos prontos para continuar. Dentro do diretório bin vamos apagar o nosso antigo Ola.jar e criar um novo, agora informando qual arquivo de manifesto que iremos utilizar,
Para isso basta mudar um pouco nosso comando jar como no exemplo abaixo:
jar cvfm Ola.jar MANIFEST.MF init/*

Agora para rodar nossa aplicação precisamos apenas do comando abaixo:
java -jar Ola.jar

E o arquivo MANIFEST.MF se encarrega de dizer a virtual machine qual a classe que queremos que seja executada.

Anexo deixo para download o arquivo jarfiles.zip, contendo os arquivos citados nesse artigo para facilitar o trabalho de todos, mais uma vez espero que este artigo tenha sido satisfatório e que venha a ajudar, até o próximo.

Fonte: http://www.plugmasters.com.br/sys/materias/793/1/Criando-arquivos-.jar

Dayvid Lima Desenvolvedor Java há mais de 5 anos, atualmente consultor java em empresa multinacional utilizando recursos avançados da tecnologia J2EE com servidores de aplicação em plataforma Solaris para gerenciamento de redes e integração de sistemas.

Oracle compra Sun por US$ 7,4 bilhões

Rogil – Após negociação com IBM, Sun é comprada pela Oracle em negócio que pagará US$ 9,5 por ação.

A Oracle comprou a Sun Microsystems por 7,4 bilhões de dólares, impulsionando a desenvolvedora de softwares corporativos no setor de hardware e fazendo com que a Sun seja a mais recente operação de TI englobada pela empresa comandada por Larry Ellison.

A Oracle pagará 9,5 dólares por ação em dinheiro para a Sun, de acordo com a Oracle, aumento de 42% em relação ao preço do seu fechamento na sexta-feira (17/04). Excluindo débitos, a aquisição é avaliada em 5,6 bilhões de dólares.

A aquisição da Sun segue outras compras feitas pela Oracle no setor de tecnologia nos últimos anos, como Siebel, PeopleSoft e BEA Systems.

O acordo é anunciado após a Sun ter se afastado de uma negociação com a IBM há algumas semanas.

Ainda que houvesse boatos sobre uma possível aquisição por parte da Oracle, a empresa nunca tinha tido uma participação nos setores de sistema operacional para servidores ou hardware.

A Oracle afirmou que o acordo com a Sun deve trazer mais receita à companhia no primeiro ano após a compra do que as aquisições da BEA Systems, PeopleSoft e Siebel juntas.

A Sun deverá contribuir com 1,5 bilhão de dólares ao lucro operacional da Oracle no primeiro ano após a fusão, número que deverá ultrapassar a marca dos 2 bilhões de dólares no segundo ano, anunciou a Oracle.

Fonte: http://idgnow.uol.com.br/mercado/2009/04/20/oracle-compra-sun-por-us-7-4-bilhoes/

Instalando e Configurando o Java (JDK) no Ubuntu 8.04

13-08-2008
Escrito por Paulo Cassiano
Fonte: http://paulocassiano.wordpress.com/2008/08/13/instalar-java-ubuntu-804/

Para instalar e configurar o JDK (versão 6) no Ubuntu 8.04, siga esses passos:

1) Abra uma janela de terminal;

2) Digite: $ sudo apt-get -y install sun-java6-bin sun-java6-plugin sun-java6-jre sun-java6-jdk sun-java6-fonts <ENTER>; Em seguinda, digite a senha de root <ENTER>;

3) Apesar de termos usado a opção -y no passo anterior, é necessário rolar a janela do terminal em que ele exibe a Licença de Uso até o final e, ao final, digitar y <ENTER>;

4) Agora digite: $ sudo update-java-alternatives -s java-6-sun <ENTER>

É necessário editar o arquivo /etc/jvm. Ele define a ordem de pesquisa padrão da JVM no sistema. Cada JVM deve listar seu diretório JAVA_HOME compatível neste arquivo. A JVM padrão do sistema é a primeira disponível de cima para baixo. Para abrir o arquivo:

5) Digite: $ sudo gedit /etc/jvm <ENTER>

Certifique-se que a linha /usr/lib/jvm/java-6-sun está adicionada no topo da lista. O arquivo deverá ficar assim:

/usr/lib/jvm/java-6-sun
/usr/lib/jvm/java-gcj
/usr/lib/jvm/ia32-java-1.5.0-sun
/usr/lib/jvm/java-1.5.0-sun
/usr

Salve e feche o arquivo.

Agora vamos configurar as variáveis de ambiente (JAVA-HOME e PATH).

6) Abra o arquivo $HOME/.bash_profile: $ sudo gedit $HOME/.bash_profile <ENTER>

Adicione as seguintes linhas:

export JAVA_HOME=/usr/lib/jvm/java-6-sun
export PATH=$PATH:$JAVA_HOME/bin

Salve e feche o arquivo.

7) Para testar a instalação, digite o seguinte comando no terminal: $ java -version <ENTER>

Se a saída for:

java version “1.6.0_03″
Java(TM) SE Runtime Environment (build 1.6.0_03-b05)
Java HotSpot(TM) Server VM (build 1.6.0_03-b05, mixed mode)

A instalação foi feita corretamente ;-)

Agora vamos criar um programa de teste.

8 ) Digite: $ gedit Teste.java <ENTER>

e acrescente as linhas abaixo:

public class Teste {
public static void main(String[] args) {
System.out.println(”A instalação funcionou!”);
}
}

Salve e feche o arquivo.

Agora vamos compilar o arquivo Teste.java.

9) Digite: $ javac Teste.java <ENTER>

E para executar este pequeno programa,

10) Digite: $ java Teste <ENTER>

Se a saída exibida for:

A instalação funcionou!

Parabéns! O JDK foi instalado corretamente em seu sistema. Agora você já pode desenvolver em Java usando o Ubuntu.

Principais Atalhos da IDE Eclipse

Conteudo retirado do site: http://robsonmedeiros.wordpress.com/2008/06/20/principais-atalhos-da-ide-eclipse/

Alguns dos principais atalhos da IDE Eclipse.

Busca

  • Ctrl+Shift+R
    Busca e abre rapidamente qualquer item do projeto, seja ele uma classe, arquivo XML, arquivo de properties, bytecode etc.
  • Ctrl+T
    Mostra a hierarquia da classe atual, permitindo abrir rapidamente qualquer classe da hierarquia.
  • Ctrl+H
    Abre a janela de pesquisa nos arquivos do workspace. Nela é possível procurar tanto por trechos textuais nos arquivos, quanto por referências a elementos da linguagem como tipos, métodos, pacotes, atributos etc.
  • Ctrl+J
    Busca incremental no arquivo aberto. O cursor é posicionado no trecho de código correspondente à medida em que o programador digita o termo de pesquisa.
  • Ctrl+Alt+G
    Pesquisa no workspace por todas as ocorrências do elemento sobre o qual o cursor está posicionado.

Navegação no código

  • Alt+Left
    Volta para a última posição editada.
  • Alt+Right
    Avança para a próxima posição editada.
  • Ctrl+O
    Mostra a estrutura (outline) do arquivo que está sendo editado e permite navegar até declaração selecionada.
  • Ctrl+G
    Localiza a declaração da classe, interface, atributo ou método selecionado.
  • Crtl+Shift+G
    Localiza todas as referências à classe, interface, atributo ou método selecionado existentes no workspace.
  • Ctrl+3
    Navegação rápida. Navega entre todos os itens abertos em todas as views e perspectivas abertas no momento. Novo no Eclipse 3.3 .

Organização do código

  • Crtl+Shift+F
    Formata automaticamente o trecho de código selecionado de acordo com as configurações definidas em Window > Preferences > Java > Code Style > Formatter
  • Crtl+Shift+O
    Organiza os imports do arquivo aberto, removendo as declarações desnecessárias.
  • Alt+(Seta para cima ou para baixo)
    Move a linha atual para cima ou para baixo.
  • Alt+Shift + (Seta para cima ou baixo)
    Copia a linha atual para cima ou para baixo

Depuração

  • Ctrl+1
    Invoca a funcionalidade de reparo rápido (quick fix) quando o compilador acusa algum erro. O reparo rápido consiste em um pop-up com uma lista de sugestões de modificação que são aplicadas automaticamente ao selecionar.
  • Ctrl+Shift+I
    Inspeciona o valor das variáveis enquanto ocorre a depuração. Disponível apenas na perspectiva Debug.

Refactoring

  • Alt+Shift+R
    Renomeia o elemento.
  • Alt+Shift+L
    Extrair para variável local. Atribui a expressão selecionada a uma váriavel.
  • Alt+Shift+M
    Extrair método. Cria um novo método contendo o trecho de código selecionado.

Configuração

  • Ctrl+Shift+L
    Mostra a lista de atalhos de teclado.
  • Ctrl+Shift+L duas vezes
    Abre a tela de personalização de atalhos de teclado.

Protegendo o seu código java da engenharia reversa

Fonte: http://erkobridee.com/2008/06/19/protegendo-o-seu-cdigo-java-da-engenharia-reversa/

Publicado por Erko Bridee em 19/06/2008 18:02 pm | sobre: Desenvolvimento, JAVA, Segurança, Tutorial, tilidade

Caso você seja um desenvolvedor de aplicações java, é importante compreender que os arquivos binários .class do Java podem ser facilmente descompilados em uma engenharia reversa. Neste post iremos ver como um arquivo .class Java é revertido para um fonte Java e como proteger o seu código disto.

O código fonte java é compilado para um arquivo ,class, o qual possui o código binário. A máquina virtual Java (JVM) precisa apenas desse arquivo para executar a sua aplicação. O problema é que este arquivo .class pode ser facilmente descompilado, recuperando o seu código fonte original, utilizando alguma ferramenta para descompilação do .class e caso você procure no Google irá perceber que não é dificil encontrar uma ferramenta para fazer exatamente isto.

A melhor solução para previnir a engenharia reversa é ofuscar o nosso arquivo .class, o que irá dificultar e muito a engenharia versa. De acordo com o dicionário ofuscar que dizer “tornar algo obscuro, não compreensível“. E é exatamente isto o que muitas ferramentas de ofuscar faz, como será explicado a seguir.

Descompilando um arquivo .class Java

Antes de compreender como um ofuscar um código java, vamos tentar compreender como alguem consegue realziar uma engenharia reversa da sua aplicação java. A seguir 3 passos para explicar como um arquivo .class é recuperado desse o código fonte java original, usando técnicas de engenharia reversa.

1. Crie um HelloWorld.java como o código abaixo:

  1. public class HelloWorld {  
  2.     public static void main (String args[]) {  
  3.         String userMessage = “Hello World!”;  
  4.         int userCount = 100;  
  5.         userCount = userCount + 1;  
  6.         System.out.println(userMessage);  
  7.         System.out.println(userCount);  
  8.     }  
  9. }  
public class HelloWorld {
    public static void main (String args[]) {
        String userMessage = “Hello World!”;
        int userCount = 100;
        userCount = userCount + 1;
        System.out.println(userMessage);
        System.out.println(userCount);
    }
}

2. Compile o programa HelloWorld.java e execute, algo como o feito a seguir:

$ javac HelloWorld.java
$ java HelloWorld
Hello World!
101

O arquivo Java .class contém apenas o byte code. caso você tente ver o conteúdo do arquivo .class, irá notar que é algo que humanamente não é compreensível, como o que é mostrado abaixo:

$ vi HelloWorld.class
Ãþº¾^@^@^@2^@
^@^G^@^P^H^@^Q  ^@^R^@^S
^@^T^@^V^G^@^W^G^@^X^A^@^F<init>^A^@^C()V^A^@^DCode^A^@^OLineNumberTable
^A^@^Dmain^A^@^V([Ljava/lang/String;)V^A^@
SourceFile^A^@^OHelloWorld.java^L^@^H^@ ^A^@^LHello World!^G^@^Y^L^@^Z^@^[^G^@^\^L^@^]^@^^^L^@^]^@^_^A^@
HelloWorld^A^@^Pjava/lang/Object^A^@^Pjava/lang/System^A^@^Cout^A^@^ULjava/io/PrintStream;^A
^@^Sjava/io/PrintStream^A^@^Gprintln^A^@^U(Ljava/lang/String;)V^A^@^D(I)V^@!^@^F^@^G^@^@^@^@^@^B^@^A^@^H^@  ^@^A^@

3. Descompilando o arquivo HelloWorld.class e vendo o código fonte original

Para esta demonstração utilizaremos o decompilador Jad que é gratuíto para um uso não comercial. Realize o download da respectiva versão para o seu sistema operacional. Use o jad para realizar a engenharia reversa do arquivo HelloWorld.class e recuperer o código fonte original, como mostrado a seguir:

$ unzip jadls158.zip
$ ./jad HelloWorld.class
Parsing HelloWorld.class…
Generating HelloWorld.jad
$ vi HelloWorld.jad <Isto irá mostrar o código fonte original, fruto da execução da engenharia reversa>

Ofuscando a sua aplicação java

Agora iremos ver como ofuscar e proteger o seu código fonte da engenharia reversa, usando o ProGuard que é um software gratuíto com licensa GPL.

1. Faça o Download e instale o ProGuard

$ cd /home/jsmith
$ unzip proguard4.2.zip

2. Crie um arquivo de configuração proguard

Crie um myconfig.pro que conterá as informações sobre a sua aplicação java.

-injar : Especifica a localização do seu arquivo jar, o qual contém os arquivos .class da compilação da sua classe java.

-outjar : Este é o arquivo jar que o proguard irá criar após a ofuscação do código. Este conterá todo o código alterado, lacrado, com as nomenclaturas de métodos e variáveis obscurar, o que vai dificultar muito para algum humano converseguir realizar a engenharia reversa.

-printmapping : ProGurad irá gerar uma saída com todas as saídas, em um arquivo com as informações mapeadas, em um arquivo que você especificar.

-keep : Incida os arquivos .class ou os métodos que você não quer que o ProGuard altere.

Para exemplificar, imagineos um mypkg.MainAppFrame como informação de onde está a nossa classe principal da aplicação, sendo esta classe neste exemplo, nós não queremos que seja ofuscada pelo ProGuard, como no exemplo a seguir:

$ cat myconfig.pro
-injars /home/jsmith/myapp.jar
-outjars /home/jsmith/myapp-obfuscated.jar This is the obfuscated jar file
-libraryjars /usr/java/jdk1.5.0_14/jre/lib/rt.jar
-printmapping proguard.map
-verbose
-keep public class mypkg.MainAppFrame

3. Execute o ProGuard

$ cd /home/jsmith/proguard4.2/lib
$ java -jar proguard.jar @myconfig.pro

Isto irá criar 2 arquivos, descritos a seguir:

* myapp-obfuscated.jar: Contém os arquivos das .class ofuscados da sua aplicação. E este você poderá distribuir sem medo algum de que alguem venha tentar realizar uma engenharia reversa, não que seja impossível, mas vai dar muito trabalho, o que acaba fazendo com que desistam da idéia.
* proguard.map: Este arquivo contém as informações do mapeamento para você se referenciar, sobre o que foi feito.

4. Exemplo de arquivo proguard.map

Este exemplo de arquivo proguard.map é o que indica o nome original que havia nos fontes java (nome do .class, métodos, variáveis, etc) e o respectivo nome a ser utilizado.

myapp.AppToolBar -> myapp.ae:
javax.swing.JButton btnNew -> d
javax.swing.JButton btnOpen -> e

5. Exemplo de código java (myapp.AppToolBar) antes de ser ofuscado

  1. btnNew = changeButtonLabel(btnNew, language.getText("new"));  
  2. btnOpen = changeButtonLabel(btnOpen, language.getText("open"));  
btnNew = changeButtonLabel(btnNew, language.getText("new"));
btnOpen = changeButtonLabel(btnOpen, language.getText("open"));

6. Exemplo de código fonte java que foi decompilado de um arquivo .class (myapp.ae) despois deste ter sido ofuscado

  1. d = a(d, n.a("new"));  
  2. e = a(e, n.a("open"));  
d = a(d, n.a("new"));
e = a(e, n.a("open"));

Aqui você pode ver a linha “btnNew = changeButtonLabel(btnNew, language.getText(”new”));” que foi traduzida para “d = a(d, n.a(”new”));”, pelo ProGuard, essa linha de código que não irá fazer sentido nenhum para alguem que venha a decompilar esta classe em uma engenharia reversa.