1#include "FEATURE/uwin"
2
3#if !_UWIN || _lib_crypt
4
5void _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)
42static 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
243typedef 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
313static 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
331static 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
344static 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
355static 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
367static 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 */
372static 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
384static 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
427static 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
438static 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
450static unsigned char itoa64[] =		/* 0..63 => ascii-64 */
451	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
452
453
454/* =====  Tables that are initialized at run time  ==================== */
455
456
457static unsigned char a64toi[128];	/* ascii-64 => 0..63 */
458
459/* Initial key schedule permutation */
460static C_block	PC1ROT[64/CHUNKBITS][1<<CHUNKBITS];
461
462/* Subsequent key schedule rotation permutations */
463static C_block	PC2ROT[2][64/CHUNKBITS][1<<CHUNKBITS];
464
465/* Initial permutation/expansion table */
466static C_block	IE3264[32/CHUNKBITS][1<<CHUNKBITS];
467
468/* Table that combines the S, P, and E operations.  */
469static long SPE[2][8][64];
470
471/* compressed/interleaved => final permutation table */
472static C_block	CF6464[64/CHUNKBITS][1<<CHUNKBITS];
473
474
475/* ==================================== */
476
477static C_block	constdatablock;			/* encryption constant */
478static 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 */
488static 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 */
509static 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
647static C_block	KS[KS_SIZE];
648
649/*
650 * Set up the key schedule from the key.
651 */
652static 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 */
684static 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 */
797extern 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 */
815extern 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 */
843extern 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
940STATIC
941prtab(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