facil.io
Cryptography & TLS

#BLAKE2

c
#define FIO_BLAKE2
#include "fio-stl.h"

BLAKE2b (64-bit, up to 64-byte digest) and BLAKE2s (32-bit, up to 32-byte digest). Both are fast, modern cryptographic hashes with built-in keyed hashing, standard HMAC wrappers, and a streaming init/consume/finalize API.

#Types

#fio_blake2b_s

c
typedef struct {
  uint64_t h[8];    /* state */
  uint64_t t[2];    /* total bytes processed (128-bit counter) */
  uint64_t f[2];    /* finalization flags */
  uint8_t buf[128]; /* input buffer */
  size_t buflen;    /* bytes in buffer */
  size_t outlen;    /* digest length */
} fio_blake2b_s;

Streaming BLAKE2b context. Treat it as opaque and initialize with fio_blake2b_init.

#fio_blake2s_s

c
typedef struct {
  uint32_t h[8];   /* state */
  uint32_t t[2];   /* total bytes processed (64-bit counter) */
  uint32_t f[2];   /* finalization flags */
  uint8_t buf[64]; /* input buffer */
  size_t buflen;   /* bytes in buffer */
  size_t outlen;   /* digest length */
} fio_blake2s_s;

Streaming BLAKE2s context. Treat it as opaque and initialize with fio_blake2s_init.

#BLAKE2b Functions

#fio_blake2b

c
FIO_IFUNC fio_u512 fio_blake2b(const void *data, uint64_t len);

One-shot BLAKE2b with the full 64-byte digest.

Parameters:

  • data — bytes to hash.
  • len — number of bytes.

Returns: the 64-byte digest as fio_u512.

Note: signature matches fio_sha512, so the two are interchangeable as fio_u512 (*)(const void *, uint64_t).

#fio_blake2b_hash

c
SFUNC void fio_blake2b_hash(void *restrict out,
                            size_t outlen,
                            const void *restrict data,
                            size_t len,
                            const void *restrict key,
                            size_t keylen);

Flexible-output BLAKE2b with optional keyed hashing.

Parameters:

  • out — destination buffer (at least outlen bytes).
  • outlen — digest length (1–64; defaults to 64 if 0).
  • data — bytes to hash.
  • len — data length.
  • key — optional secret key (NULL for unkeyed).
  • keylen — key length (0–64; clamped to 64 if larger).

Note: keyed BLAKE2b is a built-in MAC mode; for RFC-2104 HMAC, use fio_blake2b_hmac.

#fio_blake2b_hmac

c
SFUNC fio_u512 fio_blake2b_hmac(const void *key,
                                uint64_t key_len,
                                const void *msg,
                                uint64_t msg_len);

Standard HMAC-BLAKE2b with a 64-byte digest.

Parameters:

  • key — secret key.
  • key_len — key length.
  • msg — message to authenticate.
  • msg_len — message length.

Returns: 64-byte authentication code as fio_u512.

#fio_blake2b_init

c
SFUNC fio_blake2b_s fio_blake2b_init(size_t outlen,
                                     const void *key,
                                     size_t keylen);

Initializes a BLAKE2b streaming context.

Parameters:

  • outlen — desired digest length (1–64; defaults to 64 if 0).
  • key — optional secret key (NULL for unkeyed).
  • keylen — key length (0–64; clamped to 64 if larger).

#fio_blake2b_consume

c
SFUNC void fio_blake2b_consume(fio_blake2b_s *restrict h,
                               const void *restrict data,
                               size_t len);

Feeds more data into a BLAKE2b streaming context. May be called repeatedly.

#fio_blake2b_finalize

c
SFUNC fio_u512 fio_blake2b_finalize(fio_blake2b_s *h);

Finalizes the stream and returns the digest.

Returns: digest as fio_u512. Only the first outlen bytes are valid.

#BLAKE2s Functions

#fio_blake2s

c
FIO_IFUNC fio_u256 fio_blake2s(const void *data, uint64_t len);

One-shot BLAKE2s with the full 32-byte digest.

#fio_blake2s_hash

c
SFUNC void fio_blake2s_hash(void *restrict out,
                            size_t outlen,
                            const void *restrict data,
                            size_t len,
                            const void *restrict key,
                            size_t keylen);

Flexible-output BLAKE2s with optional keyed hashing. outlen is 1–32 (defaults to 32 if 0).

#fio_blake2s_hmac

c
SFUNC fio_u256 fio_blake2s_hmac(const void *key,
                                uint64_t key_len,
                                const void *msg,
                                uint64_t msg_len);

Standard HMAC-BLAKE2s with a 32-byte digest.

#fio_blake2s_init

c
SFUNC fio_blake2s_s fio_blake2s_init(size_t outlen,
                                     const void *key,
                                     size_t keylen);

Initializes a BLAKE2s streaming context. outlen is 1–32 (defaults to 32 if 0).

#fio_blake2s_consume

c
SFUNC void fio_blake2s_consume(fio_blake2s_s *restrict h,
                               const void *restrict data,
                               size_t len);

Feeds more data into a BLAKE2s streaming context.

#fio_blake2s_finalize

c
SFUNC fio_u256 fio_blake2s_finalize(fio_blake2s_s *h);

Finalizes the stream and returns the digest.

#Examples

c
#define FIO_BLAKE2
#include "fio-stl.h"

void examples(void) {
  const char *msg = "Hello, BLAKE2!";

  /* One-shot */
  fio_u512 b2b = fio_blake2b(msg, strlen(msg));
  fio_u256 b2s = fio_blake2s(msg, strlen(msg));

  /* Flexible output with key */
  uint8_t digest[16];
  fio_blake2b_hash(digest, 16, msg, strlen(msg), "key", 3);

  /* Streaming */
  fio_blake2b_s ctx = fio_blake2b_init(64, NULL, 0);
  fio_blake2b_consume(&ctx, "Hello, ", 7);
  fio_blake2b_consume(&ctx, "BLAKE2!", 7);
  fio_u512 result = fio_blake2b_finalize(&ctx);

  /* HMAC */
  fio_u512 mac = fio_blake2b_hmac("key", 3, msg, strlen(msg));
}

#BLAKE2b vs BLAKE2s

Property BLAKE2b BLAKE2s
Word size 64-bit 32-bit
Block size 128 bytes 64 bytes
Max digest 64 bytes 32 bytes
Max key 64 bytes 32 bytes
Rounds 12 10
Result type fio_u512 fio_u256