blob: 2b5e6fc05fcf2a163fdd41cd99e63f3952e39ca7 [file] [log] [blame]
/*
* Copyright (C) Tildeslash Ltd. All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* In addition, as a special exception, the copyright holders give
* permission to link the code of portions of this program with the
* OpenSSL library under certain conditions as described in each
* individual source file, and distribute linked combinations
* including the two.
*
* You must obey the GNU Affero General Public License in all respects
* for all of the code used other than OpenSSL.
*/
/*
* Based on crypt implementation 1.7 by Poul-Henning Kamp
*
* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <phk@login.dknet.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
* ----------------------------------------------------------------------------
*/
#include "config.h"
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include "md5.h"
/* 0 ... 63 => ascii - 64 */
static unsigned char itoa64[] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static void to64(char *s, unsigned long v, int n) {
while (--n >= 0) {
*s++ = itoa64[v&0x3f];
v >>= 6;
}
}
/*
* UNIX password MD5
*/
char *md5_crypt(const char *pw, const char *id, const char *salt, char *buf, int buflen) {
char *p;
const md5_byte_t *sp, *ep;
unsigned char final[16];
int i, sl, pl, pwl = (int)strlen(pw);
unsigned long l;
md5_context_t ctx, ctx1;
/* Refine the Salt first */
sp = (const md5_byte_t *)salt;
/* If it starts with the id string, then skip that */
if (! strncmp(salt, id, strlen(id)))
sp += strlen(id);
/* It stops at the first '$', max 8 chars */
for (ep = sp; *ep && *ep != '$' && ep < (sp + 8); ep++)
continue;
/* get the length of the true salt */
sl = (int)(ep - sp);
md5_init(&ctx);
/* The password first, since that is what is most unknown */
md5_append(&ctx, (const md5_byte_t *)pw, pwl);
/* Then our id string */
md5_append(&ctx, (const md5_byte_t *)id, (int)strlen(id));
/* Then the raw salt */
md5_append(&ctx, sp, sl);
/* Then just as many characters of the MD5(pw, salt, pw) */
md5_init(&ctx1);
md5_append(&ctx1, (const md5_byte_t *)pw, pwl);
md5_append(&ctx1, sp, sl);
md5_append(&ctx1, (const md5_byte_t *)pw, pwl);
md5_finish(&ctx1, final);
for (pl = pwl; pl > 0; pl -= 16)
md5_append(&ctx, final, pl > 16 ? 16 : pl);
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof(final));
/* Then something really weird... */
for (i = pwl; i; i >>= 1)
if (i & 1)
md5_append(&ctx, final, 1);
else
md5_append(&ctx, (const md5_byte_t *)pw, 1);
/* Now make the output string */
strncpy(buf, id, buflen);
strncat(buf, (const char *)sp, sl);
strcat(buf, "$");
md5_finish(&ctx, final);
/*
* and now, just to make sure things don't run too fast
* On a 60 Mhz Pentium this takes 34 msec, so you would
* need 30 seconds to build a 1000 entry dictionary...
*/
for (i = 0; i < 1000; i++) {
md5_init(&ctx1);
if (i & 1)
md5_append(&ctx1, (const md5_byte_t *)pw, pwl);
else
md5_append(&ctx1, final, 16);
if (i % 3)
md5_append(&ctx1, sp, sl);
if (i % 7)
md5_append(&ctx1, (const md5_byte_t *)pw, pwl);
if (i & 1)
md5_append(&ctx1, final, 16);
else
md5_append(&ctx1, (const md5_byte_t *)pw, pwl);
md5_finish(&ctx1, final);
}
p = buf + strlen(buf);
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';
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof(final));
return buf;
}