mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-08 08:58:00 +00:00
Rewrite MD5 implementation in my modern style.
MD5 is structurally very similar to all the SHA-1 and SHA-2 hashes (with the main difference being that the message schedule consists of just repeating the 32-bit words of the message four times in different permutations, instead of transforming them via an LFSR-style process). So it helps legibility and maintainability if all the implementations of these hashes are coded in a similar style - for example, that way, the next time I need to make a change to the ssh_hash API, I can do it the same way in all these modules without having to think everything out again. After the SHA-512 rewrite earlier today, all the hashes in that family had been updated to a consistent new style as a side effect of adding optional hardware acceleration, except for MD5, because there's no hardware-accelerated version of it. (And not much chance of anyone ever needing one, I hope!) So this is a purely stylistic update which reworks MD5 so that it looks just like all the SHA-1 and SHA-2 hash implementations. No functional change.
This commit is contained in:
Simon Tatham
parent
a9763ce4ed
commit
456120cfac
434
sshmd5.c
434
sshmd5.c
@ -1,262 +1,236 @@
|
||||
#include <assert.h>
|
||||
#include "ssh.h"
|
||||
|
||||
/*
|
||||
* MD5 implementation for PuTTY. Written directly from the spec by
|
||||
* Simon Tatham.
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
uint32_t h[4];
|
||||
} MD5_Core_State;
|
||||
#include <assert.h>
|
||||
#include "ssh.h"
|
||||
|
||||
struct MD5Context {
|
||||
MD5_Core_State core;
|
||||
unsigned char block[64];
|
||||
int blkused;
|
||||
static const uint32_t md5_initial_state[] = {
|
||||
0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476,
|
||||
};
|
||||
|
||||
static const struct md5_round_constant {
|
||||
uint32_t addition, rotation, msg_index;
|
||||
} md5_round_constants[] = {
|
||||
{ 0xd76aa478, 7, 0 }, { 0xe8c7b756, 12, 1 },
|
||||
{ 0x242070db, 17, 2 }, { 0xc1bdceee, 22, 3 },
|
||||
{ 0xf57c0faf, 7, 4 }, { 0x4787c62a, 12, 5 },
|
||||
{ 0xa8304613, 17, 6 }, { 0xfd469501, 22, 7 },
|
||||
{ 0x698098d8, 7, 8 }, { 0x8b44f7af, 12, 9 },
|
||||
{ 0xffff5bb1, 17, 10 }, { 0x895cd7be, 22, 11 },
|
||||
{ 0x6b901122, 7, 12 }, { 0xfd987193, 12, 13 },
|
||||
{ 0xa679438e, 17, 14 }, { 0x49b40821, 22, 15 },
|
||||
{ 0xf61e2562, 5, 1 }, { 0xc040b340, 9, 6 },
|
||||
{ 0x265e5a51, 14, 11 }, { 0xe9b6c7aa, 20, 0 },
|
||||
{ 0xd62f105d, 5, 5 }, { 0x02441453, 9, 10 },
|
||||
{ 0xd8a1e681, 14, 15 }, { 0xe7d3fbc8, 20, 4 },
|
||||
{ 0x21e1cde6, 5, 9 }, { 0xc33707d6, 9, 14 },
|
||||
{ 0xf4d50d87, 14, 3 }, { 0x455a14ed, 20, 8 },
|
||||
{ 0xa9e3e905, 5, 13 }, { 0xfcefa3f8, 9, 2 },
|
||||
{ 0x676f02d9, 14, 7 }, { 0x8d2a4c8a, 20, 12 },
|
||||
{ 0xfffa3942, 4, 5 }, { 0x8771f681, 11, 8 },
|
||||
{ 0x6d9d6122, 16, 11 }, { 0xfde5380c, 23, 14 },
|
||||
{ 0xa4beea44, 4, 1 }, { 0x4bdecfa9, 11, 4 },
|
||||
{ 0xf6bb4b60, 16, 7 }, { 0xbebfbc70, 23, 10 },
|
||||
{ 0x289b7ec6, 4, 13 }, { 0xeaa127fa, 11, 0 },
|
||||
{ 0xd4ef3085, 16, 3 }, { 0x04881d05, 23, 6 },
|
||||
{ 0xd9d4d039, 4, 9 }, { 0xe6db99e5, 11, 12 },
|
||||
{ 0x1fa27cf8, 16, 15 }, { 0xc4ac5665, 23, 2 },
|
||||
{ 0xf4292244, 6, 0 }, { 0x432aff97, 10, 7 },
|
||||
{ 0xab9423a7, 15, 14 }, { 0xfc93a039, 21, 5 },
|
||||
{ 0x655b59c3, 6, 12 }, { 0x8f0ccc92, 10, 3 },
|
||||
{ 0xffeff47d, 15, 10 }, { 0x85845dd1, 21, 1 },
|
||||
{ 0x6fa87e4f, 6, 8 }, { 0xfe2ce6e0, 10, 15 },
|
||||
{ 0xa3014314, 15, 6 }, { 0x4e0811a1, 21, 13 },
|
||||
{ 0xf7537e82, 6, 4 }, { 0xbd3af235, 10, 11 },
|
||||
{ 0x2ad7d2bb, 15, 2 }, { 0xeb86d391, 21, 9 },
|
||||
};
|
||||
|
||||
typedef struct md5_block md5_block;
|
||||
struct md5_block {
|
||||
uint8_t block[64];
|
||||
size_t used;
|
||||
uint64_t len;
|
||||
};
|
||||
|
||||
static inline void md5_block_setup(md5_block *blk)
|
||||
{
|
||||
blk->used = 0;
|
||||
blk->len = 0;
|
||||
}
|
||||
|
||||
static inline bool md5_block_write(
|
||||
md5_block *blk, const void **vdata, size_t *len)
|
||||
{
|
||||
size_t blkleft = sizeof(blk->block) - blk->used;
|
||||
size_t chunk = *len < blkleft ? *len : blkleft;
|
||||
|
||||
const uint8_t *p = *vdata;
|
||||
memcpy(blk->block + blk->used, p, chunk);
|
||||
*vdata = p + chunk;
|
||||
*len -= chunk;
|
||||
blk->used += chunk;
|
||||
blk->len += chunk;
|
||||
|
||||
if (blk->used == sizeof(blk->block)) {
|
||||
blk->used = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline void md5_block_pad(md5_block *blk, BinarySink *bs)
|
||||
{
|
||||
uint64_t final_len = blk->len << 3;
|
||||
size_t pad = 63 & (55 - blk->used);
|
||||
|
||||
put_byte(bs, 0x80);
|
||||
put_padding(bs, pad, 0);
|
||||
|
||||
unsigned char buf[8];
|
||||
PUT_64BIT_LSB_FIRST(buf, final_len);
|
||||
put_data(bs, buf, 8);
|
||||
smemclr(buf, 8);
|
||||
|
||||
assert(blk->used == 0 && "Should have exactly hit a block boundary");
|
||||
}
|
||||
|
||||
static inline uint32_t rol(uint32_t x, unsigned y)
|
||||
{
|
||||
return (x << (31 & y)) | (x >> (31 & -y));
|
||||
}
|
||||
|
||||
static inline uint32_t Ch(uint32_t ctrl, uint32_t if1, uint32_t if0)
|
||||
{
|
||||
return if0 ^ (ctrl & (if1 ^ if0));
|
||||
}
|
||||
|
||||
/* Parameter functions for the four MD5 round types */
|
||||
static inline uint32_t F(uint32_t x, uint32_t y, uint32_t z)
|
||||
{ return Ch(x, y, z); }
|
||||
static inline uint32_t G(uint32_t x, uint32_t y, uint32_t z)
|
||||
{ return Ch(z, x, y); }
|
||||
static inline uint32_t H(uint32_t x, uint32_t y, uint32_t z)
|
||||
{ return x ^ y ^ z; }
|
||||
static inline uint32_t I(uint32_t x, uint32_t y, uint32_t z)
|
||||
{ return y ^ (x | ~z); }
|
||||
|
||||
static inline void md5_round(
|
||||
unsigned round_index, const uint32_t *message,
|
||||
uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d,
|
||||
uint32_t (*f)(uint32_t, uint32_t, uint32_t))
|
||||
{
|
||||
struct md5_round_constant rc = md5_round_constants[round_index];
|
||||
|
||||
*a = *b + rol(*a + f(*b, *c, *d) + message[rc.msg_index] + rc.addition,
|
||||
rc.rotation);
|
||||
}
|
||||
|
||||
static void md5_do_block(uint32_t *core, const uint8_t *block)
|
||||
{
|
||||
uint32_t message_words[16];
|
||||
for (size_t i = 0; i < 16; i++)
|
||||
message_words[i] = GET_32BIT_LSB_FIRST(block + 4*i);
|
||||
|
||||
uint32_t a = core[0], b = core[1], c = core[2], d = core[3];
|
||||
|
||||
size_t t = 0;
|
||||
for (size_t u = 0; u < 4; u++) {
|
||||
md5_round(t++, message_words, &a, &b, &c, &d, F);
|
||||
md5_round(t++, message_words, &d, &a, &b, &c, F);
|
||||
md5_round(t++, message_words, &c, &d, &a, &b, F);
|
||||
md5_round(t++, message_words, &b, &c, &d, &a, F);
|
||||
}
|
||||
for (size_t u = 0; u < 4; u++) {
|
||||
md5_round(t++, message_words, &a, &b, &c, &d, G);
|
||||
md5_round(t++, message_words, &d, &a, &b, &c, G);
|
||||
md5_round(t++, message_words, &c, &d, &a, &b, G);
|
||||
md5_round(t++, message_words, &b, &c, &d, &a, G);
|
||||
}
|
||||
for (size_t u = 0; u < 4; u++) {
|
||||
md5_round(t++, message_words, &a, &b, &c, &d, H);
|
||||
md5_round(t++, message_words, &d, &a, &b, &c, H);
|
||||
md5_round(t++, message_words, &c, &d, &a, &b, H);
|
||||
md5_round(t++, message_words, &b, &c, &d, &a, H);
|
||||
}
|
||||
for (size_t u = 0; u < 4; u++) {
|
||||
md5_round(t++, message_words, &a, &b, &c, &d, I);
|
||||
md5_round(t++, message_words, &d, &a, &b, &c, I);
|
||||
md5_round(t++, message_words, &c, &d, &a, &b, I);
|
||||
md5_round(t++, message_words, &b, &c, &d, &a, I);
|
||||
}
|
||||
|
||||
core[0] += a;
|
||||
core[1] += b;
|
||||
core[2] += c;
|
||||
core[3] += d;
|
||||
|
||||
smemclr(message_words, sizeof(message_words));
|
||||
}
|
||||
|
||||
typedef struct md5 {
|
||||
uint32_t core[4];
|
||||
md5_block blk;
|
||||
BinarySink_IMPLEMENTATION;
|
||||
};
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
* Core MD5 algorithm: processes 16-word blocks into a message digest.
|
||||
*/
|
||||
|
||||
#define F(x,y,z) ( ((x) & (y)) | ((~(x)) & (z)) )
|
||||
#define G(x,y,z) ( ((x) & (z)) | ((~(z)) & (y)) )
|
||||
#define H(x,y,z) ( (x) ^ (y) ^ (z) )
|
||||
#define I(x,y,z) ( (y) ^ ( (x) | ~(z) ) )
|
||||
|
||||
#define rol(x,y) ( ((x) << (y)) | (((uint32_t)x) >> (32-y)) )
|
||||
|
||||
#define subround(f,w,x,y,z,k,s,ti) \
|
||||
w = x + rol(w + f(x,y,z) + block[k] + ti, s)
|
||||
|
||||
static void MD5_Core_Init(MD5_Core_State * s)
|
||||
{
|
||||
s->h[0] = 0x67452301;
|
||||
s->h[1] = 0xefcdab89;
|
||||
s->h[2] = 0x98badcfe;
|
||||
s->h[3] = 0x10325476;
|
||||
}
|
||||
|
||||
static void MD5_Block(MD5_Core_State *s, uint32_t *block)
|
||||
{
|
||||
uint32_t a, b, c, d;
|
||||
|
||||
a = s->h[0];
|
||||
b = s->h[1];
|
||||
c = s->h[2];
|
||||
d = s->h[3];
|
||||
|
||||
subround(F, a, b, c, d, 0, 7, 0xd76aa478);
|
||||
subround(F, d, a, b, c, 1, 12, 0xe8c7b756);
|
||||
subround(F, c, d, a, b, 2, 17, 0x242070db);
|
||||
subround(F, b, c, d, a, 3, 22, 0xc1bdceee);
|
||||
subround(F, a, b, c, d, 4, 7, 0xf57c0faf);
|
||||
subround(F, d, a, b, c, 5, 12, 0x4787c62a);
|
||||
subround(F, c, d, a, b, 6, 17, 0xa8304613);
|
||||
subround(F, b, c, d, a, 7, 22, 0xfd469501);
|
||||
subround(F, a, b, c, d, 8, 7, 0x698098d8);
|
||||
subround(F, d, a, b, c, 9, 12, 0x8b44f7af);
|
||||
subround(F, c, d, a, b, 10, 17, 0xffff5bb1);
|
||||
subround(F, b, c, d, a, 11, 22, 0x895cd7be);
|
||||
subround(F, a, b, c, d, 12, 7, 0x6b901122);
|
||||
subround(F, d, a, b, c, 13, 12, 0xfd987193);
|
||||
subround(F, c, d, a, b, 14, 17, 0xa679438e);
|
||||
subround(F, b, c, d, a, 15, 22, 0x49b40821);
|
||||
subround(G, a, b, c, d, 1, 5, 0xf61e2562);
|
||||
subround(G, d, a, b, c, 6, 9, 0xc040b340);
|
||||
subround(G, c, d, a, b, 11, 14, 0x265e5a51);
|
||||
subround(G, b, c, d, a, 0, 20, 0xe9b6c7aa);
|
||||
subround(G, a, b, c, d, 5, 5, 0xd62f105d);
|
||||
subround(G, d, a, b, c, 10, 9, 0x02441453);
|
||||
subround(G, c, d, a, b, 15, 14, 0xd8a1e681);
|
||||
subround(G, b, c, d, a, 4, 20, 0xe7d3fbc8);
|
||||
subround(G, a, b, c, d, 9, 5, 0x21e1cde6);
|
||||
subround(G, d, a, b, c, 14, 9, 0xc33707d6);
|
||||
subround(G, c, d, a, b, 3, 14, 0xf4d50d87);
|
||||
subround(G, b, c, d, a, 8, 20, 0x455a14ed);
|
||||
subround(G, a, b, c, d, 13, 5, 0xa9e3e905);
|
||||
subround(G, d, a, b, c, 2, 9, 0xfcefa3f8);
|
||||
subround(G, c, d, a, b, 7, 14, 0x676f02d9);
|
||||
subround(G, b, c, d, a, 12, 20, 0x8d2a4c8a);
|
||||
subround(H, a, b, c, d, 5, 4, 0xfffa3942);
|
||||
subround(H, d, a, b, c, 8, 11, 0x8771f681);
|
||||
subround(H, c, d, a, b, 11, 16, 0x6d9d6122);
|
||||
subround(H, b, c, d, a, 14, 23, 0xfde5380c);
|
||||
subround(H, a, b, c, d, 1, 4, 0xa4beea44);
|
||||
subround(H, d, a, b, c, 4, 11, 0x4bdecfa9);
|
||||
subround(H, c, d, a, b, 7, 16, 0xf6bb4b60);
|
||||
subround(H, b, c, d, a, 10, 23, 0xbebfbc70);
|
||||
subround(H, a, b, c, d, 13, 4, 0x289b7ec6);
|
||||
subround(H, d, a, b, c, 0, 11, 0xeaa127fa);
|
||||
subround(H, c, d, a, b, 3, 16, 0xd4ef3085);
|
||||
subround(H, b, c, d, a, 6, 23, 0x04881d05);
|
||||
subround(H, a, b, c, d, 9, 4, 0xd9d4d039);
|
||||
subround(H, d, a, b, c, 12, 11, 0xe6db99e5);
|
||||
subround(H, c, d, a, b, 15, 16, 0x1fa27cf8);
|
||||
subround(H, b, c, d, a, 2, 23, 0xc4ac5665);
|
||||
subround(I, a, b, c, d, 0, 6, 0xf4292244);
|
||||
subround(I, d, a, b, c, 7, 10, 0x432aff97);
|
||||
subround(I, c, d, a, b, 14, 15, 0xab9423a7);
|
||||
subround(I, b, c, d, a, 5, 21, 0xfc93a039);
|
||||
subround(I, a, b, c, d, 12, 6, 0x655b59c3);
|
||||
subround(I, d, a, b, c, 3, 10, 0x8f0ccc92);
|
||||
subround(I, c, d, a, b, 10, 15, 0xffeff47d);
|
||||
subround(I, b, c, d, a, 1, 21, 0x85845dd1);
|
||||
subround(I, a, b, c, d, 8, 6, 0x6fa87e4f);
|
||||
subround(I, d, a, b, c, 15, 10, 0xfe2ce6e0);
|
||||
subround(I, c, d, a, b, 6, 15, 0xa3014314);
|
||||
subround(I, b, c, d, a, 13, 21, 0x4e0811a1);
|
||||
subround(I, a, b, c, d, 4, 6, 0xf7537e82);
|
||||
subround(I, d, a, b, c, 11, 10, 0xbd3af235);
|
||||
subround(I, c, d, a, b, 2, 15, 0x2ad7d2bb);
|
||||
subround(I, b, c, d, a, 9, 21, 0xeb86d391);
|
||||
|
||||
s->h[0] += a;
|
||||
s->h[1] += b;
|
||||
s->h[2] += c;
|
||||
s->h[3] += d;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
* Outer MD5 algorithm: take an arbitrary length byte string,
|
||||
* convert it into 16-word blocks with the prescribed padding at
|
||||
* the end, and pass those blocks to the core MD5 algorithm.
|
||||
*/
|
||||
|
||||
#define BLKSIZE 64
|
||||
|
||||
static void MD5_BinarySink_write(BinarySink *bs, const void *data, size_t len);
|
||||
|
||||
static void MD5Init(struct MD5Context *s)
|
||||
{
|
||||
MD5_Core_Init(&s->core);
|
||||
s->blkused = 0;
|
||||
s->len = 0;
|
||||
BinarySink_INIT(s, MD5_BinarySink_write);
|
||||
}
|
||||
|
||||
static void MD5_BinarySink_write(BinarySink *bs, const void *data, size_t len)
|
||||
{
|
||||
struct MD5Context *s = BinarySink_DOWNCAST(bs, struct MD5Context);
|
||||
const unsigned char *q = (const unsigned char *)data;
|
||||
uint32_t wordblock[16];
|
||||
uint32_t lenw = len;
|
||||
int i;
|
||||
|
||||
assert(lenw == len);
|
||||
|
||||
/*
|
||||
* Update the length field.
|
||||
*/
|
||||
s->len += lenw;
|
||||
|
||||
if (s->blkused + len < BLKSIZE) {
|
||||
/*
|
||||
* Trivial case: just add to the block.
|
||||
*/
|
||||
memcpy(s->block + s->blkused, q, len);
|
||||
s->blkused += len;
|
||||
} else {
|
||||
/*
|
||||
* We must complete and process at least one block.
|
||||
*/
|
||||
while (s->blkused + len >= BLKSIZE) {
|
||||
memcpy(s->block + s->blkused, q, BLKSIZE - s->blkused);
|
||||
q += BLKSIZE - s->blkused;
|
||||
len -= BLKSIZE - s->blkused;
|
||||
/* Now process the block. Gather bytes little-endian into words */
|
||||
for (i = 0; i < 16; i++) {
|
||||
wordblock[i] =
|
||||
(((uint32_t) s->block[i * 4 + 3]) << 24) |
|
||||
(((uint32_t) s->block[i * 4 + 2]) << 16) |
|
||||
(((uint32_t) s->block[i * 4 + 1]) << 8) |
|
||||
(((uint32_t) s->block[i * 4 + 0]) << 0);
|
||||
}
|
||||
MD5_Block(&s->core, wordblock);
|
||||
s->blkused = 0;
|
||||
}
|
||||
memcpy(s->block, q, len);
|
||||
s->blkused = len;
|
||||
}
|
||||
}
|
||||
|
||||
static void MD5Final(unsigned char output[16], struct MD5Context *s)
|
||||
{
|
||||
int i;
|
||||
unsigned pad;
|
||||
unsigned char c[64];
|
||||
uint64_t len;
|
||||
|
||||
if (s->blkused >= 56)
|
||||
pad = 56 + 64 - s->blkused;
|
||||
else
|
||||
pad = 56 - s->blkused;
|
||||
|
||||
len = (s->len << 3);
|
||||
|
||||
memset(c, 0, pad);
|
||||
c[0] = 0x80;
|
||||
put_data(s, c, pad);
|
||||
|
||||
PUT_64BIT_LSB_FIRST(c, len);
|
||||
|
||||
put_data(s, c, 8);
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
output[4 * i + 3] = (s->core.h[i] >> 24) & 0xFF;
|
||||
output[4 * i + 2] = (s->core.h[i] >> 16) & 0xFF;
|
||||
output[4 * i + 1] = (s->core.h[i] >> 8) & 0xFF;
|
||||
output[4 * i + 0] = (s->core.h[i] >> 0) & 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
* Thin abstraction for things where hashes are pluggable.
|
||||
*/
|
||||
|
||||
struct md5_hash {
|
||||
struct MD5Context state;
|
||||
ssh_hash hash;
|
||||
};
|
||||
} md5;
|
||||
|
||||
static void md5_write(BinarySink *bs, const void *vp, size_t len);
|
||||
|
||||
static ssh_hash *md5_new(const ssh_hashalg *alg)
|
||||
{
|
||||
struct md5_hash *h = snew(struct md5_hash);
|
||||
h->hash.vt = alg;
|
||||
BinarySink_DELEGATE_INIT(&h->hash, &h->state);
|
||||
return &h->hash;
|
||||
md5 *s = snew(md5);
|
||||
|
||||
s->hash.vt = alg;
|
||||
BinarySink_INIT(s, md5_write);
|
||||
BinarySink_DELEGATE_INIT(&s->hash, s);
|
||||
return &s->hash;
|
||||
}
|
||||
|
||||
static void md5_reset(ssh_hash *hash)
|
||||
{
|
||||
struct md5_hash *h = container_of(hash, struct md5_hash, hash);
|
||||
MD5Init(&h->state);
|
||||
md5 *s = container_of(hash, md5, hash);
|
||||
|
||||
memcpy(s->core, md5_initial_state, sizeof(s->core));
|
||||
md5_block_setup(&s->blk);
|
||||
}
|
||||
|
||||
static void md5_copyfrom(ssh_hash *hcopy, ssh_hash *horig)
|
||||
{
|
||||
struct md5_hash *copy = container_of(hcopy, struct md5_hash, hash);
|
||||
struct md5_hash *orig = container_of(horig, struct md5_hash, hash);
|
||||
md5 *copy = container_of(hcopy, md5, hash);
|
||||
md5 *orig = container_of(horig, md5, hash);
|
||||
|
||||
copy->state = orig->state;
|
||||
BinarySink_COPIED(©->state);
|
||||
memcpy(copy, orig, sizeof(*copy));
|
||||
BinarySink_COPIED(copy);
|
||||
BinarySink_DELEGATE_INIT(©->hash, copy);
|
||||
}
|
||||
|
||||
static void md5_free(ssh_hash *hash)
|
||||
{
|
||||
struct md5_hash *h = container_of(hash, struct md5_hash, hash);
|
||||
md5 *s = container_of(hash, md5, hash);
|
||||
|
||||
smemclr(h, sizeof(*h));
|
||||
sfree(h);
|
||||
smemclr(s, sizeof(*s));
|
||||
sfree(s);
|
||||
}
|
||||
|
||||
static void md5_digest(ssh_hash *hash, unsigned char *output)
|
||||
static void md5_write(BinarySink *bs, const void *vp, size_t len)
|
||||
{
|
||||
struct md5_hash *h = container_of(hash, struct md5_hash, hash);
|
||||
MD5Final(output, &h->state);
|
||||
md5 *s = BinarySink_DOWNCAST(bs, md5);
|
||||
|
||||
while (len > 0)
|
||||
if (md5_block_write(&s->blk, &vp, &len))
|
||||
md5_do_block(s->core, s->blk.block);
|
||||
}
|
||||
|
||||
static void md5_digest(ssh_hash *hash, uint8_t *digest)
|
||||
{
|
||||
md5 *s = container_of(hash, md5, hash);
|
||||
|
||||
md5_block_pad(&s->blk, BinarySink_UPCAST(s));
|
||||
for (size_t i = 0; i < 4; i++)
|
||||
PUT_32BIT_LSB_FIRST(digest + 4*i, s->core[i]);
|
||||
}
|
||||
|
||||
const ssh_hashalg ssh_md5 = {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user