xref: /titanic_51/usr/src/lib/libast/common/uwin/crypt.c (revision 78b2cb9a814f49b9599bf830034a12338259e0c9)
1 #include "FEATURE/uwin"
2 
3 #if !_UWIN || _lib_crypt
4 
5 void _STUB_crypt(){}
6 
7 #else
8 
9 /*
10  * Copyright (c) 1989, 1993
11  *	The Regents of the University of California.  All rights reserved.
12  *
13  * This code is derived from software contributed to Berkeley by
14  * Tom Truscott.
15  *
16  * Redistribution and use in source and binary forms, with or without
17  * modification, are permitted provided that the following conditions
18  * are met:
19  * 1. Redistributions of source code must retain the above copyright
20  *    notice, this list of conditions and the following disclaimer.
21  * 2. Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in the
23  *    documentation and/or other materials provided with the distribution.
24  * 3. Neither the name of the University nor the names of its contributors
25  *    may be used to endorse or promote products derived from this software
26  *    without specific prior written permission.
27  *
28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38  * SUCH DAMAGE.
39  */
40 
41 #if defined(LIBC_SCCS) && !defined(lint)
42 static char sccsid[] = "@(#)crypt.c	8.1 (Berkeley) 6/4/93";
43 #endif /* LIBC_SCCS and not lint */
44 
45 #define crypt		______crypt
46 #define encrypt		______encrypt
47 #define setkey		______setkey
48 
49 /* #include <unistd.h> */
50 #include <stdio.h>
51 #include <limits.h>
52 #include <pwd.h>
53 
54 #undef	crypt
55 #undef	encrypt
56 #undef	setkey
57 
58 #ifndef _PASSWORD_EFMT1
59 #define _PASSWORD_EFMT1 '-'
60 #endif
61 
62 #if defined(__EXPORT__)
63 #define extern	__EXPORT__
64 #endif
65 
66 /*
67  * UNIX password, and DES, encryption.
68  * By Tom Truscott, trt@rti.rti.org,
69  * from algorithms by Robert W. Baldwin and James Gillogly.
70  *
71  * References:
72  * "Mathematical Cryptology for Computer Scientists and Mathematicians,"
73  * by Wayne Patterson, 1987, ISBN 0-8476-7438-X.
74  *
75  * "Password Security: A Case History," R. Morris and Ken Thompson,
76  * Communications of the ACM, vol. 22, pp. 594-597, Nov. 1979.
77  *
78  * "DES will be Totally Insecure within Ten Years," M.E. Hellman,
79  * IEEE Spectrum, vol. 16, pp. 32-39, July 1979.
80  */
81 
82 /* =====  Configuration ==================== */
83 
84 /*
85  * define "MUST_ALIGN" if your compiler cannot load/store
86  * long integers at arbitrary (e.g. odd) memory locations.
87  * (Either that or never pass unaligned addresses to des_cipher!)
88  */
89 #if !defined(vax)
90 #define	MUST_ALIGN
91 #endif
92 
93 #ifdef CHAR_BITS
94 #if CHAR_BITS != 8
95 	#error C_block structure assumes 8 bit characters
96 #endif
97 #endif
98 
99 /*
100  * define "LONG_IS_32_BITS" only if sizeof(long)==4.
101  * This avoids use of bit fields (your compiler may be sloppy with them).
102  */
103 #if !defined(cray)
104 #define	LONG_IS_32_BITS
105 #endif
106 
107 /*
108  * define "B64" to be the declaration for a 64 bit integer.
109  * XXX this feature is currently unused, see "endian" comment below.
110  */
111 #if defined(cray)
112 #define	B64	long
113 #endif
114 #if defined(convex)
115 #define	B64	long long
116 #endif
117 
118 /*
119  * define "LARGEDATA" to get faster permutations, by using about 72 kilobytes
120  * of lookup tables.  This speeds up des_setkey() and des_cipher(), but has
121  * little effect on crypt().
122  */
123 #if defined(notdef)
124 #define	LARGEDATA
125 #endif
126 
127 /* ==================================== */
128 
129 /*
130  * Cipher-block representation (Bob Baldwin):
131  *
132  * DES operates on groups of 64 bits, numbered 1..64 (sigh).  One
133  * representation is to store one bit per byte in an array of bytes.  Bit N of
134  * the NBS spec is stored as the LSB of the Nth byte (index N-1) in the array.
135  * Another representation stores the 64 bits in 8 bytes, with bits 1..8 in the
136  * first byte, 9..16 in the second, and so on.  The DES spec apparently has
137  * bit 1 in the MSB of the first byte, but that is particularly noxious so we
138  * bit-reverse each byte so that bit 1 is the LSB of the first byte, bit 8 is
139  * the MSB of the first byte.  Specifically, the 64-bit input data and key are
140  * converted to LSB format, and the output 64-bit block is converted back into
141  * MSB format.
142  *
143  * DES operates internally on groups of 32 bits which are expanded to 48 bits
144  * by permutation E and shrunk back to 32 bits by the S boxes.  To speed up
145  * the computation, the expansion is applied only once, the expanded
146  * representation is maintained during the encryption, and a compression
147  * permutation is applied only at the end.  To speed up the S-box lookups,
148  * the 48 bits are maintained as eight 6 bit groups, one per byte, which
149  * directly feed the eight S-boxes.  Within each byte, the 6 bits are the
150  * most significant ones.  The low two bits of each byte are zero.  (Thus,
151  * bit 1 of the 48 bit E expansion is stored as the "4"-valued bit of the
152  * first byte in the eight byte representation, bit 2 of the 48 bit value is
153  * the "8"-valued bit, and so on.)  In fact, a combined "SPE"-box lookup is
154  * used, in which the output is the 64 bit result of an S-box lookup which
155  * has been permuted by P and expanded by E, and is ready for use in the next
156  * iteration.  Two 32-bit wide tables, SPE[0] and SPE[1], are used for this
157  * lookup.  Since each byte in the 48 bit path is a multiple of four, indexed
158  * lookup of SPE[0] and SPE[1] is simple and fast.  The key schedule and
159  * "salt" are also converted to this 8*(6+2) format.  The SPE table size is
160  * 8*64*8 = 4K bytes.
161  *
162  * To speed up bit-parallel operations (such as XOR), the 8 byte
163  * representation is "union"ed with 32 bit values "i0" and "i1", and, on
164  * machines which support it, a 64 bit value "b64".  This data structure,
165  * "C_block", has two problems.  First, alignment restrictions must be
166  * honored.  Second, the byte-order (e.g. little-endian or big-endian) of
167  * the architecture becomes visible.
168  *
169  * The byte-order problem is unfortunate, since on the one hand it is good
170  * to have a machine-independent C_block representation (bits 1..8 in the
171  * first byte, etc.), and on the other hand it is good for the LSB of the
172  * first byte to be the LSB of i0.  We cannot have both these things, so we
173  * currently use the "little-endian" representation and avoid any multi-byte
174  * operations that depend on byte order.  This largely precludes use of the
175  * 64-bit datatype since the relative order of i0 and i1 are unknown.  It
176  * also inhibits grouping the SPE table to look up 12 bits at a time.  (The
177  * 12 bits can be stored in a 16-bit field with 3 low-order zeroes and 1
178  * high-order zero, providing fast indexing into a 64-bit wide SPE.)  On the
179  * other hand, 64-bit datatypes are currently rare, and a 12-bit SPE lookup
180  * requires a 128 kilobyte table, so perhaps this is not a big loss.
181  *
182  * Permutation representation (Jim Gillogly):
183  *
184  * A transformation is defined by its effect on each of the 8 bytes of the
185  * 64-bit input.  For each byte we give a 64-bit output that has the bits in
186  * the input distributed appropriately.  The transformation is then the OR
187  * of the 8 sets of 64-bits.  This uses 8*256*8 = 16K bytes of storage for
188  * each transformation.  Unless LARGEDATA is defined, however, a more compact
189  * table is used which looks up 16 4-bit "chunks" rather than 8 8-bit chunks.
190  * The smaller table uses 16*16*8 = 2K bytes for each transformation.  This
191  * is slower but tolerable, particularly for password encryption in which
192  * the SPE transformation is iterated many times.  The small tables total 9K
193  * bytes, the large tables total 72K bytes.
194  *
195  * The transformations used are:
196  * IE3264: MSB->LSB conversion, initial permutation, and expansion.
197  *	This is done by collecting the 32 even-numbered bits and applying
198  *	a 32->64 bit transformation, and then collecting the 32 odd-numbered
199  *	bits and applying the same transformation.  Since there are only
200  *	32 input bits, the IE3264 transformation table is half the size of
201  *	the usual table.
202  * CF6464: Compression, final permutation, and LSB->MSB conversion.
203  *	This is done by two trivial 48->32 bit compressions to obtain
204  *	a 64-bit block (the bit numbering is given in the "CIFP" table)
205  *	followed by a 64->64 bit "cleanup" transformation.  (It would
206  *	be possible to group the bits in the 64-bit block so that 2
207  *	identical 32->32 bit transformations could be used instead,
208  *	saving a factor of 4 in space and possibly 2 in time, but
209  *	byte-ordering and other complications rear their ugly head.
210  *	Similar opportunities/problems arise in the key schedule
211  *	transforms.)
212  * PC1ROT: MSB->LSB, PC1 permutation, rotate, and PC2 permutation.
213  *	This admittedly baroque 64->64 bit transformation is used to
214  *	produce the first code (in 8*(6+2) format) of the key schedule.
215  * PC2ROT[0]: Inverse PC2 permutation, rotate, and PC2 permutation.
216  *	It would be possible to define 15 more transformations, each
217  *	with a different rotation, to generate the entire key schedule.
218  *	To save space, however, we instead permute each code into the
219  *	next by using a transformation that "undoes" the PC2 permutation,
220  *	rotates the code, and then applies PC2.  Unfortunately, PC2
221  *	transforms 56 bits into 48 bits, dropping 8 bits, so PC2 is not
222  *	invertible.  We get around that problem by using a modified PC2
223  *	which retains the 8 otherwise-lost bits in the unused low-order
224  *	bits of each byte.  The low-order bits are cleared when the
225  *	codes are stored into the key schedule.
226  * PC2ROT[1]: Same as PC2ROT[0], but with two rotations.
227  *	This is faster than applying PC2ROT[0] twice,
228  *
229  * The Bell Labs "salt" (Bob Baldwin):
230  *
231  * The salting is a simple permutation applied to the 48-bit result of E.
232  * Specifically, if bit i (1 <= i <= 24) of the salt is set then bits i and
233  * i+24 of the result are swapped.  The salt is thus a 24 bit number, with
234  * 16777216 possible values.  (The original salt was 12 bits and could not
235  * swap bits 13..24 with 36..48.)
236  *
237  * It is possible, but ugly, to warp the SPE table to account for the salt
238  * permutation.  Fortunately, the conditional bit swapping requires only
239  * about four machine instructions and can be done on-the-fly with about an
240  * 8% performance penalty.
241  */
242 
243 typedef union {
244 	unsigned char b[8];
245 	struct  {
246 #if defined(LONG_IS_32_BITS)
247 		/* long is often faster than a 32-bit bit field */
248 		long	i0;
249 		long	i1;
250 #else
251 		long	i0: 32;
252 		long	i1: 32;
253 #endif
254 	} b32;
255 #if defined(B64)
256 	B64	b64;
257 #endif
258 } C_block;
259 
260 /*
261  * Convert twenty-four-bit long in host-order
262  * to six bits (and 2 low-order zeroes) per char little-endian format.
263  */
264 #define	TO_SIX_BIT(rslt, src) {				\
265 		C_block cvt;				\
266 		cvt.b[0] = (unsigned char) src; src >>= 6;		\
267 		cvt.b[1] = (unsigned char) src; src >>= 6;		\
268 		cvt.b[2] = (unsigned char) src; src >>= 6;		\
269 		cvt.b[3] = (unsigned char) src;				\
270 		rslt = (cvt.b32.i0 & 0x3f3f3f3fL) << 2;	\
271 	}
272 
273 /*
274  * These macros may someday permit efficient use of 64-bit integers.
275  */
276 #define	ZERO(d,d0,d1)			d0 = 0, d1 = 0
277 #define	LOAD(d,d0,d1,bl)		d0 = (bl).b32.i0, d1 = (bl).b32.i1
278 #define	LOADREG(d,d0,d1,s,s0,s1)	d0 = s0, d1 = s1
279 #define	OR(d,d0,d1,bl)			d0 |= (bl).b32.i0, d1 |= (bl).b32.i1
280 #define	STORE(s,s0,s1,bl)		(bl).b32.i0 = s0, (bl).b32.i1 = s1
281 #define	DCL_BLOCK(d,d0,d1)		long d0, d1
282 /* proto(1) workarounds -- barf */
283 #define DCL_BLOCK_D			DCL_BLOCK(D,D0,D1)
284 #define DCL_BLOCK_K			DCL_BLOCK(K,K0,K1)
285 
286 #if defined(LARGEDATA)
287 	/* Waste memory like crazy.  Also, do permutations in line */
288 #define	LGCHUNKBITS	3
289 #define	CHUNKBITS	(1<<LGCHUNKBITS)
290 #define	PERM6464(d,d0,d1,cpp,p)				\
291 	LOAD(d,d0,d1,(p)[(0<<CHUNKBITS)+(cpp)[0]]);		\
292 	OR (d,d0,d1,(p)[(1<<CHUNKBITS)+(cpp)[1]]);		\
293 	OR (d,d0,d1,(p)[(2<<CHUNKBITS)+(cpp)[2]]);		\
294 	OR (d,d0,d1,(p)[(3<<CHUNKBITS)+(cpp)[3]]);		\
295 	OR (d,d0,d1,(p)[(4<<CHUNKBITS)+(cpp)[4]]);		\
296 	OR (d,d0,d1,(p)[(5<<CHUNKBITS)+(cpp)[5]]);		\
297 	OR (d,d0,d1,(p)[(6<<CHUNKBITS)+(cpp)[6]]);		\
298 	OR (d,d0,d1,(p)[(7<<CHUNKBITS)+(cpp)[7]]);
299 #define	PERM3264(d,d0,d1,cpp,p)				\
300 	LOAD(d,d0,d1,(p)[(0<<CHUNKBITS)+(cpp)[0]]);		\
301 	OR (d,d0,d1,(p)[(1<<CHUNKBITS)+(cpp)[1]]);		\
302 	OR (d,d0,d1,(p)[(2<<CHUNKBITS)+(cpp)[2]]);		\
303 	OR (d,d0,d1,(p)[(3<<CHUNKBITS)+(cpp)[3]]);
304 #else
305 	/* "small data" */
306 #define	LGCHUNKBITS	2
307 #define	CHUNKBITS	(1<<LGCHUNKBITS)
308 #define	PERM6464(d,d0,d1,cpp,p)				\
309 	{ C_block tblk; permute(cpp,&tblk,p,8); LOAD (d,d0,d1,tblk); }
310 #define	PERM3264(d,d0,d1,cpp,p)				\
311 	{ C_block tblk; permute(cpp,&tblk,p,4); LOAD (d,d0,d1,tblk); }
312 
313 static void permute(unsigned char *cp, C_block *out, register C_block *p, int chars_in) {
314 	register DCL_BLOCK_D;
315 	register C_block *tp;
316 	register int t;
317 
318 	ZERO(D,D0,D1);
319 	do {
320 		t = *cp++;
321 		tp = &p[t&0xf]; OR(D,D0,D1,*tp); p += (1<<CHUNKBITS);
322 		tp = &p[t>>4];  OR(D,D0,D1,*tp); p += (1<<CHUNKBITS);
323 	} while (--chars_in > 0);
324 	STORE(D,D0,D1,*out);
325 }
326 #endif /* LARGEDATA */
327 
328 
329 /* =====  (mostly) Standard DES Tables ==================== */
330 
331 static unsigned char IP[] = {		/* initial permutation */
332 	58, 50, 42, 34, 26, 18, 10,  2,
333 	60, 52, 44, 36, 28, 20, 12,  4,
334 	62, 54, 46, 38, 30, 22, 14,  6,
335 	64, 56, 48, 40, 32, 24, 16,  8,
336 	57, 49, 41, 33, 25, 17,  9,  1,
337 	59, 51, 43, 35, 27, 19, 11,  3,
338 	61, 53, 45, 37, 29, 21, 13,  5,
339 	63, 55, 47, 39, 31, 23, 15,  7,
340 };
341 
342 /* The final permutation is the inverse of IP - no table is necessary */
343 
344 static unsigned char ExpandTr[] = {	/* expansion operation */
345 	32,  1,  2,  3,  4,  5,
346 	 4,  5,  6,  7,  8,  9,
347 	 8,  9, 10, 11, 12, 13,
348 	12, 13, 14, 15, 16, 17,
349 	16, 17, 18, 19, 20, 21,
350 	20, 21, 22, 23, 24, 25,
351 	24, 25, 26, 27, 28, 29,
352 	28, 29, 30, 31, 32,  1,
353 };
354 
355 static unsigned char PC1[] = {		/* permuted choice table 1 */
356 	57, 49, 41, 33, 25, 17,  9,
357 	 1, 58, 50, 42, 34, 26, 18,
358 	10,  2, 59, 51, 43, 35, 27,
359 	19, 11,  3, 60, 52, 44, 36,
360 
361 	63, 55, 47, 39, 31, 23, 15,
362 	 7, 62, 54, 46, 38, 30, 22,
363 	14,  6, 61, 53, 45, 37, 29,
364 	21, 13,  5, 28, 20, 12,  4,
365 };
366 
367 static unsigned char Rotates[] = {	/* PC1 rotation schedule */
368 	1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1,
369 };
370 
371 /* note: each "row" of PC2 is left-padded with bits that make it invertible */
372 static unsigned char PC2[] = {		/* permuted choice table 2 */
373 	 9, 18,    14, 17, 11, 24,  1,  5,
374 	22, 25,     3, 28, 15,  6, 21, 10,
375 	35, 38,    23, 19, 12,  4, 26,  8,
376 	43, 54,    16,  7, 27, 20, 13,  2,
377 
378 	 0,  0,    41, 52, 31, 37, 47, 55,
379 	 0,  0,    30, 40, 51, 45, 33, 48,
380 	 0,  0,    44, 49, 39, 56, 34, 53,
381 	 0,  0,    46, 42, 50, 36, 29, 32,
382 };
383 
384 static unsigned char S[8][64] = {	/* 48->32 bit substitution tables */
385 					/* S[1]			*/
386 	14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
387 	 0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
388 	 4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
389 	15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13,
390 					/* S[2]			*/
391 	15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
392 	 3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
393 	 0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
394 	13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9,
395 					/* S[3]			*/
396 	10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
397 	13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
398 	13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
399 	 1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12,
400 					/* S[4]			*/
401 	 7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
402 	13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
403 	10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
404 	 3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14,
405 					/* S[5]			*/
406 	 2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
407 	14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
408 	 4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
409 	11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3,
410 					/* S[6]			*/
411 	12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
412 	10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
413 	 9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
414 	 4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13,
415 					/* S[7]			*/
416 	 4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
417 	13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
418 	 1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
419 	 6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12,
420 					/* S[8]			*/
421 	13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
422 	 1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
423 	 7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
424 	 2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11,
425 };
426 
427 static unsigned char P32Tr[] = {	/* 32-bit permutation function */
428 	16,  7, 20, 21,
429 	29, 12, 28, 17,
430 	 1, 15, 23, 26,
431 	 5, 18, 31, 10,
432 	 2,  8, 24, 14,
433 	32, 27,  3,  9,
434 	19, 13, 30,  6,
435 	22, 11,  4, 25,
436 };
437 
438 static unsigned char CIFP[] = {		/* compressed/interleaved permutation */
439 	 1,  2,  3,  4,   17, 18, 19, 20,
440 	 5,  6,  7,  8,   21, 22, 23, 24,
441 	 9, 10, 11, 12,   25, 26, 27, 28,
442 	13, 14, 15, 16,   29, 30, 31, 32,
443 
444 	33, 34, 35, 36,   49, 50, 51, 52,
445 	37, 38, 39, 40,   53, 54, 55, 56,
446 	41, 42, 43, 44,   57, 58, 59, 60,
447 	45, 46, 47, 48,   61, 62, 63, 64,
448 };
449 
450 static unsigned char itoa64[] =		/* 0..63 => ascii-64 */
451 	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
452 
453 
454 /* =====  Tables that are initialized at run time  ==================== */
455 
456 
457 static unsigned char a64toi[128];	/* ascii-64 => 0..63 */
458 
459 /* Initial key schedule permutation */
460 static C_block	PC1ROT[64/CHUNKBITS][1<<CHUNKBITS];
461 
462 /* Subsequent key schedule rotation permutations */
463 static C_block	PC2ROT[2][64/CHUNKBITS][1<<CHUNKBITS];
464 
465 /* Initial permutation/expansion table */
466 static C_block	IE3264[32/CHUNKBITS][1<<CHUNKBITS];
467 
468 /* Table that combines the S, P, and E operations.  */
469 static long SPE[2][8][64];
470 
471 /* compressed/interleaved => final permutation table */
472 static C_block	CF6464[64/CHUNKBITS][1<<CHUNKBITS];
473 
474 
475 /* ==================================== */
476 
477 static C_block	constdatablock;			/* encryption constant */
478 static char	cryptresult[1+4+4+11+1];	/* encrypted result */
479 
480 /*
481  * Initialize "perm" to represent transformation "p", which rearranges
482  * (perhaps with expansion and/or contraction) one packed array of bits
483  * (of size "chars_in" characters) into another array (of size "chars_out"
484  * characters).
485  *
486  * "perm" must be all-zeroes on entry to this routine.
487  */
488 static void init_perm(C_block perm[64/CHUNKBITS][1<<CHUNKBITS],
489 	unsigned char p[64], int chars_in, int chars_out) {
490 	register int i, j, k, l;
491 
492 	for (k = 0; k < chars_out*8; k++) {	/* each output bit position */
493 		l = p[k] - 1;		/* where this bit comes from */
494 		if (l < 0)
495 			continue;	/* output bit is always 0 */
496 		i = l>>LGCHUNKBITS;	/* which chunk this bit comes from */
497 		l = 1<<(l&(CHUNKBITS-1));	/* mask for this bit */
498 		for (j = 0; j < (1<<CHUNKBITS); j++) {	/* each chunk value */
499 			if ((j & l) != 0)
500 				perm[i][j].b[k>>3] |= 1<<(k&07);
501 		}
502 	}
503 }
504 
505 /*
506  * Initialize various tables.  This need only be done once.  It could even be
507  * done at compile time, if the compiler were capable of that sort of thing.
508  */
509 static void init_des(void) {
510 	register int i, j;
511 	register long k;
512 	register int tableno;
513 	static unsigned char perm[64], tmp32[32];	/* "static" for speed */
514 
515 	/*
516 	 * table that converts chars "./0-9A-Za-z"to integers 0-63.
517 	 */
518 	for (i = 0; i < 64; i++)
519 		a64toi[itoa64[i]] = i;
520 
521 	/*
522 	 * PC1ROT - bit reverse, then PC1, then Rotate, then PC2.
523 	 */
524 	for (i = 0; i < 64; i++)
525 		perm[i] = 0;
526 	for (i = 0; i < 64; i++) {
527 		if ((k = PC2[i]) == 0)
528 			continue;
529 		k += Rotates[0]-1;
530 		if ((k%28) < Rotates[0]) k -= 28;
531 		k = PC1[k];
532 		if (k > 0) {
533 			k--;
534 			k = (k|07) - (k&07);
535 			k++;
536 		}
537 		perm[i] = (unsigned char) k;
538 	}
539 #ifdef DEBUG
540 	prtab("pc1tab", perm, 8);
541 #endif
542 	init_perm(PC1ROT, perm, 8, 8);
543 
544 	/*
545 	 * PC2ROT - PC2 inverse, then Rotate (once or twice), then PC2.
546 	 */
547 	for (j = 0; j < 2; j++) {
548 		unsigned char pc2inv[64];
549 		for (i = 0; i < 64; i++)
550 			perm[i] = pc2inv[i] = 0;
551 		for (i = 0; i < 64; i++) {
552 			if ((k = PC2[i]) == 0)
553 				continue;
554 			pc2inv[k-1] = i+1;
555 		}
556 		for (i = 0; i < 64; i++) {
557 			if ((k = PC2[i]) == 0)
558 				continue;
559 			k += j;
560 			if ((k%28) <= j) k -= 28;
561 			perm[i] = pc2inv[k];
562 		}
563 #ifdef DEBUG
564 		prtab("pc2tab", perm, 8);
565 #endif
566 		init_perm(PC2ROT[j], perm, 8, 8);
567 	}
568 
569 	/*
570 	 * Bit reverse, then initial permutation, then expansion.
571 	 */
572 	for (i = 0; i < 8; i++) {
573 		for (j = 0; j < 8; j++) {
574 			k = (j < 2)? 0: IP[ExpandTr[i*6+j-2]-1];
575 			if (k > 32)
576 				k -= 32;
577 			else if (k > 0)
578 				k--;
579 			if (k > 0) {
580 				k--;
581 				k = (k|07) - (k&07);
582 				k++;
583 			}
584 			perm[i*8+j] = (unsigned char) k;
585 		}
586 	}
587 #ifdef DEBUG
588 	prtab("ietab", perm, 8);
589 #endif
590 	init_perm(IE3264, perm, 4, 8);
591 
592 	/*
593 	 * Compression, then final permutation, then bit reverse.
594 	 */
595 	for (i = 0; i < 64; i++) {
596 		k = IP[CIFP[i]-1];
597 		if (k > 0) {
598 			k--;
599 			k = (k|07) - (k&07);
600 			k++;
601 		}
602 		perm[k-1] = i+1;
603 	}
604 #ifdef DEBUG
605 	prtab("cftab", perm, 8);
606 #endif
607 	init_perm(CF6464, perm, 8, 8);
608 
609 	/*
610 	 * SPE table
611 	 */
612 	for (i = 0; i < 48; i++)
613 		perm[i] = P32Tr[ExpandTr[i]-1];
614 	for (tableno = 0; tableno < 8; tableno++) {
615 		for (j = 0; j < 64; j++)  {
616 			k = (((j >> 0) &01) << 5)|
617 			    (((j >> 1) &01) << 3)|
618 			    (((j >> 2) &01) << 2)|
619 			    (((j >> 3) &01) << 1)|
620 			    (((j >> 4) &01) << 0)|
621 			    (((j >> 5) &01) << 4);
622 			k = S[tableno][k];
623 			k = (((k >> 3)&01) << 0)|
624 			    (((k >> 2)&01) << 1)|
625 			    (((k >> 1)&01) << 2)|
626 			    (((k >> 0)&01) << 3);
627 			for (i = 0; i < 32; i++)
628 				tmp32[i] = 0;
629 			for (i = 0; i < 4; i++)
630 				tmp32[4 * tableno + i] = (k >> i) & 01;
631 			k = 0;
632 			for (i = 24; --i >= 0; )
633 				k = (k<<1) | tmp32[perm[i]-1];
634 			TO_SIX_BIT(SPE[0][tableno][j], k);
635 			k = 0;
636 			for (i = 24; --i >= 0; )
637 				k = (k<<1) | tmp32[perm[i+24]-1];
638 			TO_SIX_BIT(SPE[1][tableno][j], k);
639 		}
640 	}
641 }
642 
643 /*
644  * The Key Schedule, filled in by des_setkey() or setkey().
645  */
646 #define	KS_SIZE	16
647 static C_block	KS[KS_SIZE];
648 
649 /*
650  * Set up the key schedule from the key.
651  */
652 static int des_setkey(register const char *key) {
653 	register DCL_BLOCK_K;
654 	register C_block *ptabp;
655 	register int i;
656 	static int des_ready = 0;
657 
658 	if (!des_ready) {
659 		init_des();
660 		des_ready = 1;
661 	}
662 
663 	PERM6464(K,K0,K1,(unsigned char *)key,(C_block *)PC1ROT);
664 	key = (char *)&KS[0];
665 	STORE(K&~0x03030303L, K0&~0x03030303L, K1, *(C_block *)key);
666 	for (i = 1; i < 16; i++) {
667 		key += sizeof(C_block);
668 		STORE(K,K0,K1,*(C_block *)key);
669 		ptabp = (C_block *)PC2ROT[Rotates[i]-1];
670 		PERM6464(K,K0,K1,(unsigned char *)key,ptabp);
671 		STORE(K&~0x03030303L, K0&~0x03030303L, K1, *(C_block *)key);
672 	}
673 	return (0);
674 }
675 
676 /*
677  * Encrypt (or decrypt if num_iter < 0) the 8 chars at "in" with abs(num_iter)
678  * iterations of DES, using the the given 24-bit salt and the pre-computed key
679  * schedule, and store the resulting 8 chars at "out" (in == out is permitted).
680  *
681  * NOTE: the performance of this routine is critically dependent on your
682  * compiler and machine architecture.
683  */
684 static int des_cipher(const char *in, char *out, long salt, int num_iter) {
685 	/* variables that we want in registers, most important first */
686 #if defined(pdp11)
687 	register int j;
688 #endif
689 	register long L0, L1, R0, R1, k;
690 	register C_block *kp;
691 	register int ks_inc, loop_count;
692 	C_block B;
693 
694 	L0 = salt;
695 	TO_SIX_BIT(salt, L0);	/* convert to 4*(6+2) format */
696 
697 #if defined(vax) || defined(pdp11)
698 	salt = ~salt;	/* "x &~ y" is faster than "x & y". */
699 #define	SALT (~salt)
700 #else
701 #define	SALT salt
702 #endif
703 
704 #if defined(MUST_ALIGN)
705 	B.b[0] = in[0]; B.b[1] = in[1]; B.b[2] = in[2]; B.b[3] = in[3];
706 	B.b[4] = in[4]; B.b[5] = in[5]; B.b[6] = in[6]; B.b[7] = in[7];
707 	LOAD(L,L0,L1,B);
708 #else
709 	LOAD(L,L0,L1,*(C_block *)in);
710 #endif
711 	LOADREG(R,R0,R1,L,L0,L1);
712 	L0 &= 0x55555555L;
713 	L1 &= 0x55555555L;
714 	L0 = (L0 << 1) | L1;	/* L0 is the even-numbered input bits */
715 	R0 &= 0xaaaaaaaaL;
716 	R1 = (R1 >> 1) & 0x55555555L;
717 	L1 = R0 | R1;		/* L1 is the odd-numbered input bits */
718 	STORE(L,L0,L1,B);
719 	PERM3264(L,L0,L1,B.b,  (C_block *)IE3264);	/* even bits */
720 	PERM3264(R,R0,R1,B.b+4,(C_block *)IE3264);	/* odd bits */
721 
722 	if (num_iter >= 0)
723 	{		/* encryption */
724 		kp = &KS[0];
725 		ks_inc  = sizeof(*kp);
726 	}
727 	else
728 	{		/* decryption */
729 		num_iter = -num_iter;
730 		kp = &KS[KS_SIZE-1];
731 		ks_inc  = -((int) sizeof(*kp));
732 	}
733 
734 	while (--num_iter >= 0) {
735 		loop_count = 8;
736 		do {
737 
738 #define	SPTAB(t, i)	(*(long *)((unsigned char *)t + i*(sizeof(long)/4)))
739 #if defined(gould)
740 			/* use this if B.b[i] is evaluated just once ... */
741 #define	DOXOR(x,y,i)	x^=SPTAB(SPE[0][i],B.b[i]); y^=SPTAB(SPE[1][i],B.b[i]);
742 #else
743 #if defined(pdp11)
744 			/* use this if your "long" int indexing is slow */
745 #define	DOXOR(x,y,i)	j=B.b[i]; x^=SPTAB(SPE[0][i],j); y^=SPTAB(SPE[1][i],j);
746 #else
747 			/* use this if "k" is allocated to a register ... */
748 #define	DOXOR(x,y,i)	k=B.b[i]; x^=SPTAB(SPE[0][i],k); y^=SPTAB(SPE[1][i],k);
749 #endif
750 #endif
751 
752 #define	CRUNCH(p0, p1, q0, q1)	\
753 			k = (q0 ^ q1) & SALT;	\
754 			B.b32.i0 = k ^ q0 ^ kp->b32.i0;		\
755 			B.b32.i1 = k ^ q1 ^ kp->b32.i1;		\
756 			kp = (C_block *)((char *)kp+ks_inc);	\
757 							\
758 			DOXOR(p0, p1, 0);		\
759 			DOXOR(p0, p1, 1);		\
760 			DOXOR(p0, p1, 2);		\
761 			DOXOR(p0, p1, 3);		\
762 			DOXOR(p0, p1, 4);		\
763 			DOXOR(p0, p1, 5);		\
764 			DOXOR(p0, p1, 6);		\
765 			DOXOR(p0, p1, 7);
766 
767 			CRUNCH(L0, L1, R0, R1);
768 			CRUNCH(R0, R1, L0, L1);
769 		} while (--loop_count != 0);
770 		kp = (C_block *)((char *)kp-(ks_inc*KS_SIZE));
771 
772 
773 		/* swap L and R */
774 		L0 ^= R0;  L1 ^= R1;
775 		R0 ^= L0;  R1 ^= L1;
776 		L0 ^= R0;  L1 ^= R1;
777 	}
778 
779 	/* store the encrypted (or decrypted) result */
780 	L0 = ((L0 >> 3) & 0x0f0f0f0fL) | ((L1 << 1) & 0xf0f0f0f0L);
781 	L1 = ((R0 >> 3) & 0x0f0f0f0fL) | ((R1 << 1) & 0xf0f0f0f0L);
782 	STORE(L,L0,L1,B);
783 	PERM6464(L,L0,L1,B.b, (C_block *)CF6464);
784 #if defined(MUST_ALIGN)
785 	STORE(L,L0,L1,B);
786 	out[0] = B.b[0]; out[1] = B.b[1]; out[2] = B.b[2]; out[3] = B.b[3];
787 	out[4] = B.b[4]; out[5] = B.b[5]; out[6] = B.b[6]; out[7] = B.b[7];
788 #else
789 	STORE(L,L0,L1,*(C_block *)out);
790 #endif
791 	return (0);
792 }
793 
794 /*
795  * "setkey" routine (for backwards compatibility)
796  */
797 extern int setkey(register const char *key) {
798 	register int i, j, k;
799 	C_block keyblock;
800 
801 	for (i = 0; i < 8; i++) {
802 		k = 0;
803 		for (j = 0; j < 8; j++) {
804 			k <<= 1;
805 			k |= (unsigned char)*key++;
806 		}
807 		keyblock.b[i] = k;
808 	}
809 	return (des_setkey((char *)keyblock.b));
810 }
811 
812 /*
813  * "encrypt" routine (for backwards compatibility)
814  */
815 extern int encrypt(register char *block, int flag) {
816 	register int i, j, k;
817 	C_block cblock;
818 
819 	for (i = 0; i < 8; i++) {
820 		k = 0;
821 		for (j = 0; j < 8; j++) {
822 			k <<= 1;
823 			k |= (unsigned char)*block++;
824 		}
825 		cblock.b[i] = k;
826 	}
827 	if (des_cipher((char *)&cblock, (char *)&cblock, 0L, (flag ? -1: 1)))
828 		return (1);
829 	for (i = 7; i >= 0; i--) {
830 		k = cblock.b[i];
831 		for (j = 7; j >= 0; j--) {
832 			*--block = k&01;
833 			k >>= 1;
834 		}
835 	}
836 	return (0);
837 }
838 
839 /*
840  * Return a pointer to static data consisting of the "setting"
841  * followed by an encryption produced by the "key" and "setting".
842  */
843 extern char * crypt(register const char *key, register const char *setting) {
844 	register char *encp;
845 	register long i;
846 	register int t;
847 	long salt;
848 	int num_iter, salt_size;
849 	C_block keyblock, rsltblock;
850 
851 #ifdef HL_NOENCRYPTION
852 	char buff[1024];
853 	strncpy(buff, key, 1024);
854 	buff[1023] = 0;
855 	return buff;
856 #endif
857 
858 	for (i = 0; i < 8; i++) {
859 		if ((t = 2*(unsigned char)(*key)) != 0)
860 			key++;
861 		keyblock.b[i] = t;
862 	}
863 	if (des_setkey((char *)keyblock.b))	/* also initializes "a64toi" */
864 		return (NULL);
865 
866 	encp = &cryptresult[0];
867 	switch (*setting) {
868 	case _PASSWORD_EFMT1:
869 		/*
870 		 * Involve the rest of the password 8 characters at a time.
871 		 */
872 		while (*key) {
873 			if (des_cipher((char *)&keyblock,
874 			    (char *)&keyblock, 0L, 1))
875 				return (NULL);
876 			for (i = 0; i < 8; i++) {
877 				if ((t = 2*(unsigned char)(*key)) != 0)
878 					key++;
879 				keyblock.b[i] ^= t;
880 			}
881 			if (des_setkey((char *)keyblock.b))
882 				return (NULL);
883 		}
884 
885 		*encp++ = *setting++;
886 
887 		/* get iteration count */
888 		num_iter = 0;
889 		for (i = 4; --i >= 0; ) {
890 			if ((t = (unsigned char)setting[i]) == '\0')
891 				t = '.';
892 			encp[i] = t;
893 			num_iter = (num_iter<<6) | a64toi[t];
894 		}
895 		setting += 4;
896 		encp += 4;
897 		salt_size = 4;
898 		break;
899 	default:
900 		num_iter = 25;
901 		salt_size = 2;
902 	}
903 
904 	salt = 0;
905 	for (i = salt_size; --i >= 0; ) {
906 		if ((t = (unsigned char)setting[i]) == '\0')
907 			t = '.';
908 		encp[i] = t;
909 		salt = (salt<<6) | a64toi[t];
910 	}
911 	encp += salt_size;
912 	if (des_cipher((char *)&constdatablock, (char *)&rsltblock,
913 	    salt, num_iter))
914 		return (NULL);
915 
916 	/*
917 	 * Encode the 64 cipher bits as 11 ascii characters.
918 	 */
919 	i = ((long)((rsltblock.b[0]<<8) | rsltblock.b[1])<<8) | rsltblock.b[2];
920 	encp[3] = itoa64[i&0x3f];	i >>= 6;
921 	encp[2] = itoa64[i&0x3f];	i >>= 6;
922 	encp[1] = itoa64[i&0x3f];	i >>= 6;
923 	encp[0] = itoa64[i];		encp += 4;
924 	i = ((long)((rsltblock.b[3]<<8) | rsltblock.b[4])<<8) | rsltblock.b[5];
925 	encp[3] = itoa64[i&0x3f];	i >>= 6;
926 	encp[2] = itoa64[i&0x3f];	i >>= 6;
927 	encp[1] = itoa64[i&0x3f];	i >>= 6;
928 	encp[0] = itoa64[i];		encp += 4;
929 	i = ((long)((rsltblock.b[6])<<8) | rsltblock.b[7])<<2;
930 	encp[2] = itoa64[i&0x3f];	i >>= 6;
931 	encp[1] = itoa64[i&0x3f];	i >>= 6;
932 	encp[0] = itoa64[i];
933 
934 	encp[3] = 0;
935 
936 	return (cryptresult);
937 }
938 
939 #ifdef DEBUG
940 STATIC
941 prtab(s, t, num_rows)
942 	char *s;
943 	unsigned char *t;
944 	int num_rows;
945 {
946 	register int i, j;
947 
948 	(void)printf("%s:\n", s);
949 	for (i = 0; i < num_rows; i++) {
950 		for (j = 0; j < 8; j++) {
951 			 (void)printf("%3d", t[i*8+j]);
952 		}
953 		(void)printf("\n");
954 	}
955 	(void)printf("\n");
956 }
957 #endif
958 
959 #endif
960