Salt password, salgando suas senhas para torná-las mais seguras

Uma das funções mais básicas e comuns a vários sistemas é a criação de contas com usuário e senha, que são armazenados em um banco de dados, é ai que se encontra o problema, se seu banco de dados for invadido o invasor vai ter acesso as senhas dos usuários. Existem algumas técnicas para dificultar que invasor consiga visualizar a senha do usuário, uma delas é criptografar utilizando alguma criptografia conhecida como md5, sha1, sha256, etc


Como funciona a criptografia 

Criptografias são algoritmos que transformam os dados em uma série de caracteres randômicos de tamanho fixo que não podem ser revertidos, então uma vez criptografado não é possível descriptografar (teoricamente, sera mostrado mais a frente que é possível fazer isso) e apenas uma pequena modificação no dado altera completamente o resultado da criptografia.

md5("aaa") = 2cf24dba5fb0a30e26e83b2ac5b9ea93f8146f337a69afe7dd238f3364946366
md5("aab") = c0e81794384491161f1777c232bc629e1b161e5c1fa7425e73043362938b9824

Como gravar uma senha criptografada

O usuário cria uma conta
A senha é criptografada
Senha criptografada é salva no banco
A senha sem criptografia não deve nunca ser armazenada

Como validar a senha criptografada

O usuário loga no sistema fornece seu login/senha
A senha fornecida é criptografada.
A senha do usuário fornecido é recuperada do banco de dados
É comparada a senha fornecida criptografada com a senha já criptografada recuperada do banco
Caso ambas as senhas sejam idênticas o usuário é autorizado a entrar no sistema, caso contrario retorne uma mensagem genérica do tipo login/senha invalida, nunca fale se é o login ou a senha que está invalido, isso previne que invasores tenham acesso aos usuários validos do sistema.

Criptografias seguras, só que não

Muitas vezes desenvolvedores acreditam que apenas criptografando um dado, principalmente utilizando criptografias mais fracas e antigas como md5 e sha estarão mantendo seus dados seguros, porem é possível quebrar essas criptografias facilmente, existem técnicas que tornam a tarefa de quebrar a senha fácil para um hacker como lookup Table, reverse lookup table, rainbow table.

Salgando as senhas e as tornando mais seguras

Salt é uma técnica que torna suas senhas mais seguras, consiste em gerar uma hash, concatenar com a senha e criptografar a string concatenada, abaixo sera mostrado os passos que devem ser feitos para adicionar salt a sua senha e a implementação.

Gravar o password
1- Gere uma hash
2- Concatene o password com a hash gerada e criptografe com uma criptografia forte como SHA256
3- Salve o password criptografado e a hash gerada em colunas separadas no banco

Validando o password
1- Recupere o password e a hash do banco.
2- Concatene o password fornecido pelo usuario com a hash recuperada do banco e criptografe.
3- Se a hash gerada for igual a hash recuperada do banco o password esta correto.

JSR 303 + Hibernate Validator + Spring Parte 2

JSR 303 Bean validator e Hibernate validator Parte 1

Como visto no post anterior utilizar bean validador não é nenhum grande mistério, agora chega de console e vou mostrar como utilizar em algo mais concreto, como um formulario HTML e Spring.

Recomendo que já conheça o basico do Spring, pois não vou entrar nos detalhes do framework, apenas na parte de validação

Dependencias
Spring
Hibernate validator 


Vamos começar criando a entidade como no post anterior

package br.com.cristiano;

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.hibernate.validator.constraints.Email;

public class Cliente {

 private String nome;
 private String email;
 
 @Size(min=5, message="Nome deve ter mais que 5 caracteres")
 @NotNull(message="Nome não pode ser nulo")
 public String getNome() {
  return nome;
 }
 public void setNome(String nome) {
  this.nome = nome;
 }
 
 @Email(message="Email invalido")
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 
}

Até ai nada como, isso já foi mostrado e explicado no post anterior, agora vamos para a parte do Spring criando o Controller

package br.com.cristiano;

import javax.validation.Valid;

import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ClienteController {

 @RequestMapping("formulario")
 public String form(){
  return "formulario";
 }
 
 @RequestMapping("adicionaCliente")
 public String adicionar(@Valid Cliente cliente, BindingResult result){
  if(result.hasErrors()){
   return "formulario";
  }
  return "adicionada";
 }
}

Note que o metodo recebe um anotação @Valid que vai validar a classe anotada e o parametro do tipo BidingResults tem uma grande quantidade de metodos que se referem ao registro de erros no form como, se tem erro ou não na resposta, quem deu erro, quantidade de erros, etc

Agora vou demonstrar como mostrar o(s) erro(s) no form.
O próprio Spring tem uma taglib para isso

<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>

crie uma pagina jsp com o nome formulario.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>

<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Adicionar cliente</title>
</head>
<body>
   <form action="adicionaCliente" method="post">
      Nome:
        
      <form:errors cssstyle="color:red;" path="cliente.nome">
      <br />
      Email:
      
      <form:errors cssstyle="color:red;" path="cliente.email">
      <br />
      
   </form>
</body>
</html>

Estrutura do projeto

Github: https://github.com/cristianoperez/SpringValidator

JSR 303 Bean validator e Hibernate validator Parte 1

Digamos que você gostaria de validar um dado que o usuario digitou, validar um CPF se o campo é nulo, você pode fazer no inicio do metodo algo como

if(cliente.cnpj == null, cliente.nome == null){
   throw new Exception("Preencha os campos obrigatórios");
}

Ira funcionar? Sim, ou talvez não do jeito que você planejou, e se eu quiser saber se o cnpj tem o tamanho exato, ou se ele é valido, pois podem existir outra dezenas de validações para um campo e imagina o trabalho que iria dar colocar todas a validações todas as vezes em cada metodo, não iríamos criar um metodo e sim um monstro.
Para simplificar isso foi criado e aprovado o JSR 303 ou Bean validator.

Bean validator também conhecido como JSR 303 foi uma especificação aprovada no final de 2009 pela JCP (Java community process) e faz parte do JavaEE 6, segundo a propria especificação ela faz o seguinte.

CUIDADO CONTEUDO ALTAMENTE TEÓRICO

“This JSR defines a metadata model and API for JavaBean validation. The default metadata source is annotations, with the ability to override and extend the meta-data through the use of XML validation descriptors.
The validation API developed by this JSR is not intended for use in any one tier or programming model. It is specifically not tied to either the web tier or the persistence tier, and is available for both server-side application programming, as well as rich client Swing application developers.” – JSR-303 Specification

Tradução livre feita pelo autor

Essa JSR define um modelo de matadados e API para validar o JavaBean. O matadado padrão é a anotação, tem que a habilidade de sobrescrever e estender o metadado através do uso de validação XML.
A API de validação desenvolvida por essa JRS não tem a intenção de uso em nenhuma camada ou modelo de programação. Ela não esta atrelada a nenhuma camada web ou camada de persistencia, e esta disponível tanto para aplicação do lado servidor como para desenvolvedores que utilizam Swing.

Agora você me pergunta ótimo mais como eu faço para usar essa tal de jsr 303, quero validar meus campos. Para isso você não ira precisar ficar criando validações uma a uma, ja existe implementações dessa JSR, o mais famoso e utilizado e o Hibernate validator, para utilizá-lo basta baixar o arquivo e utilizar os seguintes jars

Hibernate-validator-xxx.jar
Validation-api-xxx.jar
Jboss-logging-xxx.jar

Com isso você já esta pronto para utilizar o bean validator.
Crie uma classe chamada Cliente com os seguintes campos id, nome, email e em cima delas utilizar a anotação @NotNull @Size @Email todas do pacote.

public class Cliente {

@NotNull(message="Valor não pode ser nulo")
private Integer id;

@Size(min=5, message="Tamanho deve ser maior que 5")
@NotNull(message="Nome não pode ser nulo")
private String nome;

@Email(message="Email invalido")
private String email;

//getters and setters

}

Note que para todas as anotações existe um atributo chamado message, que é a mensagem que sera passada caso o campo não seja validado.
Agora vamos criar um cliente console para mostrar a validação em funcionamento.

public class Client {

 public static void main(String[] args) {
  //Nome menor que 5, email invalido
  Cliente cliente = new Cliente(1, "Cris", "adminqwdadmin.com");
  
  ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();
  Set<constraintviolation<Cliente> constraintViolations = validator.validate(cliente);
  for(ConstraintViolation error : constraintViolations){
   System.out.println(error.getMessage());
  }
 }
}

Retorno no console

É isso, espero que tenham gostado, essa foi apenas a primeira parte sobre Hibernate validator, o proximo post sera como integralo com Spring e utilizado em um formulario HTML.

Github: https://github.com/cristianoperez/BeanValidator

Parte 2

Maven e Eclipse ( m2e ).

Nesse tutorial mostrarei como utilizar o gerenciador de dependências Maven com o Eclipse, mostrarei o que é necessário e a criação de um projeto simples para ver o maven em funcionamento.

Maven

Maven é uma ferramenta para o gerenciamento de dependências do projeto, que utiliza um arquivo xml chamando POM (Project Object Model) para gerenciar as dependências do projeto. Em outras palavras você não vai mais precisar baixar arquivos .jar e ficar importando eles para o projeto, com o maven apenas adicionando algumas linhas dentro do arquivo pom.xml ele já se encarrega de fazer o download e adicionar na sua aplicação. 

No site Maven Repository http://mvnrepository.com/ você pode encontrar qual quer dependência que desejar para colocar no seu pom.xml.

M2E

É um pugin para o eclipse que torna a utilização do maven mais simples diretamente do eclipse.

Todos os libs baixados pelo m2e ficam dentro da pasta .m2/repository, com isso se mais de um projeto depender do mesmo lib ele não é baixado denovo.

Ferramentas
Eclipse Download
JDK Download
m2e (maven para o eclipse)

Instalando o m2e
Após abrir o Eclipse vá em Help -> Install New Software e coloque a http://download.eclipse.org/technology/m2e/releases

Após o termino da instalação reinicie o Eclipse e está na hora de iniciar a utilização do maven.

Vamos criar um maven project, vá em File -> New -> Other -> Maven Project.

Selecione Create a simple project, e clique em next,

Group Id: org.toca.maven

Artifact Id: maven-teste

Name: Maven Teste,

e clique em finish.

Sera criada a seguinte estrutura.

Veja que o arquivo pom.xml é onde colocaremos as dependências do nosso projeto de uma maneira bem simples.

Note que foram inseridas duas dependências no projeto log4j e javax.mail, no que no momento que você inserir a dependência e salvar o arquivo o eclipse começa automaticamente a baixar o .jar e o insere no projeto e está pronto para ser usado.

Caso você não queria mais por exemplo o log4j no seu projeto basta apagar as linhas da dependência do pom.xml que ao salvar o arquivo .jar sera removido do projeto.

Porque utilizar equals() e não == para comparar String

Uma pergunta bem básica e objetiva, é possível comprar String utilizando == ? Sim. Da certo 100% das vezes? Não.

Uma das primeiras coisas que aprendi quando comecei a programar em java foi JAMAIS utilizar == para comprar Strings, mais porque isso? Vamos a uma explicação técnica.

String é um objeto, o metodo equals(Object) vai retornar true se ambas as Strings tiverem o mesmo objeto. O operador == só ira retornar true se ambas referencias de String apontarem para a mesma referencia do objeto.

Quando criamos uma String de forma literal é criado um pool de Strings, quando criamos uma outra String literal com o mesmo valor a JVM procura se ja existe uma String com esse mesmo valor no pool de Strings, caso exista, faz sua variável apontar para o mesmo endereço de memória. Por este motivo, quando você testa a igualdade das variáveis a e b através do "==", ela retorna true.


String a = "abc";    //pool de string
String b = "abc";    /*ja existe uma string com o mesmo conteúdo no pool,
                                 vai para a mesma referencia na memória*/
String c = "dda";    //vai para uma nova referencia de memoria pois não existe no pool

Se você criar strings assim, você está criando um novo objeto em memória e se testar a igualdade das variáveis a e d com "==", ela retornará false, pois não apontam para o mesmo lugar na memória.

String d = new String("abc");     //Cria um novo objeto na memoria



String a = "abc";
String b = "abc";
String c = "dda";
String d = new String("abc");


a==b = true
a==c = false
a==d = false
a.equals(d) = true

Diferença entre Array e ArrayList

Um Array pode ser bem parecido com um ArrayList, muitas vezes usamos ArrayList por costume, porem existem algumas diferenças marcantes entre elas.

Modo de declaração

Array
int[] nomeDaVariavel = new int[10];


ArrayList
List<int> nomeDaVariavel = new ArrayList<int>();

Na array criamos uma variável int e indicamos que ela é uma array colocando [] apos a declaração do tipo da variável, e iniciamos a variável falando que ela é uma array de tamanho 10, portanto o tamanho da array já está definida.

Na ArrayList criamos uma lista, indicamos que ela é do tipo int e iniciamos a lista falando que é um ArrayList.

Tamanho


Note que a array ao ser criada foi definida o tamanho 10, já a ArrayList não foi definido nenhum tamanho pois a arrayList tem um tamanho dinâmico, enquanto a array tem o tamanho fixo de 10 a arrayList tem o tamanho dinâmico.

Índice 


No array quando você deleta o índice 2 ele ficara vazio, já no ArrayList quando você deletar o índice 2 a próximo elemento da lista tomara o seu lugar e toda a lista ira "recuar", o elemento do índice 3 se tornara o 2, o elemento do índice 4 se tornara o 3 e assim por diante.

Collection, diferença entre Ordenado e Classificado

Continuando com alguns assuntos que fazem parte da prova SCPJ, nesse post vou falar sobre a diferença entre Ordenado e Classificado.

Ordenado (Ordered) - É a ordem em que os elementos do conjunto serão mostrados na tela ao ser iterado. Um ArrayList é ordenado pela posição do índice. LinkedHashSet mantem a ordem estabelecida pela posição, o ultimo elemento a ser inserido sera o ultimo elemento do conjunto, diferentemente do ArrayList que você pode inserir um elemento em um índice especifico. Alguns conjuntos mantém a ordem natural dos elementos, esses conjuntos não são apenas ordenados, mas também classificados.

Classificados (Sorted) - Um conjunto classificado significa que a ordem do conjunto está determinada por alguma(s) regra(s), conhecida(s) como ordem de classificação. Semelhante ao order by do SQL.
A classificação é feita com base em propriedades do próprio objeto. Na maioria das vezes a ordem é feita utilizando a ordem natural, que nada mais é que a ordem alfabética para String e ordem numérica crescente para objetos Integer, porem e para Objetos do tipo por exemplo Cliente? Não existe uma ordem naturam para esse objeto, pelo menos até que o desenvolvedor crie uma, por meio do Comparator ou Comparable (você pode saber mais sobre elas clicando aqui e aqui)