hashlib 1.7.0

Secure hash functions, checksum generators, and key derivation algorithms optimized for Dart.

hashlib

This library contains implementations of secure hash functions, checksum generators, and key derivation algorithms optimized for Dart.

Features

Secure Hash Functions

Algorithm	Available implementations	Source
MD5	md5	RFC-1321
SHA-1	sha1	RFC-3174
SHA-2	sha224, sha256, sha384, sha512, sha512t224, sha512t256	RCC-6234
SHA-3	sha3_224, sha3_256, sha3_384, sha3_512	FIPS-202
SHAKE	Shake128, Shake256, shake128, shake256	FIPS-202
Keccak	keccak224, keccak256, keccak384, keccak512	Team Keccak
Blake2b	blake2b160, blake2b256, blake2b384, blake2b512	RFC-7693
Blake2s	blake2s128, blake2s160, blake2s224, blake2s256	RFC-7693

Message Authentication Code (MAC) generators

Algorithms	Available implementations	Source
HMAC	HMAC	RFC-2104

Password Hashing / Key Derivation

Algorithm	Available implementations	Source
Argon2	Argon2, argon2d, argon2i, argon2id	RFC-9106
PBKDF2	PBKDF2	RFC-9106

Checksum Algorithms

Algorithms	Available Methods	Source
Alder32	alder32	Wikipedia
CRC	crc16,crc32,crc64	Wikipedia

Getting Started

The following import will give you access to all of the algorithms in this package.

import 'package:hashlib/hashlib.dart' as hashlib;

Check the API Reference for details.

Usage

Examples can be found inside the example folder.

import 'dart:convert';

import 'package:hashlib/hashlib.dart';
import 'package:hashlib/src/core/utils.dart';

void main() {
  var text = "Happy Hashing!";
  var key = "password";
  var pw = key.codeUnits;
  var salt = "some salt".codeUnits;
  print("text => $text");
  print("key => $key");
  print("salt => ${toHex(salt)}");
  print('');

  // Examples of Hash generation
  print('[MD5] => ${md5.string(text)}');
  print('[SHA-1] => ${sha1.string(text)}');
  print('[SHA-224] => ${sha224.string(text)}');
  print('[SHA-256] => ${sha256.string(text)}');
  print('[SHA-384] => ${sha384.string(text)}');
  print('[SHA-512] => ${sha512.string(text)}');
  print('[SHA-512/224] => ${sha512t224.string(text)}');
  print('[SHA-512/256] => ${sha512t256.string(text)}');
  print('[SHA3-224] => ${sha3_224.string(text)}');
  print('[SHA3-256] => ${sha3_256.string(text)}');
  print('[SHA3-384] => ${sha3_384.string(text)}');
  print('[SHA3-512] => ${sha3_512.string(text)}');
  print('[Keccak-224] => ${keccak224.string(text)}');
  print('[Keccak-256] => ${keccak256.string(text)}');
  print('[Keccak-384] => ${keccak384.string(text)}');
  print('[Keccak-512] => ${keccak512.string(text)}');
  print('[SHAKE-128] => ${shake128.of(20).string(text)}');
  print('[SHAKE-256] => ${shake256.of(20).string(text)}');
  print('[BLAKE-2s/256] => ${blake2s256.string(text)}');
  print('[BLAKE-2b/512] => ${blake2b512.string(text)}');
  print('');

  // Examples of MAC generations
  print('HMAC[MD5] => ${md5.hmac(pw).string(text)}');
  print('HMAC[MD5] => ${md5.hmacBy(key, utf8).string(text)}');
  print('HMAC[MD5] => ${md5.hmacBy(key).string(text)}');
  print('HMAC[MD5] => ${HMAC(md5, pw).string(text)}');
  print("[BLAKE-2b/256] => ${blake2b256.mac(pw).string(text)}");
  print("[BLAKE-2b/256] => ${Blake2bMAC(256, pw).string(text)}");
  print('');

  // Examples of PBKDF2 key derivation
  print("PBKDF2[HMAC[SHA-256]] => ${sha256.pbkdf2(pw, salt, 100)}");
  print("PBKDF2[HMAC[SHA-256]] => ${sha256.hmac(pw).pbkdf2(salt, 100)}");
  print("PBKDF2[BLAKE-2b-MAC] => ${blake2b256.mac(pw).pbkdf2(salt, 100)}");
  print("PBKDF2[HMAC[BLAKE-2b]] => ${blake2b256.pbkdf2(pw, salt, 100)}");
  print("PBKDF2[HMAC[BLAKE-2b]] => ${blake2b256.hmac(pw).pbkdf2(salt, 100)}");
  print('');

  // Examples of Argon2 key derivation
  var security = Argon2Security.test;
  print("[Argon2i] => ${argon2i(pw, salt, security: security)}");
  print("[Argon2d] => ${argon2d(pw, salt, security: security)}");
  print("[Argon2id] => ${argon2id(pw, salt, security: security)}");
  print('');

  // Example of checksum code generators
  print('[CRC16] => ${crc16code(text)}');
  print('[CRC32] => ${crc32code(text)}');
  print('[CRC64] => ${crc64code(text)}');
  print('[Alder32] => ${alder32code(text)}');
}

Benchmarks

To obtain the following benchmarks, run this command:

dart compile exe ./benchmark/benchmark.dart && ./benchmark/benchmark.exe

Libraries:

• Hashlib : https://pub.dev/packages/hashlib
• Crypto : https://pub.dev/packages/crypto
• Hash : https://pub.dev/packages/hash
• PointyCastle : https://pub.dev/packages/pointycastle
• Sha3 : https://pub.dev/packages/sha3

With string of length 10 (100000 iterations):

Algorithms	hashlib	crypto	hash	PointyCastle	sha3
MD5	35.353 ms	99.184 ms 181% slower	132.232 ms 274% slower	84.348 ms 139% slower	➖
SHA-1	60.984 ms	115.06 ms 89% slower	204.618 ms 236% slower	132.707 ms 118% slower	➖
SHA-224	82.921 ms	137.013 ms 65% slower	376.467 ms 354% slower	317.903 ms 283% slower	➖
SHA-256	82.724 ms	135.03 ms 63% slower	375.416 ms 354% slower	318.855 ms 285% slower	➖
SHA-384	103.835 ms	344.046 ms 231% slower	722.537 ms 596% slower	2601.015 ms 2405% slower	➖
SHA-512	103.755 ms	346.637 ms 234% slower	713.643 ms 588% slower	2627.374 ms 2432% slower	➖
SHA-512/224	102.017 ms	342.321 ms 236% slower	➖	5106.248 ms 4905% slower	➖
SHA-512/256	102.386 ms	341.22 ms 233% slower	➖	5096.226 ms 4877% slower	➖
SHA3-256	82.077 ms	➖	➖	4472.259 ms 5349% slower	408.232 ms 397% slower
SHA3-512	103.6 ms	➖	➖	4481.2 ms 4225% slower	408.795 ms 295% slower
BLAKE-2s	62.667 ms	➖	➖	➖	➖
BLAKE-2b	81.948 ms	➖	➖	1144.464 ms 1297% slower	➖
HMAC(MD5)	213.07 ms	266.102 ms 25% slower	498.219 ms 134% slower	➖	➖
HMAC(SHA-256)	535.764 ms	624.437 ms 17% slower	➖	➖	➖

With string of length 1000 (5000 iterations):

Algorithms	hashlib	crypto	hash	PointyCastle	sha3
MD5	31.268 ms	41.928 ms 34% slower	52.334 ms 67% slower	60.301 ms 93% slower	➖
SHA-1	36.819 ms	53.565 ms 45% slower	105.095 ms 185% slower	89.969 ms 144% slower	➖
SHA-224	52.821 ms	63.124 ms 20% slower	238.791 ms 352% slower	237.553 ms 350% slower	➖
SHA-256	52.85 ms	62.812 ms 19% slower	238.127 ms 351% slower	236.949 ms 348% slower	➖
SHA-384	34.541 ms	107.518 ms 211% slower	257.815 ms 646% slower	1000.244 ms 2796% slower	➖
SHA-512	33.865 ms	107.616 ms 218% slower	233.219 ms 589% slower	999.335 ms 2851% slower	➖
SHA-512/224	33.684 ms	109.742 ms 226% slower	➖	1123.899 ms 3237% slower	➖
SHA-512/256	34.84 ms	109.424 ms 214% slower	➖	1143.562 ms 3182% slower	➖
SHA3-256	54.081 ms	➖	➖	1721.936 ms 3084% slower	230.092 ms 325% slower
SHA3-512	34.698 ms	➖	➖	3002.732 ms 8554% slower	337.325 ms 872% slower
BLAKE-2s	36.763 ms	➖	➖	➖	➖
BLAKE-2b	25.799 ms	➖	➖	409.533 ms 1487% slower	➖
HMAC(MD5)	40.644 ms	53.016 ms 30% slower	70.384 ms 73% slower	➖	➖
HMAC(SHA-256)	74.654 ms	91.42 ms 22% slower	➖	➖	➖

With string of length 500000 (10 iterations):

Algorithms	hashlib	crypto	hash	PointyCastle	sha3
MD5	30.376 ms	40.509 ms 33% slower	69.67 ms 129% slower	57.96 ms 91% slower	➖
SHA-1	33.523 ms	51.793 ms 54% slower	120.908 ms 261% slower	86.113 ms 157% slower	➖
SHA-224	50.253 ms	60.678 ms 21% slower	249.619 ms 397% slower	230.563 ms 359% slower	➖
SHA-256	50.344 ms	60.738 ms 21% slower	249.453 ms 395% slower	229.371 ms 356% slower	➖
SHA-384	31.777 ms	103.155 ms 225% slower	280.01 ms 781% slower	968.057 ms 2946% slower	➖
SHA-512	31.718 ms	103.332 ms 226% slower	279.144 ms 780% slower	969.389 ms 2956% slower	➖
SHA-512/224	31.656 ms	102.954 ms 225% slower	➖	970.759 ms 2967% slower	➖
SHA-512/256	32.011 ms	103.348 ms 223% slower	➖	968.022 ms 2924% slower	➖
SHA3-256	50.22 ms	➖	➖	1560.669 ms 3008% slower	212.792 ms 324% slower
SHA3-512	31.7 ms	➖	➖	2932.904 ms 9152% slower	334.856 ms 956% slower
BLAKE-2s	34.788 ms	➖	➖	➖	➖
BLAKE-2b	23.761 ms	➖	➖	393.928 ms 1558% slower	➖
HMAC(MD5)	31.094 ms	42.317 ms 36% slower	69.942 ms 125% slower	➖	➖
HMAC(SHA-256)	50.258 ms	62.296 ms 24% slower	➖	➖	➖

Argon2 benchmarks on different security parameters:

Algorithms	test	little	moderate	good	strong
argon2i	0.391 ms	2.889 ms	19.686 ms	250.008 ms	2718.1 ms
argon2d	0.29 ms	3.207 ms	19.368 ms	245.818 ms	2664.177 ms
argon2id	0.382 ms	5.554 ms	20.352 ms	250.707 ms	2683.672 ms

These benchmarks were done in AMD Ryzen 7 5800X processor and 3200MHz RAM using compiled exe on Windows 10