Java - algorytmy Hash-najszybsze wdrożenia

Edit: pierwotnie przeczytałem to pytanie jako "najszybszy algorytm skrótu" i zostało ono wyjaśnione jako "najszybsza implementacja każdego algorytmu". To ważne pytanie, a inni wskazywali na szybsze implementacje. Jednak o ile nie mieszasz dużych ilości danych w krótkim czasie, to po prostu nie będzie to miało większego znaczenia. Wątpię, że zwykle warto poświęcić czas i złożoność, aby użyć czegoś innego niż to, co jest dostarczane ze standardem JCE.

Dla adresów URL musiałbyś być hashujący z SHA-256 w górę milion na sekundę na nowoczesnym sprzęcie, aby wymagać czegoś szybciej. Nie wyobrażam sobie, aby większość aplikacji wymagała więcej niż tysiąca na sekundę (ponad 86 milionów dziennie), co oznacza, że całkowity czas procesora spędzony na hashowaniu byłby znacznie mniejszy niż 1%. Więc nawet jeśli masz nieskończenie szybki algorytm haszujący, będziesz w stanie poprawić ogólną wydajność tylko o 1% w najlepszym przypadku.

Oryginalna Odpowiedź: Uzyskanie zarówno najlepszego, jak i najszybszego jest sprzeczne ze sobą. Lepsze skróty są zazwyczaj wolniejsze. Jeśli naprawdę potrzebujesz prędkości, a bezpieczeństwo nie jest tak ważne, użyj MD5. Jeśli potrzebujesz najlepszego zabezpieczenia, wybierz SHA-256 lub nawet SHA-512. Nie wspomniałeś, do czego go używasz, więc trudno polecić jedno lub drugie. Prawdopodobnie najbezpieczniej będzie z SHA-256, ponieważ powinien być wystarczająco szybki dla większości przypadków użycia na nowoczesnym sprzęcie. Oto jak możesz to zrobić it:

String input = "your string";
MessageDigest digest = MessageDigest.getInstance("SHA-256");
digest.update(input.getBytes("UTF-8"));
byte[] hash = digest.digest();

Jeśli używasz tego do celów bezpieczeństwa, takich jak hashowanie hasła, powinieneś również dodać sól do digestu. Jeśli chcesz wypisać z hasha drukowalny ciąg znaków, możesz go zakodować z powrotem do łańcucha jako hex:

static char[] HEX_CHARS = "0123456789ABCDEF".toCharArray();

StringBuilder sb = new StringBuilder(hash.length * 2);
for (byte b : hash) {
    sb.append(HEX_CHARS[(b & 0xF0) >> 4]);
    sb.append(HEX_CHARS[b & 0x0F]);
}
String hex = sb.toString();

Zobacz: wiele przykładów SHA / MD5

Także: z tego samego wątku: Fast MD5

String hash = MD5.asHex (MD5.getHash(new File (filename)));

Kolejną rzeczą do rozważenia jest użycie MD4. Nie jest tak bezpieczny jak MD5, ale jest obliczany jeszcze szybciej. Windows do XP używany do przechowywania i wymiany haseł w MD4, więc używamy tego hasha, ponieważ nadal pozwala nam świadczyć usługi uwierzytelniania dla tej platformy.

Rozważ BLAKE2, który jest szybszy i bezpieczniejszy niż wspomniane wyżej hasze.

MD5, SHA-1, SHA256 i SHA-512 są podatne na wydłużenie.

MD5 i SHA-1 są podatne na kolizje.

MD5 jest podatny na kolizje z wybranym prefiksem.

SHA - 3 i BLAKE2 nie mają znanych problemów z bezpieczeństwem i mogą generować strawienia o różnej długości.

SHA - 3 jest najszybszy, gdy jest zaimplementowany w sprzęcie; BLAKE2 jest najszybszy, gdy jest używany w oprogramowaniu wdrożenia.

BLAKE2b jest zoptymalizowany pod kątem platform 64-bitowych i produkuje digesty o dowolnym rozmiarze od 1 do 64 bajtów.

BLAKE2s jest zoptymalizowany dla platform od 8 do 32-bitowych i produkuje digesty o dowolnym rozmiarze od 1 do 32 bajtów.

Https://blake2.net/

Https://www.cryptopp.com/benchmarks.html

W pierwszym łączu BLAKE2b (947 Mbits) jest znacznie szybszy niż SHA-256 (413 Mbits) I MD5 (632 Mbits).

W drugim łączu, AES - 256 (805 Mbits) i BLAKE2b (776 Mbits) są mniej więcej równe i szybsze niż SHA-256 (275 Mbits) i MD5 (602) Mbits.

Dla ciągu wystarczy wywołać hashCode(), ponieważ jest tańszy w pamięci.

W przeciwnym razie polecam ten kod dla private hash:

public static int hash8(String val) throws UnsupportedEncodingException {
    return hash8(val.getBytes("UTF-8"));
}

public static int hash8(byte[] val) {
    int h = 1, i = 0;
    for (; i + 7 < val.length; i += 8) {
        h = 31 * 31 * 31 * 31 * 31 * 31 * 31 * 31 * h + 31 * 31 * 31 * 31
                * 31 * 31 * 31 * val[i] + 31 * 31 * 31 * 31 * 31 * 31
                * val[i + 1] + 31 * 31 * 31 * 31 * 31 * val[i + 2] + 31
                * 31 * 31 * 31 * val[i + 3] + 31 * 31 * 31 * val[i + 4]
                + 31 * 31 * val[i + 5] + 31 * val[i + 6] + val[i + 7];
    }
    for (; i + 3 < val.length; i += 4) {
        h = 31 * 31 * 31 * 31 * h + 31 * 31 * 31 * val[i] + 31 * 31
                * val[i + 1] + 31 * val[i + 2] + val[i + 3];
    }
    for (; i < val.length; i++) {
        h = 31 * h + val[i];
    }
    return h;
}

FYI: http://lemire.me/blog/2015/10/22/faster-hashing-without-effort/