HASH Algorithmus 2 Strings ergeben das Selbe.

[clemix]

Ich habe ein Mailprogramm geschrieben, bei dem man die Möglichkeit hat Emails auf dem Server zu belassen und erst zu löschen wenn man diese auch aus der Inbox löscht (aller Thunderbird).
Um Emails eindeutig zu Identifizieren dachte ich mir, ich lese aus dem Header den Wert von "Message-ID" aus und pack noch das Sendedatum hinten drann.
Das Resultat sind dann solche Strings

String s1 = "<000a01c735bc$efdc1450$7790ba5a@portimoni>Thu Jan 11 21:13:15 CET 2007";
String s2 = "<000b01c73da6$36500db0$fe08ba5a@portimoni>Sun Jan 21 22:50:44 CET 2007";

Welche ja Recht Unterschiedlich sind! So damit die überprüfung an Zeit gewinnt und die Länge dieser Strings nicht unnötig meine Datenbank beeinflußt dachte ich mir das ich einen SHA Hash wert drüber bilde und nur noch diesen vergleiche. Das Folgende Programm zeigt genau das. Problem was jetzt entstanden ist, nachdem ich das Programm keinen Monat benutzt habe, das Emails kommen die unterschiedlich sind, aber den selben Hash Wert erzeugen.

Für Lösungen oder Anregungen jeder art bin ich sehr dankbar. Oder vieleicht sollte ich ganz anders die Lokal gepseicherten Emails mit denen auf dem Server vergleichen?!?

import java.security.MessageDigest;


public class TEST {
	public static final String MD5 = "MD5";
	public static final String SHA = "SHA";
	/**
	 * Gibt den hashwert des übergebenden Strings als Hexstring zurück.
	 * Bekannte Algorithmen sind: 
	 *  * MD5
	 *  * SHA
	 *  
	 * @param txt
	 * @param algo
	 * @return
	 * @throws Exception
	 */
	public static String hashAsString(String txt, String algo) throws Exception{
		return byteArrayToHexString(hash(txt,algo));
	}
	
	/**
	 * Füllt ein String mit Zeichen bis zu einer länge auf.
	 * @param string
	 * @param pattern
	 * @param n
	 * @return
	 * @throws Exception
	 */
	private static String fillWithTo(String string, String pattern , int n) throws Exception{
		int dif = n - string.length();
		if(dif>0){
			for(int i =0; i < dif; i++){
				string += pattern;
			}
		}else if( dif < 0){
			throw new Exception("Differents is "+dif+". But max "+n+" expected. String is: "+string);
		}
		return string;
	}
	
	/**
	 * Konvertiert ein Byte Array welches die werte von 0xff nicht überschreitet in 
	 * ein Hexstring.
	 * @param array
	 * @return
	 */
	public static String byteArrayToHexString(byte[] array){
		StringBuffer sb = new StringBuffer();
		for(int i =0; i < array.length; i++){
			try {
				sb.append(fillWithTo(Integer.toHexString(array[i] & 0xff),"0",2) );
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return sb.toString();
	}
	
	/**
	 * Gibt den hashwert des übergebenden Strings als Byte Array zurück.
	 * Bekannte Algorithmen sind:
	 *  * MD5
	 *  * SHA
	 *  
	 * @param txt
	 * @param algo
	 * @return
	 * @throws Exception
	 */
	public static byte[] hash( String txt, String algo ) throws Exception{
		MessageDigest messagedigest = MessageDigest.getInstance( algo );

	    byte md[] = new byte[8192]; 
	    
	    for( int i=0; i< txt.length(); i++ ){
	    	messagedigest.update( md, 0, txt.charAt(i) );
	    }

	    return messagedigest.digest();
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String s1 = "<000a01c735bc$efdc1450$7790ba5a@portimoni>Thu Jan 11 21:13:15 CET 2007";
		String s2 = "<000b01c73da6$36500db0$fe08ba5a@portimoni>Sun Jan 21 22:50:44 CET 2007";
		try{
			byte[] hab1 = hash(s1, SHA);
			byte[] hab2 = hash(s2, SHA);
			
			for (int i = 0; i < hab1.length; i++) {
				System.out.println(hab1[i]+ "  "+hab2[i]);
			}
			
			String ha1 = hashAsString(s1, SHA);
			String ha2 = hashAsString(s2, SHA);
			
			System.out.println("Hash1:"+ha1+"  javaHash:"+ha1.hashCode());
			System.out.println("Hash2:"+ha2+"  javaHash:"+ha2.hashCode());
			
			System.out.println("Hash1 == Hash2 is "+ha1.equals(ha2));
		}catch(Exception ex){
			ex.printStackTrace();
		}

	}

}

:### :### :###

 

[Beni]

Bei einem Hash verliert man Informationen, das ist ganz normal (ist eigentlich der Trick an einem Hash, darum ist ein Hash kleiner als der Ausgangswert). Den Hash kannst du für eine schnelle "Vorprüfung" nutzen. Aber wenn zwei Hashwerte gleich sind, musst du immer die Ausgangswerte vergleichen, um deren Gleichheit zu bestätigen. Andererseits bedeuten unterschiedliche Hashs immer unterschiedliche Ausgangswerte.

 

[clemix]

Hm jap. Ich dachte halt nur, da ja mit 160 Bit schon einiges an möglichkeiten vorhaden ist, dass da die Wahrscheinlichkeit einfach zu gering ist...
Naja hab ich mich wohl verschäzt....