static void md5_final(void *ctx, u8 *out)
{
struct md5_ctx *mctx = ctx;
const unsigned int offset = mctx->byte_count & 0x3f;
char *p = (char *)mctx->block + offset;
int padding = 56 - (offset + 1);
*p++ = 0x80;
if (padding < 0) {
memset(p, 0x00, padding + sizeof (u64));
md5_transform_helper(mctx);
p = (char *)mctx->block;
padding = 56;
}
memset(p, 0, padding);
mctx->block[14] = mctx->byte_count << 3;
mctx->block[15] = mctx->byte_count >> 29;
le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
sizeof(u64)) / sizeof(u32));
md5_transform(mctx->hash, mctx->block);
cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(u32));
memcpy(out, mctx->hash, sizeof(mctx->hash));
memset(mctx, 0, sizeof(*mctx));
}
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
static inline void
md5_final (md5_ctx_t * ctx, u8 out[16])
{
/* Number of bytes in ctx->in */
const int offset = ctx->byte_count & 0x3f;
/* p points after last content byte in ctx->in */
u8 *p = (u8 *) ctx->in + offset;
/* Bytes of padding needed to make 56 bytes (-8..55) */
int padding = 56 - (offset + 1);
/* Set the first byte of padding to 0x80. There is always room. */
*p++ = 0x80;
if (padding < 0) { /* Padding forces an extra block */
memset (p, 0x00, padding + sizeof (u64));
md5_transform_helper (ctx);
p = (u8 *) ctx->in;
padding = 56;
}
/* pad remaining bytes w/ 0x00 */
memset (p, 0x00, padding);
/* Append length in bits and transform */
ctx->in[14] = ctx->byte_count << 3; /* low order word first */
ctx->in[15] = ctx->byte_count >> 29;
/* keep the appended bit-count words in host order! */
le32_to_cpu_array (ctx->in,
(sizeof (ctx->in) - sizeof (u64)) / sizeof (u32));
md5_transform (ctx->hash, ctx->in);
/* convert digest buf from host to LE byteorder */
cpu_to_le32_array (ctx->hash, sizeof (ctx->hash) / sizeof (u32));
/* copy to output buffer */
memcpy (out, ctx->hash, sizeof (ctx->hash));
/* wipe context */
memset (ctx, 0, sizeof (ctx));
}
/*! \fn static void md5_final(struct crypto_tfm *tfm, u8 *out)
* \ingroup IFX_MD5_FUNCTIONS
* \brief compute final md5 value
* \param tfm linux crypto algo transform
* \param out final md5 output value
*/
static int md5_final(struct shash_desc *desc, u8 *out)
{
struct md5_ctx *mctx = shash_desc_ctx(desc);
const unsigned int offset = mctx->byte_count & 0x3f;
char *p = (char *)mctx->block + offset;
int padding = 56 - (offset + 1);
volatile struct deu_hash_t *hashs = (struct deu_hash_t *) HASH_START;
unsigned long flag;
*p++ = 0x80;
if (padding < 0) {
memset(p, 0x00, padding + sizeof (u64));
md5_transform_helper(mctx);
p = (char *)mctx->block;
padding = 56;
}
memset(p, 0, padding);
mctx->block[14] = endian_swap(mctx->byte_count << 3);
mctx->block[15] = endian_swap(mctx->byte_count >> 29);
#if 0
le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
sizeof(u64)) / sizeof(u32));
#endif
md5_transform(mctx, mctx->hash, mctx->block);
CRTCL_SECT_START;
*((u32 *) out + 0) = endian_swap (hashs->D1R);
*((u32 *) out + 1) = endian_swap (hashs->D2R);
*((u32 *) out + 2) = endian_swap (hashs->D3R);
*((u32 *) out + 3) = endian_swap (hashs->D4R);
CRTCL_SECT_END;
// Wipe context
memset(mctx, 0, sizeof(*mctx));
return 0;
}
void cryptohash_md4_finalize(struct md4_ctx *ctx, uint8_t *out)
{
static uint8_t padding[64] = { 0x80, };
uint64_t bits;
uint32_t index, padlen;
/* add padding and update data with it */
bits = cpu_to_le64(ctx->sz << 3);
/* pad out to 56 */
index = (uint32_t) (ctx->sz & 0x3f);
padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
cryptohash_md4_update(ctx, padding, padlen);
/* append length */
cryptohash_md4_update(ctx, (uint8_t *) &bits, sizeof(bits));
/* output hash */
le32_to_cpu_array((uint32_t *) out, ctx->h, 4);
}
static inline void md5_transform_helper(struct md5_ctx *ctx)
{
le32_to_cpu_array(ctx->block, sizeof(ctx->block) / sizeof(u32));
md5_transform(ctx->hash, ctx->block);
}
static inline void
md5_transform_helper (md5_ctx_t * ctx)
{
le32_to_cpu_array (ctx->in, sizeof (ctx->in) / sizeof (u32));
md5_transform (ctx->hash, ctx->in);
}