#include "apr_strings.h"
#include "apr_md5.h"
#include "apr_lib.h"
#include "apu_config.h"
#include "apr_sha1.h"
#if APR_HAVE_STRING_H
#include <string.h>
#endif
#if APR_HAVE_CRYPT_H
#include <crypt.h>
#endif
#if APR_HAVE_UNISTD_H
#include <unistd.h>
#endif
#if APR_HAVE_PTHREAD_H
#include <pthread.h>
#endif
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static void MD5Transform(apr_uint32_t state[4], const unsigned char block[64]);
static void Encode(unsigned char *output, const apr_uint32_t *input,
unsigned int len);
static void Decode(apr_uint32_t *output, const unsigned char *input,
unsigned int len);
static const unsigned char PADDING[64] =
{
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
#if APR_CHARSET_EBCDIC
static apr_xlate_t *xlate_ebcdic_to_ascii;
#endif
#define DO_XLATE 0
#define SKIP_XLATE 1
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
APU_DECLARE(apr_status_t) apr_md5_init(apr_md5_ctx_t *context)
{
context->count[0] = context->count[1] = 0;
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
context->xlate = NULL;
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_md5_set_xlate(apr_md5_ctx_t *context,
apr_xlate_t *xlate)
{
#if APR_HAS_XLATE
apr_status_t rv;
int is_sb;
rv = apr_xlate_sb_get(xlate, &is_sb);
if (rv != APR_SUCCESS) {
return rv;
}
if (!is_sb) {
return APR_EINVAL;
}
context->xlate = xlate;
return APR_SUCCESS;
#else
return APR_ENOTIMPL;
#endif
}
static apr_status_t md5_update_buffer(apr_md5_ctx_t *context,
const void *vinput,
apr_size_t inputLen,
int xlate_buffer)
{
const unsigned char *input = vinput;
unsigned int i, idx, partLen;
#if APR_HAS_XLATE
apr_size_t inbytes_left, outbytes_left;
#endif
idx = (unsigned int)((context->count[0] >> 3) & 0x3F);
if ((context->count[0] += ((apr_uint32_t)inputLen << 3))
< ((apr_uint32_t)inputLen << 3))
context->count[1]++;
context->count[1] += (apr_uint32_t)inputLen >> 29;
partLen = 64 - idx;
#if !APR_HAS_XLATE
if (inputLen >= partLen) {
memcpy(&context->buffer[idx], input, partLen);
MD5Transform(context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform(context->state, &input[i]);
idx = 0;
}
else
i = 0;
memcpy(&context->buffer[idx], &input[i], inputLen - i);
#else
if (inputLen >= partLen) {
if (context->xlate && (xlate_buffer == DO_XLATE)) {
inbytes_left = outbytes_left = partLen;
apr_xlate_conv_buffer(context->xlate, (const char *)input,
&inbytes_left,
(char *)&context->buffer[idx],
&outbytes_left);
}
else {
memcpy(&context->buffer[idx], input, partLen);
}
MD5Transform(context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64) {
if (context->xlate && (xlate_buffer == DO_XLATE)) {
unsigned char inp_tmp[64];
inbytes_left = outbytes_left = 64;
apr_xlate_conv_buffer(context->xlate, (const char *)&input[i],
&inbytes_left, (char *)inp_tmp,
&outbytes_left);
MD5Transform(context->state, inp_tmp);
}
else {
MD5Transform(context->state, &input[i]);
}
}
idx = 0;
}
else
i = 0;
if (context->xlate && (xlate_buffer == DO_XLATE)) {
inbytes_left = outbytes_left = inputLen - i;
apr_xlate_conv_buffer(context->xlate, (const char *)&input[i],
&inbytes_left, (char *)&context->buffer[idx],
&outbytes_left);
}
else {
memcpy(&context->buffer[idx], &input[i], inputLen - i);
}
#endif
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_md5_update(apr_md5_ctx_t *context,
const void *input,
apr_size_t inputLen)
{
return md5_update_buffer(context, input, inputLen, DO_XLATE);
}
APU_DECLARE(apr_status_t) apr_md5_final(unsigned char digest[APR_MD5_DIGESTSIZE],
apr_md5_ctx_t *context)
{
unsigned char bits[8];
unsigned int idx, padLen;
Encode(bits, context->count, 8);
#if APR_HAS_XLATE
context->xlate = NULL;
#endif
idx = (unsigned int)((context->count[0] >> 3) & 0x3f);
padLen = (idx < 56) ? (56 - idx) : (120 - idx);
apr_md5_update(context, PADDING, padLen);
apr_md5_update(context, bits, 8);
Encode(digest, context->state, APR_MD5_DIGESTSIZE);
memset(context, 0, sizeof(*context));
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_md5(unsigned char digest[APR_MD5_DIGESTSIZE],
const void *_input,
apr_size_t inputLen)
{
const unsigned char *input = _input;
apr_md5_ctx_t ctx;
apr_status_t rv;
apr_md5_init(&ctx);
if ((rv = apr_md5_update(&ctx, input, inputLen)) != APR_SUCCESS)
return rv;
return apr_md5_final(digest, &ctx);
}
static void MD5Transform(apr_uint32_t state[4], const unsigned char block[64])
{
apr_uint32_t a = state[0], b = state[1], c = state[2], d = state[3],
x[APR_MD5_DIGESTSIZE];
Decode(x, block, 64);
FF(a, b, c, d, x[0], S11, 0xd76aa478);
FF(d, a, b, c, x[1], S12, 0xe8c7b756);
FF(c, d, a, b, x[2], S13, 0x242070db);
FF(b, c, d, a, x[3], S14, 0xc1bdceee);
FF(a, b, c, d, x[4], S11, 0xf57c0faf);
FF(d, a, b, c, x[5], S12, 0x4787c62a);
FF(c, d, a, b, x[6], S13, 0xa8304613);
FF(b, c, d, a, x[7], S14, 0xfd469501);
FF(a, b, c, d, x[8], S11, 0x698098d8);
FF(d, a, b, c, x[9], S12, 0x8b44f7af);
FF(c, d, a, b, x[10], S13, 0xffff5bb1);
FF(b, c, d, a, x[11], S14, 0x895cd7be);
FF(a, b, c, d, x[12], S11, 0x6b901122);
FF(d, a, b, c, x[13], S12, 0xfd987193);
FF(c, d, a, b, x[14], S13, 0xa679438e);
FF(b, c, d, a, x[15], S14, 0x49b40821);
GG(a, b, c, d, x[1], S21, 0xf61e2562);
GG(d, a, b, c, x[6], S22, 0xc040b340);
GG(c, d, a, b, x[11], S23, 0x265e5a51);
GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);
GG(a, b, c, d, x[5], S21, 0xd62f105d);
GG(d, a, b, c, x[10], S22, 0x2441453);
GG(c, d, a, b, x[15], S23, 0xd8a1e681);
GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);
GG(a, b, c, d, x[9], S21, 0x21e1cde6);
GG(d, a, b, c, x[14], S22, 0xc33707d6);
GG(c, d, a, b, x[3], S23, 0xf4d50d87);
GG(b, c, d, a, x[8], S24, 0x455a14ed);
GG(a, b, c, d, x[13], S21, 0xa9e3e905);
GG(d, a, b, c, x[2], S22, 0xfcefa3f8);
GG(c, d, a, b, x[7], S23, 0x676f02d9);
GG(b, c, d, a, x[12], S24, 0x8d2a4c8a);
HH(a, b, c, d, x[5], S31, 0xfffa3942);
HH(d, a, b, c, x[8], S32, 0x8771f681);
HH(c, d, a, b, x[11], S33, 0x6d9d6122);
HH(b, c, d, a, x[14], S34, 0xfde5380c);
HH(a, b, c, d, x[1], S31, 0xa4beea44);
HH(d, a, b, c, x[4], S32, 0x4bdecfa9);
HH(c, d, a, b, x[7], S33, 0xf6bb4b60);
HH(b, c, d, a, x[10], S34, 0xbebfbc70);
HH(a, b, c, d, x[13], S31, 0x289b7ec6);
HH(d, a, b, c, x[0], S32, 0xeaa127fa);
HH(c, d, a, b, x[3], S33, 0xd4ef3085);
HH(b, c, d, a, x[6], S34, 0x4881d05);
HH(a, b, c, d, x[9], S31, 0xd9d4d039);
HH(d, a, b, c, x[12], S32, 0xe6db99e5);
HH(c, d, a, b, x[15], S33, 0x1fa27cf8);
HH(b, c, d, a, x[2], S34, 0xc4ac5665);
II(a, b, c, d, x[0], S41, 0xf4292244);
II(d, a, b, c, x[7], S42, 0x432aff97);
II(c, d, a, b, x[14], S43, 0xab9423a7);
II(b, c, d, a, x[5], S44, 0xfc93a039);
II(a, b, c, d, x[12], S41, 0x655b59c3);
II(d, a, b, c, x[3], S42, 0x8f0ccc92);
II(c, d, a, b, x[10], S43, 0xffeff47d);
II(b, c, d, a, x[1], S44, 0x85845dd1);
II(a, b, c, d, x[8], S41, 0x6fa87e4f);
II(d, a, b, c, x[15], S42, 0xfe2ce6e0);
II(c, d, a, b, x[6], S43, 0xa3014314);
II(b, c, d, a, x[13], S44, 0x4e0811a1);
II(a, b, c, d, x[4], S41, 0xf7537e82);
II(d, a, b, c, x[11], S42, 0xbd3af235);
II(c, d, a, b, x[2], S43, 0x2ad7d2bb);
II(b, c, d, a, x[9], S44, 0xeb86d391);
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
memset(x, 0, sizeof(x));
}
static void Encode(unsigned char *output, const apr_uint32_t *input,
unsigned int len)
{
unsigned int i, j;
apr_uint32_t k;
for (i = 0, j = 0; j < len; i++, j += 4) {
k = input[i];
output[j] = (unsigned char)(k & 0xff);
output[j + 1] = (unsigned char)((k >> 8) & 0xff);
output[j + 2] = (unsigned char)((k >> 16) & 0xff);
output[j + 3] = (unsigned char)((k >> 24) & 0xff);
}
}
static void Decode(apr_uint32_t *output, const unsigned char *input,
unsigned int len)
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((apr_uint32_t)input[j]) |
(((apr_uint32_t)input[j + 1]) << 8) |
(((apr_uint32_t)input[j + 2]) << 16) |
(((apr_uint32_t)input[j + 3]) << 24);
}
#if APR_CHARSET_EBCDIC
APU_DECLARE(apr_status_t) apr_MD5InitEBCDIC(apr_xlate_t *xlate)
{
xlate_ebcdic_to_ascii = xlate;
return APR_SUCCESS;
}
#endif
static const char *apr1_id = "$apr1$";
static void to64(char *s, unsigned long v, int n)
{
static unsigned char itoa64[] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
while (--n >= 0) {
*s++ = itoa64[v&0x3f];
v >>= 6;
}
}
APU_DECLARE(apr_status_t) apr_md5_encode(const char *pw, const char *salt,
char *result, apr_size_t nbytes)
{
char passwd[120], *p;
const char *sp, *ep;
unsigned char final[APR_MD5_DIGESTSIZE];
apr_ssize_t sl, pl, i;
apr_md5_ctx_t ctx, ctx1;
unsigned long l;
sp = salt;
if (!strncmp(sp, apr1_id, strlen(apr1_id))) {
sp += strlen(apr1_id);
}
for (ep = sp; (*ep != '\0') && (*ep != '$') && (ep < (sp + 8)); ep++) {
continue;
}
sl = ep - sp;
apr_md5_init(&ctx);
#if APR_CHARSET_EBCDIC
apr_md5_set_xlate(&ctx, xlate_ebcdic_to_ascii);
#endif
apr_md5_update(&ctx, pw, strlen(pw));
apr_md5_update(&ctx, apr1_id, strlen(apr1_id));
apr_md5_update(&ctx, sp, sl);
apr_md5_init(&ctx1);
#if APR_CHARSET_EBCDIC
apr_md5_set_xlate(&ctx1, xlate_ebcdic_to_ascii);
#endif
apr_md5_update(&ctx1, pw, strlen(pw));
apr_md5_update(&ctx1, sp, sl);
apr_md5_update(&ctx1, pw, strlen(pw));
apr_md5_final(final, &ctx1);
for (pl = strlen(pw); pl > 0; pl -= APR_MD5_DIGESTSIZE) {
md5_update_buffer(&ctx, final,
(pl > APR_MD5_DIGESTSIZE) ? APR_MD5_DIGESTSIZE : pl, SKIP_XLATE);
}
memset(final, 0, sizeof(final));
for (i = strlen(pw); i != 0; i >>= 1) {
if (i & 1) {
md5_update_buffer(&ctx, final, 1, SKIP_XLATE);
}
else {
apr_md5_update(&ctx, pw, 1);
}
}
strcpy(passwd, apr1_id);
strncat(passwd, sp, sl);
strcat(passwd, "$");
apr_md5_final(final, &ctx);
for (i = 0; i < 1000; i++) {
apr_md5_init(&ctx1);
#if APR_CHARSET_EBCDIC
apr_md5_set_xlate(&ctx1, xlate_ebcdic_to_ascii);
#endif
if (i & 1) {
apr_md5_update(&ctx1, pw, strlen(pw));
}
else {
md5_update_buffer(&ctx1, final, APR_MD5_DIGESTSIZE, SKIP_XLATE);
}
if (i % 3) {
apr_md5_update(&ctx1, sp, sl);
}
if (i % 7) {
apr_md5_update(&ctx1, pw, strlen(pw));
}
if (i & 1) {
md5_update_buffer(&ctx1, final, APR_MD5_DIGESTSIZE, SKIP_XLATE);
}
else {
apr_md5_update(&ctx1, pw, strlen(pw));
}
apr_md5_final(final,&ctx1);
}
p = passwd + strlen(passwd);
l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p, l, 4); p += 4;
l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p, l, 4); p += 4;
l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; to64(p, l, 4); p += 4;
l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; to64(p, l, 4); p += 4;
l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; to64(p, l, 4); p += 4;
l = final[11] ; to64(p, l, 2); p += 2;
*p = '\0';
memset(final, 0, sizeof(final));
apr_cpystrn(result, passwd, nbytes - 1);
return APR_SUCCESS;
}
#if !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)
#if defined(APU_CRYPT_THREADSAFE) || !APR_HAS_THREADS || \
defined(CRYPT_R_CRYPTD) || defined(CRYPT_R_STRUCT_CRYPT_DATA)
#define crypt_mutex_lock()
#define crypt_mutex_unlock()
#elif APR_HAVE_PTHREAD_H && defined(PTHREAD_MUTEX_INITIALIZER)
static pthread_mutex_t crypt_mutex = PTHREAD_MUTEX_INITIALIZER;
static void crypt_mutex_lock(void)
{
pthread_mutex_lock(&crypt_mutex);
}
static void crypt_mutex_unlock(void)
{
pthread_mutex_unlock(&crypt_mutex);
}
#else
#error apr_password_validate() is not threadsafe. rebuild APR without thread support.
#endif
#endif
APU_DECLARE(apr_status_t) apr_password_validate(const char *passwd,
const char *hash)
{
char sample[120];
#if !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)
char *crypt_pw;
#endif
if (!strncmp(hash, apr1_id, strlen(apr1_id))) {
apr_md5_encode(passwd, hash, sample, sizeof(sample));
}
else if (!strncmp(hash, APR_SHA1PW_ID, APR_SHA1PW_IDLEN)) {
apr_sha1_base64(passwd, (int)strlen(passwd), sample);
}
else {
#if defined(WIN32) || defined(BEOS) || defined(NETWARE)
apr_cpystrn(sample, passwd, sizeof(sample) - 1);
#elif defined(CRYPT_R_CRYPTD)
CRYPTD buffer;
crypt_pw = crypt_r(passwd, hash, &buffer);
apr_cpystrn(sample, crypt_pw, sizeof(sample) - 1);
#elif defined(CRYPT_R_STRUCT_CRYPT_DATA)
struct crypt_data buffer;
memset(&buffer, 0, sizeof(buffer));
crypt_pw = crypt_r(passwd, hash, &buffer);
apr_cpystrn(sample, crypt_pw, sizeof(sample) - 1);
#else
#if defined(_AIX) && APR_HAS_THREADS
#error Configuration error! crypt_r() should have been selected!
#endif
crypt_mutex_lock();
crypt_pw = crypt(passwd, hash);
apr_cpystrn(sample, crypt_pw, sizeof(sample) - 1);
crypt_mutex_unlock();
#endif
}
return (strcmp(sample, hash) == 0) ? APR_SUCCESS : APR_EMISMATCH;
}