source: trunk/src/sh_checksum.c@ 479

Last change on this file since 479 was 450, checked in by katerina, 10 years ago

Fix for ticket #351 (incorrect memset).
File size: 20.2 KB
Line 
1/* SAMHAIN file system integrity testing */
2/* Copyright (C) 2013 Rainer Wichmann */
3/* */
4/* This program is free software; you can redistribute it */
5/* and/or modify */
6/* it under the terms of the GNU General Public License as */
7/* 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20#include "config_xor.h"
21#include "samhain.h"
22#include "sh_checksum.h"
23#include <string.h>
24
25#undef FIL__
26#define FIL__ _("sh_checksum.c")
27
28/*
29 * sha2.c
30 *
31 * Version 1.0.0beta1
32 *
33 * Written by Aaron D. Gifford <me@aarongifford.com>
34 *
35 * Copyright 2000 Aaron D. Gifford. All rights reserved.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. Neither the name of the copyright holder nor the names of contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTOR(S) ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTOR(S) BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 * SUCH DAMAGE.
60 *
61 */
62
63/* Modified for use in samhain by R. Wichmann */
64
65#if WORDS_BIGENDIAN
66#define SHA2_BIG_ENDIAN 4321
67#define SHA2_BYTE_ORDER SHA2_BIG_ENDIAN
68#else
69#define SHA2_LITTLE_ENDIAN 1234
70#define SHA2_BYTE_ORDER SHA2_LITTLE_ENDIAN
71#endif
72
73#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN
74#define REVERSE32(w,x) { \
75 sha2_word32 tmp = (w); \
76 tmp = (tmp >> 16) | (tmp << 16); \
77 (x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \
78}
79#define REVERSE64(w,x) { \
80 sha2_word64 tmp = (w); \
81 tmp = (tmp >> 32) | (tmp << 32); \
82 tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \
83 ((tmp & 0x00ff00ff00ff00ffULL) << 8); \
84 (x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \
85 ((tmp & 0x0000ffff0000ffffULL) << 16); \
86}
87#endif
88
89/*
90 * Macro for incrementally adding the unsigned 64-bit integer n to the
91 * unsigned 128-bit integer (represented using a two-element array of
92 * 64-bit words):
93 */
94#define ADDINC128(w,n) { \
95 (w)[0] += (sha2_word64)(n); \
96 if ((w)[0] < (n)) { \
97 (w)[1]++; \
98 } \
99}
100
101/*** THE SIX LOGICAL FUNCTIONS ****************************************/
102/*
103 * Bit shifting and rotation (used by the six SHA-XYZ logical functions:
104 *
105 * NOTE: The naming of R and S appears backwards here (R is a SHIFT and
106 * S is a ROTATION) because the SHA-256/384/512 description document
107 * (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
108 * same "backwards" definition.
109 */
110/* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
111#define R(b,x) ((x) >> (b))
112/* 32-bit Rotate-right (used in SHA-256): */
113#define S32(b,x) (((x) >> (b)) | ((x) << (32 - (b))))
114/* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
115#define S64(b,x) (((x) >> (b)) | ((x) << (64 - (b))))
116
117/* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */
118#define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
119#define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
120
121/* Four of six logical functions used in SHA-256: */
122#define Sigma0_256(x) (S32(2, (x)) ^ S32(13, (x)) ^ S32(22, (x)))
123#define Sigma1_256(x) (S32(6, (x)) ^ S32(11, (x)) ^ S32(25, (x)))
124#define sigma0_256(x) (S32(7, (x)) ^ S32(18, (x)) ^ R(3 , (x)))
125#define sigma1_256(x) (S32(17, (x)) ^ S32(19, (x)) ^ R(10, (x)))
126
127/*** INTERNAL FUNCTION PROTOTYPES *************************************/
128/* NOTE: These should not be accessed directly from outside this
129 * library -- they are intended for private internal visibility/use
130 * only.
131 */
132void SHA256_Transform(SHA256_CTX*, const sha2_word32*);
133
134/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
135/* Hash constant words K for SHA-256: */
136static const sha2_word32 K256[64] = {
137 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
138 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
139 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
140 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
141 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
142 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
143 0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
144 0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
145 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
146 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
147 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
148 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
149 0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
150 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
151 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
152 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
153};
154
155/* Initial hash value H for SHA-256: */
156static const sha2_word32 sha256_initial_hash_value[8] = {
157 0x6a09e667UL,
158 0xbb67ae85UL,
159 0x3c6ef372UL,
160 0xa54ff53aUL,
161 0x510e527fUL,
162 0x9b05688cUL,
163 0x1f83d9abUL,
164 0x5be0cd19UL
165};
166
167/*
168 * Constant used by SHA256/384/512_End() functions for converting the
169 * digest to a readable hexadecimal character string:
170 */
171static const char *sha2_hex_digits = "0123456789abcdef";
172
173/*** SHA-256: *********************************************************/
174void SHA256_Init(SHA256_CTX* context) {
175 if (context == (SHA256_CTX*)0) {
176 return;
177 }
178 memcpy(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
179 /* bcopy(sha256_initial_hash_value, context->state, SHA256_DIGEST_LENGTH); */
180 memset(context->buffer, 0, SHA256_BLOCK_LENGTH);
181 /* bzero(context->buffer, SHA256_BLOCK_LENGTH); */
182
183 context->bitcount = 0;
184}
185
186#ifdef SHA2_UNROLL_TRANSFORM
187
188/* Unrolled SHA-256 round macros: */
189
190#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN
191
192#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
193 REVERSE32(*data++, W256[j]); \
194 T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
195 K256[j] + W256[j]; \
196 (d) += T1; \
197 (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
198 j++
199
200#else /* SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN */
201
202#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
203 T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
204 K256[j] + (W256[j] = *data++); \
205 (d) += T1; \
206 (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
207 j++
208
209#endif /* SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN */
210
211#define ROUND256(a,b,c,d,e,f,g,h) \
212 s0 = W256[(j+1)&0x0f]; \
213 s0 = sigma0_256(s0); \
214 s1 = W256[(j+14)&0x0f]; \
215 s1 = sigma1_256(s1); \
216 T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \
217 (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \
218 (d) += T1; \
219 (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
220 j++
221
222void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
223 sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
224 sha2_word32 T1, *W256;
225 int j;
226
227 W256 = (sha2_word32*)context->buffer;
228
229 /* Initialize registers with the prev. intermediate value */
230 a = context->state[0];
231 b = context->state[1];
232 c = context->state[2];
233 d = context->state[3];
234 e = context->state[4];
235 f = context->state[5];
236 g = context->state[6];
237 h = context->state[7];
238
239 j = 0;
240 do {
241 /* Rounds 0 to 15 (unrolled): */
242 ROUND256_0_TO_15(a,b,c,d,e,f,g,h);
243 ROUND256_0_TO_15(h,a,b,c,d,e,f,g);
244 ROUND256_0_TO_15(g,h,a,b,c,d,e,f);
245 ROUND256_0_TO_15(f,g,h,a,b,c,d,e);
246 ROUND256_0_TO_15(e,f,g,h,a,b,c,d);
247 ROUND256_0_TO_15(d,e,f,g,h,a,b,c);
248 ROUND256_0_TO_15(c,d,e,f,g,h,a,b);
249 ROUND256_0_TO_15(b,c,d,e,f,g,h,a);
250 } while (j < 16);
251
252 /* Now for the remaining rounds to 64: */
253 do {
254 ROUND256(a,b,c,d,e,f,g,h);
255 ROUND256(h,a,b,c,d,e,f,g);
256 ROUND256(g,h,a,b,c,d,e,f);
257 ROUND256(f,g,h,a,b,c,d,e);
258 ROUND256(e,f,g,h,a,b,c,d);
259 ROUND256(d,e,f,g,h,a,b,c);
260 ROUND256(c,d,e,f,g,h,a,b);
261 ROUND256(b,c,d,e,f,g,h,a);
262 } while (j < 64);
263
264 /* Compute the current intermediate hash value */
265 context->state[0] += a;
266 context->state[1] += b;
267 context->state[2] += c;
268 context->state[3] += d;
269 context->state[4] += e;
270 context->state[5] += f;
271 context->state[6] += g;
272 context->state[7] += h;
273
274 /* Clean up */
275 a = b = c = d = e = f = g = h = T1 = 0;
276}
277
278#else /* SHA2_UNROLL_TRANSFORM */
279
280void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
281 sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
282 sha2_word32 T1, T2, *W256;
283 int j;
284
285 W256 = (sha2_word32*)context->buffer;
286
287 /* Initialize registers with the prev. intermediate value */
288 a = context->state[0];
289 b = context->state[1];
290 c = context->state[2];
291 d = context->state[3];
292 e = context->state[4];
293 f = context->state[5];
294 g = context->state[6];
295 h = context->state[7];
296
297 j = 0;
298 do {
299#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN
300 /* Copy data while converting to host byte order */
301 REVERSE32(*data++,W256[j]);
302 /* Apply the SHA-256 compression function to update a..h */
303 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
304#else /* SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN */
305 /* Apply the SHA-256 compression function to update a..h with copy */
306 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);
307#endif /* SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN */
308 T2 = Sigma0_256(a) + Maj(a, b, c);
309 h = g;
310 g = f;
311 f = e;
312 e = d + T1;
313 d = c;
314 c = b;
315 b = a;
316 a = T1 + T2;
317
318 j++;
319 } while (j < 16);
320
321 do {
322 /* Part of the message block expansion: */
323 s0 = W256[(j+1)&0x0f];
324 s0 = sigma0_256(s0);
325 s1 = W256[(j+14)&0x0f];
326 s1 = sigma1_256(s1);
327
328 /* Apply the SHA-256 compression function to update a..h */
329 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] +
330 (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);
331 T2 = Sigma0_256(a) + Maj(a, b, c);
332 h = g;
333 g = f;
334 f = e;
335 e = d + T1;
336 d = c;
337 c = b;
338 b = a;
339 a = T1 + T2;
340
341 j++;
342 } while (j < 64);
343
344 /* Compute the current intermediate hash value */
345 context->state[0] += a;
346 context->state[1] += b;
347 context->state[2] += c;
348 context->state[3] += d;
349 context->state[4] += e;
350 context->state[5] += f;
351 context->state[6] += g;
352 context->state[7] += h;
353
354 /* Clean up */
355 a = b = c = d = e = f = g = h = T1 = T2 = 0;
356}
357
358#endif /* SHA2_UNROLL_TRANSFORM */
359
360void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
361 unsigned int freespace, usedspace;
362
363 if (len == 0) {
364 /* Calling with no data is valid - we do nothing */
365 return;
366 }
367
368 usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
369
370 if (usedspace > 0) {
371 /* Calculate how much free space is available in the buffer */
372 freespace = SHA256_BLOCK_LENGTH - usedspace;
373
374 if (len >= freespace) {
375 /* Fill the buffer completely and process it */
376 memcpy(&context->buffer[usedspace], data, freespace);
377 /* bcopy(data, &context->buffer[usedspace], freespace); */
378 context->bitcount += freespace << 3;
379 len -= freespace;
380 data += freespace;
381 SHA256_Transform(context, (sha2_word32*)context->buffer);
382 } else {
383 /* The buffer is not yet full */
384 memcpy(&context->buffer[usedspace], data, len);
385 /* bcopy(data, &context->buffer[usedspace], len); */
386 context->bitcount += len << 3;
387
388 /* Clean up: */
389 usedspace = freespace = 0;
390 return;
391 }
392 }
393 while (len >= SHA256_BLOCK_LENGTH) {
394 /* Process as many complete blocks as we can */
395 SHA256_Transform(context, (const sha2_word32*)data);
396 context->bitcount += SHA256_BLOCK_LENGTH << 3;
397 len -= SHA256_BLOCK_LENGTH;
398 data += SHA256_BLOCK_LENGTH;
399 }
400 if (len > 0) {
401 /* There's left-overs, so save 'em */
402 memcpy(context->buffer, data, len);
403 /* bcopy(data, context->buffer, len); */
404 context->bitcount += len << 3;
405 }
406 /* Clean up: */
407 usedspace = freespace = 0;
408}
409
410void SHA256_Final(sha2_byte digest[], SHA256_CTX* context)
411{
412 sha2_word32 *d = (sha2_word32*)digest;
413 unsigned int usedspace;
414 union {
415 sha2_word64 bitcount;
416 sha2_byte buffer[sizeof(sha2_word64)];
417 } sha2_union;
418
419 /* If no digest buffer is passed, we don't bother doing this: */
420 if (digest != (sha2_byte*)0) {
421
422 usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
423
424#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN
425 /* Convert FROM host byte order */
426 REVERSE64(context->bitcount,context->bitcount);
427#endif
428 if (usedspace > 0) {
429 /* Begin padding with a 1 bit: */
430 context->buffer[usedspace++] = 0x80;
431
432 if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
433 /* Set-up for the last transform: */
434 memset(&context->buffer[usedspace], 0, SHA256_SHORT_BLOCK_LENGTH - usedspace);
435 } else {
436 if (usedspace < SHA256_BLOCK_LENGTH) {
437 memset(&context->buffer[usedspace], 0, SHA256_BLOCK_LENGTH - usedspace);
438 }
439 /* Do second-to-last transform: */
440 SHA256_Transform(context, (sha2_word32*)context->buffer);
441
442 /* And set-up for the last transform: */
443 memset(context->buffer, 0, SHA256_SHORT_BLOCK_LENGTH);
444 }
445 } else {
446 /* Set-up for the last transform: */
447 memset(context->buffer, 0, SHA256_SHORT_BLOCK_LENGTH);
448
449 /* Begin padding with a 1 bit: */
450 *context->buffer = 0x80;
451 }
452
453 /* Set the bit count (with fix for gcc type-punning warning): */
454 sha2_union.bitcount = context->bitcount;
455 memcpy (&context->buffer[SHA256_SHORT_BLOCK_LENGTH], sha2_union.buffer, sizeof(sha2_word64));
456 /* *(sha2_word64*) &context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount; */
457
458 /* Final transform: */
459 SHA256_Transform(context, (sha2_word32*)context->buffer);
460
461#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN
462 {
463 /* Convert TO host byte order */
464 int j;
465 for (j = 0; j < 8; j++) {
466 REVERSE32(context->state[j],context->state[j]);
467 *d++ = context->state[j];
468 }
469 }
470#else
471 memset(d, context->state, SHA256_DIGEST_LENGTH);
472 /* bcopy(context->state, d, SHA256_DIGEST_LENGTH); */
473#endif
474 }
475
476 /* Clean up state data: */
477 memset(context, 0, sizeof(SHA256_CTX));
478 usedspace = 0;
479}
480
481#include "sh_utils.h"
482
483/* If buffer is of length KEYBUF_SIZE, the digest will fit */
484char *SHA256_End(SHA256_CTX* context, char buffer[])
485{
486 sha2_byte digest[SHA256_DIGEST_LENGTH];
487
488 if (buffer != (char*)0) {
489 SHA256_Final(digest, context);
490 sh_util_base64_enc ((unsigned char *)buffer, digest, SHA256_DIGEST_LENGTH);
491 } else {
492 memset(context, 0, sizeof(SHA256_CTX));
493 }
494 memset(digest, 0, SHA256_DIGEST_LENGTH);
495 return buffer;
496}
497
498char* SHA256_Data(const sha2_byte* data, size_t len, char digest[KEYBUF_SIZE])
499{
500 SHA256_CTX context;
501
502 SHA256_Init(&context);
503 SHA256_Update(&context, data, len);
504 return SHA256_End(&context, digest);
505}
506
507char* SHA256_Base2Hex(char * b64digest, char * hexdigest)
508{
509 int i;
510 sha2_byte data[512];
511 sha2_byte *d;
512 size_t len;
513 char * buffer;
514
515 len = strlen(b64digest);
516 sh_util_base64_dec ((unsigned char*) data, (unsigned char *)b64digest, len);
517 d = data;
518
519 buffer = hexdigest;
520 for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
521 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
522 *buffer++ = sha2_hex_digits[*d & 0x0f];
523 d++;
524 }
525 *buffer = (char)0;
526
527 return hexdigest;
528}
529
530char * SHA256_ReplaceBaseByHex(const char * str, char * before, char after)
531{
532 char keybuf[KEYBUF_SIZE];
533 char * s = strstr(str, before);
534
535 if (s)
536 {
537 char * p;
538
539 s += strlen(before);
540 memcpy(keybuf, s, sizeof(keybuf));
541 keybuf[sizeof(keybuf)-1] = '\0';
542 p = strchr(keybuf, after);
543
544 if (p)
545 {
546 char hexbuf[SHA256_DIGEST_STRING_LENGTH];
547 char * ret = SH_ALLOC(strlen(str) + 1 + sizeof(keybuf));
548 char * r = ret;
549
550 *p = '\0';
551 SHA256_Base2Hex(keybuf, hexbuf);
552
553 memcpy(ret, str, (s - str));
554 r += (int)(s - str); *r = '\0';
555 strcpy(r, hexbuf); /* flawfinder: ignore */
556 r += strlen(hexbuf);
557 p = strchr(s, after);
558 strcpy(r, p); /* flawfinder: ignore */
559
560 return ret;
561 }
562 }
563 return NULL;
564}
565
566
567#ifdef SH_CUTEST
568#include <stdlib.h>
569#include "CuTest.h"
570
571void Test_sha256 (CuTest *tc) {
572
573 char hexdigest[SHA256_DIGEST_STRING_LENGTH];
574 char b64digest[KEYBUF_SIZE];
575 char * b64;
576 char * buffer;
577 size_t len;
578 sha2_byte data[512];
579 sha2_byte *d;
580 int i;
581
582 data[0] = '\0'; len = 0;
583 b64 = SHA256_Data(data, len, b64digest);
584 CuAssertPtrNotNull(tc, b64);
585
586 len = strlen((char*)b64);
587 sh_util_base64_dec (data, (unsigned char*)b64, len);
588 d = data;
589 buffer = hexdigest;
590 for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
591 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
592 *buffer++ = sha2_hex_digits[*d & 0x0f];
593 d++;
594 }
595 *buffer = (char)0;
596 CuAssertStrEquals(tc, hexdigest, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
597
598 memset(hexdigest, 0, sizeof(hexdigest));
599 buffer = SHA256_Base2Hex(b64digest, hexdigest);
600 CuAssertPtrNotNull(tc, buffer);
601 CuAssertStrEquals(tc, hexdigest, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
602 CuAssertStrEquals(tc, buffer, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
603
604 strcpy((char*)data, "The quick brown fox jumps over the lazy dog"); len = strlen((char*)data);
605 b64 = SHA256_Data(data, len, b64digest);
606 CuAssertPtrNotNull(tc, b64);
607
608 len = strlen((char*)b64);
609 sh_util_base64_dec (data, (unsigned char*)b64, len);
610 d = data;
611 buffer = hexdigest;
612 for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
613 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
614 *buffer++ = sha2_hex_digits[*d & 0x0f];
615 d++;
616 }
617 *buffer = (char)0;
618 CuAssertStrEquals(tc, hexdigest, "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592");
619
620 strcpy((char*)data, "The quick brown fox jumps over the lazy dog."); len = strlen((char*)data);
621 b64 = SHA256_Data(data, len, b64digest);
622 CuAssertPtrNotNull(tc, b64);
623
624 len = strlen((char*)b64);
625 sh_util_base64_dec (data, (unsigned char*)b64, len);
626 d = data;
627 buffer = hexdigest;
628 for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
629 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
630 *buffer++ = sha2_hex_digits[*d & 0x0f];
631 d++;
632 }
633 *buffer = (char)0;
634 CuAssertStrEquals(tc, hexdigest, "ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c");
635
636}
637
638#endif
Note: See TracBrowser for help on using the repository browser.