Add support for salt for BLAKE

Signed-off-by: Mattias Andrée <maandree@kth.se>

10 files changed, 239 insertions, 57 deletions

diff --git a/libhashsum.h b/libhashsum.h
index d85dadd..00fbb17 100644
--- a/libhashsum.h
+++ b/libhashsum.h
@@ -424,22 +424,26 @@ union libhashsum_state {
 	struct {
 		struct libblake_blake224_state s;
 		uint8_t buf[128];
-	} blake224; /* size = 184 */
+		char algostr[49];
+	} blake224; /* size = 233 */
 
 	struct {
 		struct libblake_blake256_state s;
 		uint8_t buf[128];
-	} blake256; /* size = 184 */
+		char algostr[49];
+	} blake256; /* size = 233 */
 
 	struct {
 		struct libblake_blake384_state s;
 		uint8_t buf[256];
-	} blake384; /* size = 368 */
+		char algostr[81];
+	} blake384; /* size = 449 */
 
 	struct {
 		struct libblake_blake512_state s;
 		uint8_t buf[256];
-	} blake512; /* size = 368 */
+		char algostr[81];
+	} blake512; /* size = 449 */
 #endif
 
 	/* libblake: 48(2s), 96(2b), 144(2Xs), 276(2Xb) */
@@ -1180,6 +1184,7 @@ int libhashsum_init_rawshake_hasher(struct libhashsum_hasher *this, size_t hcapb
  * hashing and return hash functions and details
  * 
  * @param   this  The output parameter for the functions, details, and state
+ * @param   salt  `NULL` (for all zeroes) or a 16-byte salt
  * @return        0 on success, -1 on failure
  * 
  * @throws  ENOSYS  Support was excluded at compile time
@@ -1187,13 +1192,14 @@ int libhashsum_init_rawshake_hasher(struct libhashsum_hasher *this, size_t hcapb
  * @since  1.0
  */
 LIBHASHSUM_1_NONNULL_
-int libhashsum_init_blake224_hasher(struct libhashsum_hasher *this);
+int libhashsum_init_blake224_hasher(struct libhashsum_hasher *this, const void *salt);
 
 /**
  * Create an initialised state for BLAKE256 (BLAKE, BLAKEs)
  * hashing and return hash functions and details
  * 
  * @param   this  The output parameter for the functions, details, and state
+ * @param   salt  `NULL` (for all zeroes) or a 16-byte salt
  * @return        0 on success, -1 on failure
  * 
  * @throws  ENOSYS  Support was excluded at compile time
@@ -1201,7 +1207,7 @@ int libhashsum_init_blake224_hasher(struct libhashsum_hasher *this);
  * @since  1.0
  */
 LIBHASHSUM_1_NONNULL_
-int libhashsum_init_blake256_hasher(struct libhashsum_hasher *this);
+int libhashsum_init_blake256_hasher(struct libhashsum_hasher *this, const void *salt);
 
 /**
  * Create an initialised state for BLAKEs (BLAKE)
@@ -1209,6 +1215,7 @@ int libhashsum_init_blake256_hasher(struct libhashsum_hasher *this);
  * 
  * @param   this      The output parameter for the functions, details, and state
  * @param   hashbits  Hash output size in bits
+ * @param   salt      `NULL` (for all zeroes) or a 16-byte salt
  * @return            0 on success, -1 on failure
  * 
  * @throws  EINVAL  `hashbits` is invalid (neither 224 nor 256)
@@ -1217,13 +1224,14 @@ int libhashsum_init_blake256_hasher(struct libhashsum_hasher *this);
  * @since  1.0
  */
 LIBHASHSUM_1_NONNULL_
-int libhashsum_init_blakes_hasher(struct libhashsum_hasher *this, size_t hashbits);
+int libhashsum_init_blakes_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt);
 
 /**
  * Create an initialised state for BLAKE384 (BLAKE, BLAKEb)
  * hashing and return hash functions and details
  * 
  * @param   this  The output parameter for the functions, details, and state
+ * @param   salt  `NULL` (for all zeroes) or a 32-byte salt
  * @return        0 on success, -1 on failure
  * 
  * @throws  ENOSYS  Support was excluded at compile time
@@ -1231,13 +1239,14 @@ int libhashsum_init_blakes_hasher(struct libhashsum_hasher *this, size_t hashbit
  * @since  1.0
  */
 LIBHASHSUM_1_NONNULL_
-int libhashsum_init_blake384_hasher(struct libhashsum_hasher *this);
+int libhashsum_init_blake384_hasher(struct libhashsum_hasher *this, const void *salt);
 
 /**
  * Create an initialised state for BLAKE512 (BLAKE, BLAKEb)
  * hashing and return hash functions and details
  * 
  * @param   this  The output parameter for the functions, details, and state
+ * @param   salt  `NULL` (for all zeroes) or a 32-byte salt
  * @return        0 on success, -1 on failure
  * 
  * @throws  ENOSYS  Support was excluded at compile time
@@ -1245,7 +1254,7 @@ int libhashsum_init_blake384_hasher(struct libhashsum_hasher *this);
  * @since  1.0
  */
 LIBHASHSUM_1_NONNULL_
-int libhashsum_init_blake512_hasher(struct libhashsum_hasher *this);
+int libhashsum_init_blake512_hasher(struct libhashsum_hasher *this, const void *salt);
 
 /**
  * Create an initialised state for BLAKEb (BLAKE)
@@ -1253,6 +1262,7 @@ int libhashsum_init_blake512_hasher(struct libhashsum_hasher *this);
  * 
  * @param   this      The output parameter for the functions, details, and state
  * @param   hashbits  Hash output size in bits
+ * @param   salt      `NULL` (for all zeroes) or a 32-byte salt
  * @return            0 on success, -1 on failure
  * 
  * @throws  EINVAL  `hashbits` is invalid (neither 384 nor 512)
@@ -1261,23 +1271,29 @@ int libhashsum_init_blake512_hasher(struct libhashsum_hasher *this);
  * @since  1.0
  */
 LIBHASHSUM_1_NONNULL_
-int libhashsum_init_blakeb_hasher(struct libhashsum_hasher *this, size_t hashbits);
+int libhashsum_init_blakeb_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt);
 
 /**
  * Create an initialised state for BLAKE
  * hashing and return hash functions and details
  * 
- * @param   this      The output parameter for the functions, details, and state
- * @param   hashbits  Hash output size in bits
- * @return            0 on success, -1 on failure
+ * @param   this       The output parameter for the functions, details, and state
+ * @param   hashbits   Hash output size in bits
+ * @param   salt       `NULL` (for all zeroes) or a salt
+ * @parma   saltbytes  The number of bytes in `salt` (ignored if `salt` is `NULL`),
+ *                     shall be 16 for if `hashbits` is 224 or 256, and 32 if
+ *                     `hashbits` is 384 or 512
+ * @return             0 on success, -1 on failure
  * 
  * @throws  EINVAL  `hashbits` is invalid (neither 224, 256, 384, nor 512)
+ * @throws  EINVAL  `salt` is not `NULL` but `saltbytes` does not match
+ *                  the expected value for the input `hashbits`
  * @throws  ENOSYS  Support was excluded at compile time
  * 
  * @since  1.0
  */
 LIBHASHSUM_1_NONNULL_
-int libhashsum_init_blake_hasher(struct libhashsum_hasher *this, size_t hashbits);
+int libhashsum_init_blake_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt, size_t saltbytes);
 
 
 #endif
diff --git a/libhashsum_init_blake224_hasher.c b/libhashsum_init_blake224_hasher.c
index 65d0ee1..642af8d 100644
--- a/libhashsum_init_blake224_hasher.c
+++ b/libhashsum_init_blake224_hasher.c
@@ -68,12 +68,35 @@ finalise(struct libhashsum_hasher *this, void *data, size_t bytes, unsigned extr
 }
 
 
+static const char *
+mkalgostr(char *buf, const char *name, const uint8_t *salt)
+{
+	char *p;
+	size_t i;
+	if (!salt)
+		return name;
+	for (i = 0; i < 16U; i++)
+		if (salt[i])
+			goto nonzero;
+	return name;
+nonzero:
+	p = stpcpy(stpcpy(buf, name), "[salt=");
+	for (i = 0; i < 16U; i++) {
+		*p++ = "0123456789abcdef"[(salt[i] >> 4) & 15];
+		*p++ = "0123456789abcdef"[(salt[i] >> 0) & 15];
+	}
+	*p++ = ']';
+	*p++ = '\0';
+	return buf;
+}
+
+
 int
-libhashsum_init_blake224_hasher(struct libhashsum_hasher *this)
+libhashsum_init_blake224_hasher(struct libhashsum_hasher *this, const void *salt)
 {
 	libblake_init();
 	this->algorithm = LIBHASHSUM_BLAKE224;
-	this->algorithm_string = "BLAKE224";
+	this->algorithm_string = mkalgostr(this->state.blake224.algostr, "BLAKE224", salt);
 	this->input_block_size = 64U;
 	this->hash_size = LIBHASHSUM_BLAKE224_HASH_SIZE;
 	this->hash_output = NULL;
@@ -82,16 +105,17 @@ libhashsum_init_blake224_hasher(struct libhashsum_hasher *this)
 	this->finalise_const = &finalise_const;
 	this->finalise = &finalise;
 	this->destroy = NULL;
-	libblake_blake224_init2(&this->state.blake224.s, NULL);
+	libblake_blake224_init2(&this->state.blake224.s, salt);
 	return 0;
 }
 
 
 #else
 int
-libhashsum_init_blake224_hasher(struct libhashsum_hasher *this)
+libhashsum_init_blake224_hasher(struct libhashsum_hasher *this, const void *salt)
 {
 	(void) this;
+	(void) salt;
 	errno = ENOSYS;
 	return -1;
 }
diff --git a/libhashsum_init_blake256_hasher.c b/libhashsum_init_blake256_hasher.c
index 202dc37..fd77878 100644
--- a/libhashsum_init_blake256_hasher.c
+++ b/libhashsum_init_blake256_hasher.c
@@ -68,12 +68,35 @@ finalise(struct libhashsum_hasher *this, void *data, size_t bytes, unsigned extr
 }
 
 
+static const char *
+mkalgostr(char *buf, const char *name, const uint8_t *salt)
+{
+	char *p;
+	size_t i;
+	if (!salt)
+		return name;
+	for (i = 0; i < 16U; i++)
+		if (salt[i])
+			goto nonzero;
+	return name;
+nonzero:
+	p = stpcpy(stpcpy(buf, name), "[salt=");
+	for (i = 0; i < 16U; i++) {
+		*p++ = "0123456789abcdef"[(salt[i] >> 4) & 15];
+		*p++ = "0123456789abcdef"[(salt[i] >> 0) & 15];
+	}
+	*p++ = ']';
+	*p++ = '\0';
+	return buf;
+}
+
+
 int
-libhashsum_init_blake256_hasher(struct libhashsum_hasher *this)
+libhashsum_init_blake256_hasher(struct libhashsum_hasher *this, const void *salt)
 {
 	libblake_init();
 	this->algorithm = LIBHASHSUM_BLAKE256;
-	this->algorithm_string = "BLAKE256";
+	this->algorithm_string = mkalgostr(this->state.blake224.algostr, "BLAKE256", salt);
 	this->input_block_size = 64U;
 	this->hash_size = LIBHASHSUM_BLAKE256_HASH_SIZE;
 	this->hash_output = NULL;
@@ -82,16 +105,17 @@ libhashsum_init_blake256_hasher(struct libhashsum_hasher *this)
 	this->finalise_const = &finalise_const;
 	this->finalise = &finalise;
 	this->destroy = NULL;
-	libblake_blake256_init2(&this->state.blake256.s, NULL);
+	libblake_blake256_init2(&this->state.blake256.s, salt);
 	return 0;
 }
 
 
 #else
 int
-libhashsum_init_blake256_hasher(struct libhashsum_hasher *this)
+libhashsum_init_blake256_hasher(struct libhashsum_hasher *this, const void *salt)
 {
 	(void) this;
+	(void) salt;
 	errno = ENOSYS;
 	return -1;
 }
diff --git a/libhashsum_init_blake384_hasher.c b/libhashsum_init_blake384_hasher.c
index 6f92c6c..cd6457f 100644
--- a/libhashsum_init_blake384_hasher.c
+++ b/libhashsum_init_blake384_hasher.c
@@ -68,12 +68,35 @@ finalise(struct libhashsum_hasher *this, void *data, size_t bytes, unsigned extr
 }
 
 
+static const char *
+mkalgostr(char *buf, const char *name, const uint8_t *salt)
+{
+	char *p;
+	size_t i;
+	if (!salt)
+		return name;
+	for (i = 0; i < 32U; i++)
+		if (salt[i])
+			goto nonzero;
+	return name;
+nonzero:
+	p = stpcpy(stpcpy(buf, name), "[salt=");
+	for (i = 0; i < 32U; i++) {
+		*p++ = "0123456789abcdef"[(salt[i] >> 4) & 15];
+		*p++ = "0123456789abcdef"[(salt[i] >> 0) & 15];
+	}
+	*p++ = ']';
+	*p++ = '\0';
+	return buf;
+}
+
+
 int
-libhashsum_init_blake384_hasher(struct libhashsum_hasher *this)
+libhashsum_init_blake384_hasher(struct libhashsum_hasher *this, const void *salt)
 {
 	libblake_init();
 	this->algorithm = LIBHASHSUM_BLAKE384;
-	this->algorithm_string = "BLAKE384";
+	this->algorithm_string = mkalgostr(this->state.blake224.algostr, "BLAKE384", salt);
 	this->input_block_size = 128U;
 	this->hash_size = LIBHASHSUM_BLAKE384_HASH_SIZE;
 	this->hash_output = NULL;
@@ -82,16 +105,17 @@ libhashsum_init_blake384_hasher(struct libhashsum_hasher *this)
 	this->finalise_const = &finalise_const;
 	this->finalise = &finalise;
 	this->destroy = NULL;
-	libblake_blake384_init2(&this->state.blake384.s, NULL);
+	libblake_blake384_init2(&this->state.blake384.s, salt);
 	return 0;
 }
 
 
 #else
 int
-libhashsum_init_blake384_hasher(struct libhashsum_hasher *this)
+libhashsum_init_blake384_hasher(struct libhashsum_hasher *this, const void *salt)
 {
 	(void) this;
+	(void) salt;
 	errno = ENOSYS;
 	return -1;
 }
diff --git a/libhashsum_init_blake512_hasher.c b/libhashsum_init_blake512_hasher.c
index b1d2c13..d174fdd 100644
--- a/libhashsum_init_blake512_hasher.c
+++ b/libhashsum_init_blake512_hasher.c
@@ -68,12 +68,35 @@ finalise(struct libhashsum_hasher *this, void *data, size_t bytes, unsigned extr
 }
 
 
+static const char *
+mkalgostr(char *buf, const char *name, const uint8_t *salt)
+{
+	char *p;
+	size_t i;
+	if (!salt)
+		return name;
+	for (i = 0; i < 32U; i++)
+		if (salt[i])
+			goto nonzero;
+	return name;
+nonzero:
+	p = stpcpy(stpcpy(buf, name), "[salt=");
+	for (i = 0; i < 32U; i++) {
+		*p++ = "0123456789abcdef"[(salt[i] >> 4) & 15];
+		*p++ = "0123456789abcdef"[(salt[i] >> 0) & 15];
+	}
+	*p++ = ']';
+	*p++ = '\0';
+	return buf;
+}
+
+
 int
-libhashsum_init_blake512_hasher(struct libhashsum_hasher *this)
+libhashsum_init_blake512_hasher(struct libhashsum_hasher *this, const void *salt)
 {
 	libblake_init();
 	this->algorithm = LIBHASHSUM_BLAKE512;
-	this->algorithm_string = "BLAKE512";
+	this->algorithm_string = mkalgostr(this->state.blake224.algostr, "BLAKE512", salt);
 	this->input_block_size = 128U;
 	this->hash_size = LIBHASHSUM_BLAKE512_HASH_SIZE;
 	this->hash_output = NULL;
@@ -82,16 +105,17 @@ libhashsum_init_blake512_hasher(struct libhashsum_hasher *this)
 	this->finalise_const = &finalise_const;
 	this->finalise = &finalise;
 	this->destroy = NULL;
-	libblake_blake512_init2(&this->state.blake512.s, NULL);
+	libblake_blake512_init2(&this->state.blake512.s, salt);
 	return 0;
 }
 
 
 #else
 int
-libhashsum_init_blake512_hasher(struct libhashsum_hasher *this)
+libhashsum_init_blake512_hasher(struct libhashsum_hasher *this, const void *salt)
 {
 	(void) this;
+	(void) salt;
 	errno = ENOSYS;
 	return -1;
 }
diff --git a/libhashsum_init_blake_hasher.c b/libhashsum_init_blake_hasher.c
index 645ab95..7b6d78e 100644
--- a/libhashsum_init_blake_hasher.c
+++ b/libhashsum_init_blake_hasher.c
@@ -4,17 +4,28 @@
 
 
 int
-libhashsum_init_blake_hasher(struct libhashsum_hasher *this, size_t hashbits)
+libhashsum_init_blake_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt, size_t salybytes)
 {
+	if (salt) {
+		if (hashbits == 224U || hashbits == 256U) {
+			if (salybytes != 16U)
+				goto einval;
+		} else if (hashbits == 384U || hashbits == 512U) {
+			if (salybytes != 32U)
+				goto einval;
+		}
+	}
+
 	if (hashbits == 224U)
-		return libhashsum_init_blake224_hasher(this);
+		return libhashsum_init_blake224_hasher(this, salt);
 	if (hashbits == 256U)
-		return libhashsum_init_blake256_hasher(this);
+		return libhashsum_init_blake256_hasher(this, salt);
 	if (hashbits == 384U)
-		return libhashsum_init_blake384_hasher(this);
+		return libhashsum_init_blake384_hasher(this, salt);
 	if (hashbits == 512U)
-		return libhashsum_init_blake512_hasher(this);
+		return libhashsum_init_blake512_hasher(this, salt);
 
+einval:
 	errno = EINVAL;
 	return -1;
 }
@@ -22,10 +33,12 @@ libhashsum_init_blake_hasher(struct libhashsum_hasher *this, size_t hashbits)
 
 #else
 int
-libhashsum_init_blake_hasher(struct libhashsum_hasher *this, size_t hashbits)
+libhashsum_init_blake_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt, size_t salybytes)
 {
 	(void) this;
 	(void) hashbits;
+	(void) salt;
+	(void) saltbytes;
 	errno = ENOSYS;
 	return -1;
 }
diff --git a/libhashsum_init_blakeb_hasher.c b/libhashsum_init_blakeb_hasher.c
index 417553b..42cdb16 100644
--- a/libhashsum_init_blakeb_hasher.c
+++ b/libhashsum_init_blakeb_hasher.c
@@ -4,12 +4,12 @@
 
 
 int
-libhashsum_init_blakeb_hasher(struct libhashsum_hasher *this, size_t hashbits)
+libhashsum_init_blakeb_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt)
 {
 	if (hashbits == 384U)
-		return libhashsum_init_blake384_hasher(this);
+		return libhashsum_init_blake384_hasher(this, salt);
 	if (hashbits == 512U)
-		return libhashsum_init_blake512_hasher(this);
+		return libhashsum_init_blake512_hasher(this, salt);
 
 	errno = EINVAL;
 	return -1;
@@ -18,10 +18,11 @@ libhashsum_init_blakeb_hasher(struct libhashsum_hasher *this, size_t hashbits)
 
 #else
 int
-libhashsum_init_blakeb_hasher(struct libhashsum_hasher *this, size_t hashbits)
+libhashsum_init_blakeb_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt)
 {
 	(void) this;
 	(void) hashbits;
+	(void) salt;
 	errno = ENOSYS;
 	return -1;
 }
diff --git a/libhashsum_init_blakes_hasher.c b/libhashsum_init_blakes_hasher.c
index f5e7c20..32bf9a3 100644
--- a/libhashsum_init_blakes_hasher.c
+++ b/libhashsum_init_blakes_hasher.c
@@ -4,12 +4,12 @@
 
 
 int
-libhashsum_init_blakes_hasher(struct libhashsum_hasher *this, size_t hashbits)
+libhashsum_init_blakes_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt)
 {
 	if (hashbits == 224U)
-		return libhashsum_init_blake224_hasher(this);
+		return libhashsum_init_blake224_hasher(this, salt);
 	if (hashbits == 256U)
-		return libhashsum_init_blake256_hasher(this);
+		return libhashsum_init_blake256_hasher(this, salt);
 
 	errno = EINVAL;
 	return -1;
@@ -18,10 +18,11 @@ libhashsum_init_blakes_hasher(struct libhashsum_hasher *this, size_t hashbits)
 
 #else
 int
-libhashsum_init_blakes_hasher(struct libhashsum_hasher *this, size_t hashbits)
+libhashsum_init_blakes_hasher(struct libhashsum_hasher *this, size_t hashbits, const void *salt)
 {
 	(void) this;
 	(void) hashbits;
+	(void) salt;
 	errno = ENOSYS;
 	return -1;
 }
diff --git a/libhashsum_init_hasher.c b/libhashsum_init_hasher.c
index ab44ac1..6f09629 100644
--- a/libhashsum_init_hasher.c
+++ b/libhashsum_init_hasher.c
@@ -65,13 +65,13 @@ libhashsum_init_hasher(struct libhashsum_hasher *this, enum libhashsum_algorithm
 	case LIBHASHSUM_RAWSHAKE512:
 		return libhashsum_init_rawshake512_hasher(this, 0);
 	case LIBHASHSUM_BLAKE224:
-		return libhashsum_init_blake224_hasher(this);
+		return libhashsum_init_blake224_hasher(this, NULL);
 	case LIBHASHSUM_BLAKE256:
-		return libhashsum_init_blake256_hasher(this);
+		return libhashsum_init_blake256_hasher(this, NULL);
 	case LIBHASHSUM_BLAKE384:
-		return libhashsum_init_blake384_hasher(this);
+		return libhashsum_init_blake384_hasher(this, NULL);
 	case LIBHASHSUM_BLAKE512:
-		return libhashsum_init_blake512_hasher(this);
+		return libhashsum_init_blake512_hasher(this, NULL);
 	default:
 	case LIBHASHSUM_KECCAK:
 		errno = EINVAL;
diff --git a/libhashsum_init_hasher_from_string.c b/libhashsum_init_hasher_from_string.c
index 9a53864..1bdc70d 100644
--- a/libhashsum_init_hasher_from_string.c
+++ b/libhashsum_init_hasher_from_string.c
@@ -32,7 +32,7 @@ with_n(int (*initfunc)(struct libhashsum_hasher *, size_t), struct libhashsum_ha
 	if (!p || *++p == ']')
 		return initfunc(this, 0);
 
-	if ((*p++ != 'n' && *p++ != 'N'))
+	if (*p++ != 'n' && *p++ != 'N')
 		goto einval;
 	if (*p++ != '=' || !('1' <= *p && *p <= '9'))
 		goto einval;
@@ -117,6 +117,61 @@ einval:
 }
 
 
+static int
+with_salt(int (*initfunc)(struct libhashsum_hasher *, const void *),
+          struct libhashsum_hasher *this, const char *algorithm, size_t saltbytes)
+{
+	const char *p;
+	uint8_t a, b, salt[32];
+	size_t salti = 0;
+
+	p = strchr(algorithm, '[');
+	if (!p || *++p == ']')
+		return initfunc(this, NULL);
+
+	if (*p++ != 's' && *p++ != 'S')
+		goto einval;
+	if (*p++ != 'a' && *p++ != 'A')
+		goto einval;
+	if (*p++ != 'l' && *p++ != 'L')
+		goto einval;
+	if (*p++ != 't' && *p++ != 'T')
+		goto einval;
+	if (*p++ != '=')
+		goto einval;
+
+	if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X'))
+		p = &p[2];
+
+	for (;;) {
+		if (isxdigit(p[0]) && isxdigit(p[1])) {
+			if (!saltbytes)
+				goto einval;
+			saltbytes--;
+		} else if (isxdigit(p[0])) {
+			goto einval;
+		} else if (saltbytes) {
+			goto einval;
+		} else {
+			break;
+		}
+
+		a = (uint8_t)(((*p & 15) + (*p > '9' ? 9 : 0)) << 4);
+		b = (uint8_t)(((*p & 15) + (*p > '9' ? 9 : 0)) << 0);
+		salt[salti++] = (uint8_t)(a | b);
+	}
+
+	if (*p++ != ']' || *p)
+		goto einval;
+
+	return initfunc(this, salt);
+
+einval:
+	errno = EINVAL;
+	return -1;
+}
+
+
 int
 libhashsum_init_hasher_from_string(struct libhashsum_hasher *this, const char *algorithm)
 {
@@ -180,14 +235,14 @@ libhashsum_init_hasher_from_string(struct libhashsum_hasher *this, const char *a
 		return with_n(&libhashsum_init_rawshake512_hasher, this, algorithm);
 	if (equiv(algorithm, "Keccak["))
 		return with_rcn(&libhashsum_init_keccak_hasher, this, algorithm);
-	if (equiv(algorithm, "BLAKE-224"))
-		return libhashsum_init_blake224_hasher(this);
-	if (equiv(algorithm, "BLAKE-256"))
-		return libhashsum_init_blake256_hasher(this);
-	if (equiv(algorithm, "BLAKE-384"))
-		return libhashsum_init_blake384_hasher(this);
-	if (equiv(algorithm, "BLAKE-512"))
-		return libhashsum_init_blake512_hasher(this);
+	if (equiv(algorithm, "BLAKE-224["))
+		return with_salt(&libhashsum_init_blake224_hasher, this, algorithm, 16U);
+	if (equiv(algorithm, "BLAKE-256["))
+		return with_salt(&libhashsum_init_blake256_hasher, this, algorithm, 16U);
+	if (equiv(algorithm, "BLAKE-384["))
+		return with_salt(&libhashsum_init_blake384_hasher, this, algorithm, 32U);
+	if (equiv(algorithm, "BLAKE-512["))
+		return with_salt(&libhashsum_init_blake512_hasher, this, algorithm, 32U);
 
 	errno = EINVAL;
 	return -1;