summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorjsing <>2023-03-27 10:27:12 +0000
committerjsing <>2023-03-27 10:27:12 +0000
commitdb22babe26d5739ea80fe73c5c7ce7a6d32a4518 (patch)
tree82b99654b88c140ad3e856bfac186a35df23807f /src
parentaeb32cad44c92f3786167b06a0f9c4310cbb713d (diff)
downloadopenbsd-db22babe26d5739ea80fe73c5c7ce7a6d32a4518.tar.gz
openbsd-db22babe26d5739ea80fe73c5c7ce7a6d32a4518.tar.bz2
openbsd-db22babe26d5739ea80fe73c5c7ce7a6d32a4518.zip
Reorder functions/code.
No intended functional change.
Diffstat (limited to 'src')
-rw-r--r--src/lib/libcrypto/sha/sha512.c476
1 files changed, 238 insertions, 238 deletions
diff --git a/src/lib/libcrypto/sha/sha512.c b/src/lib/libcrypto/sha/sha512.c
index 7899ca3288..042badecd5 100644
--- a/src/lib/libcrypto/sha/sha512.c
+++ b/src/lib/libcrypto/sha/sha512.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: sha512.c,v 1.21 2023/03/27 10:13:08 jsing Exp $ */ 1/* $OpenBSD: sha512.c,v 1.22 2023/03/27 10:27:12 jsing Exp $ */
2/* ==================================================================== 2/* ====================================================================
3 * Copyright (c) 1998-2011 The OpenSSL Project. All rights reserved. 3 * Copyright (c) 1998-2011 The OpenSSL Project. All rights reserved.
4 * 4 *
@@ -102,248 +102,11 @@
102#define SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA 102#define SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
103#endif 103#endif
104 104
105int
106SHA384_Init(SHA512_CTX *c)
107{
108 c->h[0] = U64(0xcbbb9d5dc1059ed8);
109 c->h[1] = U64(0x629a292a367cd507);
110 c->h[2] = U64(0x9159015a3070dd17);
111 c->h[3] = U64(0x152fecd8f70e5939);
112 c->h[4] = U64(0x67332667ffc00b31);
113 c->h[5] = U64(0x8eb44a8768581511);
114 c->h[6] = U64(0xdb0c2e0d64f98fa7);
115 c->h[7] = U64(0x47b5481dbefa4fa4);
116
117 c->Nl = 0;
118 c->Nh = 0;
119 c->num = 0;
120 c->md_len = SHA384_DIGEST_LENGTH;
121 return 1;
122}
123
124int
125SHA512_Init(SHA512_CTX *c)
126{
127 c->h[0] = U64(0x6a09e667f3bcc908);
128 c->h[1] = U64(0xbb67ae8584caa73b);
129 c->h[2] = U64(0x3c6ef372fe94f82b);
130 c->h[3] = U64(0xa54ff53a5f1d36f1);
131 c->h[4] = U64(0x510e527fade682d1);
132 c->h[5] = U64(0x9b05688c2b3e6c1f);
133 c->h[6] = U64(0x1f83d9abfb41bd6b);
134 c->h[7] = U64(0x5be0cd19137e2179);
135
136 c->Nl = 0;
137 c->Nh = 0;
138 c->num = 0;
139 c->md_len = SHA512_DIGEST_LENGTH;
140 return 1;
141}
142
143#ifndef SHA512_ASM 105#ifndef SHA512_ASM
144static 106static
145#endif 107#endif
146void sha512_block_data_order (SHA512_CTX *ctx, const void *in, size_t num); 108void sha512_block_data_order (SHA512_CTX *ctx, const void *in, size_t num);
147 109
148int
149SHA512_Final(unsigned char *md, SHA512_CTX *c)
150{
151 unsigned char *p = (unsigned char *)c->u.p;
152 size_t n = c->num;
153
154 p[n]=0x80; /* There always is a room for one */
155 n++;
156 if (n > (sizeof(c->u) - 16)) {
157 memset(p + n, 0, sizeof(c->u) - n);
158 n = 0;
159 sha512_block_data_order(c, p, 1);
160 }
161
162 memset (p + n, 0, sizeof(c->u) - 16 - n);
163#if BYTE_ORDER == BIG_ENDIAN
164 c->u.d[SHA_LBLOCK - 2] = c->Nh;
165 c->u.d[SHA_LBLOCK - 1] = c->Nl;
166#else
167 p[sizeof(c->u) - 1] = (unsigned char)(c->Nl);
168 p[sizeof(c->u) - 2] = (unsigned char)(c->Nl >> 8);
169 p[sizeof(c->u) - 3] = (unsigned char)(c->Nl >> 16);
170 p[sizeof(c->u) - 4] = (unsigned char)(c->Nl >> 24);
171 p[sizeof(c->u) - 5] = (unsigned char)(c->Nl >> 32);
172 p[sizeof(c->u) - 6] = (unsigned char)(c->Nl >> 40);
173 p[sizeof(c->u) - 7] = (unsigned char)(c->Nl >> 48);
174 p[sizeof(c->u) - 8] = (unsigned char)(c->Nl >> 56);
175 p[sizeof(c->u) - 9] = (unsigned char)(c->Nh);
176 p[sizeof(c->u) - 10] = (unsigned char)(c->Nh >> 8);
177 p[sizeof(c->u) - 11] = (unsigned char)(c->Nh >> 16);
178 p[sizeof(c->u) - 12] = (unsigned char)(c->Nh >> 24);
179 p[sizeof(c->u) - 13] = (unsigned char)(c->Nh >> 32);
180 p[sizeof(c->u) - 14] = (unsigned char)(c->Nh >> 40);
181 p[sizeof(c->u) - 15] = (unsigned char)(c->Nh >> 48);
182 p[sizeof(c->u) - 16] = (unsigned char)(c->Nh >> 56);
183#endif
184
185 sha512_block_data_order(c, p, 1);
186
187 if (md == 0)
188 return 0;
189
190 switch (c->md_len) {
191 /* Let compiler decide if it's appropriate to unroll... */
192 case SHA384_DIGEST_LENGTH:
193 for (n = 0; n < SHA384_DIGEST_LENGTH/8; n++) {
194 SHA_LONG64 t = c->h[n];
195
196 *(md++) = (unsigned char)(t >> 56);
197 *(md++) = (unsigned char)(t >> 48);
198 *(md++) = (unsigned char)(t >> 40);
199 *(md++) = (unsigned char)(t >> 32);
200 *(md++) = (unsigned char)(t >> 24);
201 *(md++) = (unsigned char)(t >> 16);
202 *(md++) = (unsigned char)(t >> 8);
203 *(md++) = (unsigned char)(t);
204 }
205 break;
206 case SHA512_DIGEST_LENGTH:
207 for (n = 0; n < SHA512_DIGEST_LENGTH/8; n++) {
208 SHA_LONG64 t = c->h[n];
209
210 *(md++) = (unsigned char)(t >> 56);
211 *(md++) = (unsigned char)(t >> 48);
212 *(md++) = (unsigned char)(t >> 40);
213 *(md++) = (unsigned char)(t >> 32);
214 *(md++) = (unsigned char)(t >> 24);
215 *(md++) = (unsigned char)(t >> 16);
216 *(md++) = (unsigned char)(t >> 8);
217 *(md++) = (unsigned char)(t);
218 }
219 break;
220 /* ... as well as make sure md_len is not abused. */
221 default:
222 return 0;
223 }
224
225 return 1;
226}
227
228int
229SHA384_Final(unsigned char *md, SHA512_CTX *c)
230{
231 return SHA512_Final(md, c);
232}
233
234int
235SHA512_Update(SHA512_CTX *c, const void *_data, size_t len)
236{
237 SHA_LONG64 l;
238 unsigned char *p = c->u.p;
239 const unsigned char *data = (const unsigned char *)_data;
240
241 if (len == 0)
242 return 1;
243
244 l = (c->Nl + (((SHA_LONG64)len) << 3))&U64(0xffffffffffffffff);
245 if (l < c->Nl)
246 c->Nh++;
247 if (sizeof(len) >= 8)
248 c->Nh += (((SHA_LONG64)len) >> 61);
249 c->Nl = l;
250
251 if (c->num != 0) {
252 size_t n = sizeof(c->u) - c->num;
253
254 if (len < n) {
255 memcpy(p + c->num, data, len);
256 c->num += (unsigned int)len;
257 return 1;
258 } else{
259 memcpy(p + c->num, data, n);
260 c->num = 0;
261 len -= n;
262 data += n;
263 sha512_block_data_order(c, p, 1);
264 }
265 }
266
267 if (len >= sizeof(c->u)) {
268#ifndef SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
269 if ((size_t)data % sizeof(c->u.d[0]) != 0) {
270 while (len >= sizeof(c->u)) {
271 memcpy(p, data, sizeof(c->u));
272 sha512_block_data_order(c, p, 1);
273 len -= sizeof(c->u);
274 data += sizeof(c->u);
275 }
276 } else
277#endif
278 {
279 sha512_block_data_order(c, data, len/sizeof(c->u));
280 data += len;
281 len %= sizeof(c->u);
282 data -= len;
283 }
284 }
285
286 if (len != 0) {
287 memcpy(p, data, len);
288 c->num = (int)len;
289 }
290
291 return 1;
292}
293
294int
295SHA384_Update(SHA512_CTX *c, const void *data, size_t len)
296{
297 return SHA512_Update(c, data, len);
298}
299
300void
301SHA512_Transform(SHA512_CTX *c, const unsigned char *data)
302{
303#ifndef SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
304 if ((size_t)data % sizeof(c->u.d[0]) != 0)
305 memcpy(c->u.p, data, sizeof(c->u.p)),
306 data = c->u.p;
307#endif
308 sha512_block_data_order(c, data, 1);
309}
310
311unsigned char *
312SHA384(const unsigned char *d, size_t n, unsigned char *md)
313{
314 SHA512_CTX c;
315 static unsigned char m[SHA384_DIGEST_LENGTH];
316
317 if (md == NULL)
318 md = m;
319
320 SHA384_Init(&c);
321 SHA512_Update(&c, d, n);
322 SHA512_Final(md, &c);
323
324 explicit_bzero(&c, sizeof(c));
325
326 return (md);
327}
328
329unsigned char *
330SHA512(const unsigned char *d, size_t n, unsigned char *md)
331{
332 SHA512_CTX c;
333 static unsigned char m[SHA512_DIGEST_LENGTH];
334
335 if (md == NULL)
336 md = m;
337
338 SHA512_Init(&c);
339 SHA512_Update(&c, d, n);
340 SHA512_Final(md, &c);
341
342 explicit_bzero(&c, sizeof(c));
343
344 return (md);
345}
346
347#ifndef SHA512_ASM 110#ifndef SHA512_ASM
348static const SHA_LONG64 K512[80] = { 111static const SHA_LONG64 K512[80] = {
349 U64(0x428a2f98d728ae22), U64(0x7137449123ef65cd), 112 U64(0x428a2f98d728ae22), U64(0x7137449123ef65cd),
@@ -700,4 +463,241 @@ sha512_block_data_order(SHA512_CTX *ctx, const void *in, size_t num)
700 463
701#endif /* SHA512_ASM */ 464#endif /* SHA512_ASM */
702 465
466int
467SHA384_Init(SHA512_CTX *c)
468{
469 c->h[0] = U64(0xcbbb9d5dc1059ed8);
470 c->h[1] = U64(0x629a292a367cd507);
471 c->h[2] = U64(0x9159015a3070dd17);
472 c->h[3] = U64(0x152fecd8f70e5939);
473 c->h[4] = U64(0x67332667ffc00b31);
474 c->h[5] = U64(0x8eb44a8768581511);
475 c->h[6] = U64(0xdb0c2e0d64f98fa7);
476 c->h[7] = U64(0x47b5481dbefa4fa4);
477
478 c->Nl = 0;
479 c->Nh = 0;
480 c->num = 0;
481 c->md_len = SHA384_DIGEST_LENGTH;
482 return 1;
483}
484
485int
486SHA384_Update(SHA512_CTX *c, const void *data, size_t len)
487{
488 return SHA512_Update(c, data, len);
489}
490
491int
492SHA384_Final(unsigned char *md, SHA512_CTX *c)
493{
494 return SHA512_Final(md, c);
495}
496
497unsigned char *
498SHA384(const unsigned char *d, size_t n, unsigned char *md)
499{
500 SHA512_CTX c;
501 static unsigned char m[SHA384_DIGEST_LENGTH];
502
503 if (md == NULL)
504 md = m;
505
506 SHA384_Init(&c);
507 SHA512_Update(&c, d, n);
508 SHA512_Final(md, &c);
509
510 explicit_bzero(&c, sizeof(c));
511
512 return (md);
513}
514
515int
516SHA512_Init(SHA512_CTX *c)
517{
518 c->h[0] = U64(0x6a09e667f3bcc908);
519 c->h[1] = U64(0xbb67ae8584caa73b);
520 c->h[2] = U64(0x3c6ef372fe94f82b);
521 c->h[3] = U64(0xa54ff53a5f1d36f1);
522 c->h[4] = U64(0x510e527fade682d1);
523 c->h[5] = U64(0x9b05688c2b3e6c1f);
524 c->h[6] = U64(0x1f83d9abfb41bd6b);
525 c->h[7] = U64(0x5be0cd19137e2179);
526
527 c->Nl = 0;
528 c->Nh = 0;
529 c->num = 0;
530 c->md_len = SHA512_DIGEST_LENGTH;
531 return 1;
532}
533
534void
535SHA512_Transform(SHA512_CTX *c, const unsigned char *data)
536{
537#ifndef SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
538 if ((size_t)data % sizeof(c->u.d[0]) != 0)
539 memcpy(c->u.p, data, sizeof(c->u.p)),
540 data = c->u.p;
541#endif
542 sha512_block_data_order(c, data, 1);
543}
544
545int
546SHA512_Update(SHA512_CTX *c, const void *_data, size_t len)
547{
548 SHA_LONG64 l;
549 unsigned char *p = c->u.p;
550 const unsigned char *data = (const unsigned char *)_data;
551
552 if (len == 0)
553 return 1;
554
555 l = (c->Nl + (((SHA_LONG64)len) << 3))&U64(0xffffffffffffffff);
556 if (l < c->Nl)
557 c->Nh++;
558 if (sizeof(len) >= 8)
559 c->Nh += (((SHA_LONG64)len) >> 61);
560 c->Nl = l;
561
562 if (c->num != 0) {
563 size_t n = sizeof(c->u) - c->num;
564
565 if (len < n) {
566 memcpy(p + c->num, data, len);
567 c->num += (unsigned int)len;
568 return 1;
569 } else{
570 memcpy(p + c->num, data, n);
571 c->num = 0;
572 len -= n;
573 data += n;
574 sha512_block_data_order(c, p, 1);
575 }
576 }
577
578 if (len >= sizeof(c->u)) {
579#ifndef SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
580 if ((size_t)data % sizeof(c->u.d[0]) != 0) {
581 while (len >= sizeof(c->u)) {
582 memcpy(p, data, sizeof(c->u));
583 sha512_block_data_order(c, p, 1);
584 len -= sizeof(c->u);
585 data += sizeof(c->u);
586 }
587 } else
588#endif
589 {
590 sha512_block_data_order(c, data, len/sizeof(c->u));
591 data += len;
592 len %= sizeof(c->u);
593 data -= len;
594 }
595 }
596
597 if (len != 0) {
598 memcpy(p, data, len);
599 c->num = (int)len;
600 }
601
602 return 1;
603}
604
605int
606SHA512_Final(unsigned char *md, SHA512_CTX *c)
607{
608 unsigned char *p = (unsigned char *)c->u.p;
609 size_t n = c->num;
610
611 p[n]=0x80; /* There always is a room for one */
612 n++;
613 if (n > (sizeof(c->u) - 16)) {
614 memset(p + n, 0, sizeof(c->u) - n);
615 n = 0;
616 sha512_block_data_order(c, p, 1);
617 }
618
619 memset (p + n, 0, sizeof(c->u) - 16 - n);
620#if BYTE_ORDER == BIG_ENDIAN
621 c->u.d[SHA_LBLOCK - 2] = c->Nh;
622 c->u.d[SHA_LBLOCK - 1] = c->Nl;
623#else
624 p[sizeof(c->u) - 1] = (unsigned char)(c->Nl);
625 p[sizeof(c->u) - 2] = (unsigned char)(c->Nl >> 8);
626 p[sizeof(c->u) - 3] = (unsigned char)(c->Nl >> 16);
627 p[sizeof(c->u) - 4] = (unsigned char)(c->Nl >> 24);
628 p[sizeof(c->u) - 5] = (unsigned char)(c->Nl >> 32);
629 p[sizeof(c->u) - 6] = (unsigned char)(c->Nl >> 40);
630 p[sizeof(c->u) - 7] = (unsigned char)(c->Nl >> 48);
631 p[sizeof(c->u) - 8] = (unsigned char)(c->Nl >> 56);
632 p[sizeof(c->u) - 9] = (unsigned char)(c->Nh);
633 p[sizeof(c->u) - 10] = (unsigned char)(c->Nh >> 8);
634 p[sizeof(c->u) - 11] = (unsigned char)(c->Nh >> 16);
635 p[sizeof(c->u) - 12] = (unsigned char)(c->Nh >> 24);
636 p[sizeof(c->u) - 13] = (unsigned char)(c->Nh >> 32);
637 p[sizeof(c->u) - 14] = (unsigned char)(c->Nh >> 40);
638 p[sizeof(c->u) - 15] = (unsigned char)(c->Nh >> 48);
639 p[sizeof(c->u) - 16] = (unsigned char)(c->Nh >> 56);
640#endif
641
642 sha512_block_data_order(c, p, 1);
643
644 if (md == 0)
645 return 0;
646
647 switch (c->md_len) {
648 /* Let compiler decide if it's appropriate to unroll... */
649 case SHA384_DIGEST_LENGTH:
650 for (n = 0; n < SHA384_DIGEST_LENGTH/8; n++) {
651 SHA_LONG64 t = c->h[n];
652
653 *(md++) = (unsigned char)(t >> 56);
654 *(md++) = (unsigned char)(t >> 48);
655 *(md++) = (unsigned char)(t >> 40);
656 *(md++) = (unsigned char)(t >> 32);
657 *(md++) = (unsigned char)(t >> 24);
658 *(md++) = (unsigned char)(t >> 16);
659 *(md++) = (unsigned char)(t >> 8);
660 *(md++) = (unsigned char)(t);
661 }
662 break;
663 case SHA512_DIGEST_LENGTH:
664 for (n = 0; n < SHA512_DIGEST_LENGTH/8; n++) {
665 SHA_LONG64 t = c->h[n];
666
667 *(md++) = (unsigned char)(t >> 56);
668 *(md++) = (unsigned char)(t >> 48);
669 *(md++) = (unsigned char)(t >> 40);
670 *(md++) = (unsigned char)(t >> 32);
671 *(md++) = (unsigned char)(t >> 24);
672 *(md++) = (unsigned char)(t >> 16);
673 *(md++) = (unsigned char)(t >> 8);
674 *(md++) = (unsigned char)(t);
675 }
676 break;
677 /* ... as well as make sure md_len is not abused. */
678 default:
679 return 0;
680 }
681
682 return 1;
683}
684
685unsigned char *
686SHA512(const unsigned char *d, size_t n, unsigned char *md)
687{
688 SHA512_CTX c;
689 static unsigned char m[SHA512_DIGEST_LENGTH];
690
691 if (md == NULL)
692 md = m;
693
694 SHA512_Init(&c);
695 SHA512_Update(&c, d, n);
696 SHA512_Final(md, &c);
697
698 explicit_bzero(&c, sizeof(c));
699
700 return (md);
701}
702
703#endif /* !OPENSSL_NO_SHA512 */ 703#endif /* !OPENSSL_NO_SHA512 */
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-12-07 04:52:26 +0000