Dúvida Criptografar Senha

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

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

JavaEvangelist Membro desde: 02/12/2003 14:51:32 Mensagens: 443 Offline

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

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

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!

GUJ Hacker Membro desde: 26/09/2009 09:18:56 Mensagens: 5750 Offline

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.

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?

Java Ninja Membro desde: 30/07/2005 12:42:29 Mensagens: 262 Offline

ja tentou o jasypt?

JavaBaby Membro desde: 01/09/2009 11:09:41 Mensagens: 95 Offline

colored wrote: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?

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).

Notícias, artigos e o maior fórum brasileiro sobre Java