Dúvida Criptografar Senha

30 de junho de 2010 7 respostas

colored 30 de junho de 2010

Olá. Estava precisando encontrar algo para criptografar senha do usuario, consegui achar uma solução aqui mesmo no forum…

MessageDigest md = MessageDigest.getInstance("MD5");   
	    String senha = "[telefone removido]";   
	    byte[] senhaC =  md.digest(senha.getBytes());   
	    BASE64Encoder b = new BASE64Encoder();   
	    System.out.println(b.encode(senhaC)); 
	    resultado = p8R3hXYcgOwDQDznkupbig==

Até ai blz… era mais o menos oq eu precisava… só que surgiu uma dúvida.
Tipo no sistema aqui tem uma parte que eu tenho que reenviar a senha do usuario por email…
Com a senha criptografada no banco… como eu faço pra transformar ela na senha real pra poder enviar pro Usuario???

Se Alguem puder dar uma força ai valeo

7 Respostas

finotti 30 de jun. de 2010

recupere a senha do banco e use o método decode antes de enviar ao usuário

davidbuzatto 30 de jun. de 2010

Uma outra opção, seria vc criar uma nova senha, salvar a versão criptografada da nova senha no banco e enviar a versão criada para o usuário.
Ai ele loga no sistema e muda a senha de novo.

Ai vc não precisa enviar a senha salva no banco nem se preocupar com o decode.

[]´s

aeciovc 30 de jun. de 2010

lembrando só que o algoritmo MD5 é um algoritmo de Hash, ou seja, ele não tem volta. pra que vc reenvie a senha pro usuário só criando outra!

entanglement 30 de jun. de 2010

Usar só o MD5, sem incluir mais alguma informação que é diferente para cada usuário, não é adequado. Uma auditoria em uma empresa que trabalhei revelou que muitos usuários tinham senhas simples ou então a mesmíssima senha, só de verificar que o algoritmo para o determinado sistema era MD5.

colored 30 de jun. de 2010

Tipo… Eu Achei uma Classe aki No Forum…

package Unimed.Teste;

import java.io.FileInputStream;     
import java.io.FileOutputStream;     
import java.io.IOException;     
import java.io.ObjectInputStream;     
import java.io.ObjectOutputStream;     
import javax.crypto.*;     
import javax.crypto.spec.*;     
import java.security.*;     
import java.security.spec.*;     
import java.security.InvalidKeyException;     
import java.security.NoSuchAlgorithmException;     
import java.security.spec.KeySpec;     
import sun.misc.BASE64Encoder; // para simplificar o exemplo. Use alguma outra classe para converter     
import sun.misc.BASE64Decoder; // para Base-64.     
public final class Teste {     
    /** A chave secreta */   
    private SecretKey skey;     
    /** A especificação da chave */   
    private KeySpec ks;     
    /** Parâmetros passados para converter uma senha em uma chave */   
    private PBEParameterSpec ps;     
    // Nome do algoritmo usado - veja em PKCS#5, ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-5v2/pkcs5v2-0.pdf   
    private final String algorithm = "PBEWithMD5AndDES";     
    private BASE64Encoder enc = new BASE64Encoder();     
    private BASE64Decoder dec = new BASE64Decoder();     
    private void convertPasswordToKey (final String password) {   
        try {   
            // Obtendo uma instância da fábrica de chaves secretas.   
            // O algoritmo dessa fábrica, chamado PBEWithMD5AndDES,   
            // transforma uma senha (conjunto de caracteres digitáveis)   
            // em uma chave (bits aleatórios que devem ser mantidos em sigilo).   
            // Essa chave é gerada segundo um algoritmo especificado em:   
            // PKCS#5 - disponível em: ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-5v2/pkcs5v2-0.pdf   
            SecretKeyFactory skf = SecretKeyFactory.getInstance(algorithm);     
            // Um dos parâmetros necessários para gerar a senha a partir da chave é um   
            // "salt" (que neste caso especifiquei como uma série de bytes que   
            // são a representação decimal dos primeiros dígitos de pi) e   
            // um "iteration count".   
            ps = new PBEParameterSpec (new byte[]{3,1,4,1,5,9,2,6}, 20);     
            // Aqui temos a senha...   
            ks = new PBEKeySpec (password.toCharArray());   
            // E aqui temos o resultado final, que é a chave secreta.   
            skey = skf.generateSecret (ks);     
        } catch (java.security.NoSuchAlgorithmException ex) {     
            ex.printStackTrace();     
        } catch (java.security.spec.InvalidKeySpecException ex) {     
            ex.printStackTrace();     
        }     
    }     
    /**  
     * Cifra um texto com a senha passada.  
     */   
    public final String encrypt(final String password, final String text)     
        throws     
        BadPaddingException,     
        NoSuchPaddingException,     
        IllegalBlockSizeException,     
        InvalidKeyException,     
        NoSuchAlgorithmException,     
        InvalidAlgorithmParameterException {     
        // Converte a senha em uma chave   
        convertPasswordToKey (password);   
        // Obtém o algoritmo de criptografia (no caso DES)   
        final Cipher cipher = Cipher.getInstance(algorithm);     
        // Inicializa o algoritmo com a chave   
        cipher.init(Cipher.ENCRYPT_MODE, skey, ps);     
        // Efetua a criptografia, usando "doFinal", e converte para Base-64   
        return enc.encode (cipher.doFinal(text.getBytes()));     
    }     
    /**  
     * Decifra um texto com a senha passada  
     */   
    public final String decrypt(final String password, final String text)     
        throws     
        BadPaddingException,     
        NoSuchPaddingException,     
        IllegalBlockSizeException,     
        InvalidKeyException,     
        NoSuchAlgorithmException,     
        InvalidAlgorithmParameterException {     
                 
        // Converte a senha em uma chave   
        convertPasswordToKey (password);   
        // Obtém o algoritmo de criptografia (no caso DES)   
        final Cipher cipher = Cipher.getInstance(algorithm);     
        // Inicializa o algoritmo com a chave   
        cipher.init(Cipher.DECRYPT_MODE, skey, ps);     
        String ret = null;     
        try {     
            // Converte de Base-64 para bytes, e então efetua a decifração ("descriptografia").   
            ret = new String(cipher.doFinal(dec.decodeBuffer (text)));     
        } catch (Exception ex) {     
        }     
        return ret;     
    }     
    public static void main(String[] args) throws Exception {     
        String password = "Jefferson 2";   
        String cleartext = "Texto Clear";   
        System.out.println ("Texto original em claro");   
        System.out.println (cleartext);   
        String encrypted = new Teste().encrypt (password, cleartext);   
        System.out.println ("Texto criptografado");   
        System.out.println (encrypted);   
        String decrypted = new Teste().decrypt (password, encrypted);   
        System.out.println ("Texto decifrado");   
        System.out.println (decrypted);   
        System.out.println ("O texto original e o decifrado " + (cleartext.equals(decrypted) ? " batem" : " não batem"));   
    }     
}

Voltando a Ajuda… Tipo Que nem o amigo disse pra eu guardar A Senha Criptografada em Outro Campo… mas ai então acho q nem rola… de qqr jeito a senha original vai estar lá…
Será q eh realmente vantajoso criptografar essa senha?

orlandocn 30 de jun. de 2010

ja tentou o jasypt?

Gustavokt 30 de jun. de 2010

colored:

Tipo… Eu Achei uma Classe aki No Forum…

package Unimed.Teste;

import java.io.FileInputStream;     
import java.io.FileOutputStream;     
import java.io.IOException;     
import java.io.ObjectInputStream;     
import java.io.ObjectOutputStream;     
import javax.crypto.*;     
import javax.crypto.spec.*;     
import java.security.*;     
import java.security.spec.*;     
import java.security.InvalidKeyException;     
import java.security.NoSuchAlgorithmException;     
import java.security.spec.KeySpec;     
import sun.misc.BASE64Encoder; // para simplificar o exemplo. Use alguma outra classe para converter     
import sun.misc.BASE64Decoder; // para Base-64.     
public final class Teste {     
    /** A chave secreta */   
    private SecretKey skey;     
    /** A especificação da chave */   
    private KeySpec ks;     
    /** Parâmetros passados para converter uma senha em uma chave */   
    private PBEParameterSpec ps;     
    // Nome do algoritmo usado - veja em PKCS#5, ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-5v2/pkcs5v2-0.pdf   
    private final String algorithm = "PBEWithMD5AndDES";     
    private BASE64Encoder enc = new BASE64Encoder();     
    private BASE64Decoder dec = new BASE64Decoder();     
    private void convertPasswordToKey (final String password) {   
        try {   
            // Obtendo uma instância da fábrica de chaves secretas.   
            // O algoritmo dessa fábrica, chamado PBEWithMD5AndDES,   
            // transforma uma senha (conjunto de caracteres digitáveis)   
            // em uma chave (bits aleatórios que devem ser mantidos em sigilo).   
            // Essa chave é gerada segundo um algoritmo especificado em:   
            // PKCS#5 - disponível em: ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-5v2/pkcs5v2-0.pdf   
            SecretKeyFactory skf = SecretKeyFactory.getInstance(algorithm);     
            // Um dos parâmetros necessários para gerar a senha a partir da chave é um   
            // "salt" (que neste caso especifiquei como uma série de bytes que   
            // são a representação decimal dos primeiros dígitos de pi) e   
            // um "iteration count".   
            ps = new PBEParameterSpec (new byte[]{3,1,4,1,5,9,2,6}, 20);     
            // Aqui temos a senha...   
            ks = new PBEKeySpec (password.toCharArray());   
            // E aqui temos o resultado final, que é a chave secreta.   
            skey = skf.generateSecret (ks);     
        } catch (java.security.NoSuchAlgorithmException ex) {     
            ex.printStackTrace();     
        } catch (java.security.spec.InvalidKeySpecException ex) {     
            ex.printStackTrace();     
        }     
    }     
    /**  
     * Cifra um texto com a senha passada.  
     */   
    public final String encrypt(final String password, final String text)     
        throws     
        BadPaddingException,     
        NoSuchPaddingException,     
        IllegalBlockSizeException,     
        InvalidKeyException,     
        NoSuchAlgorithmException,     
        InvalidAlgorithmParameterException {     
        // Converte a senha em uma chave   
        convertPasswordToKey (password);   
        // Obtém o algoritmo de criptografia (no caso DES)   
        final Cipher cipher = Cipher.getInstance(algorithm);     
        // Inicializa o algoritmo com a chave   
        cipher.init(Cipher.ENCRYPT_MODE, skey, ps);     
        // Efetua a criptografia, usando "doFinal", e converte para Base-64   
        return enc.encode (cipher.doFinal(text.getBytes()));     
    }     
    /**  
     * Decifra um texto com a senha passada  
     */   
    public final String decrypt(final String password, final String text)     
        throws     
        BadPaddingException,     
        NoSuchPaddingException,     
        IllegalBlockSizeException,     
        InvalidKeyException,     
        NoSuchAlgorithmException,     
        InvalidAlgorithmParameterException {     
                 
        // Converte a senha em uma chave   
        convertPasswordToKey (password);   
        // Obtém o algoritmo de criptografia (no caso DES)   
        final Cipher cipher = Cipher.getInstance(algorithm);     
        // Inicializa o algoritmo com a chave   
        cipher.init(Cipher.DECRYPT_MODE, skey, ps);     
        String ret = null;     
        try {     
            // Converte de Base-64 para bytes, e então efetua a decifração ("descriptografia").   
            ret = new String(cipher.doFinal(dec.decodeBuffer (text)));     
        } catch (Exception ex) {     
        }     
        return ret;     
    }     
    public static void main(String[] args) throws Exception {     
        String password = "Jefferson 2";   
        String cleartext = "Texto Clear";   
        System.out.println ("Texto original em claro");   
        System.out.println (cleartext);   
        String encrypted = new Teste().encrypt (password, cleartext);   
        System.out.println ("Texto criptografado");   
        System.out.println (encrypted);   
        String decrypted = new Teste().decrypt (password, encrypted);   
        System.out.println ("Texto decifrado");   
        System.out.println (decrypted);   
        System.out.println ("O texto original e o decifrado " + (cleartext.equals(decrypted) ? " batem" : " não batem"));   
    }     
}

Depende do nível de segurança você precisa dar… Caso você não use criptografia, qualquer um que acessar o banco vai ver as senhas abertas…

Se você realmente precisa devolver a senha decriptografada, então vai precisar usar o 2o. algoritmo e ter uma senha “master” para fazer a encriptação e decriptação.

O mais seguro seria fazer como o pessoal falou antes, gerar uma nova senha (aleatória) e pedir para o usuário se logar e mudar a senha. Provavelmente você precisa da senha original caso o usuário tenha pedido para reiniciar a senha sem querer (ou alguém mal intencionado forçou o reset).

Criado 30 de junho de 2010

Ultima resposta 30 de jun. de 2010

Respostas 7

Participantes 7

7 Respostas

Topicos relacionados