sha256.c File Reference

#include <openssl/sha.h>
#include <string.h>
#include <openssl/mem.h>
#include "../digest/md32_common.h"

Macros
#define	DATA_ORDER_IS_BIG_ENDIAN
#define	HASH_CTX   SHA256_CTX
#define	HASH_CBLOCK   64
#define	HASH_MAKE_STRING(c, s)
#define	HASH_UPDATE   SHA256_Update
#define	HASH_TRANSFORM   SHA256_Transform
#define	HASH_FINAL   SHA256_Final
#define	HASH_BLOCK_DATA_ORDER   sha256_block_data_order
#define	ROTATE(a, n)   (((a) << (n)) | ((a) >> (32 - (n))))
#define	Sigma0(x)   (ROTATE((x), 30) ^ ROTATE((x), 19) ^ ROTATE((x), 10))
#define	Sigma1(x)   (ROTATE((x), 26) ^ ROTATE((x), 21) ^ ROTATE((x), 7))
#define	sigma0(x)   (ROTATE((x), 25) ^ ROTATE((x), 14) ^ ((x) >> 3))
#define	sigma1(x)   (ROTATE((x), 15) ^ ROTATE((x), 13) ^ ((x) >> 10))
#define	Ch(x, y, z)   (((x) & (y)) ^ ((~(x)) & (z)))
#define	Maj(x, y, z)   (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define	ROUND_00_15(i, a, b, c, d, e, f, g, h)
#define	ROUND_16_63(i, a, b, c, d, e, f, g, h, X)

Functions
int	SHA224_Init (SHA256_CTX *sha)
int	SHA256_Init (SHA256_CTX *sha)
uint8_t *	SHA224 (const uint8_t *data, size_t len, uint8_t *out)
uint8_t *	SHA256 (const uint8_t *data, size_t len, uint8_t *out)
int	SHA224_Update (SHA256_CTX *ctx, const void *data, size_t len)
int	SHA224_Final (uint8_t *md, SHA256_CTX *ctx)

Macro Definition Documentation

Ch

#define Ch	(		x,
			y,
			z
	)		(((x) & (y)) ^ ((~(x)) & (z)))

DATA_ORDER_IS_BIG_ENDIAN

#define DATA_ORDER_IS_BIG_ENDIAN

HASH_BLOCK_DATA_ORDER

#define HASH_BLOCK_DATA_ORDER   sha256_block_data_order

HASH_CBLOCK

#define HASH_CBLOCK   64

HASH_CTX

#define HASH_CTX   SHA256_CTX

HASH_FINAL

#define HASH_FINAL   SHA256_Final

HASH_MAKE_STRING

#define HASH_MAKE_STRING	(		c,
			s
	)

Value:

do {                                                      \
    uint32_t ll;                                            \
    unsigned int nn;                                        \
    switch ((c)->md_len) {                                  \
      case SHA224_DIGEST_LENGTH:                            \
        for (nn = 0; nn < SHA224_DIGEST_LENGTH / 4; nn++) { \
          ll = (c)->h[nn];                                  \
          HOST_l2c(ll, (s));                                \
        }                                                   \
        break;                                              \
      case SHA256_DIGEST_LENGTH:                            \
        for (nn = 0; nn < SHA256_DIGEST_LENGTH / 4; nn++) { \
          ll = (c)->h[nn];                                  \
          HOST_l2c(ll, (s));                                \
        }                                                   \
        break;                                              \
      default:                                              \
        if ((c)->md_len > SHA256_DIGEST_LENGTH) {           \
          return 0;                                         \
        }                                                   \
        for (nn = 0; nn < (c)->md_len / 4; nn++) {          \
          ll = (c)->h[nn];                                  \
          HOST_l2c(ll, (s));                                \
        }                                                   \
        break;                                              \
    }                                                       \
  } while (0)

HASH_TRANSFORM

#define HASH_TRANSFORM   SHA256_Transform

HASH_UPDATE

#define HASH_UPDATE   SHA256_Update

Maj

#define Maj	(		x,
			y,
			z
	)		(((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))

ROTATE

#define ROTATE	(		a,
			n
	)		(((a) << (n)) | ((a) >> (32 - (n))))

ROUND_00_15

#define ROUND_00_15	(		i,
			a,
			b,
			c,
			d,
			e,
			f,
			g,
			h
	)

Value:

do {                                           \
    T1 += h + Sigma1(e) + Ch(e, f, g) + K256[i]; \
    h = Sigma0(a) + Maj(a, b, c);                \
    d += T1;                                     \
    h += T1;                                     \
  } while (0)

ROUND_16_63

#define ROUND_16_63	(		i,
			a,
			b,
			c,
			d,
			e,
			f,
			g,
			h,
			X
	)

Value:

do {                                                 \
    s0 = X[(i + 1) & 0x0f];                            \
    s0 = sigma0(s0);                                   \
    s1 = X[(i + 14) & 0x0f];                           \
    s1 = sigma1(s1);                                   \
    T1 = X[(i) & 0x0f] += s0 + s1 + X[(i + 9) & 0x0f]; \
    ROUND_00_15(i, a, b, c, d, e, f, g, h);            \
  } while (0)

Sigma0

#define Sigma0

(

x

)

(ROTATE((x), 30) ^ ROTATE((x), 19) ^ ROTATE((x), 10))

sigma0

#define sigma0

(

x

)

(ROTATE((x), 25) ^ ROTATE((x), 14) ^ ((x) >> 3))

Sigma1

#define Sigma1

(

x

)

(ROTATE((x), 26) ^ ROTATE((x), 21) ^ ROTATE((x), 7))

sigma1

#define sigma1

(

x

)

(ROTATE((x), 15) ^ ROTATE((x), 13) ^ ((x) >> 10))

Function Documentation

SHA224()

uint8_t* SHA224	(	const uint8_t *	data,
		size_t	len,
		uint8_t *	out
	)

SHA224_Final()

int SHA224_Final	(	uint8_t *	md,
		SHA256_CTX *	ctx
	)

SHA224_Init()

int SHA224_Init

(

SHA256_CTX *

sha

)

SHA224_Update()

int SHA224_Update	(	SHA256_CTX *	ctx,
		const void *	data,
		size_t	len
	)

SHA256()

uint8_t* SHA256	(	const uint8_t *	data,
		size_t	len,
		uint8_t *	out
	)

SHA256_Init()

int SHA256_Init

(

SHA256_CTX *

sha

)