md5.c revision 734b6a94890be549309b21156f8ed6d4561cac51
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Cleaned-up and optimized version of MD5, based on the reference
* implementation provided in RFC 1321. See RSA Copyright information
* below.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
*/
/*
* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
* rights reserved.
*
* License to copy and use this software is granted provided that it
* is identified as the "RSA Data Security, Inc. MD5 Message-Digest
* Algorithm" in all material mentioning or referencing this software
* or this function.
*
* License is also granted to make and use derivative works provided
* that such works are identified as "derived from the RSA Data
* Security, Inc. MD5 Message-Digest Algorithm" in all material
* mentioning or referencing the derived work.
*
* RSA Data Security, Inc. makes no representations concerning either
* the merchantability of this software or the suitability of this
* software for any particular purpose. It is provided "as is"
* without express or implied warranty of any kind.
*
* These notices must be retained in any copies of any part of this
*/
#include "md5_byteswap.h"
#include <strings.h>
#endif /* !_KERNEL || _BOOT */
#ifdef _KERNEL
#endif /* _KERNEL */
const uint8_t [64]);
/*
* F, G, H and I are the basic MD5 functions.
*/
#define F(b, c, d) (((b) & (c)) | ((~b) & (d)))
#define G(b, c, d) (((b) & (d)) | ((c) & (~d)))
#define H(b, c, d) ((b) ^ (c) ^ (d))
#define I(b, c, d) ((c) ^ ((b) | (~d)))
/*
* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) \
(((x) << (n)) | ((x) >> ((sizeof (x) << 3) - (n))))
/*
* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
* Rotation is separate from addition to prevent recomputation.
*/
(a) += F((b), (c), (d)) + (x) + ((unsigned long long)(ac)); \
(a) = ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
(a) += G((b), (c), (d)) + (x) + ((unsigned long long)(ac)); \
(a) = ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
(a) += H((b), (c), (d)) + (x) + ((unsigned long long)(ac)); \
(a) = ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
(a) += I((b), (c), (d)) + (x) + ((unsigned long long)(ac)); \
(a) = ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
/*
* Loading 32-bit constants on a RISC is expensive since it involves both a
* `sethi' and an `or'. thus, we instead have the compiler generate `ld's to
* load the constants from an array called `md5_consts'. however, on intel
* (and other CISC processors), it is cheaper to load the constant
* directly. thus, the c code in MD5Transform() uses the macro MD5_CONST()
* which either expands to a constant or an array reference, depending on the
* architecture the code is being compiled for.
*
* Right now, i386 and amd64 are the CISC exceptions.
* If we get another CISC ISA, we'll have to change the ifdef.
*/
#define MD5_CONST(x) (MD5_CONST_ ## x)
#define MD5_CONST_e(x) MD5_CONST(x)
#define MD5_CONST_o(x) MD5_CONST(x)
#else
/*
*
* while it is somewhat counter-intuitive, on sparc (and presumably other RISC
* machines), it is more efficient to place all the constants used in this
* function in an array and load the values out of the array than to manually
* load the constants. this is because setting a register to a 32-bit value
* takes two ops in most cases: a `sethi' and an `or', but loading a 32-bit
* value from memory only takes one `ld' (or `lduw' on v9). while this
* increases memory usage, the compiler can find enough other things to do
* while waiting to keep the pipeline does not stall. additionally, it is
* likely that many of these constants are cached so that later accesses do
* not even go out to the bus.
*
* this array is declared `static' to keep the compiler from having to
* bcopy() this array onto the stack frame of MD5Transform() each time it is
* called -- which is unacceptably expensive.
*
* the `const' is to ensure that callers are good citizens and do not try to
* munge the array. since these routines are going to be called from inside
* multithreaded kernelland, this is a good safety check. -- `constants' will
* end up in .rodata.
*
* unfortunately, loading from an array in this manner hurts performance under
* intel (and presumably other CISC machines). so, there is a macro,
* MD5_CONST(), used in MD5Transform(), that either expands to a reference to
* this array, or to the actual constant, depending on what platform this code
* is compiled for.
*/
#ifdef sun4v
/*
* Going to load these consts in 8B chunks, so need to enforce 8B alignment
*/
/* CSTYLED */
#endif /* sun4v */
static const uint32_t md5_consts[] = {
};
#ifdef sun4v
/*
* To reduce the number of loads, load consts in 64-bit
* chunks and then split.
*
* No need to mask upper 32-bits, as just interested in
* low 32-bits (saves an & operation and means that this
* optimization doesn't increases the icount.
*/
#else
#define MD5_CONST_e(x) (md5_consts[x])
#define MD5_CONST_o(x) (md5_consts[x])
#endif /* sun4v */
#endif
/*
* MD5Init()
*
* purpose: initializes the md5 context and begins and md5 digest operation
* input: MD5_CTX * : the context to initialize.
* output: void
*/
void
{
/* load magic initialization constants */
}
/*
* MD5Update()
*
* purpose: continues an md5 digest operation, using the message block
* to update the context.
* input: MD5_CTX * : the context to update
* uint8_t * : the message block
* uint32_t : the length of the message block in bytes
* output: void
*
* MD5 crunches in 64-byte blocks. All numeric constants here are related to
* that property of MD5.
*/
void
{
#ifdef sun4v
#endif /* sun4v */
/* compute (number of bytes computed so far) mod 64 */
/* update number of bits hashed into this MD5 computation so far */
/* transform as many times as possible */
i = 0;
/*
* general optimization:
*
* only do initial bcopy() and MD5Transform() if
* buf_index != 0. if buf_index == 0, we're just
* wasting our time doing the bcopy() since there
* wasn't any data left over from a previous call to
* MD5Update().
*/
#ifdef sun4v
/*
* For N1 use %asi register. However, costly to repeatedly set
* in MD5Transform. Therefore, set once here.
* Should probably restore the old value afterwards...
*/
old_asi = get_little();
set_little(0x88);
#endif /* sun4v */
if (buf_index) {
i = buf_len;
}
#ifdef sun4v
/*
* Restore old %ASI value
*/
#endif /* sun4v */
/*
* general optimization:
*
* if i and input_len are the same, return now instead
* of calling bcopy(), since the bcopy() in this
* case will be an expensive nop.
*/
if (input_len == i)
return;
buf_index = 0;
}
/* buffer remaining input */
}
/*
* MD5Final()
*
* purpose: ends an md5 digest operation, finalizing the message digest and
* zeroing the context.
* input: uint8_t * : a buffer to store the digest in
* MD5_CTX * : the context to finalize, save, and zero
* output: void
*/
void
{
/* store bit count, little endian */
/* pad out to 56 mod 64 */
/* append length (before padding) */
/* store state in digest */
/* zeroize sensitive information */
}
#ifndef _KERNEL
void
{
}
#endif /* !_KERNEL */
/*
* sparc register window optimization:
*
* `a', `b', `c', and `d' are passed into MD5Transform explicitly
* since it increases the number of registers available to the
* compiler. under this scheme, these variables can be held in
* %i0 - %i3, which leaves more local and out registers available.
*/
/*
* MD5Transform()
*
* purpose: md5 transformation -- updates the digest based on `block'
* input: uint32_t : bytes 1 - 4 of the digest
* uint32_t : bytes 5 - 8 of the digest
* uint32_t : bytes 9 - 12 of the digest
* uint32_t : bytes 12 - 16 of the digest
* MD5_CTX * : the context to update
* uint8_t [64]: the block to use to update the digest
* output: void
*/
static void
{
/*
* general optimization:
*
* use individual integers instead of using an array. this is a
* win, although the amount it wins by seems to vary quite a bit.
*/
#ifdef sun4v
unsigned long long *md5_consts64;
/* LINTED E_BAD_PTR_CAST_ALIGN */
md5_consts64 = (unsigned long long *) md5_consts;
#endif /* sun4v */
/*
* general optimization:
*
* the compiler (at least SC4.2/5.x) generates better code if
* variable use is localized. in this case, swapping the integers in
* this order allows `x_0 'to be swapped nearest to its first use in
* FF(), and likewise for `x_1' and up. note that the compiler
* prefers this to doing each swap right before the FF() that
* uses it.
*/
/*
*
* if `block' is already aligned on a 4-byte boundary, use the
* optimized load_little_32() directly. otherwise, bcopy()
* into a buffer that *is* aligned on a 4-byte boundary and
* then do the load_little_32() on that buffer. benchmarks
* have shown that using the bcopy() is better than loading
* the bytes individually and doing the endian-swap by hand.
*
* even though it's quite tempting to assign to do:
*
* blk = bcopy(blk, ctx->buf_un.buf32, sizeof (ctx->buf_un.buf32));
*
* and only have one set of LOAD_LITTLE_32()'s, the compiler (at least
* SC4.2/5.x) *does not* like that, so please resist the urge.
*/
#ifdef _MD5_CHECK_ALIGNMENT
#ifdef sun4v
#else
#endif /* sun4v */
} else
#endif
{
#ifdef sun4v
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
#else
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
/* LINTED E_BAD_PTR_CAST_ALIGN */
#endif /* sun4v */
}
/* round 1 */
/* round 2 */
/* round 3 */
/* round 4 */
/*
* zeroize sensitive information -- compiler will optimize
* this out if everything is kept in registers
*/
}
/*
* Encode()
*
* purpose: to convert a list of numbers from big endian to little endian
* input: uint8_t * : place to store the converted little endian numbers
* uint32_t * : place to get numbers to convert from
* size_t : the length of the input in bytes
* output: void
*/
static void
{
size_t i, j;
#ifdef _LITTLE_ENDIAN
#ifdef _MD5_CHECK_ALIGNMENT
#else
/*LINTED E_BAD_PTR_CAST_ALIGN*/
#endif /* _MD5_CHECK_ALIGNMENT */
#else /* big endian -- will work on little endian, but slowly */
#endif
}
}