Criptografia com MD5 no Java ME

27 agosto 2009 0 comentários

O MD5 (Message-Digest algorithm 5) é um algoritmo de hash de 128 bits unidirecional, muito utilizado por softwares com protocolo ponto-a-ponto, verificação de integridade e logins.
Os hashes MD5 de 128-bit (16-byte) são normalmente representados por uma sequência de 32 caracteres hexadecimais. O seguinte mostra uma string ASCII com 43-bytes e o hash correspondente:

MD5("The quick brown fox jumps over the lazy dog")
= 9e107d9d372bb6826bd81d3542a419d6


Vulnerabilidade

Como o MD5 faz apenas uma passagem sobre os dados, se dois prefixos com o mesmo hash forem construídos, um sufixo comum pode ser adicionado a ambos para tornar uma colisão mais provável. Deste modo é possível que duas strings diferentes produzam o mesmo hash.

Vale ressaltar que o MD5 é um algoritmo de mão única! Então se gravarmos dados criptografados no banco (ex. Login/Senha), para fazermos a autenticação é necessário criptografar a string de entrada e comparar com o dado criptografado que está gravado no BD.

Neste post vamos mostrar um exemplo utilizando o algoritmo MD5 para criptografar uma senha afim de gravá-la no banco de dados. Essa técnica pode ser usada para qualquer tipo (ou toda) de informação que trafega pela rede ou que são gravadas no banco.

O MD5 é uma das soluções para criptografar informações, porém esta criptografia já é falha! Hoje já existem procedimentos que quebram este algoritmo, justamente por possuir uma Vulnerabilidade (citada acima).

Uma outra solução é um novo projeto Open Source brasileiro em Java, chamado BR1E.

Então vamos ao código para exemplificar o MD5 no Java / Java ME.


import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import com.twmacinta.util.MD5;

public class MD5Hash extends MIDlet implements CommandListener {

private Display display;
private Form FormTeste;
private TextField textField1;
private TextField textField2;
private Command comandoDeSaida;
private Command comandoCriptografar;

public void startApp() {
display.setCurrent(FormTeste);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
display.setCurrent(null);
notifyDestroyed();
}

public MD5Hash() {
display = Display.getDisplay(this);
textField1 = new TextField("Senha", null, 120, TextField.ANY);
textField2 = new TextField("Senha Criptografada", null, 120, TextField.ANY);
FormTeste = new Form("Formulário");
FormTeste.append(textField1);

comandoDeSaida = new Command("Sair", Command.EXIT,1);
comandoCriptografar = new Command("Criptografar", Command.OK,1);
FormTeste.addCommand(comandoCriptografar);
FormTeste.addCommand(comandoDeSaida);
FormTeste.setCommandListener(this);
}

public void commandAction(Command comando, Displayable s)
{
if (comando == comandoDeSaida){
destroyApp(false);
}
if (comando == comandoCriptografar){
Criptografar();
}

}

public void Criptografar() {
FormTeste.append(textField2);

//converter o texto em bytes
byte plain[] = textField1.getString().getBytes();
// criar um objeto MD5Hash passando a sequencia de bytes resultante do texto digitado
MD5 md5 = new MD5(plain);
// pegando o resultado hash gerado
byte[] result = md5.doFinal();
// convertendo o conjunto de bytes em hexadecimal e aplicando ao objeto texto do display
textField2.setString(MD5.toHex(result));
}
}
Fonte:
http://pt.wikipedia.org/wiki/MD5
http://mobilepit.com/10/compact-md5-class-library-for-j2me-javame-app.html
http://www.devmedia.com.br/articles/viewcomp.asp?comp=6290&hl=

Transições de tela no LWUIT

20 agosto 2009 0 comentários

Hoje vamos aprender como fazer aqueles tão atraentes efeitos de transição de tela.

A transição pode ser Out ou In. No modo Out a transição é aplicada na saída do form. E no modo In o efeito de transição é aplicado quando o form está entrando, ou seja sendo mostrado na tela.

Tipos de Transições

Transições Comuns
  • Fade: a próxima tela surge de forma transparente sobrepondo a tela anterior.
 NOMEDOFORM.setTransitionOutAnimator(CommonTransitions.createFade(TEMPO));
TEMPO: Tempo de duração da transição, em milissegundos

  • Slide: transição estilo de slide. A próxima tela surge pela vertical ou
horizontal.
 NOMEDOFORM.setTransitionOutAnimator(CommonTransitions.createSlide(TIPO, BOOLEAN, TEMPO));
TIPO:
- CommonTransitions.SLIDE_HORIZONTAL
- CommonTransitions.SLIDE_VERTICAL
BOOLEAN:
- true: a tela vem da esquerda para a direita ou de cima para baixo
- false: a tela vem da direita para a esquerda ou de baixo para cima

Transições 3D
  • Cube: a transição funciona como um cubo giratório
  NOMEDOFORM.setTransitionOutAnimator(Transition3D.createCube(TEMPO,BOOLEAN));
BOOLEAN:
- true: a tela gira da esquerda para a direita
- false: a tela gira da direita para a esquerda


  • Rotation: É realizada uma rotação em torno do eixo central da tela
 NOMEDOFORM.setTransitionOutAnimator(Transition3D.createRotation(TEMPO, BOOLEAN));
BOOLEAN:
- true: a tela gira da direita para a esquerda
- false: a tela gira da esquerda para a direita


  • FlyIn: A nova tela surge do centro e cresce até preencher todo o espaço.
 NOMEDOFORM.setTransitionOutAnimator(Transition3D.createFlyIn(TEMPO));


  • SwingIn: A próxima tela surge como uma janela balançando.
  NOMEDOFORM.setTransitionOutAnimator(Transition3D.createSwingIn(TEMPO));
ou
  NOMEDOFORM.setTransitionOutAnimator(Transition3D.createSwingIn(TEMPO, BOOLEAN));
BOOLEAN:
-true: a tela está presa em cima e balança em baixo
- false: a tela está presa em baixo e balança em cima


Veja um aplicação de exemplo
import com.sun.lwuit.Command;
import com.sun.lwuit.Display;
import com.sun.lwuit.Form;
import com.sun.lwuit.animations.CommonTransitions;
import com.sun.lwuit.animations.Transition3D;
import com.sun.lwuit.events.ActionEvent;
import com.sun.lwuit.events.ActionListener;
import com.sun.lwuit.plaf.UIManager;
import com.sun.lwuit.util.Resources;
import java.io.IOException;

import javax.microedition.midlet.*;

public class midletPrincipal extends MIDlet implements ActionListener{
Command troca, voltar;
Form fPrincipal;
Form fSecundario;

public void startApp() {
Display.init(this);
// TEMA
try{
Resources res = Resources.open("/imagens/javaTheme.res");
UIManager.getInstance().setThemeProps(res.getTheme(res.getThemeResourceNames()[0]));
}catch(IOException e){
}

fPrincipal = new Form("Transicoes");
fPrincipal.setTransitionOutAnimator(Transition3D.createCube(500, false));

troca = new Command("Trocar Tela");
fPrincipal.setCommandListener(this);
fPrincipal.addCommand(troca);
fPrincipal.show();
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void actionPerformed(ActionEvent e) {
if(e.getSource() == troca){
fSecundario = new Form();
voltar = new Command("Voltar");
fSecundario.addCommand(voltar);
fSecundario.setCommandListener(this);
fSecundario.setTransitionOutAnimator(CommonTransitions.createSlide(CommonTransitions.SLIDE_HORIZONTAL, false, 500));
fSecundario.show();
}
if(e.getSource() == voltar){
fPrincipal.show();
}
}
}
Para baixar o projeto completo clique aqui.

Brasil atinge 161 milhões de linhas móveis

19 agosto 2009 0 comentários

Segundo Alberto Alerigi (Reuters), o número de linhas celulares ativas em julho no Brasil cresceu 1,45 por cento ante junho, superando a barreira dos 160 milhões, segundo dados divulgados pela Agência Nacional de Telecomunicações (Anatel), nesta quarta-feira.

O país encerrou o mês passado com 161,922 milhões de linhas móveis, o que equivale a quase um celular por habitante (IBGE). Ante os 135,33 milhões de celulares de julho de 2008, a base avançou 19,64 por cento.

Segundo a agência, três Estados rompem a barreira de um celular por habitante: Rio de Janeiro, Mato Grosso do Sul (quem diria!) e São Paulo. Até então, o Distrito Federal era o único nessa categoria.

A Vivo, maior operadora móvel do país e controlada por Telefônica e Portugal Telecom, registrou ligeiro avanço sobre junho, encerrando o mês passado com 29,38 por cento de participação, equivalente a 47,565 milhões de linhas. Em junho, a empresa teve fatia de 29,33 por cento.

Enquanto isso, a Claro, da mexicana América Móvil e segunda colocada, teve leve recuo, de 25,36 por cento para 25,35 por cento, com 41,054 milhões de clientes.

A TIM, da Telecom Italia, fechou o mês passado com fatia de 23,75 por cento contra 23,71 por cento em junho.

A Oi, incluindo a Brasil Telecom, saiu de 21,22 por cento em junho para 21,15 por cento em julho.

Segundo a Anatel, de janeiro a julho foram adicionadas 11,28 milhões de linhas à base celular do país ante 14,35 milhões um ano antes.

Fonte: Reuters