sha256.h File Reference

#include <esp8266.h>
#include <stdint.h>
#include "crypto/crypto.h"

Include dependency graph for sha256.h:

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

Go to the source code of this file.

Data Structures
struct	sha256_ctx_t

Macros
#define	SHA256_BLOCK_LENGTH   64
#define	SHA256_DIGEST_LENGTH   32
#define	SHA256_DIGEST_STRING_LENGTH   (SHA256_DIGEST_LENGTH * 2 + 1)

Functions
ICACHE_FLASH_ATTR void	sha256_init (sha256_ctx_t *context)
ICACHE_FLASH_ATTR void	sha256_update (sha256_ctx_t *context, uint8_t *data, size_t len)
ICACHE_FLASH_ATTR void	sha256_final (sha256_ctx_t *context, uint8_t digest[SHA256_DIGEST_LENGTH])
ICACHE_FLASH_ATTR char *	sha256_end (sha256_ctx_t *context, char buffer[SHA256_DIGEST_STRING_LENGTH])
ICACHE_FLASH_ATTR void	sha256_raw (uint8_t *data, size_t len, uint8_t digest[SHA256_DIGEST_LENGTH])
ICACHE_FLASH_ATTR char *	sha256_data (uint8_t *data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH])

Macro Definition Documentation

SHA256_BLOCK_LENGTH

#define SHA256_BLOCK_LENGTH   64

Copyright (c) 2000-2001 Aaron D. Gifford Copyright (c) 2013-2014 Pavol Rusnak All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Definition at line 38 of file sha256.h.

Referenced by hmac_sha256_final(), hmac_sha256_init(), sha256_final(), sha256_init(), and sha256_update().

SHA256_DIGEST_LENGTH

#define SHA256_DIGEST_LENGTH   32

Definition at line 39 of file sha256.h.

Referenced by decrypt_aes_hmac_combined(), encrypt_aes_hmac_combined(), hmac_sha256_final(), sha256_end(), and sha256_init().

SHA256_DIGEST_STRING_LENGTH

#define SHA256_DIGEST_STRING_LENGTH   (SHA256_DIGEST_LENGTH * 2 + 1)

Definition at line 40 of file sha256.h.

Function Documentation

sha256_data()

ICACHE_FLASH_ATTR char* sha256_data	(	uint8_t *	data,
		size_t	len,
		char	digest[SHA256_DIGEST_STRING_LENGTH]
	)

Definition at line 430 of file sha256.c.

References sha256_end(), sha256_init(), and sha256_update().

                                                                                       {
    sha256_ctx_t context;

    sha256_init(&context);
    sha256_update(&context, data, len);
    return sha256_end(&context, digest);
}

Here is the call graph for this function:

sha256_end()

ICACHE_FLASH_ATTR char* sha256_end	(	sha256_ctx_t *	context,
		char	buffer[SHA256_DIGEST_STRING_LENGTH]
	)

Definition at line 399 of file sha256.c.

References ICACHE_FLASH_ATTR, memset, SHA256_DIGEST_LENGTH, sha256_final(), and sha2_hex_digits.

Referenced by sha256_data().

                                                                                  {
    uint8_t digest[SHA256_DIGEST_LENGTH];
    uint8_t *d = digest;
    int i;

    if (buffer != (char*)0) {
        sha256_final(context, digest);

        for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
            *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
            *buffer++ = sha2_hex_digits[*d & 0x0f];
            d++;
        }
        *buffer = (char)0;
    } else {
        memset(context, 0, sizeof(sha256_ctx_t));
    }
    memset(digest, 0, SHA256_DIGEST_LENGTH);
    return buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sha256_final()

ICACHE_FLASH_ATTR void sha256_final	(	sha256_ctx_t *	context,
		uint8_t	digest[SHA256_DIGEST_LENGTH]
	)

Definition at line 334 of file sha256.c.

References sha256_ctx_t::bitcount, sha256_ctx_t::buffer, ICACHE_FLASH_ATTR, memcpy, memset, REVERSE32, REVERSE64, SHA256_BLOCK_LENGTH, SHA256_SHORT_BLOCK_LENGTH, sha256_transform(), and sha256_ctx_t::state.

Referenced by hmac_sha256_final(), sha256_end(), and sha256_raw().

                                                                               {
    unsigned int usedspace;

    /* If no digest buffer is passed, we don't bother doing this: */
    if (digest != (uint8_t*)0) {
        usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
#if BYTE_ORDER == LITTLE_ENDIAN
        /* Convert FROM host byte order */
        REVERSE64(context->bitcount,context->bitcount);
#endif
        if (usedspace > 0) {
            /* Begin padding with a 1 bit: */
            context->buffer[usedspace++] = 0x80;

            if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
                /* Set-up for the last transform: */
                memset(&context->buffer[usedspace], 0, SHA256_SHORT_BLOCK_LENGTH - usedspace);
            } else {
                if (usedspace < SHA256_BLOCK_LENGTH) {
                    memset(&context->buffer[usedspace], 0, SHA256_BLOCK_LENGTH - usedspace);
                }
                /* Do second-to-last transform: */
                sha256_transform(context, context->buffer);

                /* And set-up for the last transform: */
                memset(context->buffer, 0, SHA256_SHORT_BLOCK_LENGTH);
            }
        } else {
            /* Set-up for the last transform: */
            memset(context->buffer, 0, SHA256_SHORT_BLOCK_LENGTH);

            /* Begin padding with a 1 bit: */
            *context->buffer = 0x80;
        }
        /* Set the bit count: */
        uint64_t *t = (uint64_t *)(void*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH];
        *t = context->bitcount;

        /* Final transform: */
        sha256_transform(context, context->buffer);

#if BYTE_ORDER == LITTLE_ENDIAN
        {
            /* Convert TO host byte order */
            int j;
            for (j = 0; j < 8; j++) {
                REVERSE32(context->state[j],context->state[j]);
                digest[0] = ((context->state[j] >> 0) & 0xff);
                digest[1] = ((context->state[j] >> 8) & 0xff);
                digest[2] = ((context->state[j] >> 16) & 0xff);
                digest[3] = ((context->state[j] >> 24) & 0xff);
                digest += sizeof(uint32_t);
            }
        }
#else
        memcpy(d, context->state, SHA256_DIGEST_LENGTH);
#endif
    }

    /* Clean up state data: */
    memset(context, 0, sizeof(sha256_ctx_t));
    usedspace = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sha256_init()

ICACHE_FLASH_ATTR void sha256_init

(

sha256_ctx_t *

context

)

Definition at line 196 of file sha256.c.

References sha256_ctx_t::bitcount, sha256_ctx_t::buffer, ICACHE_FLASH_ATTR, memcpy, memset, SHA256_BLOCK_LENGTH, SHA256_DIGEST_LENGTH, sha256_initial_hash_value, and sha256_ctx_t::state.

Referenced by hmac_sha256_final(), hmac_sha256_init(), sha256_data(), and sha256_raw().

                                        {
    if (context == (sha256_ctx_t*)0) {
        return;
    }
    memcpy(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
    memset(context->buffer, 0, SHA256_BLOCK_LENGTH);
    context->bitcount = 0;
}

Here is the caller graph for this function:

sha256_raw()

ICACHE_FLASH_ATTR void sha256_raw	(	uint8_t *	data,
		size_t	len,
		uint8_t	digest[SHA256_DIGEST_LENGTH]
	)

Definition at line 421 of file sha256.c.

References ICACHE_FLASH_ATTR, sha256_final(), sha256_init(), and sha256_update().

Referenced by hmac_sha256_init(), and init_aes_hmac_combined().

                                                                                 {
    sha256_ctx_t context;
    
    sha256_init(&context);
    sha256_update(&context, data, len);
    sha256_final(&context, digest);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sha256_update()

ICACHE_FLASH_ATTR void sha256_update	(	sha256_ctx_t *	context,
		uint8_t *	data,
		size_t	len
	)

Definition at line 288 of file sha256.c.

References sha256_ctx_t::bitcount, sha256_ctx_t::buffer, ICACHE_FLASH_ATTR, memcpy, SHA256_BLOCK_LENGTH, and sha256_transform().

Referenced by hmac_sha256_final(), hmac_sha256_init(), hmac_sha256_update(), sha256_data(), and sha256_raw().

                                                                     {
    unsigned int freespace, usedspace;

    if (len == 0) {
        // Calling with no data is valid - we do nothing
        return;
    }

    usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
    if (usedspace > 0) {
        // Calculate how much free space is available in the buffer
        freespace = SHA256_BLOCK_LENGTH - usedspace;

        if (len >= freespace) {
            // Fill the buffer completely and process it
            memcpy(&context->buffer[usedspace], data, freespace);
            context->bitcount += freespace << 3;
            len -= freespace;
            data += freespace;
            sha256_transform(context, context->buffer);
        } else {
            // The buffer is not yet full
            memcpy(&context->buffer[usedspace], data, len);
            context->bitcount += len << 3;
            // Clean up:
            usedspace = freespace = 0;
            return;
        }
    }
    while (len >= SHA256_BLOCK_LENGTH) {
        // Process as many complete blocks as we can
        sha256_transform(context, data);
        context->bitcount += SHA256_BLOCK_LENGTH << 3;
        len -= SHA256_BLOCK_LENGTH;
        data += SHA256_BLOCK_LENGTH;
    }
    if (len > 0) {
        // There's left-overs, so save 'em
        memcpy(context->buffer, data, len);
        context->bitcount += len << 3;
    }
    // Clean up:
    usedspace = freespace = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: