diff options
Diffstat (limited to 'libsec/port/sha2.c')
| -rw-r--r-- | libsec/port/sha2.c | 281 |
1 files changed, 281 insertions, 0 deletions
diff --git a/libsec/port/sha2.c b/libsec/port/sha2.c new file mode 100644 index 00000000..581ecc5f --- /dev/null +++ b/libsec/port/sha2.c @@ -0,0 +1,281 @@ +#include "os.h" +#include <libsec.h> + +extern void _sha256block(SHA256state*, uchar*); +extern void _sha512block(SHA512state*, uchar*); + +u32int sha224h0[] = { +0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, +0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4, +}; +u32int sha256h0[] = { +0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, +0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, +}; + +u64int sha384h0[] = { +0xcbbb9d5dc1059ed8ULL, 0x629a292a367cd507ULL, 0x9159015a3070dd17ULL, 0x152fecd8f70e5939ULL, +0x67332667ffc00b31ULL, 0x8eb44a8768581511ULL, 0xdb0c2e0d64f98fa7ULL, 0x47b5481dbefa4fa4ULL, +}; +u64int sha512h0[] = { +0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL, +0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL, +}; + + +static SHA256state * +sha256init(void) +{ + SHA256state *s; + + s = malloc(sizeof(*s)); + if(s == nil) + return nil; + s->malloced = 1; + s->seeded = 0; + s->len = 0; + s->blen = 0; + + return s; +} + +static void +p32(u32int v, uchar *p) +{ + p[0] = v>>24; + p[1] = v>>16; + p[2] = v>>8; + p[3] = v>>0; +} + +static void +p64(u64int v, uchar *p) +{ + p32(v>>32, p); + p32(v, p+4); +} + +enum { + HI = 0, + LO = 1, +}; +static void +p128(u64int v[2], uchar *p) +{ + p64(v[HI], p); + p64(v[LO], p+8); +} + +static void +uvvadd(u64int v[2], int n) +{ + v[LO] += n; + if(v[LO] < n) /* overflow */ + v[HI]++; +} + +static void +uvvmult8(u64int v[2]) +{ + v[HI] = (v[HI]<<3) | (v[LO] >> (64-3)); + v[LO] <<= 3; +} + + +static void +_sha256(uchar *p, ulong len, SHA256state *s) +{ + u32int take; + + /* complete possible partial block from last time */ + if(s->blen > 0 && s->blen+len >= SHA256bsize) { + take = SHA256bsize-s->blen; + memmove(s->buf+s->blen, p, take); + p += take; + len -= take; + _sha256block(s, s->buf); + s->len += SHA256bsize; + s->blen = 0; + memset(s->buf, 0, SHA256bsize); + } + /* whole blocks */ + while(len >= SHA256bsize) { + _sha256block(s, p); + s->len += SHA256bsize; + p += SHA256bsize; + len -= SHA256bsize; + } + /* keep possible leftover bytes */ + if(len > 0) { + memmove(s->buf+s->blen, p, len); + s->blen += len; + } +} + +static void +sha256finish(SHA256state *s, uchar *digest, int smaller) +{ + int i; + uchar end[SHA256bsize+8]; + u32int nzero, nb, nd; + + nzero = (2*SHA256bsize - s->blen - 1 - 8) % SHA256bsize; + end[0] = 0x80; + memset(end+1, 0, nzero); + nb = 8*(s->len+s->blen); + p64(nb, end+1+nzero); + _sha256(end, 1+nzero+8, s); + + nd = SHA256dlen/4; + if(smaller) + nd = SHA224dlen/4; + for(i = 0; i < nd; i++, digest += 4) + p32(s->h32[i], digest); +} + +static SHA256state* +sha256x(uchar *p, ulong len, uchar *digest, SHA256state *s, int smaller) +{ + if(s == nil) { + s = sha256init(); + if(s == nil) + return nil; + } + + if(s->seeded == 0){ + memmove(s->h32, smaller? sha224h0: sha256h0, sizeof s->h32); + s->seeded = 1; + } + + _sha256(p, len, s); + + if(digest == 0) + return s; + + sha256finish(s, digest, smaller); + if(s->malloced == 1) + free(s); + return nil; +} + +SHA256state* +sha224(uchar *p, ulong len, uchar *digest, SHA256state *s) +{ + return sha256x(p, len, digest, s, 1); +} + +SHA256state* +sha256(uchar *p, ulong len, uchar *digest, SHA256state *s) +{ + return sha256x(p, len, digest, s, 0); +} + + +static SHA512state * +sha512init(void) +{ + SHA512state *s; + + s = malloc(sizeof(*s)); + if(s == nil) + return nil; + s->malloced = 1; + s->seeded = 0; + s->nb128[HI] = 0; + s->nb128[LO] = 0; + s->blen = 0; + + return s; +} + +static void +_sha512(uchar *p, ulong len, SHA512state *s) +{ + u32int take; + + /* complete possible partial block from last time */ + if(s->blen > 0 && s->blen+len >= SHA512bsize) { + take = SHA512bsize-s->blen; + memmove(s->buf+s->blen, p, take); + p += take; + len -= take; + _sha512block(s, s->buf); + uvvadd(s->nb128, SHA512bsize); + s->blen = 0; + memset(s->buf, 0, SHA512bsize); + } + /* whole blocks */ + while(len >= SHA512bsize) { + _sha512block(s, p); + uvvadd(s->nb128, SHA512bsize); + p += SHA512bsize; + len -= SHA512bsize; + } + /* keep possible leftover bytes */ + if(len > 0) { + memmove(s->buf+s->blen, p, len); + s->blen += len; + } +} + +void +sha512finish(SHA512state *s, uchar *digest, int smaller) +{ + int i; + uchar end[SHA512bsize+16]; + u32int nzero, n; + u64int nb[2]; + + nzero = (2*SHA512bsize - s->blen - 1 - 16) % SHA512bsize; + end[0] = 0x80; + memset(end+1, 0, nzero); + nb[0] = s->nb128[0]; + nb[1] = s->nb128[1]; + uvvadd(nb, s->blen); + uvvmult8(nb); + p128(nb, end+1+nzero); + _sha512(end, 1+nzero+16, s); + + n = SHA512dlen/8; + if(smaller) + n = SHA384dlen/8; + for(i = 0; i < n; i++, digest += 8) + p64(s->h64[i], digest); +} + +static SHA512state* +sha512x(uchar *p, ulong len, uchar *digest, SHA512state *s, int smaller) +{ + if(s == nil) { + s = sha512init(); + if(s == nil) + return nil; + } + + if(s->seeded == 0){ + memmove(s->h64, smaller? sha384h0: sha512h0, sizeof s->h64); + s->seeded = 1; + } + + _sha512(p, len, s); + + if(digest == 0) + return s; + + sha512finish(s, digest, smaller); + if(s->malloced == 1) + free(s); + return nil; +} + +SHA512state* +sha384(uchar *p, ulong len, uchar *digest, SHA512state *s) +{ + return sha512x(p, len, digest, s, 1); +} + +SHA512state* +sha512(uchar *p, ulong len, uchar *digest, SHA512state *s) +{ + return sha512x(p, len, digest, s, 0); +} |