2 * This function implements the "bigcrypt" algorithm specifically for
5 * This algorithm is algorithm 0 (default) shipped with the C2 secure
6 * implementation of Digital UNIX.
8 * Disclaimer: This work is not based on the source code to Digital
9 * UNIX, nor am I connected to Digital Equipment Corp, in any way
10 * other than as a customer. This code is based on published
11 * interfaces and reasonable guesswork.
13 * Description: The cleartext is divided into blocks of SEGMENT_SIZE=8
14 * characters or less. Each block is encrypted using the standard UNIX
15 * libc crypt function. The result of the encryption for one block
16 * provides the salt for the suceeding block.
18 * Restrictions: The buffer used to hold the encrypted result is
19 * statically allocated. (see MAX_PASS_LEN below). This is necessary,
20 * as the returned pointer points to "static data that are overwritten
21 * by each call", (XPG3: XSI System Interface + Headers pg 109), and
22 * this is a drop in replacement for crypt();
24 * Andy Phillips <atp@mssl.ucl.ac.uk>
25 * $FreeBSD: src/contrib/libpam/modules/pam_unix/bigcrypt.c,v 1.1.1.1.2.2 2001/06/11 15:28:30 markm Exp $
26 * $DragonFly: src/contrib/libpam/modules/pam_unix/Attic/bigcrypt.c,v 1.2 2003/06/17 04:24:03 dillon Exp $
30 #include <security/_pam_macros.h>
32 char *crypt(const char *key, const char *salt);
33 char *bigcrypt(const char *key, const char *salt);
36 * Max cleartext password length in segments of 8 characters this
37 * function can deal with (16 segments of 8 chars= max 128 character
41 #define MAX_PASS_LEN 16
42 #define SEGMENT_SIZE 8
44 #define KEYBUF_SIZE ((MAX_PASS_LEN*SEGMENT_SIZE)+SALT_SIZE)
45 #define ESEGMENT_SIZE 11
46 #define CBUF_SIZE ((MAX_PASS_LEN*ESEGMENT_SIZE)+SALT_SIZE+1)
48 char *bigcrypt(const char *key, const char *salt)
50 static char dec_c2_cryptbuf[CBUF_SIZE]; /* static storage area */
52 unsigned long int keylen, n_seg, j;
53 char *cipher_ptr, *plaintext_ptr, *tmp_ptr, *salt_ptr;
54 char keybuf[KEYBUF_SIZE + 1];
56 D(("called with key='%s', salt='%s'.", key, salt));
59 memset(keybuf, 0, KEYBUF_SIZE + 1);
60 memset(dec_c2_cryptbuf, 0, CBUF_SIZE);
62 /* fill KEYBUF_SIZE with key */
63 strncpy(keybuf, key, KEYBUF_SIZE);
65 /* deal with case that we are doing a password check for a
66 conventially encrypted password: the salt will be
67 SALT_SIZE+ESEGMENT_SIZE long. */
68 if (strlen(salt) == (SALT_SIZE + ESEGMENT_SIZE))
69 keybuf[SEGMENT_SIZE] = '\0'; /* terminate password early(?) */
71 keylen = strlen(keybuf);
76 /* work out how many segments */
77 n_seg = 1 + ((keylen - 1) / SEGMENT_SIZE);
80 if (n_seg > MAX_PASS_LEN)
81 n_seg = MAX_PASS_LEN; /* truncate at max length */
83 /* set up some pointers */
84 cipher_ptr = dec_c2_cryptbuf;
85 plaintext_ptr = keybuf;
87 /* do the first block with supplied salt */
88 tmp_ptr = crypt(plaintext_ptr, salt); /* libc crypt() */
90 /* and place in the static area */
91 strncpy(cipher_ptr, tmp_ptr, 13);
92 cipher_ptr += ESEGMENT_SIZE + SALT_SIZE;
93 plaintext_ptr += SEGMENT_SIZE; /* first block of SEGMENT_SIZE */
95 /* change the salt (1st 2 chars of previous block) - this was found
98 salt_ptr = cipher_ptr - ESEGMENT_SIZE;
100 /* so far this is identical to "return crypt(key, salt);", if
101 there is more than one block encrypt them... */
104 for (j = 2; j <= n_seg; j++) {
106 tmp_ptr = crypt(plaintext_ptr, salt_ptr);
108 /* skip the salt for seg!=0 */
109 strncpy(cipher_ptr, (tmp_ptr + SALT_SIZE), ESEGMENT_SIZE);
111 cipher_ptr += ESEGMENT_SIZE;
112 plaintext_ptr += SEGMENT_SIZE;
113 salt_ptr = cipher_ptr - ESEGMENT_SIZE;
116 D(("key=|%s|, salt=|%s|\nbuf=|%s|\n", key, salt, dec_c2_cryptbuf));
118 /* this is the <NUL> terminated encrypted password */
120 return dec_c2_cryptbuf;