# MD5 und Base64



## pooner (12. Sep 2008)

Hallo,

ich suche verzweifelt Hilfe.

Mein Problem ist folgendes:

Ich habe ein Programm welches Benutzer und Passwörter in einer HSQL-DB ablegt. ich bin nun gezwungen ein anderes Programm gegen diese DB zu authentifizieren. Also lese ich mir die Daten aus der DB aus. Die Passwörter sind angeblich laut Hersteller md5 und dann base64 verschlüsselt. Lese ich die Passwörter jedoch aus und versuche diese mit base64 zu entschlüsseln kommt immer nichts vernünftiges bei raus. Kann es sein das Java aus dem MD5 gar keinen String machen, sondern die Byte-Darstellung mit base64 kodiert ? Wenn ja wie kann ich das decodieren ? Als Beispiels ist der string root verschlüsselt und das Ergebnis lautet _Z++/ve+/ve+/vWFoUCTvv73vv73vv71V77+977+9e++/vQ==_

Auszüge aus dem Programm Source -Code:

```
ublic class DBFunctions {

    /**
     * Tests whether a string matches a supplied regular expression and returns
     * the text if it does.
     * 
     * @param text text to match
     * @param regex regular expression
     * @return text
     */
    public static String matches(String text, String regex) {
        Pattern pattern = ReplacementEngine.getPatternPool().getPattern(regex, false, false);
        try {
            Matcher matcher = pattern.matcher(text);
            return matcher.find() ? text : "";
        } finally {
            ReplacementEngine.getPatternPool().releasePattern(pattern);
        }
    }

    /*
     * This is required to make fresh installs work correctly. As of 0.1.4,
     * passwords became BASE64 encoded and now use the ENCPASSWORD function.
     */
    public static String password(String text) throws UnsupportedEncodingException, NoSuchAlgorithmException {
        return digest(text);
    }

    /**
     * Encode a password one-way by first by producing an MD5 hash of the password
     * then encoding that in BASE64.
     * 
     * @param password password to encode
     * @return encoded password
     * @throws UnsupportedEncodingException
     * @throws NoSuchAlgorithmException
     */
    public static String encPassword(String password) throws UnsupportedEncodingException, NoSuchAlgorithmException {
        String encoded = encode(digest(password));
        return encoded;
    }

    /**
     * Encode a string as BASE64.
     * 
     * @param string string to encode
     * @return encoded string
     */
    public static String encode(String string) {
        return new String(Base64.encode(string.getBytes()));
    }

    /**
     * Decode a string from BASE64 to its original form.
     * 
     * @param string string to decode
     * @return decoded string
     */
    public static String decode(String string) {
        return new String(Base64.decode(string.getBytes()));
    }

    /**
     * Create an MD5 hash of the provided string
     * 
     * @param string string to hash
     * @return hashed string
     */
    public static String digest(String string) throws NoSuchAlgorithmException, UnsupportedEncodingException {
        byte[] b = string.getBytes();
        MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(b);
        byte[] digest = md.digest();
        return new String(digest);
    }

}
```

Danke für eure Hilfe


----------



## FArt (12. Sep 2008)

Du meinst vermutlich, über das Passwort wurde ein MD5 Hash gebildet und dieser Base64 enkodiert in der DB abgelegt.

Und du willst jetzt das Passwort wieder ermitteln? Das geht nicht, denn das wäre ja nicht im Sinne des Erfinders. 

Du kannst aus dem Base64 enkodierten MD5 wieder den MD5 erhalten, mehr nicht.

http://de.wikipedia.org/wiki/Message-Digest_Algorithm_5


----------



## pooner (12. Sep 2008)

genau das möchte ich erreichen und dann den ermittelten  md5-hash mit einem anderen vergleichen.

mein bisheriger Ansatz ist wie folgt:

-Datenbankverbindung aufgebaut, Daten abgefragt, Passwd in variable abgelegt:



```
ResultSet rs = stmt.executeQuery("SELECT *  FROM USERS");

/* Columns des Recordsets  sind USERNAME, FULLNAME, EMAIL, PASSWORD, LAST_PASSWORD_CHANGE_REALM */
while (rs.next()) {
                String username = rs.getString("USERNAME");
                String encrypted_password = rs.getString("PASSWORD");
                System.out.println(username + " " +  encrypted_password);

               /* md5 Ermittlung */
                String decoded = new String(new BASE64Decoder().decodeBuffer(encrypted_password),"UTF-8");
                System.out.println(decoded);
                 } /* end while */
```

ich weiss nur nicht welche Klassen ich importieren muss um den md5 zu ermitteln. So wie oben angegeben kriege ich Kompilierungsfehler

```
Ausgabe.java:54: unreported exception java.io.IOException; must be caught or declared to be thrown
                String decoded = new String(new BASE64Decoder().decodeBuffer(encrypted_password),"UTF-8");
                                                                            ^
Ausgabe.java:54: unreported exception java.io.UnsupportedEncodingException; must be caught or declared to be thrown
                String decoded = new String(new BASE64Decoder().decodeBuffer(encrypted_password),"UTF-8");
```

Kann mir dabei einer helfen?[/code]


----------



## FArt (12. Sep 2008)

Base64: http://exampledepot.com/egs/java.net/Base64.html
MD5: http://exampledepot.com/egs/java.security/Digest.html

Exceptions, die geworfen werden können fangen und verarbeiten oder weiterwerfen. Fertig.


----------

