[people/ms/u-boot.git] / lib_generic / sha256.c

/*
 * FIPS-180-2 compliant SHA-256 implementation
 *
 * Copyright (C) 2001-2003  Christophe Devine
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef USE_HOSTCC
#include <common.h>
#endif /* USE_HOSTCC */
#include <watchdog.h>
#include <linux/string.h>
#include <sha256.h>

/*
 * 32-bit integer manipulation macros (big endian)
 */
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i) {				\
	(n) = ( (unsigned long) (b)[(i)    ] << 24 )	\
	    | ( (unsigned long) (b)[(i) + 1] << 16 )	\
	    | ( (unsigned long) (b)[(i) + 2] <<  8 )	\
	    | ( (unsigned long) (b)[(i) + 3]       );	\
}
#endif
#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i) {				\
	(b)[(i)    ] = (unsigned char) ( (n) >> 24 );	\
	(b)[(i) + 1] = (unsigned char) ( (n) >> 16 );	\
	(b)[(i) + 2] = (unsigned char) ( (n) >>  8 );	\
	(b)[(i) + 3] = (unsigned char) ( (n)       );	\
}
#endif

void sha256_starts(sha256_context * ctx)
{
	ctx->total[0] = 0;
	ctx->total[1] = 0;

	ctx->state[0] = 0x6A09E667;
	ctx->state[1] = 0xBB67AE85;
	ctx->state[2] = 0x3C6EF372;
	ctx->state[3] = 0xA54FF53A;
	ctx->state[4] = 0x510E527F;
	ctx->state[5] = 0x9B05688C;
	ctx->state[6] = 0x1F83D9AB;
	ctx->state[7] = 0x5BE0CD19;
}

void sha256_process(sha256_context * ctx, uint8_t data[64])
{
	uint32_t temp1, temp2;
	uint32_t W[64];
	uint32_t A, B, C, D, E, F, G, H;

	GET_UINT32_BE(W[0], data, 0);
	GET_UINT32_BE(W[1], data, 4);
	GET_UINT32_BE(W[2], data, 8);
	GET_UINT32_BE(W[3], data, 12);
	GET_UINT32_BE(W[4], data, 16);
	GET_UINT32_BE(W[5], data, 20);
	GET_UINT32_BE(W[6], data, 24);
	GET_UINT32_BE(W[7], data, 28);
	GET_UINT32_BE(W[8], data, 32);
	GET_UINT32_BE(W[9], data, 36);
	GET_UINT32_BE(W[10], data, 40);
	GET_UINT32_BE(W[11], data, 44);
	GET_UINT32_BE(W[12], data, 48);
	GET_UINT32_BE(W[13], data, 52);
	GET_UINT32_BE(W[14], data, 56);
	GET_UINT32_BE(W[15], data, 60);

#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
#define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))

#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))

#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))

#define F0(x,y,z) ((x & y) | (z & (x | y)))
#define F1(x,y,z) (z ^ (x & (y ^ z)))

#define R(t)					\
(						\
	W[t] = S1(W[t - 2]) + W[t - 7] +	\
		S0(W[t - 15]) + W[t - 16]	\
)

#define P(a,b,c,d,e,f,g,h,x,K) {		\
	temp1 = h + S3(e) + F1(e,f,g) + K + x;	\
	temp2 = S2(a) + F0(a,b,c);		\
	d += temp1; h = temp1 + temp2;		\
}

	A = ctx->state[0];
	B = ctx->state[1];
	C = ctx->state[2];
	D = ctx->state[3];
	E = ctx->state[4];
	F = ctx->state[5];
	G = ctx->state[6];
	H = ctx->state[7];

	P(A, B, C, D, E, F, G, H, W[0], 0x428A2F98);
	P(H, A, B, C, D, E, F, G, W[1], 0x71374491);
	P(G, H, A, B, C, D, E, F, W[2], 0xB5C0FBCF);
	P(F, G, H, A, B, C, D, E, W[3], 0xE9B5DBA5);
	P(E, F, G, H, A, B, C, D, W[4], 0x3956C25B);
	P(D, E, F, G, H, A, B, C, W[5], 0x59F111F1);
	P(C, D, E, F, G, H, A, B, W[6], 0x923F82A4);
	P(B, C, D, E, F, G, H, A, W[7], 0xAB1C5ED5);
	P(A, B, C, D, E, F, G, H, W[8], 0xD807AA98);
	P(H, A, B, C, D, E, F, G, W[9], 0x12835B01);
	P(G, H, A, B, C, D, E, F, W[10], 0x243185BE);
	P(F, G, H, A, B, C, D, E, W[11], 0x550C7DC3);
	P(E, F, G, H, A, B, C, D, W[12], 0x72BE5D74);
	P(D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE);
	P(C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7);
	P(B, C, D, E, F, G, H, A, W[15], 0xC19BF174);
	P(A, B, C, D, E, F, G, H, R(16), 0xE49B69C1);
	P(H, A, B, C, D, E, F, G, R(17), 0xEFBE4786);
	P(G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6);
	P(F, G, H, A, B, C, D, E, R(19), 0x240CA1CC);
	P(E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F);
	P(D, E, F, G, H, A, B, C, R(21), 0x4A7484AA);
	P(C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC);
	P(B, C, D, E, F, G, H, A, R(23), 0x76F988DA);
	P(A, B, C, D, E, F, G, H, R(24), 0x983E5152);
	P(H, A, B, C, D, E, F, G, R(25), 0xA831C66D);
	P(G, H, A, B, C, D, E, F, R(26), 0xB00327C8);
	P(F, G, H, A, B, C, D, E, R(27), 0xBF597FC7);
	P(E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3);
	P(D, E, F, G, H, A, B, C, R(29), 0xD5A79147);
	P(C, D, E, F, G, H, A, B, R(30), 0x06CA6351);
	P(B, C, D, E, F, G, H, A, R(31), 0x14292967);
	P(A, B, C, D, E, F, G, H, R(32), 0x27B70A85);
	P(H, A, B, C, D, E, F, G, R(33), 0x2E1B2138);
	P(G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC);
	P(F, G, H, A, B, C, D, E, R(35), 0x53380D13);
	P(E, F, G, H, A, B, C, D, R(36), 0x650A7354);
	P(D, E, F, G, H, A, B, C, R(37), 0x766A0ABB);
	P(C, D, E, F, G, H, A, B, R(38), 0x81C2C92E);
	P(B, C, D, E, F, G, H, A, R(39), 0x92722C85);
	P(A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1);
	P(H, A, B, C, D, E, F, G, R(41), 0xA81A664B);
	P(G, H, A, B, C, D, E, F, R(42), 0xC24B8B70);
	P(F, G, H, A, B, C, D, E, R(43), 0xC76C51A3);
	P(E, F, G, H, A, B, C, D, R(44), 0xD192E819);
	P(D, E, F, G, H, A, B, C, R(45), 0xD6990624);
	P(C, D, E, F, G, H, A, B, R(46), 0xF40E3585);
	P(B, C, D, E, F, G, H, A, R(47), 0x106AA070);
	P(A, B, C, D, E, F, G, H, R(48), 0x19A4C116);
	P(H, A, B, C, D, E, F, G, R(49), 0x1E376C08);
	P(G, H, A, B, C, D, E, F, R(50), 0x2748774C);
	P(F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5);
	P(E, F, G, H, A, B, C, D, R(52), 0x391C0CB3);
	P(D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A);
	P(C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F);
	P(B, C, D, E, F, G, H, A, R(55), 0x682E6FF3);
	P(A, B, C, D, E, F, G, H, R(56), 0x748F82EE);
	P(H, A, B, C, D, E, F, G, R(57), 0x78A5636F);
	P(G, H, A, B, C, D, E, F, R(58), 0x84C87814);
	P(F, G, H, A, B, C, D, E, R(59), 0x8CC70208);
	P(E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA);
	P(D, E, F, G, H, A, B, C, R(61), 0xA4506CEB);
	P(C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7);
	P(B, C, D, E, F, G, H, A, R(63), 0xC67178F2);

	ctx->state[0] += A;
	ctx->state[1] += B;
	ctx->state[2] += C;
	ctx->state[3] += D;
	ctx->state[4] += E;
	ctx->state[5] += F;
	ctx->state[6] += G;
	ctx->state[7] += H;
}

void sha256_update(sha256_context * ctx, uint8_t * input, uint32_t length)
{
	uint32_t left, fill;

	if (!length)
		return;

	left = ctx->total[0] & 0x3F;
	fill = 64 - left;

	ctx->total[0] += length;
	ctx->total[0] &= 0xFFFFFFFF;

	if (ctx->total[0] < length)
		ctx->total[1]++;

	if (left && length >= fill) {
		memcpy((void *) (ctx->buffer + left), (void *) input, fill);
		sha256_process(ctx, ctx->buffer);
		length -= fill;
		input += fill;
		left = 0;
	}

	while (length >= 64) {
		sha256_process(ctx, input);
		length -= 64;
		input += 64;
	}

	if (length)
		memcpy((void *) (ctx->buffer + left), (void *) input, length);
}

static uint8_t sha256_padding[64] = {
	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

void sha256_finish(sha256_context * ctx, uint8_t digest[32])
{
	uint32_t last, padn;
	uint32_t high, low;
	uint8_t msglen[8];

	high = ((ctx->total[0] >> 29)
		| (ctx->total[1] << 3));
	low = (ctx->total[0] << 3);

	PUT_UINT32_BE(high, msglen, 0);
	PUT_UINT32_BE(low, msglen, 4);

	last = ctx->total[0] & 0x3F;
	padn = (last < 56) ? (56 - last) : (120 - last);

	sha256_update(ctx, sha256_padding, padn);
	sha256_update(ctx, msglen, 8);

	PUT_UINT32_BE(ctx->state[0], digest, 0);
	PUT_UINT32_BE(ctx->state[1], digest, 4);
	PUT_UINT32_BE(ctx->state[2], digest, 8);
	PUT_UINT32_BE(ctx->state[3], digest, 12);
	PUT_UINT32_BE(ctx->state[4], digest, 16);
	PUT_UINT32_BE(ctx->state[5], digest, 20);
	PUT_UINT32_BE(ctx->state[6], digest, 24);
	PUT_UINT32_BE(ctx->state[7], digest, 28);
}
Commit	Line	Data
b571afde JCPV	1	/*
	2	* FIPS-180-2 compliant SHA-256 implementation
	3	*
	4	* Copyright (C) 2001-2003 Christophe Devine
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*/
	20
	21	#ifndef USE_HOSTCC
	22	#include <common.h>
	23	#endif /* USE_HOSTCC */
	24	#include <watchdog.h>
	25	#include <linux/string.h>
	26	#include <sha256.h>
	27
	28	/*
	29	* 32-bit integer manipulation macros (big endian)
	30	*/
	31	#ifndef GET_UINT32_BE
	32	#define GET_UINT32_BE(n,b,i) { \
	33	(n) = ( (unsigned long) (b)[(i) ] << 24 ) \
	34	\| ( (unsigned long) (b)[(i) + 1] << 16 ) \
	35	\| ( (unsigned long) (b)[(i) + 2] << 8 ) \
	36	\| ( (unsigned long) (b)[(i) + 3] ); \
	37	}
	38	#endif
	39	#ifndef PUT_UINT32_BE
	40	#define PUT_UINT32_BE(n,b,i) { \
	41	(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
	42	(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
	43	(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
	44	(b)[(i) + 3] = (unsigned char) ( (n) ); \
	45	}
	46	#endif
	47
	48	void sha256_starts(sha256_context * ctx)
	49	{
	50	ctx->total[0] = 0;
	51	ctx->total[1] = 0;
	52
	53	ctx->state[0] = 0x6A09E667;
	54	ctx->state[1] = 0xBB67AE85;
	55	ctx->state[2] = 0x3C6EF372;
	56	ctx->state[3] = 0xA54FF53A;
	57	ctx->state[4] = 0x510E527F;
	58	ctx->state[5] = 0x9B05688C;
	59	ctx->state[6] = 0x1F83D9AB;
	60	ctx->state[7] = 0x5BE0CD19;
	61	}
	62
	63	void sha256_process(sha256_context * ctx, uint8_t data[64])
	64	{
65	uint32_t temp1, temp2;
66	uint32_t W[64];
67	uint32_t A, B, C, D, E, F, G, H;
68
69	GET_UINT32_BE(W[0], data, 0);
70	GET_UINT32_BE(W[1], data, 4);
71	GET_UINT32_BE(W[2], data, 8);
72	GET_UINT32_BE(W[3], data, 12);
73	GET_UINT32_BE(W[4], data, 16);
74	GET_UINT32_BE(W[5], data, 20);
75	GET_UINT32_BE(W[6], data, 24);
76	GET_UINT32_BE(W[7], data, 28);
77	GET_UINT32_BE(W[8], data, 32);
78	GET_UINT32_BE(W[9], data, 36);
79	GET_UINT32_BE(W[10], data, 40);
80	GET_UINT32_BE(W[11], data, 44);
81	GET_UINT32_BE(W[12], data, 48);
82	GET_UINT32_BE(W[13], data, 52);
83	GET_UINT32_BE(W[14], data, 56);
84	GET_UINT32_BE(W[15], data, 60);
85
86	#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
87	#define ROTR(x,n) (SHR(x,n) \| (x << (32 - n)))
88
89	#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
90	#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
91
92	#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
93	#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
94
95	#define F0(x,y,z) ((x & y) \| (z & (x \| y)))
96	#define F1(x,y,z) (z ^ (x & (y ^ z)))
97
98	#define R(t) \
99	( \
100	W[t] = S1(W[t - 2]) + W[t - 7] + \
101	S0(W[t - 15]) + W[t - 16] \
102	)
103
104	#define P(a,b,c,d,e,f,g,h,x,K) { \
105	temp1 = h + S3(e) + F1(e,f,g) + K + x; \
106	temp2 = S2(a) + F0(a,b,c); \
107	d += temp1; h = temp1 + temp2; \
108	}
109
110	A = ctx->state[0];
111	B = ctx->state[1];
112	C = ctx->state[2];
113	D = ctx->state[3];
114	E = ctx->state[4];
115	F = ctx->state[5];
116	G = ctx->state[6];
117	H = ctx->state[7];
118
119	P(A, B, C, D, E, F, G, H, W[0], 0x428A2F98);
120	P(H, A, B, C, D, E, F, G, W[1], 0x71374491);
121	P(G, H, A, B, C, D, E, F, W[2], 0xB5C0FBCF);
122	P(F, G, H, A, B, C, D, E, W[3], 0xE9B5DBA5);
123	P(E, F, G, H, A, B, C, D, W[4], 0x3956C25B);
124	P(D, E, F, G, H, A, B, C, W[5], 0x59F111F1);
125	P(C, D, E, F, G, H, A, B, W[6], 0x923F82A4);
126	P(B, C, D, E, F, G, H, A, W[7], 0xAB1C5ED5);
127	P(A, B, C, D, E, F, G, H, W[8], 0xD807AA98);
128	P(H, A, B, C, D, E, F, G, W[9], 0x12835B01);
129	P(G, H, A, B, C, D, E, F, W[10], 0x243185BE);
130	P(F, G, H, A, B, C, D, E, W[11], 0x550C7DC3);
131	P(E, F, G, H, A, B, C, D, W[12], 0x72BE5D74);
132	P(D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE);
133	P(C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7);
134	P(B, C, D, E, F, G, H, A, W[15], 0xC19BF174);
135	P(A, B, C, D, E, F, G, H, R(16), 0xE49B69C1);
136	P(H, A, B, C, D, E, F, G, R(17), 0xEFBE4786);
137	P(G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6);
138	P(F, G, H, A, B, C, D, E, R(19), 0x240CA1CC);
139	P(E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F);
140	P(D, E, F, G, H, A, B, C, R(21), 0x4A7484AA);
141	P(C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC);
142	P(B, C, D, E, F, G, H, A, R(23), 0x76F988DA);
143	P(A, B, C, D, E, F, G, H, R(24), 0x983E5152);
144	P(H, A, B, C, D, E, F, G, R(25), 0xA831C66D);
145	P(G, H, A, B, C, D, E, F, R(26), 0xB00327C8);
146	P(F, G, H, A, B, C, D, E, R(27), 0xBF597FC7);
147	P(E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3);
148	P(D, E, F, G, H, A, B, C, R(29), 0xD5A79147);
149	P(C, D, E, F, G, H, A, B, R(30), 0x06CA6351);
150	P(B, C, D, E, F, G, H, A, R(31), 0x14292967);
151	P(A, B, C, D, E, F, G, H, R(32), 0x27B70A85);
152	P(H, A, B, C, D, E, F, G, R(33), 0x2E1B2138);
153	P(G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC);
154	P(F, G, H, A, B, C, D, E, R(35), 0x53380D13);
155	P(E, F, G, H, A, B, C, D, R(36), 0x650A7354);
156	P(D, E, F, G, H, A, B, C, R(37), 0x766A0ABB);
157	P(C, D, E, F, G, H, A, B, R(38), 0x81C2C92E);
158	P(B, C, D, E, F, G, H, A, R(39), 0x92722C85);
159	P(A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1);
160	P(H, A, B, C, D, E, F, G, R(41), 0xA81A664B);
161	P(G, H, A, B, C, D, E, F, R(42), 0xC24B8B70);
162	P(F, G, H, A, B, C, D, E, R(43), 0xC76C51A3);
163	P(E, F, G, H, A, B, C, D, R(44), 0xD192E819);
164	P(D, E, F, G, H, A, B, C, R(45), 0xD6990624);
165	P(C, D, E, F, G, H, A, B, R(46), 0xF40E3585);
166	P(B, C, D, E, F, G, H, A, R(47), 0x106AA070);
167	P(A, B, C, D, E, F, G, H, R(48), 0x19A4C116);
168	P(H, A, B, C, D, E, F, G, R(49), 0x1E376C08);
169	P(G, H, A, B, C, D, E, F, R(50), 0x2748774C);
170	P(F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5);
171	P(E, F, G, H, A, B, C, D, R(52), 0x391C0CB3);
172	P(D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A);
173	P(C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F);
174	P(B, C, D, E, F, G, H, A, R(55), 0x682E6FF3);
175	P(A, B, C, D, E, F, G, H, R(56), 0x748F82EE);
176	P(H, A, B, C, D, E, F, G, R(57), 0x78A5636F);
177	P(G, H, A, B, C, D, E, F, R(58), 0x84C87814);
178	P(F, G, H, A, B, C, D, E, R(59), 0x8CC70208);
179	P(E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA);
180	P(D, E, F, G, H, A, B, C, R(61), 0xA4506CEB);
181	P(C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7);
182	P(B, C, D, E, F, G, H, A, R(63), 0xC67178F2);
183
184	ctx->state[0] += A;
185	ctx->state[1] += B;
186	ctx->state[2] += C;
187	ctx->state[3] += D;
188	ctx->state[4] += E;
189	ctx->state[5] += F;
190	ctx->state[6] += G;
191	ctx->state[7] += H;
192	}
193
194	void sha256_update(sha256_context * ctx, uint8_t * input, uint32_t length)
195	{
196	uint32_t left, fill;
197
198	if (!length)
199	return;
200
201	left = ctx->total[0] & 0x3F;
202	fill = 64 - left;
203
204	ctx->total[0] += length;
205	ctx->total[0] &= 0xFFFFFFFF;
206
207	if (ctx->total[0] < length)
208	ctx->total[1]++;
209
210	if (left && length >= fill) {
211	memcpy((void ) (ctx->buffer + left), (void ) input, fill);
212	sha256_process(ctx, ctx->buffer);
213	length -= fill;
214	input += fill;
215	left = 0;
216	}
217
218	while (length >= 64) {
219	sha256_process(ctx, input);
220	length -= 64;
221	input += 64;
222	}
223
224	if (length)
225	memcpy((void ) (ctx->buffer + left), (void ) input, length);
226	}
227
228	static uint8_t sha256_padding[64] = {
229	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
230	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
231	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
232	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
233	};
234
235	void sha256_finish(sha256_context * ctx, uint8_t digest[32])
236	{
237	uint32_t last, padn;
238	uint32_t high, low;
239	uint8_t msglen[8];
240
241	high = ((ctx->total[0] >> 29)
242	\| (ctx->total[1] << 3));
243	low = (ctx->total[0] << 3);
244
245	PUT_UINT32_BE(high, msglen, 0);
246	PUT_UINT32_BE(low, msglen, 4);
247
248	last = ctx->total[0] & 0x3F;
249	padn = (last < 56) ? (56 - last) : (120 - last);
250
251	sha256_update(ctx, sha256_padding, padn);
252	sha256_update(ctx, msglen, 8);
253
254	PUT_UINT32_BE(ctx->state[0], digest, 0);
255	PUT_UINT32_BE(ctx->state[1], digest, 4);
256	PUT_UINT32_BE(ctx->state[2], digest, 8);
257	PUT_UINT32_BE(ctx->state[3], digest, 12);
258	PUT_UINT32_BE(ctx->state[4], digest, 16);
259	PUT_UINT32_BE(ctx->state[5], digest, 20);
260	PUT_UINT32_BE(ctx->state[6], digest, 24);
261	PUT_UINT32_BE(ctx->state[7], digest, 28);
262	}