Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

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