busybox/libbb/pw_encrypt.c

/* vi: set sw=4 ts=4: */
/*
 * Utility routines.
 *
 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
 *
 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
 */

#include "libbb.h"

/* static const uint8_t ascii64[] =
 * "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 */

static int i64c(int i)
{
	i &= 0x3f;
	if (i == 0)
		return '.';
	if (i == 1)
		return '/';
	if (i < 12)
		return ('0' - 2 + i);
	if (i < 38)
		return ('A' - 12 + i);
	return ('a' - 38 + i);
}

int FAST_FUNC crypt_make_salt(char *p, int cnt, int x)
{
	x += getpid() + time(NULL);
	do {
		/* x = (x*1664525 + 1013904223) % 2^32 generator is lame
		 * (low-order bit is not "random", etc...),
		 * but for our purposes it is good enough */
		x = x*1664525 + 1013904223;
		/* BTW, Park and Miller's "minimal standard generator" is
		 * x = x*16807 % ((2^31)-1)
		 * It has no problem with visibly alternating lowest bit
		 * but is also weak in cryptographic sense + needs div,
		 * which needs more code (and slower) on many CPUs */
		*p++ = i64c(x >> 16);
		*p++ = i64c(x >> 22);
	} while (--cnt);
	*p = '\0';
	return x;
}

#if ENABLE_USE_BB_CRYPT

static char*
to64(char *s, unsigned v, int n)
{
	while (--n >= 0) {
		/* *s++ = ascii64[v & 0x3f]; */
		*s++ = i64c(v);
		v >>= 6;
	}
	return s;
}

/*
 * DES and MD5 crypt implementations are taken from uclibc.
 * They were modified to not use static buffers.
 */

#include "pw_encrypt_des.c"
#include "pw_encrypt_md5.c"
#if ENABLE_USE_BB_CRYPT_SHA
#include "pw_encrypt_sha.c"
#endif

/* Other advanced crypt ids (TODO?): */
/* $2$ or $2a$: Blowfish */

static struct const_des_ctx *des_cctx;
static struct des_ctx *des_ctx;

/* my_crypt returns malloc'ed data */
static char *my_crypt(const char *key, const char *salt)
{
	/* MD5 or SHA? */
	if (salt[0] == '$' && salt[1] && salt[2] == '$') {
		if (salt[1] == '1')
			return md5_crypt(xzalloc(MD5_OUT_BUFSIZE), (unsigned char*)key, (unsigned char*)salt);
#if ENABLE_USE_BB_CRYPT_SHA
		if (salt[1] == '5' || salt[1] == '6')
			return sha_crypt((char*)key, (char*)salt);
#endif
	}

	if (!des_cctx)
		des_cctx = const_des_init();
	des_ctx = des_init(des_ctx, des_cctx);
	return des_crypt(des_ctx, xzalloc(DES_OUT_BUFSIZE), (unsigned char*)key, (unsigned char*)salt);
}

/* So far nobody wants to have it public */
static void my_crypt_cleanup(void)
{
	free(des_cctx);
	free(des_ctx);
	des_cctx = NULL;
	des_ctx = NULL;
}

char* FAST_FUNC pw_encrypt(const char *clear, const char *salt, int cleanup)
{
	char *encrypted;

	encrypted = my_crypt(clear, salt);

	if (cleanup)
		my_crypt_cleanup();

	return encrypted;
}

#else /* if !ENABLE_USE_BB_CRYPT */

char* FAST_FUNC pw_encrypt(const char *clear, const char *salt, int cleanup)
{
	return xstrdup(crypt(clear, salt));
}

#endif
1	niro	532	/* vi: set sw=4 ts=4: */
2			/*
3	niro	984	* Utility routines.
4	niro	532	*
5			* Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
6			*
7			* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
8			*/
9
10			#include "libbb.h"
11
12	niro	984	/* static const uint8_t ascii64[] =
13			* "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
14			*/
15
16			static int i64c(int i)
17			{
18			i &= 0x3f;
19			if (i == 0)
20			return '.';
21			if (i == 1)
22			return '/';
23			if (i < 12)
24			return ('0' - 2 + i);
25			if (i < 38)
26			return ('A' - 12 + i);
27			return ('a' - 38 + i);
28			}
29
30			int FAST_FUNC crypt_make_salt(char *p, int cnt, int x)
31			{
32			x += getpid() + time(NULL);
33			do {
34			/* x = (x*1664525 + 1013904223) % 2^32 generator is lame
35			* (low-order bit is not "random", etc...),
36			* but for our purposes it is good enough */
37			x = x*1664525 + 1013904223;
38			/* BTW, Park and Miller's "minimal standard generator" is
39			* x = x*16807 % ((2^31)-1)
40			* It has no problem with visibly alternating lowest bit
41			* but is also weak in cryptographic sense + needs div,
42			* which needs more code (and slower) on many CPUs */
43			*p++ = i64c(x >> 16);
44			*p++ = i64c(x >> 22);
45			} while (--cnt);
46			*p = '\0';
47			return x;
48			}
49
50	niro	816	#if ENABLE_USE_BB_CRYPT
51
52	niro	984	static char*
53			to64(char *s, unsigned v, int n)
54			{
55			while (--n >= 0) {
56			/* s++ = ascii64[v & 0x3f]; /
57			*s++ = i64c(v);
58			v >>= 6;
59			}
60			return s;
61			}
62
63	niro	816	/*
64			* DES and MD5 crypt implementations are taken from uclibc.
65			* They were modified to not use static buffers.
66			*/
67	niro	984
68	niro	816	#include "pw_encrypt_des.c"
69			#include "pw_encrypt_md5.c"
70	niro	984	#if ENABLE_USE_BB_CRYPT_SHA
71			#include "pw_encrypt_sha.c"
72			#endif
73	niro	816
74	niro	984	/* Other advanced crypt ids (TODO?): */
75	niro	816	/* $2$ or $2a$: Blowfish */
76
77			static struct const_des_ctx *des_cctx;
78			static struct des_ctx *des_ctx;
79
80			/* my_crypt returns malloc'ed data */
81			static char my_crypt(const char key, const char *salt)
82	niro	532	{
83	niro	984	/* MD5 or SHA? */
84			if (salt[0] == '$' && salt[1] && salt[2] == '$') {
85			if (salt[1] == '1')
86			return md5_crypt(xzalloc(MD5_OUT_BUFSIZE), (unsigned char)key, (unsigned char)salt);
87			#if ENABLE_USE_BB_CRYPT_SHA
88			if (salt[1] == '5' \|\| salt[1] == '6')
89			return sha_crypt((char)key, (char)salt);
90			#endif
91	niro	816	}
92	niro	532
93	niro	984	if (!des_cctx)
94			des_cctx = const_des_init();
95			des_ctx = des_init(des_ctx, des_cctx);
96			return des_crypt(des_ctx, xzalloc(DES_OUT_BUFSIZE), (unsigned char)key, (unsigned char)salt);
97	niro	816	}
98
99			/* So far nobody wants to have it public */
100			static void my_crypt_cleanup(void)
101			{
102			free(des_cctx);
103			free(des_ctx);
104			des_cctx = NULL;
105			des_ctx = NULL;
106			}
107
108			char* FAST_FUNC pw_encrypt(const char clear, const char salt, int cleanup)
109			{
110			char *encrypted;
111
112			encrypted = my_crypt(clear, salt);
113
114			if (cleanup)
115			my_crypt_cleanup();
116
117			return encrypted;
118			}
119
120			#else /* if !ENABLE_USE_BB_CRYPT */
121
122			char* FAST_FUNC pw_encrypt(const char clear, const char salt, int cleanup)
123			{
124			return xstrdup(crypt(clear, salt));
125			}
126
127	niro	532	#endif