sha2.h File Reference

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

Go to the source code of this file.

Data Structures
struct	_SHA256_CTX
struct	_SHA512_CTX

Macros
#define	SHA256_BLOCK_LENGTH   64
#define	SHA256_DIGEST_LENGTH   32
#define	SHA256_DIGEST_STRING_LENGTH   (SHA256_DIGEST_LENGTH * 2 + 1)
#define	SHA512_BLOCK_LENGTH   128
#define	SHA512_DIGEST_LENGTH   64
#define	SHA512_DIGEST_STRING_LENGTH   (SHA512_DIGEST_LENGTH * 2 + 1)

Typedefs
typedef struct _SHA256_CTX	SHA256_CTX
typedef struct _SHA512_CTX	SHA512_CTX

Functions
void	sha256_Init (SHA256_CTX *)
void	sha256_Update (SHA256_CTX *, const uint8_t *, size_t)
void	sha256_Final (uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX *)
void	sha256_Raw (const uint8_t *, size_t, uint8_t[SHA256_DIGEST_LENGTH])
void	sha512_Init (SHA512_CTX *)
void	sha512_Update (SHA512_CTX *, const uint8_t *, size_t)
void	sha512_Final (uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX *)
void	sha512_Raw (const uint8_t *, size_t, uint8_t[SHA512_DIGEST_LENGTH])
void	hmac_sha256 (const uint8_t *key, const uint32_t keylen, const uint8_t *msg, const uint32_t msglen, uint8_t *hmac)
void	hmac_sha512 (const uint8_t *key, const uint32_t keylen, const uint8_t *msg, const uint32_t msglen, uint8_t *hmac)

Macro Definition Documentation

#define SHA256_BLOCK_LENGTH   64

Copyright (c) 2000-2001 Aaron D. Gifford Copyright (c) 2013 Pavol Rusnak Copyright (c) 2015 Jonas Schnelli 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 sha2.h.

Referenced by hmac_sha256(), sha256_Final(), sha256_Init(), and sha256_Update().

#define SHA256_DIGEST_LENGTH   32

Definition at line 39 of file sha2.h.

Referenced by hmac_sha256(), sha256_Final(), and sha256_Init().

#define SHA256_DIGEST_STRING_LENGTH   (SHA256_DIGEST_LENGTH * 2 + 1)

Definition at line 40 of file sha2.h.

#define SHA512_BLOCK_LENGTH   128

Definition at line 41 of file sha2.h.

Referenced by hmac_sha512(), sha512_Init(), sha512_Last(), and sha512_Update().

#define SHA512_DIGEST_LENGTH   64

Definition at line 42 of file sha2.h.

Referenced by hmac_sha512(), sha512_Final(), and sha512_Init().

#define SHA512_DIGEST_STRING_LENGTH   (SHA512_DIGEST_LENGTH * 2 + 1)

Definition at line 43 of file sha2.h.

Typedef Documentation

typedef struct _SHA256_CTX SHA256_CTX

typedef struct _SHA512_CTX SHA512_CTX

Function Documentation

void hmac_sha256	(	const uint8_t *	key,
		const uint32_t	keylen,
		const uint8_t *	msg,
		const uint32_t	msglen,
		uint8_t *	hmac
	)

Definition at line 966 of file sha2.c.

References SHA256_BLOCK_LENGTH, SHA256_DIGEST_LENGTH, sha256_Final(), sha256_Init(), sha256_Raw(), and sha256_Update().

{
    int i;
    uint8_t buf[SHA256_BLOCK_LENGTH], o_key_pad[SHA256_BLOCK_LENGTH],
        i_key_pad[SHA256_BLOCK_LENGTH];
    SHA256_CTX ctx;

    memset(buf, 0, SHA256_BLOCK_LENGTH);
    if (keylen > SHA256_BLOCK_LENGTH) {
        sha256_Raw(key, keylen, buf);
    } else {
        memcpy(buf, key, keylen);
    }

    for (i = 0; i < SHA256_BLOCK_LENGTH; i++) {
        o_key_pad[i] = buf[i] ^ 0x5c;
        i_key_pad[i] = buf[i] ^ 0x36;
    }

    sha256_Init(&ctx);
    sha256_Update(&ctx, i_key_pad, SHA256_BLOCK_LENGTH);
    sha256_Update(&ctx, msg, msglen);
    sha256_Final(buf, &ctx);

    sha256_Init(&ctx);
    sha256_Update(&ctx, o_key_pad, SHA256_BLOCK_LENGTH);
    sha256_Update(&ctx, buf, SHA256_DIGEST_LENGTH);
    sha256_Final(hmac, &ctx);
}

void hmac_sha512	(	const uint8_t *	key,
		const uint32_t	keylen,
		const uint8_t *	msg,
		const uint32_t	msglen,
		uint8_t *	hmac
	)

Definition at line 996 of file sha2.c.

References SHA512_BLOCK_LENGTH, SHA512_DIGEST_LENGTH, sha512_Final(), sha512_Init(), sha512_Raw(), and sha512_Update().

Referenced by btc_hdnode_from_seed(), btc_hdnode_private_ckd(), and btc_hdnode_public_ckd().

{
    int i;
    uint8_t buf[SHA512_BLOCK_LENGTH], o_key_pad[SHA512_BLOCK_LENGTH],
        i_key_pad[SHA512_BLOCK_LENGTH];
    SHA512_CTX ctx;

    memset(buf, 0, SHA512_BLOCK_LENGTH);
    if (keylen > SHA512_BLOCK_LENGTH) {
        sha512_Raw(key, keylen, buf);
    } else {
        memcpy(buf, key, keylen);
    }

    for (i = 0; i < SHA512_BLOCK_LENGTH; i++) {
        o_key_pad[i] = buf[i] ^ 0x5c;
        i_key_pad[i] = buf[i] ^ 0x36;
    }

    sha512_Init(&ctx);
    sha512_Update(&ctx, i_key_pad, SHA512_BLOCK_LENGTH);
    sha512_Update(&ctx, msg, msglen);
    sha512_Final(buf, &ctx);

    sha512_Init(&ctx);
    sha512_Update(&ctx, o_key_pad, SHA512_BLOCK_LENGTH);
    sha512_Update(&ctx, buf, SHA512_DIGEST_LENGTH);
    sha512_Final(hmac, &ctx);
}

void sha256_Final	(	uint8_t	[SHA256_DIGEST_LENGTH],
		SHA256_CTX *
	)

void sha256_Init

(

SHA256_CTX *

)

Definition at line 360 of file sha2.c.

References _SHA256_CTX::bitcount, _SHA256_CTX::buffer, MEMCPY_BCOPY, MEMSET_BZERO, SHA256_BLOCK_LENGTH, SHA256_DIGEST_LENGTH, sha256_initial_hash_value, and _SHA256_CTX::state.

Referenced by hmac_sha256(), and sha256_Raw().

{
    if (context == (SHA256_CTX*)0) {
        return;
    }
    MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
    MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH);
    context->bitcount = 0;
}

void sha256_Raw	(	const uint8_t *	,
		size_t	,
		uint8_t	[SHA256_DIGEST_LENGTH]
	)

Definition at line 652 of file sha2.c.

References sha256_Final(), sha256_Init(), and sha256_Update().

Referenced by btc_b58check(), btc_base58_encode_check(), btc_hash(), btc_hash_sngl_sha256(), btc_hdnode_private_ckd(), btc_hdnode_public_ckd(), btc_tx_hash(), btc_tx_sighash(), and hmac_sha256().

{
    SHA256_CTX context;
    sha256_Init(&context);
    sha256_Update(&context, data, len);
    sha256_Final(digest, &context);
}

void sha256_Update	(	SHA256_CTX *	,
		const uint8_t *	,
		size_t
	)

Definition at line 544 of file sha2.c.

References _SHA256_CTX::bitcount, _SHA256_CTX::buffer, MEMCPY_BCOPY, SHA256_BLOCK_LENGTH, and sha256_Transform().

Referenced by hmac_sha256(), 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_BCOPY(&context->buffer[usedspace], data, freespace);
            context->bitcount += freespace << 3;
            len -= freespace;
            data += freespace;
            sha256_Transform(context, (sha2_word32*)context->buffer);
        } else {
            /* The buffer is not yet full */
            MEMCPY_BCOPY(&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, (const sha2_word32*)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_BCOPY(context->buffer, data, len);
        context->bitcount += len << 3;
    }
    /* Clean up: */
    usedspace = freespace = 0;
}

void sha512_Final	(	uint8_t	[SHA512_DIGEST_LENGTH],
		SHA512_CTX *
	)

void sha512_Init

(

SHA512_CTX *

)

Definition at line 662 of file sha2.c.

References _SHA512_CTX::bitcount, _SHA512_CTX::buffer, MEMCPY_BCOPY, MEMSET_BZERO, SHA512_BLOCK_LENGTH, SHA512_DIGEST_LENGTH, sha512_initial_hash_value, and _SHA512_CTX::state.

Referenced by hmac_sha512(), and sha512_Raw().

{
    if (context == (SHA512_CTX*)0) {
        return;
    }
    MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
    MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
    context->bitcount[0] = context->bitcount[1] = 0;
}

void sha512_Raw	(	const uint8_t *	,
		size_t	,
		uint8_t	[SHA512_DIGEST_LENGTH]
	)

Definition at line 958 of file sha2.c.

References sha512_Final(), sha512_Init(), and sha512_Update().

Referenced by hmac_sha512().

{
    SHA512_CTX context;
    sha512_Init(&context);
    sha512_Update(&context, data, len);
    sha512_Final(digest, &context);
}

void sha512_Update	(	SHA512_CTX *	,
		const uint8_t *	,
		size_t
	)

Definition at line 840 of file sha2.c.

References ADDINC128, _SHA512_CTX::bitcount, _SHA512_CTX::buffer, MEMCPY_BCOPY, SHA512_BLOCK_LENGTH, and sha512_Transform().

Referenced by hmac_sha512(), and sha512_Raw().

{
    unsigned int freespace, usedspace;

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

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

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