#include <stddef.h>
#include <stdint.h>

Include dependency graph for fips202.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	shake128incctx

struct	shake128ctx

struct	shake256incctx

struct	shake256ctx

struct	sha3_256incctx

struct	sha3_384incctx

struct	sha3_512incctx

Macros
#define	SHAKE128_RATE 168

#define	SHAKE256_RATE 136

#define	SHA3_256_RATE 136

#define	SHA3_384_RATE 104

#define	SHA3_512_RATE 72

Functions
void	shake128_absorb (shake128ctx state, const uint8_t input, size_t inlen)

void	shake128_squeezeblocks (uint8_t output, size_t nblocks, shake128ctx state)

void	shake128_ctx_release (shake128ctx *state)

void	shake128_ctx_clone (shake128ctx dest, const shake128ctx src)

void	cshake128_simple_absorb (shake128ctx state, uint16_t cstm, const uint8_t input, size_t inlen)

void	cshake128_simple_squeezeblocks (uint8_t output, size_t nblocks, shake128ctx state)

void	cshake128_simple (uint8_t output, size_t outlen, uint16_t cstm, const uint8_t input, size_t inlen)

void	shake128_inc_init (shake128incctx *state)

void	shake128_inc_absorb (shake128incctx state, const uint8_t input, size_t inlen)

void	shake128_inc_finalize (shake128incctx *state)

void	shake128_inc_squeeze (uint8_t output, size_t outlen, shake128incctx state)

void	shake128_inc_ctx_clone (shake128incctx dest, const shake128incctx src)

void	shake128_inc_ctx_release (shake128incctx *state)

void	shake256_absorb (shake256ctx state, const uint8_t input, size_t inlen)

void	shake256_squeezeblocks (uint8_t output, size_t nblocks, shake256ctx state)

void	shake256_ctx_release (shake256ctx *state)

void	shake256_ctx_clone (shake256ctx dest, const shake256ctx src)

void	cshake256_simple_absorb (shake256ctx state, uint16_t cstm, const uint8_t input, size_t inlen)

void	cshake256_simple_squeezeblocks (uint8_t output, size_t nblocks, shake256ctx state)

void	cshake256_simple (uint8_t output, size_t outlen, uint16_t cstm, const uint8_t input, size_t inlen)

void	shake256_inc_init (shake256incctx *state)

void	shake256_inc_absorb (shake256incctx state, const uint8_t input, size_t inlen)

void	shake256_inc_finalize (shake256incctx *state)

void	shake256_inc_squeeze (uint8_t output, size_t outlen, shake256incctx state)

void	shake256_inc_ctx_clone (shake256incctx dest, const shake256incctx src)

void	shake256_inc_ctx_release (shake256incctx *state)

void	shake128 (uint8_t output, size_t outlen, const uint8_t input, size_t inlen)

void	shake256 (uint8_t output, size_t outlen, const uint8_t input, size_t inlen)

void	sha3_256_inc_init (sha3_256incctx *state)

void	sha3_256_inc_absorb (sha3_256incctx state, const uint8_t input, size_t inlen)

void	sha3_256_inc_finalize (uint8_t output, sha3_256incctx state)

void	sha3_256_inc_ctx_clone (sha3_256incctx dest, const sha3_256incctx src)

void	sha3_256_inc_ctx_release (sha3_256incctx *state)

void	sha3_256 (uint8_t output, const uint8_t input, size_t inlen)

void	sha3_384_inc_init (sha3_384incctx *state)

void	sha3_384_inc_absorb (sha3_384incctx state, const uint8_t input, size_t inlen)

void	sha3_384_inc_finalize (uint8_t output, sha3_384incctx state)

void	sha3_384_inc_ctx_clone (sha3_384incctx dest, const sha3_384incctx src)

void	sha3_384_inc_ctx_release (sha3_384incctx *state)

void	sha3_384 (uint8_t output, const uint8_t input, size_t inlen)

void	sha3_512_inc_init (sha3_512incctx *state)

void	sha3_512_inc_absorb (sha3_512incctx state, const uint8_t input, size_t inlen)

void	sha3_512_inc_finalize (uint8_t output, sha3_512incctx state)

void	sha3_512_inc_ctx_clone (sha3_512incctx dest, const sha3_512incctx src)

void	sha3_512_inc_ctx_release (sha3_512incctx *state)

void	sha3_512 (uint8_t output, const uint8_t input, size_t inlen)

Macro Definition Documentation

◆ SHA3_256_RATE

#define SHA3_256_RATE 136

Definition at line 9 of file fips202.h.

◆ SHA3_384_RATE

#define SHA3_384_RATE 104

Definition at line 10 of file fips202.h.

◆ SHA3_512_RATE

#define SHA3_512_RATE 72

Definition at line 11 of file fips202.h.

◆ SHAKE128_RATE

#define SHAKE128_RATE 168

Definition at line 7 of file fips202.h.

◆ SHAKE256_RATE

#define SHAKE256_RATE 136

Definition at line 8 of file fips202.h.

Function Documentation

◆ cshake128_simple()

void cshake128_simple	(	uint8_t *	output,
		size_t	outlen,
		uint16_t	cstm,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 370 of file fips202.c.

{
  shake128incctx state;
  uint8_t sep[8];
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
 
  keccak_inc_init(state.ctx);
 
  /* Absorb customization (domain-separation) string */
  sep[0] = 0x01;
  sep[1] = 0xa8;
  sep[2] = 0x01;
  sep[3] = 0x00;
  sep[4] = 0x01;
  sep[5] = 16; // fixed bitlen of cstm
  sep[6] = cstm & 0xff;
  sep[7] = cstm >> 8;
 
  KeccakF1600_StateXORBytes(state.ctx, sep, 0, 8);
  KeccakF1600_StatePermute(state.ctx);
 
  /* Absorb input */
  keccak_inc_absorb(state.ctx, SHAKE128_RATE, in, inlen);
  keccak_inc_finalize(state.ctx, SHAKE128_RATE, 0x04);
 
  /* Squeeze output */
  keccak_inc_squeeze(output, outlen, state.ctx, SHAKE128_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128incctx::ctx, hal_get_time(), KeccakF1600_StatePermute(), KeccakF1600_StateXORBytes(), and SHAKE128_RATE.

Here is the call graph for this function:

◆ cshake128_simple_absorb()

void cshake128_simple_absorb	(	shake128ctx *	state,
		uint16_t	cstm,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 320 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
 
 
  uint8_t sep[8];
  size_t i;
 
  for (i = 0; i < 25; i++)
    state->ctx[i] = 0;
 
  /* Absorb customization (domain-separation) string */
  sep[0] = 0x01;
  sep[1] = 0xa8;
  sep[2] = 0x01;
  sep[3] = 0x00;
  sep[4] = 0x01;
  sep[5] = 16; // fixed bitlen of cstm
  sep[6] = cstm & 0xff;
  sep[7] = cstm >> 8;
 
  KeccakF1600_StateXORBytes(state->ctx, sep, 0, 8);
  KeccakF1600_StatePermute(state->ctx);
 
  /* Absorb input */
  keccak_absorb(state->ctx, SHAKE128_RATE, in, inlen, 0x04);
 
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
 
}

References shake128ctx::ctx, hal_get_time(), i, KeccakF1600_StatePermute(), KeccakF1600_StateXORBytes(), and SHAKE128_RATE.

Here is the call graph for this function:

◆ cshake128_simple_squeezeblocks()

void cshake128_simple_squeezeblocks	(	uint8_t *	output,
		size_t	nblocks,
		shake128ctx *	state
	)

Definition at line 357 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE128_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128ctx::ctx, hal_get_time(), and SHAKE128_RATE.

Here is the call graph for this function:

◆ cshake256_simple()

void cshake256_simple	(	uint8_t *	output,
		size_t	outlen,
		uint16_t	cstm,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 829 of file fips202.c.

{
  shake256incctx state;
  uint8_t sep[8];
  #ifdef PROFILE_HASHING
    uint64_t t0 = hal_get_time();
  #endif
 
 
  keccak_inc_init(state.ctx);
 
  /* Absorb customization (domain-separation) string */
  sep[0] = 0x01;
  sep[1] = 0x88;
  sep[2] = 0x01;
  sep[3] = 0x00;
  sep[4] = 0x01;
  sep[5] = 16; // fixed bitlen of cstm
  sep[6] = cstm & 0xff;
  sep[7] = cstm >> 8;
 
  KeccakF1600_StateXORBytes(state.ctx, sep, 0, 8);
  KeccakF1600_StatePermute(state.ctx);
 
  /* Absorb input */
  keccak_inc_absorb(state.ctx, SHAKE256_RATE, in, inlen);
  keccak_inc_finalize(state.ctx, SHAKE256_RATE, 0x04);
 
  /* Squeeze output */
  keccak_inc_squeeze(output, outlen, state.ctx, SHAKE256_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256incctx::ctx, hal_get_time(), KeccakF1600_StatePermute(), KeccakF1600_StateXORBytes(), and SHAKE256_RATE.

Here is the call graph for this function:

◆ cshake256_simple_absorb()

void cshake256_simple_absorb	(	shake256ctx *	state,
		uint16_t	cstm,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 783 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  uint8_t sep[8];
  size_t i;
 
  for (i = 0; i < 25; i++)
    state->ctx[i] = 0;
 
  /* Absorb customization (domain-separation) string */
  sep[0] = 0x01;
  sep[1] = 0x88;
  sep[2] = 0x01;
  sep[3] = 0x00;
  sep[4] = 0x01;
  sep[5] = 16; // fixed bitlen of cstm
  sep[6] = cstm & 0xff;
  sep[7] = cstm >> 8;
 
  KeccakF1600_StateXORBytes(state->ctx, sep, 0, 8);
  KeccakF1600_StatePermute(state->ctx);
 
  /* Absorb input */
  keccak_absorb(state->ctx, SHAKE256_RATE, in, inlen, 0x04);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256ctx::ctx, hal_get_time(), i, KeccakF1600_StatePermute(), KeccakF1600_StateXORBytes(), and SHAKE256_RATE.

Here is the call graph for this function:

◆ cshake256_simple_squeezeblocks()

void cshake256_simple_squeezeblocks	(	uint8_t *	output,
		size_t	nblocks,
		shake256ctx *	state
	)

Definition at line 816 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE256_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256ctx::ctx, hal_get_time(), and SHAKE256_RATE.

Here is the call graph for this function:

◆ sha3_256()

void sha3_256	(	uint8_t *	output,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 563 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  sha3_256incctx state;
  keccak_inc_init(state.ctx);
 
  /* Absorb input */
  keccak_inc_absorb(state.ctx, SHA3_256_RATE, input, inlen);
  keccak_inc_finalize(state.ctx, SHA3_256_RATE, 0x06);
 
  /* Squeeze output */
  keccak_inc_squeeze(output, 32, state.ctx, SHA3_256_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_256incctx::ctx, hal_get_time(), and SHA3_256_RATE.

Here is the call graph for this function:

◆ sha3_256_inc_absorb()

void sha3_256_inc_absorb	(	sha3_256incctx *	state,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 593 of file fips202.c.

                                                                                    {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_absorb(state->ctx, SHA3_256_RATE, input, inlen);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_256incctx::ctx, hal_get_time(), and SHA3_256_RATE.

Here is the call graph for this function:

◆ sha3_256_inc_ctx_clone()

void sha3_256_inc_ctx_clone	(	sha3_256incctx *	dest,
		const sha3_256incctx *	src
	)

Definition at line 622 of file fips202.c.

                                                                             {
    memcpy(dest, src, sizeof(sha3_256incctx));
}

◆ sha3_256_inc_ctx_release()

void sha3_256_inc_ctx_release ( sha3_256incctx * state )

Definition at line 626 of file fips202.c.

                                                     {
    (void) state;
}

◆ sha3_256_inc_finalize()

void sha3_256_inc_finalize	(	uint8_t *	output,
		sha3_256incctx *	state
	)

Definition at line 604 of file fips202.c.

                                                                   {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    uint8_t t[SHA3_256_RATE];
    keccak_inc_finalize(state->ctx, SHA3_256_RATE, 0x06);
 
    keccak_squeezeblocks(t, 1, state->ctx, SHA3_256_RATE);
 
    for (size_t i = 0; i < 32; i++) {
        output[i] = t[i];
    }
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_256incctx::ctx, hal_get_time(), i, and SHA3_256_RATE.

Here is the call graph for this function:

◆ sha3_256_inc_init()

void sha3_256_inc_init ( sha3_256incctx * state )

Definition at line 582 of file fips202.c.

                                              {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_init(state->ctx);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_256incctx::ctx, and hal_get_time().

Here is the call graph for this function:

◆ sha3_384()

void sha3_384	(	uint8_t *	output,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 687 of file fips202.c.

                                                                   {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  sha3_384incctx state;
  keccak_inc_init(state.ctx);
 
  /* Absorb input */
  keccak_inc_absorb(state.ctx, SHA3_384_RATE, input, inlen);
  keccak_inc_finalize(state.ctx, SHA3_384_RATE, 0x06);
 
  /* Squeeze output */
  keccak_inc_squeeze(output, 48, state.ctx, SHA3_384_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_384incctx::ctx, hal_get_time(), and SHA3_384_RATE.

Here is the call graph for this function:

◆ sha3_384_inc_absorb()

void sha3_384_inc_absorb	(	sha3_384incctx *	state,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 641 of file fips202.c.

                                                                                    {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_absorb(state->ctx, SHA3_384_RATE, input, inlen);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_384incctx::ctx, hal_get_time(), and SHA3_384_RATE.

Here is the call graph for this function:

◆ sha3_384_inc_ctx_clone()

void sha3_384_inc_ctx_clone	(	sha3_384incctx *	dest,
		const sha3_384incctx *	src
	)

Definition at line 670 of file fips202.c.

                                                                             {
    memcpy(dest, src, sizeof(sha3_384incctx));
}

◆ sha3_384_inc_ctx_release()

void sha3_384_inc_ctx_release ( sha3_384incctx * state )

Definition at line 674 of file fips202.c.

                                                     {
    (void) state;
}

◆ sha3_384_inc_finalize()

void sha3_384_inc_finalize	(	uint8_t *	output,
		sha3_384incctx *	state
	)

Definition at line 652 of file fips202.c.

                                                                   {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    uint8_t t[SHA3_384_RATE];
    keccak_inc_finalize(state->ctx, SHA3_384_RATE, 0x06);
 
    keccak_squeezeblocks(t, 1, state->ctx, SHA3_384_RATE);
 
    for (size_t i = 0; i < 48; i++) {
        output[i] = t[i];
    }
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_384incctx::ctx, hal_get_time(), i, and SHA3_384_RATE.

Here is the call graph for this function:

◆ sha3_384_inc_init()

void sha3_384_inc_init ( sha3_384incctx * state )

Definition at line 630 of file fips202.c.

                                              {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_init(state->ctx);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_384incctx::ctx, and hal_get_time().

Here is the call graph for this function:

◆ sha3_512()

void sha3_512	(	uint8_t *	output,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 714 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  sha3_512incctx state;
  keccak_inc_init(state.ctx);
 
  /* Absorb input */
  keccak_inc_absorb(state.ctx, SHA3_512_RATE, input, inlen);
  keccak_inc_finalize(state.ctx, SHA3_512_RATE, 0x06);
 
  /* Squeeze output */
  keccak_inc_squeeze(output, 64, state.ctx, SHA3_512_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_512incctx::ctx, hal_get_time(), and SHA3_512_RATE.

Here is the call graph for this function:

◆ sha3_512_inc_absorb()

void sha3_512_inc_absorb	(	sha3_512incctx *	state,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 744 of file fips202.c.

                                                                                    {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_absorb(state->ctx, SHA3_512_RATE, input, inlen);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_512incctx::ctx, hal_get_time(), and SHA3_512_RATE.

Here is the call graph for this function:

◆ sha3_512_inc_ctx_clone()

void sha3_512_inc_ctx_clone	(	sha3_512incctx *	dest,
		const sha3_512incctx *	src
	)

Definition at line 773 of file fips202.c.

                                                                             {
    memcpy(dest, src, sizeof(sha3_512incctx));
}

◆ sha3_512_inc_ctx_release()

void sha3_512_inc_ctx_release ( sha3_512incctx * state )

Definition at line 777 of file fips202.c.

                                                     {
    (void) state;
}

◆ sha3_512_inc_finalize()

void sha3_512_inc_finalize	(	uint8_t *	output,
		sha3_512incctx *	state
	)

Definition at line 755 of file fips202.c.

                                                                   {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    uint8_t t[SHA3_512_RATE];
    keccak_inc_finalize(state->ctx, SHA3_512_RATE, 0x06);
 
    keccak_squeezeblocks(t, 1, state->ctx, SHA3_512_RATE);
 
    for (size_t i = 0; i < 64; i++) {
        output[i] = t[i];
    }
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_512incctx::ctx, hal_get_time(), i, and SHA3_512_RATE.

Here is the call graph for this function:

◆ sha3_512_inc_init()

void sha3_512_inc_init ( sha3_512incctx * state )

Definition at line 733 of file fips202.c.

                                              {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_init(state->ctx);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References sha3_512incctx::ctx, and hal_get_time().

Here is the call graph for this function:

◆ shake128()

void shake128	(	uint8_t *	output,
		size_t	outlen,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 456 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  shake128incctx state;
 
  keccak_inc_init(state.ctx);
 
  /* Absorb input */
  keccak_inc_absorb(state.ctx, SHAKE128_RATE, input, inlen);
  keccak_inc_finalize(state.ctx, SHAKE128_RATE, 0x1F);
 
  /* Squeeze output */
  keccak_inc_squeeze(output, outlen, state.ctx, SHAKE128_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128incctx::ctx, hal_get_time(), and SHAKE128_RATE.

Here is the call graph for this function:

◆ shake128_absorb()

void shake128_absorb	(	shake128ctx *	state,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 417 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  int i;
  for (i = 0; i < 25; i++)
    state->ctx[i] = 0;
 
  keccak_absorb(state->ctx, SHAKE128_RATE, input, inlen, 0x1F);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128ctx::ctx, hal_get_time(), i, and SHAKE128_RATE.

Here is the call graph for this function:

◆ shake128_ctx_clone()

void shake128_ctx_clone	(	shake128ctx *	dest,
		const shake128ctx *	src
	)

Definition at line 480 of file fips202.c.

                                                                   {
    memcpy(dest, src, sizeof(shake128ctx));
}

◆ shake128_ctx_release()

void shake128_ctx_release ( shake128ctx * state )

Definition at line 477 of file fips202.c.

                                              {
    (void) state;
}

◆ shake128_inc_absorb()

void shake128_inc_absorb	(	shake128incctx *	state,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 225 of file fips202.c.

                                                                                    {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_absorb(state->ctx, SHAKE128_RATE, input, inlen);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128incctx::ctx, hal_get_time(), and SHAKE128_RATE.

Here is the call graph for this function:

◆ shake128_inc_ctx_clone()

void shake128_inc_ctx_clone	(	shake128incctx *	dest,
		const shake128incctx *	src
	)

Definition at line 258 of file fips202.c.

                                                                             {
    memcpy(dest, src, sizeof(shake128incctx));
}

◆ shake128_inc_ctx_release()

void shake128_inc_ctx_release ( shake128incctx * state )

Definition at line 262 of file fips202.c.

                                                     {
    (void) state;
}

◆ shake128_inc_finalize()

void shake128_inc_finalize ( shake128incctx * state )

Definition at line 236 of file fips202.c.

                                                  {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_finalize(state->ctx, SHAKE128_RATE, 0x1F);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128incctx::ctx, hal_get_time(), and SHAKE128_RATE.

Here is the call graph for this function:

◆ shake128_inc_init()

void shake128_inc_init ( shake128incctx * state )

Definition at line 214 of file fips202.c.

                                              {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_init(state->ctx);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128incctx::ctx, and hal_get_time().

Here is the call graph for this function:

◆ shake128_inc_squeeze()

void shake128_inc_squeeze	(	uint8_t *	output,
		size_t	outlen,
		shake128incctx *	state
	)

Definition at line 247 of file fips202.c.

                                                                                 {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_squeeze(output, outlen, state->ctx, SHAKE128_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128incctx::ctx, hal_get_time(), and SHAKE128_RATE.

Here is the call graph for this function:

◆ shake128_squeezeblocks()

void shake128_squeezeblocks	(	uint8_t *	output,
		size_t	nblocks,
		shake128ctx *	state
	)

Definition at line 444 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE128_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake128ctx::ctx, hal_get_time(), and SHAKE128_RATE.

Here is the call graph for this function:

◆ shake256()

void shake256	(	uint8_t *	output,
		size_t	outlen,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 523 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  shake256incctx state;
 
  keccak_inc_init(state.ctx);
 
  /* Absorb input */
  keccak_inc_absorb(state.ctx, SHAKE256_RATE, input, inlen);
  keccak_inc_finalize(state.ctx, SHAKE256_RATE, 0x1F);
 
  /* Squeeze output */
  keccak_inc_squeeze(output, outlen, state.ctx, SHAKE256_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256incctx::ctx, hal_get_time(), and SHAKE256_RATE.

Here is the call graph for this function:

◆ shake256_absorb()

void shake256_absorb	(	shake256ctx *	state,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 484 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  int i;
  for (i = 0; i < 25; i++)
    state->ctx[i] = 0;
 
  keccak_absorb(state->ctx, SHAKE256_RATE, input, inlen, 0x1F);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256ctx::ctx, hal_get_time(), i, and SHAKE256_RATE.

Here is the call graph for this function:

◆ shake256_ctx_clone()

void shake256_ctx_clone	(	shake256ctx *	dest,
		const shake256ctx *	src
	)

Definition at line 549 of file fips202.c.

                                                                   {
    memcpy(dest, src, sizeof(shake256ctx));
}

◆ shake256_ctx_release()

void shake256_ctx_release ( shake256ctx * state )

Definition at line 545 of file fips202.c.

                                              {
    (void) state;
}

◆ shake256_inc_absorb()

void shake256_inc_absorb	(	shake256incctx *	state,
		const uint8_t *	input,
		size_t	inlen
	)

Definition at line 277 of file fips202.c.

                                                                                    {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_absorb(state->ctx, SHAKE256_RATE, input, inlen);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256incctx::ctx, hal_get_time(), and SHAKE256_RATE.

Here is the call graph for this function:

◆ shake256_inc_ctx_clone()

void shake256_inc_ctx_clone	(	shake256incctx *	dest,
		const shake256incctx *	src
	)

Definition at line 310 of file fips202.c.

                                                                             {
    memcpy(dest, src, sizeof(shake256incctx));
}

◆ shake256_inc_ctx_release()

void shake256_inc_ctx_release ( shake256incctx * state )

Definition at line 314 of file fips202.c.

                                                     {
    (void) state;
}

◆ shake256_inc_finalize()

void shake256_inc_finalize ( shake256incctx * state )

Definition at line 288 of file fips202.c.

                                                  {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_finalize(state->ctx, SHAKE256_RATE, 0x1F);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256incctx::ctx, hal_get_time(), and SHAKE256_RATE.

Here is the call graph for this function:

◆ shake256_inc_init()

void shake256_inc_init ( shake256incctx * state )

Definition at line 266 of file fips202.c.

                                              {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_init(state->ctx);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256incctx::ctx, and hal_get_time().

Here is the call graph for this function:

◆ shake256_inc_squeeze()

void shake256_inc_squeeze	(	uint8_t *	output,
		size_t	outlen,
		shake256incctx *	state
	)

Definition at line 299 of file fips202.c.

                                                                                 {
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
    keccak_inc_squeeze(output, outlen, state->ctx, SHAKE256_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256incctx::ctx, hal_get_time(), and SHAKE256_RATE.

Here is the call graph for this function:

◆ shake256_squeezeblocks()

void shake256_squeezeblocks	(	uint8_t *	output,
		size_t	nblocks,
		shake256ctx *	state
	)

Definition at line 501 of file fips202.c.

{
#ifdef PROFILE_HASHING
  uint64_t t0 = hal_get_time();
#endif
  keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE256_RATE);
#ifdef PROFILE_HASHING
  uint64_t t1 = hal_get_time();
  hash_cycles += (t1-t0);
#endif
}

References shake256ctx::ctx, hal_get_time(), and SHAKE256_RATE.

Here is the call graph for this function:

Data Structures

Macros

Functions

Macro Definition Documentation

◆ SHA3_256_RATE

◆ SHA3_384_RATE

◆ SHA3_512_RATE

◆ SHAKE128_RATE

◆ SHAKE256_RATE

Function Documentation

◆ cshake128_simple()

◆ cshake128_simple_absorb()

◆ cshake128_simple_squeezeblocks()

◆ cshake256_simple()

◆ cshake256_simple_absorb()

◆ cshake256_simple_squeezeblocks()

◆ sha3_256()

◆ sha3_256_inc_absorb()

◆ sha3_256_inc_ctx_clone()

◆ sha3_256_inc_ctx_release()

◆ sha3_256_inc_finalize()

◆ sha3_256_inc_init()

◆ sha3_384()

◆ sha3_384_inc_absorb()

◆ sha3_384_inc_ctx_clone()

◆ sha3_384_inc_ctx_release()

◆ sha3_384_inc_finalize()

◆ sha3_384_inc_init()

◆ sha3_512()

◆ sha3_512_inc_absorb()

◆ sha3_512_inc_ctx_clone()

◆ sha3_512_inc_ctx_release()

◆ sha3_512_inc_finalize()

◆ sha3_512_inc_init()

◆ shake128()

◆ shake128_absorb()

◆ shake128_ctx_clone()

◆ shake128_ctx_release()

◆ shake128_inc_absorb()

◆ shake128_inc_ctx_clone()

◆ shake128_inc_ctx_release()

◆ shake128_inc_finalize()

◆ shake128_inc_init()

◆ shake128_inc_squeeze()

◆ shake128_squeezeblocks()

◆ shake256()

◆ shake256_absorb()

◆ shake256_ctx_clone()

◆ shake256_ctx_release()

◆ shake256_inc_absorb()

◆ shake256_inc_ctx_clone()

◆ shake256_inc_ctx_release()

◆ shake256_inc_finalize()

◆ shake256_inc_init()

◆ shake256_inc_squeeze()

◆ shake256_squeezeblocks()