2 * sha.c: routines to compute SHA-1/224/256/384/512 digests
4 * Ref: NIST FIPS PUB 180-2 Secure Hash Standard
6 * Copyright (C) 2003-2005 Mark Shelor, All Rights Reserved
9 * Fri Dec 2 02:32:20 MST 2005
21 #define W32 SHA32 /* useful abbreviations */
22 #define C32 SHA32_CONST
23 #define SR32 SHA32_SHR
24 #define SL32 SHA32_SHL
26 #define UCHR unsigned char
27 #define UINT unsigned int
28 #define ULNG unsigned long
31 #define ROTR(x, n) (SR32(x, n) | SL32(x, 32-(n)))
32 #define ROTL(x, n) (SL32(x, n) | SR32(x, 32-(n)))
34 #define Ch(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
35 #define Pa(x, y, z) ((x) ^ (y) ^ (z))
36 #define Ma(x, y, z) (((x) & (y)) | ((z) & ((x) | (y))))
38 #define SIGMA0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
39 #define SIGMA1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
40 #define sigma0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SR32(x, 3))
41 #define sigma1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SR32(x, 10))
43 #define K1 C32(0x5a827999) /* SHA-1 constants */
44 #define K2 C32(0x6ed9eba1)
45 #define K3 C32(0x8f1bbcdc)
46 #define K4 C32(0xca62c1d6)
48 static W32 K256[64] = /* SHA-224/256 constants */
50 C32(0x428a2f98), C32(0x71374491), C32(0xb5c0fbcf), C32(0xe9b5dba5),
51 C32(0x3956c25b), C32(0x59f111f1), C32(0x923f82a4), C32(0xab1c5ed5),
52 C32(0xd807aa98), C32(0x12835b01), C32(0x243185be), C32(0x550c7dc3),
53 C32(0x72be5d74), C32(0x80deb1fe), C32(0x9bdc06a7), C32(0xc19bf174),
54 C32(0xe49b69c1), C32(0xefbe4786), C32(0x0fc19dc6), C32(0x240ca1cc),
55 C32(0x2de92c6f), C32(0x4a7484aa), C32(0x5cb0a9dc), C32(0x76f988da),
56 C32(0x983e5152), C32(0xa831c66d), C32(0xb00327c8), C32(0xbf597fc7),
57 C32(0xc6e00bf3), C32(0xd5a79147), C32(0x06ca6351), C32(0x14292967),
58 C32(0x27b70a85), C32(0x2e1b2138), C32(0x4d2c6dfc), C32(0x53380d13),
59 C32(0x650a7354), C32(0x766a0abb), C32(0x81c2c92e), C32(0x92722c85),
60 C32(0xa2bfe8a1), C32(0xa81a664b), C32(0xc24b8b70), C32(0xc76c51a3),
61 C32(0xd192e819), C32(0xd6990624), C32(0xf40e3585), C32(0x106aa070),
62 C32(0x19a4c116), C32(0x1e376c08), C32(0x2748774c), C32(0x34b0bcb5),
63 C32(0x391c0cb3), C32(0x4ed8aa4a), C32(0x5b9cca4f), C32(0x682e6ff3),
64 C32(0x748f82ee), C32(0x78a5636f), C32(0x84c87814), C32(0x8cc70208),
65 C32(0x90befffa), C32(0xa4506ceb), C32(0xbef9a3f7), C32(0xc67178f2)
68 static W32 H01[5] = /* SHA-1 initial hash value */
70 C32(0x67452301), C32(0xefcdab89), C32(0x98badcfe),
71 C32(0x10325476), C32(0xc3d2e1f0)
74 static W32 H0224[8] = /* SHA-224 initial hash value */
76 C32(0xc1059ed8), C32(0x367cd507), C32(0x3070dd17), C32(0xf70e5939),
77 C32(0xffc00b31), C32(0x68581511), C32(0x64f98fa7), C32(0xbefa4fa4)
80 static W32 H0256[8] = /* SHA-256 initial hash value */
82 C32(0x6a09e667), C32(0xbb67ae85), C32(0x3c6ef372), C32(0xa54ff53a),
83 C32(0x510e527f), C32(0x9b05688c), C32(0x1f83d9ab), C32(0x5be0cd19)
86 static void sha1(s, block) /* SHA-1 transform */
91 SHA_STO_CLASS W32 W[16];
93 W32 *H = (W32 *) s->H;
95 SHA32_SCHED(W, block);
98 * Use SHA-1 alternate method from FIPS PUB 180-2 (ref. 6.1.3)
100 * To improve performance, unroll the loop and consolidate assignments
101 * by changing the roles of variables "a" through "e" at each step.
102 * Note that the variable "T" is no longer needed.
105 #define M1(a, b, c, d, e, f, k, w) \
106 e += ROTL(a, 5) + f(b, c, d) + k + w; \
109 #define M11(f, k, w) M1(a, b, c, d, e, f, k, w);
110 #define M12(f, k, w) M1(e, a, b, c, d, f, k, w);
111 #define M13(f, k, w) M1(d, e, a, b, c, f, k, w);
112 #define M14(f, k, w) M1(c, d, e, a, b, f, k, w);
113 #define M15(f, k, w) M1(b, c, d, e, a, f, k, w);
115 #define W11(s) W[(s+ 0) & 0xf]
116 #define W12(s) W[(s+13) & 0xf]
117 #define W13(s) W[(s+ 8) & 0xf]
118 #define W14(s) W[(s+ 2) & 0xf]
120 #define A1(s) (W11(s) = ROTL(W11(s) ^ W12(s) ^ W13(s) ^ W14(s), 1))
122 a = H[0]; b = H[1]; c = H[2]; d = H[3]; e = H[4];
124 M11(Ch, K1, *wp++); M12(Ch, K1, *wp++); M13(Ch, K1, *wp++);
125 M14(Ch, K1, *wp++); M15(Ch, K1, *wp++); M11(Ch, K1, *wp++);
126 M12(Ch, K1, *wp++); M13(Ch, K1, *wp++); M14(Ch, K1, *wp++);
127 M15(Ch, K1, *wp++); M11(Ch, K1, *wp++); M12(Ch, K1, *wp++);
128 M13(Ch, K1, *wp++); M14(Ch, K1, *wp++); M15(Ch, K1, *wp++);
129 M11(Ch, K1, *wp ); M12(Ch, K1, A1( 0)); M13(Ch, K1, A1( 1));
130 M14(Ch, K1, A1( 2)); M15(Ch, K1, A1( 3)); M11(Pa, K2, A1( 4));
131 M12(Pa, K2, A1( 5)); M13(Pa, K2, A1( 6)); M14(Pa, K2, A1( 7));
132 M15(Pa, K2, A1( 8)); M11(Pa, K2, A1( 9)); M12(Pa, K2, A1(10));
133 M13(Pa, K2, A1(11)); M14(Pa, K2, A1(12)); M15(Pa, K2, A1(13));
134 M11(Pa, K2, A1(14)); M12(Pa, K2, A1(15)); M13(Pa, K2, A1( 0));
135 M14(Pa, K2, A1( 1)); M15(Pa, K2, A1( 2)); M11(Pa, K2, A1( 3));
136 M12(Pa, K2, A1( 4)); M13(Pa, K2, A1( 5)); M14(Pa, K2, A1( 6));
137 M15(Pa, K2, A1( 7)); M11(Ma, K3, A1( 8)); M12(Ma, K3, A1( 9));
138 M13(Ma, K3, A1(10)); M14(Ma, K3, A1(11)); M15(Ma, K3, A1(12));
139 M11(Ma, K3, A1(13)); M12(Ma, K3, A1(14)); M13(Ma, K3, A1(15));
140 M14(Ma, K3, A1( 0)); M15(Ma, K3, A1( 1)); M11(Ma, K3, A1( 2));
141 M12(Ma, K3, A1( 3)); M13(Ma, K3, A1( 4)); M14(Ma, K3, A1( 5));
142 M15(Ma, K3, A1( 6)); M11(Ma, K3, A1( 7)); M12(Ma, K3, A1( 8));
143 M13(Ma, K3, A1( 9)); M14(Ma, K3, A1(10)); M15(Ma, K3, A1(11));
144 M11(Pa, K4, A1(12)); M12(Pa, K4, A1(13)); M13(Pa, K4, A1(14));
145 M14(Pa, K4, A1(15)); M15(Pa, K4, A1( 0)); M11(Pa, K4, A1( 1));
146 M12(Pa, K4, A1( 2)); M13(Pa, K4, A1( 3)); M14(Pa, K4, A1( 4));
147 M15(Pa, K4, A1( 5)); M11(Pa, K4, A1( 6)); M12(Pa, K4, A1( 7));
148 M13(Pa, K4, A1( 8)); M14(Pa, K4, A1( 9)); M15(Pa, K4, A1(10));
149 M11(Pa, K4, A1(11)); M12(Pa, K4, A1(12)); M13(Pa, K4, A1(13));
150 M14(Pa, K4, A1(14)); M15(Pa, K4, A1(15));
152 H[0] += a; H[1] += b; H[2] += c; H[3] += d; H[4] += e;
155 static void sha256(s, block) /* SHA-224/256 transform */
159 W32 a, b, c, d, e, f, g, h, T1;
160 SHA_STO_CLASS W32 W[16];
163 W32 *H = (W32 *) s->H;
165 SHA32_SCHED(W, block);
168 * Use same technique as in sha1()
170 * To improve performance, unroll the loop and consolidate assignments
171 * by changing the roles of variables "a" through "h" at each step.
172 * Note that the variable "T2" is no longer needed.
175 #define M2(a, b, c, d, e, f, g, h, w) \
176 T1 = h + SIGMA1(e) + Ch(e, f, g) + (*kp++) + w; \
177 h = T1 + SIGMA0(a) + Ma(a, b, c); d += T1;
179 #define W21(s) W[(s+ 0) & 0xf]
180 #define W22(s) W[(s+14) & 0xf]
181 #define W23(s) W[(s+ 9) & 0xf]
182 #define W24(s) W[(s+ 1) & 0xf]
184 #define A2(s) (W21(s) += sigma1(W22(s)) + W23(s) + sigma0(W24(s)))
186 #define M21(w) M2(a, b, c, d, e, f, g, h, w)
187 #define M22(w) M2(h, a, b, c, d, e, f, g, w)
188 #define M23(w) M2(g, h, a, b, c, d, e, f, w)
189 #define M24(w) M2(f, g, h, a, b, c, d, e, w)
190 #define M25(w) M2(e, f, g, h, a, b, c, d, w)
191 #define M26(w) M2(d, e, f, g, h, a, b, c, w)
192 #define M27(w) M2(c, d, e, f, g, h, a, b, w)
193 #define M28(w) M2(b, c, d, e, f, g, h, a, w)
195 a = H[0]; b = H[1]; c = H[2]; d = H[3];
196 e = H[4]; f = H[5]; g = H[6]; h = H[7];
198 M21( *wp++); M22( *wp++); M23( *wp++); M24( *wp++);
199 M25( *wp++); M26( *wp++); M27( *wp++); M28( *wp++);
200 M21( *wp++); M22( *wp++); M23( *wp++); M24( *wp++);
201 M25( *wp++); M26( *wp++); M27( *wp++); M28( *wp );
202 M21(A2( 0)); M22(A2( 1)); M23(A2( 2)); M24(A2( 3));
203 M25(A2( 4)); M26(A2( 5)); M27(A2( 6)); M28(A2( 7));
204 M21(A2( 8)); M22(A2( 9)); M23(A2(10)); M24(A2(11));
205 M25(A2(12)); M26(A2(13)); M27(A2(14)); M28(A2(15));
206 M21(A2( 0)); M22(A2( 1)); M23(A2( 2)); M24(A2( 3));
207 M25(A2( 4)); M26(A2( 5)); M27(A2( 6)); M28(A2( 7));
208 M21(A2( 8)); M22(A2( 9)); M23(A2(10)); M24(A2(11));
209 M25(A2(12)); M26(A2(13)); M27(A2(14)); M28(A2(15));
210 M21(A2( 0)); M22(A2( 1)); M23(A2( 2)); M24(A2( 3));
211 M25(A2( 4)); M26(A2( 5)); M27(A2( 6)); M28(A2( 7));
212 M21(A2( 8)); M22(A2( 9)); M23(A2(10)); M24(A2(11));
213 M25(A2(12)); M26(A2(13)); M27(A2(14)); M28(A2(15));
215 H[0] += a; H[1] += b; H[2] += c; H[3] += d;
216 H[4] += e; H[5] += f; H[6] += g; H[7] += h;
219 #include "sha64bit.c"
221 #define SETBIT(s, pos) s[(pos) >> 3] |= (0x01 << (7 - (pos) % 8))
222 #define CLRBIT(s, pos) s[(pos) >> 3] &= ~(0x01 << (7 - (pos) % 8))
223 #define NBYTES(nbits) ((nbits) > 0 ? 1 + (((nbits) - 1) >> 3) : 0)
224 #define HEXLEN(nbytes) ((nbytes) << 1)
225 #define B64LEN(nbytes) (((nbytes) % 3 == 0) ? ((nbytes) / 3) * 4 \
226 : ((nbytes) / 3) * 4 + ((nbytes) % 3) + 1)
228 /* w32mem: writes 32-bit word to memory in big-endian order */
229 static void w32mem(mem, w32)
235 for (i = 0; i < 4; i++)
236 *mem++ = (UCHR) (SR32(w32, 24-i*8) & 0xff);
239 /* digcpy: writes current state to digest buffer */
240 static void digcpy(s)
245 W32 *p32 = (W32 *) s->H;
246 W64 *p64 = (W64 *) s->H;
248 if (s->alg <= SHA256)
249 for (i = 0; i < 8; i++, d += 4)
252 for (i = 0; i < 8; i++, d += 8) {
253 w32mem(d, (W32) ((*p64 >> 16) >> 16));
254 w32mem(d+4, (W32) (*p64++ & SHA32_MAX));
258 #define SHA_INIT(algo, transform) \
260 memset(s, 0, sizeof(SHA)); \
261 s->alg = algo; s->sha = sha ## transform; \
262 memcpy(s->H, H0 ## algo, sizeof(H0 ## algo)); \
263 s->blocksize = SHA ## algo ## _BLOCK_BITS; \
264 s->digestlen = SHA ## algo ## _DIGEST_BITS >> 3; \
267 /* sharewind: re-initializes the digest object */
271 if (s->alg == SHA1) SHA_INIT(1, 1);
272 else if (s->alg == SHA224) SHA_INIT(224, 256);
273 else if (s->alg == SHA256) SHA_INIT(256, 256);
274 else if (s->alg == SHA384) SHA_INIT(384, 512);
275 else if (s->alg == SHA512) SHA_INIT(512, 512);
278 /* shaopen: creates a new digest object */
284 if (alg != SHA1 && alg != SHA224 && alg != SHA256 &&
285 alg != SHA384 && alg != SHA512)
287 if (alg >= SHA384 && !sha_384_512)
289 SHA_newz(0, s, 1, SHA);
297 /* shadirect: updates state directly (w/o going through s->block) */
298 static ULNG shadirect(bitstr, bitcnt, s)
303 ULNG savecnt = bitcnt;
305 while (bitcnt >= s->blocksize) {
307 bitstr += (s->blocksize >> 3);
308 bitcnt -= s->blocksize;
311 memcpy(s->block, bitstr, NBYTES(bitcnt));
312 s->blockcnt = bitcnt;
317 /* shabytes: updates state for byte-aligned input data */
318 static ULNG shabytes(bitstr, bitcnt, s)
325 ULNG savecnt = bitcnt;
327 offset = s->blockcnt >> 3;
328 if (s->blockcnt + bitcnt >= s->blocksize) {
329 nbits = s->blocksize - s->blockcnt;
330 memcpy(s->block+offset, bitstr, nbits>>3);
332 bitstr += (nbits >> 3);
333 s->sha(s, s->block), s->blockcnt = 0;
334 shadirect(bitstr, bitcnt, s);
337 memcpy(s->block+offset, bitstr, NBYTES(bitcnt));
338 s->blockcnt += bitcnt;
343 /* shabits: updates state for bit-aligned input data */
344 static ULNG shabits(bitstr, bitcnt, s)
353 UINT bufsize = sizeof(buf);
354 ULNG bufbits = (ULNG) bufsize << 3;
355 UINT nbytes = NBYTES(bitcnt);
356 ULNG savecnt = bitcnt;
358 gap = 8 - s->blockcnt % 8;
359 s->block[s->blockcnt>>3] &= ~0 << gap;
360 s->block[s->blockcnt>>3] |= *bitstr >> (8 - gap);
361 s->blockcnt += bitcnt < gap ? bitcnt : gap;
364 if (s->blockcnt == s->blocksize)
365 s->sha(s, s->block), s->blockcnt = 0;
366 if ((bitcnt -= gap) == 0)
368 while (nbytes > bufsize) {
369 for (i = 0; i < bufsize; i++)
370 buf[i] = bitstr[i] << gap | bitstr[i+1] >> (8-gap);
371 nbits = bitcnt < bufbits ? bitcnt : bufbits;
372 shabytes(buf, nbits, s);
373 bitcnt -= nbits, bitstr += bufsize, nbytes -= bufsize;
375 for (i = 0; i < nbytes - 1; i++)
376 buf[i] = bitstr[i] << gap | bitstr[i+1] >> (8-gap);
377 buf[nbytes-1] = bitstr[nbytes-1] << gap;
378 shabytes(buf, bitcnt, s);
382 /* shawrite: triggers a state update using data in bitstr/bitcnt */
383 ULNG shawrite(bitstr, bitcnt, s)
390 if (SHA_LO32(s->lenll += bitcnt) < bitcnt)
391 if (SHA_LO32(++s->lenlh) == 0)
392 if (SHA_LO32(++s->lenhl) == 0)
394 if (s->blockcnt == 0)
395 return(shadirect(bitstr, bitcnt, s));
396 else if (s->blockcnt % 8 == 0)
397 return(shabytes(bitstr, bitcnt, s));
399 return(shabits(bitstr, bitcnt, s));
402 /* shafinish: pads remaining block(s) and computes final digest state */
406 UINT lenpos, lhpos, llpos;
408 lenpos = s->blocksize == SHA1_BLOCK_BITS ? 448 : 896;
409 lhpos = s->blocksize == SHA1_BLOCK_BITS ? 56 : 120;
410 llpos = s->blocksize == SHA1_BLOCK_BITS ? 60 : 124;
411 SETBIT(s->block, s->blockcnt), s->blockcnt++;
412 while (s->blockcnt > lenpos)
413 if (s->blockcnt < s->blocksize)
414 CLRBIT(s->block, s->blockcnt), s->blockcnt++;
416 s->sha(s, s->block), s->blockcnt = 0;
417 while (s->blockcnt < lenpos)
418 CLRBIT(s->block, s->blockcnt), s->blockcnt++;
419 if (s->blocksize > SHA1_BLOCK_BITS) {
420 w32mem(s->block + 112, s->lenhh);
421 w32mem(s->block + 116, s->lenhl);
423 w32mem(s->block + lhpos, s->lenlh);
424 w32mem(s->block + llpos, s->lenll);
428 /* shadigest: returns pointer to current digest (binary) */
436 /* shahex: returns pointer to current digest (hexadecimal) */
444 if (HEXLEN((size_t) s->digestlen) >= sizeof(s->hex))
446 for (i = 0; i < s->digestlen; i++)
447 sprintf(s->hex+i*2, "%02x", s->digest[i]);
451 /* map: translation map for Base 64 encoding */
453 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
455 /* encbase64: encodes input (0 to 3 bytes) into Base 64 */
456 static void encbase64(in, n, out)
461 UCHR byte[3] = {0, 0, 0};
467 out[0] = map[byte[0] >> 2];
468 out[1] = map[((byte[0] & 0x03) << 4) | (byte[1] >> 4)];
469 out[2] = map[((byte[1] & 0x0f) << 2) | (byte[2] >> 6)];
470 out[3] = map[byte[2] & 0x3f];
474 /* shabase64: returns pointer to current digest (Base 64) */
484 if (B64LEN(s->digestlen) >= sizeof(s->base64))
486 for (n = s->digestlen, q = s->digest; n > 3; n -= 3, q += 3) {
487 encbase64(q, 3, out);
488 strcat(s->base64, out);
490 encbase64(q, n, out);
491 strcat(s->base64, out);
495 /* shadsize: returns length of digest in bytes */
499 return(s->digestlen);
502 /* shadup: duplicates current digest object */
508 SHA_new(0, p, 1, SHA);
511 memcpy(p, s, sizeof(SHA));
515 /* shadump: dumps digest object to a human-readable ASCII file */
522 UCHR *p = shadigest(s);
524 if (file == NULL || strlen(file) == 0)
526 else if ((f = SHA_open(file, "w")) == NULL)
528 SHA_fprintf(f, "alg:%d\nH", s->alg);
529 for (i = 0; i < 8; i++)
530 for (j = 0; j < (s->alg <= 256 ? 4 : 8); j++)
531 SHA_fprintf(f, "%s%02x", j==0 ? ":" : "", *p++);
532 SHA_fprintf(f, "\nblock");
533 for (i = 0; i < s->blocksize>>3; i++)
534 SHA_fprintf(f, ":%02x", s->block[i]);
535 SHA_fprintf(f, "\nblockcnt:%u\n", s->blockcnt);
536 SHA_fprintf(f, "lenhh:%lu\nlenhl:%lu\nlenlh:%lu\nlenll:%lu\n",
537 (ULNG) LO32(s->lenhh), (ULNG) LO32(s->lenhl),
538 (ULNG) LO32(s->lenlh), (ULNG) LO32(s->lenll));
539 if (f != SHA_stdout())
544 /* fgetstr: reads (and returns pointer to) next line of file */
545 static char *fgetstr(line, maxsize, f)
552 if (SHA_feof(f) || maxsize == 0)
554 for (p = line; !SHA_feof(f) && maxsize > 1; maxsize--)
555 if ((*p++ = SHA_getc(f)) == '\n')
561 /* empty: returns true if line contains only whitespace characters */
562 static int empty(line)
567 for (p = line; *p; p++)
573 /* getval: null-terminates field value, and sets pointer to rest of line */
574 static char *getval(line, pprest)
580 for (v = line; *v == ':' || isspace(*v); v++)
582 for (p = v; *p; p++) {
583 if (*p == ':' || isspace(*p)) {
589 return(p == v ? NULL : v);
592 /* types of values present in dump file */
593 #define T_C 1 /* character */
594 #define T_I 2 /* normal integer */
595 #define T_L 3 /* 32-bit value */
596 #define T_Q 4 /* 64-bit value */
598 /* ldvals: checks next line in dump file against tag, and loads values */
599 static int ldvals(f, tag, type, pval, reps, base)
607 char *p, *pr, line[512];
608 UCHR *pc = (UCHR *) pval; UINT *pi = (UINT *) pval;
609 W32 *pl = (W32 *) pval; W64 *pq = (W64 *) pval;
611 while ((p = fgetstr(line, sizeof(line), f)) != NULL)
612 if (line[0] != '#' && !empty(line))
614 if (p == NULL || strcmp(getval(line, &pr), tag) != 0)
617 if ((p = getval(pr, &pr)) == NULL)
620 case T_C: *pc++ = (UCHR) strtoul(p, NULL, base); break;
621 case T_I: *pi++ = (UINT) strtoul(p, NULL, base); break;
622 case T_L: *pl++ = (W32 ) strtoul(p, NULL, base); break;
623 case T_Q: *pq++ = (W64 ) strto64(p ); break;
629 /* closeall: closes dump file and de-allocates digest object */
630 static SHA *closeall(f, s)
634 if (f != NULL && f != SHA_stdin())
641 /* shaload: creates digest object corresponding to contents of dump file */
649 if (file == NULL || strlen(file) == 0)
651 else if ((f = SHA_open(file, "r")) == NULL)
654 /* avoid parens by exploiting precedence of (type)&-> */
655 !ldvals(f,"alg",T_I,(VP)&alg,1,10) ||
656 ((s = shaopen(alg)) == NULL) ||
657 !ldvals(f,"H",alg<=SHA256?T_L:T_Q,(VP)s->H,8,16) ||
658 !ldvals(f,"block",T_C,(VP)s->block,s->blocksize/8,16) ||
659 !ldvals(f,"blockcnt",T_I,(VP)&s->blockcnt,1,10) ||
660 (alg <= SHA256 && s->blockcnt >= SHA1_BLOCK_BITS) ||
661 (alg >= SHA384 && s->blockcnt >= SHA384_BLOCK_BITS) ||
662 !ldvals(f,"lenhh",T_L,(VP)&s->lenhh,1,10) ||
663 !ldvals(f,"lenhl",T_L,(VP)&s->lenhl,1,10) ||
664 !ldvals(f,"lenlh",T_L,(VP)&s->lenlh,1,10) ||
665 !ldvals(f,"lenll",T_L,(VP)&s->lenll,1,10)
667 return(closeall(f, s));
668 if (f != SHA_stdin())
673 /* shaclose: de-allocates digest object */
678 memset(s, 0, sizeof(SHA));