+/* $OpenLDAP$ */
+/*
+ * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+ */
/*
* Modified by Kurt D. Zeilenga for inclusion into OpenLDAP
* I hereby disclaim copyright in any changes I have made; this
copyright in any changes I have made; this code remains in the
public domain. */
-#include <string.h>
+#include "portable.h"
+
+#include <ac/string.h>
+
+/* include socket.h to get sys/types.h and/or winsock2.h */
+#include <ac/socket.h>
-#include "lutil_md5.h"
+#include <lutil_md5.h>
/* Little-endian byte-swapping routines. Note that these do not
- depend on the size of datatypes such as uint32, nor do they require
+ depend on the size of datatypes such as ber_uint_t, nor do they require
us to detect the endianness of the machine we are running on. It
is possible they should be macros for speed, but I would be
surprised if they were a performance bottleneck for MD5. */
-static uint32
-getu32 (addr)
- const unsigned char *addr;
+static ber_uint_t
+getu32( const unsigned char *addr )
{
return (((((unsigned long)addr[3] << 8) | addr[2]) << 8)
| addr[1]) << 8 | addr[0];
}
static void
-putu32 (data, addr)
- uint32 data;
- unsigned char *addr;
+putu32( ber_uint_t data, unsigned char *addr )
{
addr[0] = (unsigned char)data;
addr[1] = (unsigned char)(data >> 8);
* initialization constants.
*/
void
-MD5Init(ctx)
- struct MD5Context *ctx;
+lutil_MD5Init( struct lutil_MD5Context *ctx )
{
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
* of bytes.
*/
void
-MD5Update(ctx, buf, len)
- struct MD5Context *ctx;
- unsigned char const *buf;
- unsigned len;
+lutil_MD5Update(
+ struct lutil_MD5Context *ctx,
+ const unsigned char *buf,
+ ber_len_t len
+)
{
- uint32 t;
+ ber_uint_t t;
/* Update bitcount */
t = ctx->bits[0];
- if ((ctx->bits[0] = (t + ((uint32)len << 3)) & 0xffffffff) < t)
+ if ((ctx->bits[0] = (t + ((ber_uint_t)len << 3)) & 0xffffffff) < t)
ctx->bits[1]++; /* Carry from low to high */
ctx->bits[1] += len >> 29;
t = 64-t;
if (len < t) {
- memcpy(p, buf, len);
+ AC_MEMCPY(p, buf, len);
return;
}
- memcpy(p, buf, t);
- MD5Transform(ctx->buf, ctx->in);
+ AC_MEMCPY(p, buf, t);
+ lutil_MD5Transform(ctx->buf, ctx->in);
buf += t;
len -= t;
}
/* Process data in 64-byte chunks */
while (len >= 64) {
- memcpy(ctx->in, buf, 64);
- MD5Transform(ctx->buf, ctx->in);
+ AC_MEMCPY(ctx->in, buf, 64);
+ lutil_MD5Transform(ctx->buf, ctx->in);
buf += 64;
len -= 64;
}
/* Handle any remaining bytes of data. */
- memcpy(ctx->in, buf, len);
+ AC_MEMCPY(ctx->in, buf, len);
}
/*
* 1 0* (64-bit count of bits processed, MSB-first)
*/
void
-MD5Final(digest, ctx)
- unsigned char digest[16];
- struct MD5Context *ctx;
+lutil_MD5Final( unsigned char *digest, struct lutil_MD5Context *ctx )
{
unsigned count;
unsigned char *p;
/* Pad out to 56 mod 64 */
if (count < 8) {
/* Two lots of padding: Pad the first block to 64 bytes */
- memset(p, 0, count);
- MD5Transform(ctx->buf, ctx->in);
+ memset(p, '\0', count);
+ lutil_MD5Transform(ctx->buf, ctx->in);
/* Now fill the next block with 56 bytes */
- memset(ctx->in, 0, 56);
+ memset(ctx->in, '\0', 56);
} else {
/* Pad block to 56 bytes */
- memset(p, 0, count-8);
+ memset(p, '\0', count-8);
}
/* Append length in bits and transform */
putu32(ctx->bits[0], ctx->in + 56);
putu32(ctx->bits[1], ctx->in + 60);
- MD5Transform(ctx->buf, ctx->in);
+ lutil_MD5Transform(ctx->buf, ctx->in);
putu32(ctx->buf[0], digest);
putu32(ctx->buf[1], digest + 4);
putu32(ctx->buf[2], digest + 8);
putu32(ctx->buf[3], digest + 12);
- memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */
+ memset(ctx, '\0', sizeof(ctx)); /* In case it's sensitive */
}
#ifndef ASM_MD5
* the data and converts bytes into longwords for this routine.
*/
void
-MD5Transform(buf, inraw)
- uint32 buf[4];
- const unsigned char inraw[64];
+lutil_MD5Transform( ber_uint_t *buf, const unsigned char *inraw )
{
- register uint32 a, b, c, d;
- uint32 in[16];
+ register ber_uint_t a, b, c, d;
+ ber_uint_t in[16];
int i;
for (i = 0; i < 16; ++i)
#include <stdio.h>
int
-main (int argc, char **argv)
+main (int argc, char **argv )
{
- struct MD5Context context;
- unsigned char checksum[16];
+ struct lutil_MD5Context context;
+ unsigned char checksum[LUTIL_MD5_BYTES];
int i;
int j;
if (argc < 2)
{
fprintf (stderr, "usage: %s string-to-hash\n", argv[0]);
- exit (1);
+ return EXIT_FAILURE;
}
for (j = 1; j < argc; ++j)
{
printf ("MD5 (\"%s\") = ", argv[j]);
- MD5Init (&context);
- MD5Update (&context, argv[j], strlen (argv[j]));
- MD5Final (checksum, &context);
- for (i = 0; i < 16; i++)
+ lutil_MD5Init (&context);
+ lutil_MD5Update (&context, argv[j], strlen (argv[j]));
+ lutil_MD5Final (checksum, &context);
+ for (i = 0; i < LUTIL_MD5_BYTES; i++)
{
printf ("%02x", (unsigned int) checksum[i]);
}
printf ("\n");
}
- return 0;
+ return EXIT_SUCCESS;
}
#endif /* TEST */
projects / openldap / blobdiff