mirror of
https://git.openldap.org/openldap/openldap.git
synced 2025-12-24 16:49:39 -05:00
Fixed md5/sha files.
This commit is contained in:
Kurt Zeilenga
parent
4662b7d124
commit
14df2c8ba2
11 changed files with 1176 additions and 265 deletions
7
aclocal.m4
vendored
7
aclocal.m4
vendored
|
|
@ -231,6 +231,10 @@ dnl AC_CHECK_FUNC(dbm_open)
|
|||
dnl AC_CHECK_LIB(ndbm,dbm_open)
|
||||
dnl AC_CHECK_LIB(dbm,dbm_open)
|
||||
dnl
|
||||
dnl restrictions:
|
||||
dnl should also check SVR4 case: dbm_open() in -lucb but that
|
||||
dnl would requiring dealing with -L/usr/ucblib
|
||||
dnl
|
||||
AC_DEFUN([OL_LIB_NDBM],
|
||||
[AC_CACHE_CHECK(for NDBM library, [ol_cv_lib_ndbm],
|
||||
[ ol_LIBS="$LIBS"
|
||||
|
|
@ -253,6 +257,9 @@ dnl uses:
|
|||
dnl OL_LIB_NDBM
|
||||
dnl AC_CHECK_HEADERS(ndbm.h)
|
||||
dnl
|
||||
dnl restrictions:
|
||||
dnl Doesn't handle SVR4 case (see above)
|
||||
dnl
|
||||
AC_DEFUN([OL_NDBM],
|
||||
[AC_REQUIRE([OL_LIB_NDBM])
|
||||
AC_CHECK_HEADERS(ndbm.h)
|
||||
|
|
|
|||
20
configure.in
20
configure.in
|
|
@ -210,12 +210,26 @@ AC_PATH_PROG(FINGER, finger, /usr/ucb/finger, $PATH:/usr/ucb)
|
|||
dnl ----------------------------------------------------------------
|
||||
dnl Checks for libraries
|
||||
|
||||
AC_CHECK_FUNC(socket, :,
|
||||
[ AC_CHECK_LIB(nsl, gethostname)
|
||||
AC_CHECK_LIB(socket, socket)
|
||||
dnl Find socket()
|
||||
dnl Likely combinations:
|
||||
dnl -lsocket [ -lnsl_s | -lnsl ]
|
||||
dnl -linet
|
||||
|
||||
AC_CHECK_FUNC(socket, :, [
|
||||
dnl
|
||||
dnl hopefully we won't include too many libraries
|
||||
dnl
|
||||
AC_CHECK_LIB(socket, main)
|
||||
AC_CHECK_LIB(net, main)
|
||||
AC_CHECK_LIB(nsl_s, main)
|
||||
AC_CHECK_LIB(nsl, main)
|
||||
AC_CHECK_LIB(inet, socket)
|
||||
AC_CHECK_LIB(gen, main)
|
||||
])
|
||||
|
||||
dnl HP-UX requires -lV3
|
||||
AC_CHECK_LIB(V3, sigset)
|
||||
|
||||
if test $ol_with_kerberos = auto -o $ol_with_kerberos = k5 ; then
|
||||
AC_CHECK_HEADERS(kerberosIV/krb.h kerberosIV/des.h)
|
||||
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@
|
|||
|
||||
/* This file SHOULD go away !!! */
|
||||
|
||||
#ifndef _LDAP_BRIDGE_H
|
||||
#define _LDAP_BRIDGE_H
|
||||
#ifndef LDAP_BRIDGE
|
||||
#define LDAP_BRIDGE
|
||||
|
||||
/*
|
||||
* portable.h for LDAP -- this is where we define common stuff to make
|
||||
|
|
@ -204,4 +204,4 @@
|
|||
extern char *strdup();
|
||||
#endif /* ultrix || nextstep */
|
||||
|
||||
#endif /* _LDAP_BRIDGE_H */
|
||||
#endif /* LDAP_BRIDGE */
|
||||
|
|
|
|||
18
include/lutil.h
Normal file
18
include/lutil.h
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
#ifndef _LUTIL_H
|
||||
#define _LUTIL_H 1
|
||||
|
||||
#include <ldap_cdefs.h>
|
||||
/*
|
||||
* Include file for LDAP utility routine
|
||||
*/
|
||||
|
||||
/* ISC Base64 Routines */
|
||||
|
||||
LDAP_BEGIN_DECL
|
||||
|
||||
LDAP_F int b64_ntop LDAP_P((u_char const *, size_t, char *, size_t));
|
||||
LDAP_F int b64_pton LDAP_P((char const *, u_char *, size_t));
|
||||
|
||||
LDAP_END_DECL
|
||||
|
||||
#endif /* _LUTIL_H */
|
||||
50
include/lutil_md5.h
Normal file
50
include/lutil_md5.h
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
/* See md5.c for explanation and copyright information. */
|
||||
|
||||
#ifndef _LDAP_MD5_H_
|
||||
#define _LDAP_MD5_H_
|
||||
|
||||
#include <ldap_cdefs.h>
|
||||
|
||||
LDAP_BEGIN_DECL
|
||||
|
||||
/* Unlike previous versions of this code, uint32 need not be exactly
|
||||
32 bits, merely 32 bits or more. Choosing a data type which is 32
|
||||
bits instead of 64 is not important; speed is considerably more
|
||||
important. ANSI guarantees that "unsigned long" will be big enough,
|
||||
and always using it seems to have few disadvantages. */
|
||||
|
||||
#ifndef LDAP_UINT32
|
||||
#define LDAP_UINT32
|
||||
typedef unsigned long uint32;
|
||||
#endif
|
||||
|
||||
struct ldap_MD5Context {
|
||||
uint32 buf[4];
|
||||
uint32 bits[2];
|
||||
unsigned char in[64];
|
||||
};
|
||||
|
||||
LDAP_F void ldap_MD5Init LDAP_P((
|
||||
struct ldap_MD5Context *context));
|
||||
|
||||
LDAP_F void ldap_MD5Update LDAP_P((
|
||||
struct ldap_MD5Context *context,
|
||||
unsigned char const *buf,
|
||||
unsigned len));
|
||||
|
||||
LDAP_F void ldap_MD5Final LDAP_P((
|
||||
unsigned char digest[16],
|
||||
struct ldap_MD5Context *context));
|
||||
|
||||
LDAP_F void ldap_MD5Transform LDAP_P((
|
||||
uint32 buf[4],
|
||||
const unsigned char in[64]));
|
||||
|
||||
/*
|
||||
* This is needed to make RSAREF happy on some MS-DOS compilers.
|
||||
*/
|
||||
typedef struct ldap_MD5Context ldap_MD5_CTX;
|
||||
|
||||
LDAP_END_DECL
|
||||
|
||||
#endif /* _LDAP_MD5_H_ */
|
||||
52
include/lutil_sha1.h
Normal file
52
include/lutil_sha1.h
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
/* This version is based on:
|
||||
* $OpenBSD: sha1.h,v 1.8 1997/07/15 01:54:23 millert Exp $ */
|
||||
|
||||
#ifndef _LDAP_SHA1_H_
|
||||
#define _LDAP_SHA1_H_
|
||||
|
||||
#include <ldap_cdefs.h>
|
||||
|
||||
LDAP_BEGIN_DECL
|
||||
|
||||
/*
|
||||
* SHA-1 in C
|
||||
* By Steve Reid <steve@edmweb.com>
|
||||
* 100% Public Domain
|
||||
*/
|
||||
|
||||
/* XXX I wonder if this will work on 64bit architectures... */
|
||||
#ifndef LDAP_UINT32
|
||||
#define LDAP_UINT32
|
||||
typedef unsigned long uint32;
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
uint32 state[5];
|
||||
uint32 count[2];
|
||||
unsigned char buffer[64];
|
||||
} ldap_SHA1_CTX;
|
||||
|
||||
LDAP_F void ldap_SHA1Transform
|
||||
LDAP_P((uint32 state[5], const unsigned char buffer[64]));
|
||||
|
||||
LDAP_F void ldap_SHA1Init
|
||||
LDAP_P((ldap_SHA1_CTX *context));
|
||||
|
||||
LDAP_F void ldap_SHA1Update
|
||||
LDAP_P((ldap_SHA1_CTX *context, const unsigned char *data, u_int len));
|
||||
|
||||
LDAP_F void ldap_SHA1Final
|
||||
LDAP_P((unsigned char digest[20], ldap_SHA1_CTX *context));
|
||||
|
||||
LDAP_F char *ldap_SHA1End
|
||||
LDAP_P((ldap_SHA1_CTX *, char *));
|
||||
|
||||
LDAP_F char *ldap_SHA1File
|
||||
LDAP_P((char *, char *));
|
||||
|
||||
LDAP_F char *ldap_SHA1Data
|
||||
LDAP_P((const unsigned char *, size_t, char *));
|
||||
|
||||
LDAP_END_DECL
|
||||
|
||||
#endif _LDAP_SHA1_H_
|
||||
|
|
@ -238,12 +238,24 @@
|
|||
/* Define if you have the <unistd.h> header file. */
|
||||
#undef HAVE_UNISTD_H
|
||||
|
||||
/* Define if you have the V3 library (-lV3). */
|
||||
#undef HAVE_LIBV3
|
||||
|
||||
/* Define if you have the gen library (-lgen). */
|
||||
#undef HAVE_LIBGEN
|
||||
|
||||
/* Define if you have the inet library (-linet). */
|
||||
#undef HAVE_LIBINET
|
||||
|
||||
/* Define if you have the net library (-lnet). */
|
||||
#undef HAVE_LIBNET
|
||||
|
||||
/* Define if you have the nsl library (-lnsl). */
|
||||
#undef HAVE_LIBNSL
|
||||
|
||||
/* Define if you have the nsl_s library (-lnsl_s). */
|
||||
#undef HAVE_LIBNSL_S
|
||||
|
||||
/* Define if you have the socket library (-lsocket). */
|
||||
#undef HAVE_LIBSOCKET
|
||||
|
||||
|
|
|
|||
322
libraries/liblutil/md5.c
Normal file
322
libraries/liblutil/md5.c
Normal file
|
|
@ -0,0 +1,322 @@
|
|||
/*
|
||||
* Modified by Kurt D. Zeilenga for inclusion into OpenLDAP
|
||||
* I hereby disclaim copyright in any changes I have made; this
|
||||
* code remains in the public domain.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This code implements the MD5 message-digest algorithm.
|
||||
* The algorithm is due to Ron Rivest. This code was
|
||||
* written by Colin Plumb in 1993, no copyright is claimed.
|
||||
* This code is in the public domain; do with it what you wish.
|
||||
*
|
||||
* Equivalent code is available from RSA Data Security, Inc.
|
||||
* This code has been tested against that, and is equivalent,
|
||||
* except that you don't need to include two pages of legalese
|
||||
* with every copy.
|
||||
*
|
||||
* To compute the message digest of a chunk of bytes, declare an
|
||||
* MD5Context structure, pass it to MD5Init, call MD5Update as
|
||||
* needed on buffers full of bytes, and then call MD5Final, which
|
||||
* will fill a supplied 16-byte array with the digest.
|
||||
*/
|
||||
|
||||
/* This code was modified in 1997 by Jim Kingdon of Cyclic Software to
|
||||
not require an integer type which is exactly 32 bits. This work
|
||||
draws on the changes for the same purpose by Tatu Ylonen
|
||||
<ylo@cs.hut.fi> as part of SSH, but since I didn't actually use
|
||||
that code, there is no copyright issue. I hereby disclaim
|
||||
copyright in any changes I have made; this code remains in the
|
||||
public domain. */
|
||||
|
||||
#include "portable.h"
|
||||
|
||||
#include <ac/string.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
|
||||
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;
|
||||
{
|
||||
return (((((unsigned long)addr[3] << 8) | addr[2]) << 8)
|
||||
| addr[1]) << 8 | addr[0];
|
||||
}
|
||||
|
||||
static void
|
||||
putu32 (data, addr)
|
||||
uint32 data;
|
||||
unsigned char *addr;
|
||||
{
|
||||
addr[0] = (unsigned char)data;
|
||||
addr[1] = (unsigned char)(data >> 8);
|
||||
addr[2] = (unsigned char)(data >> 16);
|
||||
addr[3] = (unsigned char)(data >> 24);
|
||||
}
|
||||
|
||||
/*
|
||||
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
|
||||
* initialization constants.
|
||||
*/
|
||||
void
|
||||
ldap_MD5Init(ctx)
|
||||
struct ldap_MD5Context *ctx;
|
||||
{
|
||||
ctx->buf[0] = 0x67452301;
|
||||
ctx->buf[1] = 0xefcdab89;
|
||||
ctx->buf[2] = 0x98badcfe;
|
||||
ctx->buf[3] = 0x10325476;
|
||||
|
||||
ctx->bits[0] = 0;
|
||||
ctx->bits[1] = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Update context to reflect the concatenation of another buffer full
|
||||
* of bytes.
|
||||
*/
|
||||
void
|
||||
ldap_MD5Update(ctx, buf, len)
|
||||
struct ldap_MD5Context *ctx;
|
||||
unsigned char const *buf;
|
||||
unsigned len;
|
||||
{
|
||||
uint32 t;
|
||||
|
||||
/* Update bitcount */
|
||||
|
||||
t = ctx->bits[0];
|
||||
if ((ctx->bits[0] = (t + ((uint32)len << 3)) & 0xffffffff) < t)
|
||||
ctx->bits[1]++; /* Carry from low to high */
|
||||
ctx->bits[1] += len >> 29;
|
||||
|
||||
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
|
||||
|
||||
/* Handle any leading odd-sized chunks */
|
||||
|
||||
if ( t ) {
|
||||
unsigned char *p = ctx->in + t;
|
||||
|
||||
t = 64-t;
|
||||
if (len < t) {
|
||||
memcpy(p, buf, len);
|
||||
return;
|
||||
}
|
||||
memcpy(p, buf, t);
|
||||
ldap_MD5Transform(ctx->buf, ctx->in);
|
||||
buf += t;
|
||||
len -= t;
|
||||
}
|
||||
|
||||
/* Process data in 64-byte chunks */
|
||||
|
||||
while (len >= 64) {
|
||||
memcpy(ctx->in, buf, 64);
|
||||
ldap_MD5Transform(ctx->buf, ctx->in);
|
||||
buf += 64;
|
||||
len -= 64;
|
||||
}
|
||||
|
||||
/* Handle any remaining bytes of data. */
|
||||
|
||||
memcpy(ctx->in, buf, len);
|
||||
}
|
||||
|
||||
/*
|
||||
* Final wrapup - pad to 64-byte boundary with the bit pattern
|
||||
* 1 0* (64-bit count of bits processed, MSB-first)
|
||||
*/
|
||||
void
|
||||
ldap_MD5Final(digest, ctx)
|
||||
unsigned char digest[16];
|
||||
struct ldap_MD5Context *ctx;
|
||||
{
|
||||
unsigned count;
|
||||
unsigned char *p;
|
||||
|
||||
/* Compute number of bytes mod 64 */
|
||||
count = (ctx->bits[0] >> 3) & 0x3F;
|
||||
|
||||
/* Set the first char of padding to 0x80. This is safe since there is
|
||||
always at least one byte free */
|
||||
p = ctx->in + count;
|
||||
*p++ = 0x80;
|
||||
|
||||
/* Bytes of padding needed to make 64 bytes */
|
||||
count = 64 - 1 - count;
|
||||
|
||||
/* Pad out to 56 mod 64 */
|
||||
if (count < 8) {
|
||||
/* Two lots of padding: Pad the first block to 64 bytes */
|
||||
memset(p, 0, count);
|
||||
ldap_MD5Transform(ctx->buf, ctx->in);
|
||||
|
||||
/* Now fill the next block with 56 bytes */
|
||||
memset(ctx->in, 0, 56);
|
||||
} else {
|
||||
/* Pad block to 56 bytes */
|
||||
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);
|
||||
|
||||
ldap_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 */
|
||||
}
|
||||
|
||||
#ifndef ASM_MD5
|
||||
|
||||
/* The four core functions - F1 is optimized somewhat */
|
||||
|
||||
/* #define F1(x, y, z) (x & y | ~x & z) */
|
||||
#define F1(x, y, z) (z ^ (x & (y ^ z)))
|
||||
#define F2(x, y, z) F1(z, x, y)
|
||||
#define F3(x, y, z) (x ^ y ^ z)
|
||||
#define F4(x, y, z) (y ^ (x | ~z))
|
||||
|
||||
/* This is the central step in the MD5 algorithm. */
|
||||
#define MD5STEP(f, w, x, y, z, data, s) \
|
||||
( w += f(x, y, z) + data, w &= 0xffffffff, w = w<<s | w>>(32-s), w += x )
|
||||
|
||||
/*
|
||||
* The core of the MD5 algorithm, this alters an existing MD5 hash to
|
||||
* reflect the addition of 16 longwords of new data. MD5Update blocks
|
||||
* the data and converts bytes into longwords for this routine.
|
||||
*/
|
||||
void
|
||||
ldap_MD5Transform(buf, inraw)
|
||||
uint32 buf[4];
|
||||
const unsigned char inraw[64];
|
||||
{
|
||||
register uint32 a, b, c, d;
|
||||
uint32 in[16];
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 16; ++i)
|
||||
in[i] = getu32 (inraw + 4 * i);
|
||||
|
||||
a = buf[0];
|
||||
b = buf[1];
|
||||
c = buf[2];
|
||||
d = buf[3];
|
||||
|
||||
MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
|
||||
|
||||
MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
|
||||
|
||||
MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
|
||||
|
||||
MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
|
||||
|
||||
buf[0] += a;
|
||||
buf[1] += b;
|
||||
buf[2] += c;
|
||||
buf[3] += d;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef TEST
|
||||
/* Simple test program. Can use it to manually run the tests from
|
||||
RFC1321 for example. */
|
||||
#include <stdio.h>
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
struct ldap_MD5Context context;
|
||||
unsigned char checksum[16];
|
||||
int i;
|
||||
int j;
|
||||
|
||||
if (argc < 2)
|
||||
{
|
||||
fprintf (stderr, "usage: %s string-to-hash\n", argv[0]);
|
||||
exit (1);
|
||||
}
|
||||
for (j = 1; j < argc; ++j)
|
||||
{
|
||||
printf ("MD5 (\"%s\") = ", argv[j]);
|
||||
ldap_MD5Init (&context);
|
||||
ldap_MD5Update (&context, argv[j], strlen (argv[j]));
|
||||
ldap_MD5Final (checksum, &context);
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
printf ("%02x", (unsigned int) checksum[i]);
|
||||
}
|
||||
printf ("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif /* TEST */
|
||||
265
libraries/liblutil/sha1.c
Normal file
265
libraries/liblutil/sha1.c
Normal file
|
|
@ -0,0 +1,265 @@
|
|||
/* Acquired from:
|
||||
* $OpenBSD: sha1.c,v 1.9 1997/07/23 21:12:32 kstailey Exp $ */
|
||||
|
||||
/*
|
||||
* SHA-1 in C
|
||||
* By Steve Reid <steve@edmweb.com>
|
||||
* 100% Public Domain
|
||||
*
|
||||
* Test Vectors (from FIPS PUB 180-1)
|
||||
* "abc"
|
||||
* A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
|
||||
* "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
|
||||
* 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
|
||||
* A million repetitions of "a"
|
||||
* 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
|
||||
*/
|
||||
|
||||
#define SHA1HANDSOFF /* Copies data before messing with it. */
|
||||
|
||||
#define LDAP_BRIDGE
|
||||
#include "portable.h"
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <ac/string.h>
|
||||
|
||||
#include "lutil_sha1.h"
|
||||
|
||||
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
|
||||
|
||||
/*
|
||||
* blk0() and blk() perform the initial expand.
|
||||
* I got the idea of expanding during the round function from SSLeay
|
||||
*/
|
||||
#if BYTE_ORDER == LITTLE_ENDIAN
|
||||
# define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
|
||||
|(rol(block->l[i],8)&0x00FF00FF))
|
||||
#else
|
||||
# define blk0(i) block->l[i]
|
||||
#endif
|
||||
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
|
||||
^block->l[(i+2)&15]^block->l[i&15],1))
|
||||
|
||||
/*
|
||||
* (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1
|
||||
*/
|
||||
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
|
||||
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
|
||||
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
|
||||
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
|
||||
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
|
||||
|
||||
|
||||
/*
|
||||
* Hash a single 512-bit block. This is the core of the algorithm.
|
||||
*/
|
||||
void ldap_SHA1Transform(state, buffer)
|
||||
uint32 state[5];
|
||||
const unsigned char buffer[64];
|
||||
{
|
||||
uint32 a, b, c, d, e;
|
||||
typedef union {
|
||||
unsigned char c[64];
|
||||
u_int l[16];
|
||||
} CHAR64LONG16;
|
||||
CHAR64LONG16 *block;
|
||||
|
||||
#ifdef SHA1HANDSOFF
|
||||
static unsigned char workspace[64];
|
||||
block = (CHAR64LONG16 *)workspace;
|
||||
(void)memcpy(block, buffer, 64);
|
||||
#else
|
||||
block = (CHAR64LONG16 *)buffer;
|
||||
#endif
|
||||
|
||||
/* Copy context->state[] to working vars */
|
||||
a = state[0];
|
||||
b = state[1];
|
||||
c = state[2];
|
||||
d = state[3];
|
||||
e = state[4];
|
||||
|
||||
/* 4 rounds of 20 operations each. Loop unrolled. */
|
||||
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
|
||||
R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
|
||||
R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
|
||||
R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
|
||||
R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
|
||||
R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
|
||||
R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
|
||||
R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
|
||||
R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
|
||||
R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
|
||||
R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
|
||||
R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
|
||||
R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
|
||||
R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
|
||||
R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
|
||||
R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
|
||||
R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
|
||||
R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
|
||||
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
|
||||
R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
|
||||
|
||||
/* Add the working vars back into context.state[] */
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
state[4] += e;
|
||||
|
||||
/* Wipe variables */
|
||||
a = b = c = d = e = 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* ldap_SHA1Init - Initialize new context
|
||||
*/
|
||||
void ldap_SHA1Init(context)
|
||||
ldap_SHA1_CTX *context;
|
||||
{
|
||||
|
||||
/* SHA1 initialization constants */
|
||||
context->state[0] = 0x67452301;
|
||||
context->state[1] = 0xEFCDAB89;
|
||||
context->state[2] = 0x98BADCFE;
|
||||
context->state[3] = 0x10325476;
|
||||
context->state[4] = 0xC3D2E1F0;
|
||||
context->count[0] = context->count[1] = 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Run your data through this.
|
||||
*/
|
||||
void ldap_SHA1Update(context, data, len)
|
||||
ldap_SHA1_CTX *context;
|
||||
const unsigned char *data;
|
||||
u_int len;
|
||||
{
|
||||
u_int i, j;
|
||||
|
||||
j = context->count[0];
|
||||
if ((context->count[0] += len << 3) < j)
|
||||
context->count[1] += (len>>29)+1;
|
||||
j = (j >> 3) & 63;
|
||||
if ((j + len) > 63) {
|
||||
(void)memcpy(&context->buffer[j], data, (i = 64-j));
|
||||
ldap_SHA1Transform(context->state, context->buffer);
|
||||
for ( ; i + 63 < len; i += 64)
|
||||
ldap_SHA1Transform(context->state, &data[i]);
|
||||
j = 0;
|
||||
} else {
|
||||
i = 0;
|
||||
}
|
||||
(void)memcpy(&context->buffer[j], &data[i], len - i);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Add padding and return the message digest.
|
||||
*/
|
||||
void ldap_SHA1Final(digest, context)
|
||||
unsigned char digest[20];
|
||||
ldap_SHA1_CTX* context;
|
||||
{
|
||||
u_int i;
|
||||
unsigned char finalcount[8];
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
|
||||
>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
|
||||
}
|
||||
ldap_SHA1Update(context, (unsigned char *)"\200", 1);
|
||||
while ((context->count[0] & 504) != 448)
|
||||
ldap_SHA1Update(context, (unsigned char *)"\0", 1);
|
||||
ldap_SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
|
||||
|
||||
if (digest) {
|
||||
for (i = 0; i < 20; i++)
|
||||
digest[i] = (unsigned char)
|
||||
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* sha1hl.c
|
||||
* ----------------------------------------------------------------------------
|
||||
* "THE BEER-WARE LICENSE" (Revision 42):
|
||||
* <phk@login.dkuug.dk> wrote this file. As long as you retain this notice you
|
||||
* can do whatever you want with this stuff. If we meet some day, and you think
|
||||
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
|
||||
* ----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#if defined(LIBC_SCCS) && !defined(lint)
|
||||
static char rcsid[] = "$OpenBSD: sha1hl.c,v 1.1 1997/07/12 20:06:03 millert Exp $";
|
||||
#endif /* LIBC_SCCS and not lint */
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <sys/file.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/uio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
/* ARGSUSED */
|
||||
char *
|
||||
ldap_SHA1End(ctx, buf)
|
||||
ldap_SHA1_CTX *ctx;
|
||||
char *buf;
|
||||
{
|
||||
int i;
|
||||
char *p = buf;
|
||||
unsigned char digest[20];
|
||||
static const char hex[]="0123456789abcdef";
|
||||
|
||||
if (p == NULL && (p = malloc(41)) == NULL)
|
||||
return 0;
|
||||
|
||||
ldap_SHA1Final(digest,ctx);
|
||||
for (i = 0; i < 20; i++) {
|
||||
p[i + i] = hex[digest[i] >> 4];
|
||||
p[i + i + 1] = hex[digest[i] & 0x0f];
|
||||
}
|
||||
p[i + i] = '\0';
|
||||
return(p);
|
||||
}
|
||||
|
||||
char *
|
||||
ldap_SHA1File (filename, buf)
|
||||
char *filename;
|
||||
char *buf;
|
||||
{
|
||||
unsigned char buffer[BUFSIZ];
|
||||
ldap_SHA1_CTX ctx;
|
||||
int fd, num, oerrno;
|
||||
|
||||
ldap_SHA1Init(&ctx);
|
||||
|
||||
if ((fd = open(filename,O_RDONLY)) < 0)
|
||||
return(0);
|
||||
|
||||
while ((num = read(fd, buffer, sizeof(buffer))) > 0)
|
||||
ldap_SHA1Update(&ctx, buffer, num);
|
||||
|
||||
oerrno = errno;
|
||||
close(fd);
|
||||
errno = oerrno;
|
||||
return(num < 0 ? 0 : ldap_SHA1End(&ctx, buf));
|
||||
}
|
||||
|
||||
char *
|
||||
ldap_SHA1Data (data, len, buf)
|
||||
const unsigned char *data;
|
||||
size_t len;
|
||||
char *buf;
|
||||
{
|
||||
ldap_SHA1_CTX ctx;
|
||||
|
||||
ldap_SHA1Init(&ctx);
|
||||
ldap_SHA1Update(&ctx, data, len);
|
||||
return(ldap_SHA1End(&ctx, buf));
|
||||
}
|
||||
|
|
@ -66,7 +66,7 @@ crypted_value_find(
|
|||
#ifdef LDAP_MD5
|
||||
} else if ( syntax != SYNTAX_BIN && strncasecmp( "{MD5}",
|
||||
vals[i]->bv_val, (sizeof("{MD5}") - 1 ) ) == 0 ) {
|
||||
MD5_CTX MD5context;
|
||||
ldap_MD5_CTX MD5context;
|
||||
unsigned char MD5digest[20];
|
||||
char base64digest[29]; /* ceiling(sizeof(input)/3) * 4 + 1 */
|
||||
|
||||
|
|
@ -89,7 +89,7 @@ crypted_value_find(
|
|||
#ifdef LDAP_SHA1
|
||||
} else if ( syntax != SYNTAX_BIN && strncasecmp( "{SHA}",
|
||||
vals[i]->bv_val, (sizeof("{SHA}") - 1 ) ) == 0 ) {
|
||||
SHA1_CTX SHA1context;
|
||||
ldap_SHA1_CTX SHA1context;
|
||||
unsigned char SHA1digest[20];
|
||||
char base64digest[29]; /* ceiling(sizeof(input)/3) * 4 + 1 */
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue