fc::sha3_impl Struct Reference

Public Member Functions
	sha3_impl ()
void	update_step ()
void	init ()
void	update (const uint8_t *data, std::size_t len)
void	finalize (char *buffer)

Public Attributes
union {
uint8_t   bytes [number_of_words *8]
uint64_t   words [number_of_words *5]
};
bool	keccak = false
int	point
int	size

Static Public Attributes
static constexpr uint8_t	number_of_rounds = 24
static constexpr uint8_t	number_of_words = 25
static constexpr uint8_t	digest_size = 32
static constexpr uint64_t	round_constants [number_of_rounds]
static constexpr uint8_t	rot_constants [number_of_rounds] = {1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44}
static constexpr uint8_t	pi_lanes [number_of_rounds] = {10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1}

Detailed Description

Definition at line 41 of file sha3.cpp.

Constructor & Destructor Documentation

sha3_impl()

fc::sha3_impl::sha3_impl ( )

inline

Definition at line 42 of file sha3.cpp.

{ init(); }

Here is the call graph for this function:

Member Function Documentation

finalize()

void fc::sha3_impl::finalize ( char * buffer )

inline

Definition at line 160 of file sha3.cpp.

                                {
        bytes[point] ^= keccak ? 0x01 : 0x06;
        bytes[size-1] ^= 0x80;
        update_step();
     memcpy(buffer, (const char*)bytes, digest_size);
    }

Here is the call graph for this function:

init()

void fc::sha3_impl::init ( )

inline

Definition at line 141 of file sha3.cpp.

                {
        memset((char *)this, 0, sizeof(*this));
        size = 136;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void fc::sha3_impl::update ( const uint8_t * data, std::size_t len )

inline

Definition at line 146 of file sha3.cpp.

                                                    {
        int j = point;
        for (std::size_t i = 0; i < len; i++)
        {
            bytes[j++] ^= data[i];
            if (j >= size)
            {
                update_step();
                j = 0;
            }
        }
        point = j;
    }

Here is the call graph for this function:

update_step()

void fc::sha3_impl::update_step ( )

inline

Definition at line 57 of file sha3.cpp.

    {
        uint64_t bc[5];
 
        if constexpr (!is_little_endian)
        {
            uint8_t *v;
            // convert the buffer to little endian
            for (std::size_t i; i < number_of_words; i++)
            {
                v = reinterpret_cast<uint8_t *>(words + i);
                words[i] = ((uint64_t)v[0]) | (((uint64_t)v[1]) << 8) |
                              (((uint64_t)v[2]) << 16) | (((uint64_t)v[3]) << 24) |
                              (((uint64_t)v[4]) << 32) | (((uint64_t)v[5]) << 40) |
                              (((uint64_t)v[6]) << 48) | (((uint64_t)v[7]) << 56);
            }
        }
 
        #pragma clang loop vectorize(enable) interleave(enable)
        for (std::size_t i = 0; i < number_of_rounds; i++)
        {
            // theta
            #pragma clang loop vectorize(enable) interleave(enable)
            for (std::size_t j = 0; j < 5; j++)
                bc[j] = words[j] ^ words[j + 5] ^ words[j + 10] ^ words[j + 15] ^ words[j + 20];
 
            uint64_t t;
            #pragma clang loop vectorize(enable) interleave(enable)
            for (std::size_t j = 0; j < 5; j++)
            {
                t = bc[(j + 4) % 5] ^ rotl64(bc[(j + 1) % 5], 1);
                #pragma clang loop vectorize(enable) interleave(enable)
                for (std::size_t k = 0; k < number_of_words; k += 5)
                    words[k + j] ^= t;
            }
 
            // rho pi
            t = words[1];
            #pragma clang loop vectorize(enable) interleave(enable)
            for (std::size_t j = 0; j < number_of_rounds; j++)
            {
                uint8_t p = pi_lanes[j];
                bc[0] = words[p];
                words[p] = rotl64(t, rot_constants[j]);
                t = bc[0];
            }
 
            // chi
            #pragma clang loop vectorize(enable) interleave(enable)
            for (std::size_t j = 0; j < number_of_words; j += 5)
            {
                #pragma clang loop vectorize(enable) interleave(enable)
                for (std::size_t k = 0; k < 5; k++)
                    bc[k] = words[k + j];
                #pragma clang loop vectorize(enable) interleave(enable)
                for (std::size_t k = 0; k < 5; k++)
                    words[k + j] ^= (~bc[(k + 1) % 5]) & bc[(k + 2) % 5];
            }
 
            // iota
            words[0] ^= round_constants[i];
        }
 
        if constexpr (!is_little_endian)
        {
            uint8_t *v;
            uint64_t tmp;
            // convert back to big endian
            for (std::size_t i = 0; i < sizeof(words); i++)
            {
                v = (uint8_t *)(words + i);
                tmp = words[i];
                v[0] = tmp & 0xFF;
                v[1] = (tmp >> 8) & 0xFF;
                v[2] = (tmp >> 16) & 0xFF;
                v[3] = (tmp >> 24) & 0xFF;
                v[4] = (tmp >> 32) & 0xFF;
                v[5] = (tmp >> 40) & 0xFF;
                v[6] = (tmp >> 48) & 0xFF;
                v[7] = (tmp >> 56) & 0xFF;
            }
        }
    }

Here is the caller graph for this function:

Member Data Documentation

[union]

union { ... } fc::sha3_impl

bytes

uint8_t fc::sha3_impl::bytes[number_of_words *8]

Definition at line 168 of file sha3.cpp.

digest_size

uint8_t fc::sha3_impl::digest_size = 32

staticconstexpr

Definition at line 46 of file sha3.cpp.

keccak

bool fc::sha3_impl::keccak = false

Definition at line 171 of file sha3.cpp.

number_of_rounds

uint8_t fc::sha3_impl::number_of_rounds = 24

staticconstexpr

Definition at line 44 of file sha3.cpp.

number_of_words

uint8_t fc::sha3_impl::number_of_words = 25

staticconstexpr

Definition at line 45 of file sha3.cpp.

pi_lanes

uint8_t fc::sha3_impl::pi_lanes[number_of_rounds] = {10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1}

staticconstexpr

Definition at line 55 of file sha3.cpp.

{10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1};

point

int fc::sha3_impl::point

Definition at line 172 of file sha3.cpp.

rot_constants

uint8_t fc::sha3_impl::rot_constants[number_of_rounds] = {1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44}

staticconstexpr

Definition at line 54 of file sha3.cpp.

{1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44};

round_constants

uint64_t fc::sha3_impl::round_constants[number_of_rounds]

staticconstexpr

Initial value:

= {
         UINT64_C(0x0000000000000001), UINT64_C(0x0000000000008082), UINT64_C(0x800000000000808a), UINT64_C(0x8000000080008000),
         UINT64_C(0x000000000000808b), UINT64_C(0x0000000080000001), UINT64_C(0x8000000080008081), UINT64_C(0x8000000000008009),
         UINT64_C(0x000000000000008a), UINT64_C(0x0000000000000088), UINT64_C(0x0000000080008009), UINT64_C(0x000000008000000a),
         UINT64_C(0x000000008000808b), UINT64_C(0x800000000000008b), UINT64_C(0x8000000000008089), UINT64_C(0x8000000000008003),
         UINT64_C(0x8000000000008002), UINT64_C(0x8000000000000080), UINT64_C(0x000000000000800a), UINT64_C(0x800000008000000a),
         UINT64_C(0x8000000080008081), UINT64_C(0x8000000000008080), UINT64_C(0x0000000080000001), UINT64_C(0x8000000080008008)}

Definition at line 47 of file sha3.cpp.

                                                                  {
         UINT64_C(0x0000000000000001), UINT64_C(0x0000000000008082), UINT64_C(0x800000000000808a), UINT64_C(0x8000000080008000),
         UINT64_C(0x000000000000808b), UINT64_C(0x0000000080000001), UINT64_C(0x8000000080008081), UINT64_C(0x8000000000008009),
         UINT64_C(0x000000000000008a), UINT64_C(0x0000000000000088), UINT64_C(0x0000000080008009), UINT64_C(0x000000008000000a),
         UINT64_C(0x000000008000808b), UINT64_C(0x800000000000008b), UINT64_C(0x8000000000008089), UINT64_C(0x8000000000008003),
         UINT64_C(0x8000000000008002), UINT64_C(0x8000000000000080), UINT64_C(0x000000000000800a), UINT64_C(0x800000008000000a),
         UINT64_C(0x8000000080008081), UINT64_C(0x8000000000008080), UINT64_C(0x0000000080000001), UINT64_C(0x8000000080008008)};

size

int fc::sha3_impl::size

Definition at line 173 of file sha3.cpp.

words

uint64_t fc::sha3_impl::words[number_of_words *5]

Definition at line 169 of file sha3.cpp.

---

The documentation for this struct was generated from the following file:

• libraries/fc/src/crypto/sha3.cpp