keccak256.hpp File Reference

#include <cstdint>

Include dependency graph for keccak256.hpp:

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

Go to the source code of this file.

Classes
struct	SHA3_CTX

Macros
#define	__KECCAK256_HPP_
#define	sha3_max_permutation_size   25
#define	sha3_max_rate_in_qwords   24

Typedefs
typedef struct SHA3_CTX	SHA3_CTX

Functions
void	keccak_init (SHA3_CTX *ctx)
void	keccak_update (SHA3_CTX *ctx, const unsigned char *msg, uint16_t size)
void	keccak_final (SHA3_CTX *ctx, unsigned char *result)

Macro Definition Documentation

__KECCAK256_HPP_

#define __KECCAK256_HPP_

Definition at line 25 of file keccak256.hpp.

sha3_max_permutation_size

#define sha3_max_permutation_size   25

Definition at line 27 of file keccak256.hpp.

sha3_max_rate_in_qwords

#define sha3_max_rate_in_qwords   24

Definition at line 28 of file keccak256.hpp.

Typedef Documentation

SHA3_CTX

typedef struct SHA3_CTX SHA3_CTX

Function Documentation

keccak_final()

void keccak_final	(	SHA3_CTX *	ctx,
		unsigned char *	result )

Store calculated hash into the given array.

Parameters

ctx	the algorithm context containing current hashing state
result	calculated hash in binary form

Definition at line 220 of file keccak256.cpp.

{
    uint16_t digest_length = 100 - BLOCK_SIZE / 2;
 
//    if (!(ctx->rest & SHA3_FINALIZED)) {
        /* clear the rest of the data queue */
        memset((char*)ctx->message + ctx->rest, 0, BLOCK_SIZE - ctx->rest);
        ((char*)ctx->message)[ctx->rest] |= 0x01;
        ((char*)ctx->message)[BLOCK_SIZE - 1] |= 0x80;
 
        /* process final block */
        sha3_process_block(ctx->hash, ctx->message);
//        ctx->rest = SHA3_FINALIZED; /* mark context as finalized */
//    }
 
    if (result) {
         me64_to_le_str(result, ctx->hash, digest_length);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

keccak_init()

void keccak_init

(

SHA3_CTX *

ctx

)

Definition at line 75 of file keccak256.cpp.

                                {
    /* NB: The Keccak capacity parameter = bits * 2 */
 
    std::memset(ctx, 0, sizeof(SHA3_CTX));
}

Here is the caller graph for this function:

keccak_update()

void keccak_update	(	SHA3_CTX *	ctx,
		const unsigned char *	msg,
		uint16_t	size )

Calculate message hash. Can be called repeatedly with chunks of the message to be hashed.

Parameters

ctx	the algorithm context containing current hashing state
msg	message chunk
size	length of the message chunk

Definition at line 175 of file keccak256.cpp.

{
    uint16_t idx = (uint16_t)ctx->rest;
 
    //if (ctx->rest & SHA3_FINALIZED) return; /* too late for additional input */
    ctx->rest = (unsigned)((ctx->rest + size) % BLOCK_SIZE);
 
    /* fill partial block */
    if (idx) {
        uint16_t left = BLOCK_SIZE - idx;
        memcpy((char*)ctx->message + idx, msg, (size < left ? size : left));
        if (size < left) return;
 
        /* process partial block */
        sha3_process_block(ctx->hash, ctx->message);
        msg  += left;
        size -= left;
    }
 
    while (size >= BLOCK_SIZE) {
        uint64_t* aligned_message_block;
        if (IS_ALIGNED_64(msg)) {
            // the most common case is processing of an already aligned message without copying it
            aligned_message_block = (uint64_t*)(void*)msg;
        } else {
            memcpy(ctx->message, msg, BLOCK_SIZE);
            aligned_message_block = ctx->message;
        }
 
        sha3_process_block(ctx->hash, aligned_message_block);
        msg  += BLOCK_SIZE;
        size -= BLOCK_SIZE;
    }
 
    if (size) {
        memcpy(ctx->message, msg, size); /* save leftovers */
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: