Lines Matching defs:sha
140 * during compile or in the sha.h header file.
144 * ones in sha.h too) by hand according to their system architecture.
452 [+(version)?sha-256 (FIPS) 2000-01-01]\
455 #define sha256_match "sha256|sha-256|SHA256|SHA-256"
510 static void SHA256_Transform(SHA256_CTX* sha, const sha2_word32* data) {
515 W256 = (sha2_word32*)sha->buffer;
518 a = sha->state[0];
519 b = sha->state[1];
520 c = sha->state[2];
521 d = sha->state[3];
522 e = sha->state[4];
523 f = sha->state[5];
524 g = sha->state[6];
525 h = sha->state[7];
553 sha->state[0] += a;
554 sha->state[1] += b;
555 sha->state[2] += c;
556 sha->state[3] += d;
557 sha->state[4] += e;
558 sha->state[5] += f;
559 sha->state[6] += g;
560 sha->state[7] += h;
568 static void SHA256_Transform(SHA256_CTX* sha, const sha2_word32* data) {
573 W256 = (sha2_word32*)sha->buffer;
576 a = sha->state[0];
577 b = sha->state[1];
578 c = sha->state[2];
579 d = sha->state[3];
580 e = sha->state[4];
581 f = sha->state[5];
582 g = sha->state[6];
583 h = sha->state[7];
633 sha->state[0] += a;
634 sha->state[1] += b;
635 sha->state[2] += c;
636 sha->state[3] += d;
637 sha->state[4] += e;
638 sha->state[5] += f;
639 sha->state[6] += g;
640 sha->state[7] += h;
651 Sha256_t* sha = (Sha256_t*)p;
657 usedspace = (sha->bitcount >> 3) % SHA256_BLOCK_LENGTH;
664 MEMCPY_BCOPY(&sha->buffer[usedspace], data, freespace);
665 sha->bitcount += freespace << 3;
668 SHA256_Transform(sha, (sha2_word32*)sha->buffer);
671 MEMCPY_BCOPY(&sha->buffer[usedspace], data, len);
672 sha->bitcount += len << 3;
680 SHA256_Transform(sha, (sha2_word32*)data);
681 sha->bitcount += SHA256_BLOCK_LENGTH << 3;
687 MEMCPY_BCOPY(sha->buffer, data, len);
688 sha->bitcount += len << 3;
699 register Sha256_t* sha = (Sha256_t*)p;
701 MEMCPY_BCOPY(sha->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
702 MEMSET_BZERO(sha->buffer, SHA256_BLOCK_LENGTH);
703 sha->bitcount = 0;
711 Sha256_t* sha;
713 if (sha = newof(0, Sha256_t, 1, 0))
715 sha->method = (Method_t*)method;
716 sha->name = name;
717 sha256_init((Sum_t*)sha);
719 return (Sum_t*)sha;
725 Sha256_t* sha = (Sha256_t*)p;
730 assert(sha != (SHA256_CTX*)0);
732 usedspace = (sha->bitcount >> 3) % SHA256_BLOCK_LENGTH;
735 REVERSE64(sha->bitcount,sha->bitcount);
739 sha->buffer[usedspace++] = 0x80;
743 MEMSET_BZERO(&sha->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace);
746 MEMSET_BZERO(&sha->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace);
749 SHA256_Transform(sha, (sha2_word32*)sha->buffer);
752 MEMSET_BZERO(sha->buffer, SHA256_SHORT_BLOCK_LENGTH);
756 MEMSET_BZERO(sha->buffer, SHA256_SHORT_BLOCK_LENGTH);
759 *sha->buffer = 0x80;
762 *(sha2_word64*)&sha->buffer[SHA256_SHORT_BLOCK_LENGTH] = sha->bitcount;
765 SHA256_Transform(sha, (sha2_word32*)sha->buffer);
771 sha2_word32* d = (sha2_word32*)sha->digest;
773 REVERSE32(sha->state[j],sha->state[j]);
774 *d++ = sha->state[j];
778 MEMCPY_BCOPY(sha->digest, sha->state, SHA256_DIGEST_LENGTH);
783 sha->digest_sum[i] ^= sha->digest[i];
786 MEMSET_BZERO(&sha->state, sizeof(*sha) - offsetof(Sha256_t, state));
795 register Sha256_t* sha = (Sha256_t*)p;
799 d = (flags & SUM_TOTAL) ? sha->digest_sum : sha->digest;
809 register Sha256_t* sha = (Sha256_t*)p;
813 data->buf = sha->digest;
821 [+(version)?sha-512 (FIPS) 2000-01-01]\
824 #define sha512_match "sha512|sha-512|SHA512|SHA-512"
878 static void SHA512_Transform(SHA512_CTX* sha, const sha2_word64* data) {
880 sha2_word64 T1, *W512 = (sha2_word64*)sha->buffer;
884 a = sha->state[0];
885 b = sha->state[1];
886 c = sha->state[2];
887 d = sha->state[3];
888 e = sha->state[4];
889 f = sha->state[5];
890 g = sha->state[6];
891 h = sha->state[7];
918 sha->state[0] += a;
919 sha->state[1] += b;
920 sha->state[2] += c;
921 sha->state[3] += d;
922 sha->state[4] += e;
923 sha->state[5] += f;
924 sha->state[6] += g;
925 sha->state[7] += h;
933 static void SHA512_Transform(SHA512_CTX* sha, const sha2_word64* data) {
935 sha2_word64 T1, T2, *W512 = (sha2_word64*)sha->buffer;
939 a = sha->state[0];
940 b = sha->state[1];
941 c = sha->state[2];
942 d = sha->state[3];
943 e = sha->state[4];
944 f = sha->state[5];
945 g = sha->state[6];
946 h = sha->state[7];
996 sha->state[0] += a;
997 sha->state[1] += b;
998 sha->state[2] += c;
999 sha->state[3] += d;
1000 sha->state[4] += e;
1001 sha->state[5] += f;
1002 sha->state[6] += g;
1003 sha->state[7] += h;
1014 Sha512_t* sha = (Sha512_t*)p;
1020 usedspace = (sha->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
1027 MEMCPY_BCOPY(&sha->buffer[usedspace], data, freespace);
1028 ADDINC128(sha->bitcount, freespace << 3);
1031 SHA512_Transform(sha, (sha2_word64*)sha->buffer);
1034 MEMCPY_BCOPY(&sha->buffer[usedspace], data, len);
1035 ADDINC128(sha->bitcount, len << 3);
1043 SHA512_Transform(sha, (sha2_word64*)data);
1044 ADDINC128(sha->bitcount, SHA512_BLOCK_LENGTH << 3);
1050 MEMCPY_BCOPY(sha->buffer, data, len);
1051 ADDINC128(sha->bitcount, len << 3);
1062 register Sha512_t* sha = (Sha512_t*)p;
1064 MEMCPY_BCOPY(sha->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
1065 MEMSET_BZERO(sha->buffer, SHA512_BLOCK_LENGTH);
1066 sha->bitcount[0] = sha->bitcount[1] = 0;
1074 Sha512_t* sha;
1076 if (sha = newof(0, Sha512_t, 1, 0))
1078 sha->method = (Method_t*)method;
1079 sha->name = name;
1080 sha512_init((Sum_t*)sha);
1082 return (Sum_t*)sha;
1088 Sha512_t* sha = (Sha512_t*)p;
1092 usedspace = (sha->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
1095 REVERSE64(sha->bitcount[0],sha->bitcount[0]);
1096 REVERSE64(sha->bitcount[1],sha->bitcount[1]);
1100 sha->buffer[usedspace++] = 0x80;
1104 MEMSET_BZERO(&sha->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace);
1107 MEMSET_BZERO(&sha->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace);
1110 SHA512_Transform(sha, (sha2_word64*)sha->buffer);
1113 MEMSET_BZERO(sha->buffer, SHA512_BLOCK_LENGTH - 2);
1117 MEMSET_BZERO(sha->buffer, SHA512_SHORT_BLOCK_LENGTH);
1120 *sha->buffer = 0x80;
1123 *(sha2_word64*)&sha->buffer[SHA512_SHORT_BLOCK_LENGTH] = sha->bitcount[1];
1124 *(sha2_word64*)&sha->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = sha->bitcount[0];
1127 SHA512_Transform(sha, (sha2_word64*)sha->buffer);
1132 sha2_word64* d = (sha2_word64*)sha->digest;
1135 REVERSE64(sha->state[j],sha->state[j]);
1136 *d++ = sha->state[j];
1140 MEMCPY_BCOPY(sha->digest, sha->state, SHA512_DIGEST_LENGTH);
1145 sha->digest_sum[i] ^= sha->digest[i];
1148 MEMSET_BZERO(&sha->state, sizeof(*sha) - offsetof(Sha512_t, state));
1157 register Sha512_t* sha = (Sha512_t*)p;
1161 d = (flags & SUM_TOTAL) ? sha->digest_sum : sha->digest;
1171 register Sha512_t* sha = (Sha512_t*)p;
1175 data->buf = sha->digest;
1183 [+(version)?sha-384 (FIPS) 2000-01-01]\
1186 #define sha384_match "sha384|sha-384|SHA384|SHA-384"
1200 register Sha384_t* sha = (Sha384_t*)p;
1202 MEMCPY_BCOPY(sha->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
1203 MEMSET_BZERO(sha->buffer, SHA384_BLOCK_LENGTH);
1204 sha->bitcount[0] = sha->bitcount[1] = 0;
1212 Sha384_t* sha;
1214 if (sha = newof(0, Sha384_t, 1, 0))
1216 sha->method = (Method_t*)method;
1217 sha->name = name;
1218 sha384_init((Sum_t*)sha);
1220 return (Sum_t*)sha;
1226 register Sha384_t* sha = (Sha384_t*)p;
1230 d = (flags & SUM_TOTAL) ? sha->digest_sum : sha->digest;
1240 register Sha384_t* sha = (Sha384_t*)p;
1244 data->buf = sha->digest;