keccak256.cpp File Reference

#include <fc/crypto/keccak256.hpp>
#include <cstring>

Include dependency graph for keccak256.cpp:

Go to the source code of this file.

Macros
#define	BLOCK_SIZE   ((1600 - 256 * 2) / 8)
#define	I64(x)
#define	ROTL64(qword, n)
#define	le2me_64(x)
#define	IS_ALIGNED_64(p)
#define	me64_to_le_str(to, from, length)
#define	TYPE_ROUND_INFO   0
#define	TYPE_PI_TRANSFORM   24
#define	TYPE_RHO_TRANSFORM   48

Functions
uint8_t	getConstant (uint8_t type, uint8_t index)
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)

Variables
const uint8_t	constants []

Macro Definition Documentation

BLOCK_SIZE

#define BLOCK_SIZE   ((1600 - 256 * 2) / 8)

Definition at line 23 of file keccak256.cpp.

I64

#define I64

(

x

)

Value:

x##LL

Definition at line 25 of file keccak256.cpp.

IS_ALIGNED_64

#define IS_ALIGNED_64

(

p

)

Value:

(0 == (7 & ((const char*)(p) - (const char*)0)))

Definition at line 28 of file keccak256.cpp.

le2me_64

#define le2me_64

(

x

)

Value:

(x)

Definition at line 27 of file keccak256.cpp.

me64_to_le_str

#define me64_to_le_str	(		to,
			from,
			length )

Value:

memcpy((to), (from), (length))

Definition at line 29 of file keccak256.cpp.

ROTL64

#define ROTL64	(		qword,
			n )

Value:

((qword) << (n) ^ ((qword) >> (64 - (n))))

Definition at line 26 of file keccak256.cpp.

TYPE_PI_TRANSFORM

#define TYPE_PI_TRANSFORM   24

Definition at line 49 of file keccak256.cpp.

TYPE_RHO_TRANSFORM

#define TYPE_RHO_TRANSFORM   48

Definition at line 50 of file keccak256.cpp.

TYPE_ROUND_INFO

#define TYPE_ROUND_INFO   0

Definition at line 48 of file keccak256.cpp.

Function Documentation

getConstant()

uint8_t getConstant ( uint8_t type, uint8_t index )

inline

Definition at line 52 of file keccak256.cpp.

                                                        {
    return constants[type + index];
    //return pgm_read_byte(&constants[type + index]);
}

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:

Variable Documentation

constants

const uint8_t constants[]

Initial value:

= {
 
    1, 26, 94, 112, 31, 33, 121, 85, 14, 12, 53, 38, 63, 79, 93, 83, 82, 72, 22, 102, 121, 88, 33, 116,
 
 
 
    1, 6, 9, 22, 14, 20, 2, 12, 13, 19, 23, 15, 4, 24, 21, 8, 16, 5, 3, 18, 17, 11, 7, 10,
 
 
 
    1, 62, 28, 27, 36, 44, 6, 55, 20, 3, 10, 43, 25, 39, 41, 45, 15, 21, 8, 18, 2, 61, 56, 14,
}

Definition at line 35 of file keccak256.cpp.

                             {
 
    1, 26, 94, 112, 31, 33, 121, 85, 14, 12, 53, 38, 63, 79, 93, 83, 82, 72, 22, 102, 121, 88, 33, 116,
//};
 
//const uint8_t pi_transform[] PROGMEM = {
    1, 6, 9, 22, 14, 20, 2, 12, 13, 19, 23, 15, 4, 24, 21, 8, 16, 5, 3, 18, 17, 11, 7, 10,
//};
 
//const uint8_t rhoTransforms[] PROGMEM = {
    1, 62, 28, 27, 36, 44, 6, 55, 20, 3, 10, 43, 25, 39, 41, 45, 15, 21, 8, 18, 2, 61, 56, 14,
};