[unix-history] / contrib / xntpd / authstuff / omakeIPFP.c

/* omakeIPFP.c,v 3.1 1993/07/06 01:05:10 jbj Exp
 * makeIPFP - make fast DES IP and FP tables
 *
 * This is an older version which generated tables half the size of
 * the current version, but which took about double the CPU time to
 * compute permutations from these tables.  Since the CPU spent on the
 * permutations is small compared to the CPU spent in the cipher code,
 * I may go back to the smaller tables to save the space some day.
 */

#include <stdio.h>
#include <sys/types.h>

#include "ntp_stdlib.h"

#define	STREQ(a, b)	(*(a) == *(b) && strcmp((a), (b)) == 0)

U_LONG IPL[8][16];
U_LONG FPL[8][16];

char *progname;
int debug;

static	void	perm	P((u_char *, u_char *, U_LONG *, U_LONG *));
static	void	doit	P((void));

/*
 * main - parse arguments and handle options
 */
void
main(argc, argv)
int argc;
char *argv[];
{
	int c;
	int errflg = 0;
	extern int optind;
	extern char *optarg;

	progname = argv[0];
	while ((c = getopt_l(argc, argv, "d")) != EOF)
		switch (c) {
		case 'd':
			++debug;
			break;
		default:
			errflg++;
			break;
		}
	if (errflg) {
		(void) fprintf(stderr, "usage: %s [-d]\n", progname);
		exit(2);
	}
	doit();
	exit(0);
}


/*
 * Initial permutation table
 */
u_char IP[64] = {
	58, 50, 42, 34, 26, 18, 10,  2,
	60, 52, 44, 36, 28, 20, 12,  4,
	62, 54, 46, 38, 30, 22, 14,  6,
	64, 56, 48, 40, 32, 24, 16,  8,
	57, 49, 41, 33, 25, 17,  9,  1,
	59, 51, 43, 35, 27, 19, 11,  3,
	61, 53, 45, 37, 29, 21, 13,  5,
	63, 55, 47, 39, 31, 23, 15,  7
};

/*
 * Inverse initial permutation table
 */
u_char FP[64] = {
	40,  8, 48, 16, 56, 24, 64, 32,
	39,  7, 47, 15, 55, 23, 63, 31,
	38,  6, 46, 14, 54, 22, 62, 30,
	37,  5, 45, 13, 53, 21, 61, 29,
	36,  4, 44, 12, 52, 20, 60, 28,
	35,  3, 43, 11, 51, 19, 59, 27,
	34,  2, 42, 10, 50, 18, 58, 26,
	33,  1, 41,  9, 49, 17, 57, 25
};


/*
 * Bit order after the operation
 *
 * ((left & 0x55555555) << 1) | (right & 0x55555555)
 */
u_char IPLbits[32] = {
	 2, 34,  4, 36,  6, 38,  8, 40,
	10, 42, 12, 44, 14, 46, 16, 48,
	18, 50, 20, 52, 22, 54, 24, 56,
	26, 58, 28, 60, 30, 62, 32, 64
};


/*
 * Bit order after the operation
 *
 * (left & 0xaaaaaaaa) | ((right & 0xaaaaaaaa) >> 1)
 */
u_char IPRbits[32] = {
	 1, 33,  3, 35,  5, 37,  7, 39,
	 9, 41, 11, 43, 13, 45, 15, 47,
	17, 49, 19, 51, 21, 53, 23, 55,
	25, 57, 27, 59, 29, 61, 31, 63
};


/*
 * Bit order after the operation
 *
 * ((left & 0x0f0f0f0f) << 4) | (right & 0x0f0f0f0f)
 */
u_char FPLbits[32] = {
	 5,  6,  7,  8, 37, 38, 39, 40,
	13, 14, 15, 16, 45, 46, 47, 48,
	21, 22, 23, 24, 53, 54, 55, 56,
	29, 30, 31, 32, 61, 62, 63, 64
};


/*
 * Bit order after the operation
 *
 * (left & 0xf0f0f0f0) | ((right & 0xf0f0f0f0) >> 4)
 */
u_char FPRbits[32] = {
	 1,  2,  3,  4, 33, 34, 35, 36,
	 9, 10, 11, 12, 41, 42, 43, 44,
	17, 18, 19, 20, 49, 50, 51, 52,
	25, 26, 27, 28, 57, 58, 59, 60
};


/*
 * perm - do a permutation with the given table
 */
static void
perm(databits, permtab, leftp, rightp)
	u_char *databits;
	u_char *permtab;
	U_LONG *leftp;
	U_LONG *rightp;
{
	register U_LONG left;
	register U_LONG right;
	register u_char *PT;
	register u_char *bits;
	register int i;

	left = right = 0;
	PT = permtab;
	bits = databits;

	for (i = 0; i < 32; i++) {
		left <<= 1;
		if (bits[PT[i]-1])
			left |= 1;
	}

	for (i = 32; i < 64; i++) {
		right <<= 1;
		if (bits[PT[i]-1])
			right |= 1;
	}

	*leftp = left;
	*rightp = right;
}


/*
 * doit - make up the tables
 */
static void
doit()
{
	u_char bits[64];
	U_LONG left;
	U_LONG right;
	int tabno;
	int i;
	int ind0, ind1, ind2, ind3;
	int quadbits;

	bzero((char *)bits, sizeof bits);

	/*
	 * Do the rounds for the IPL table.  We save the results of
	 * this as well as printing them.  Note that this is the
	 * left-half table.
	 */
	printf("static U_LONG IP[8][16] = {");
	for (tabno = 0; tabno < 8; tabno++) {
		i = tabno * 4;
		ind3 = IPLbits[i] - 1;
		ind2 = IPLbits[i+1] - 1;
		ind1 = IPLbits[i+2] - 1;
		ind0 = IPLbits[i+3] - 1;
		for (quadbits = 0; quadbits < 16; quadbits++) {
			if (quadbits & (1 << 3))
				bits[ind3] = 1;
			if (quadbits & (1 << 2))
				bits[ind2] = 1;
			if (quadbits & (1 << 1))
				bits[ind1] = 1;
			if (quadbits & 1)
				bits[ind0] = 1;
			perm(bits, IP, &left, &right);
			bits[ind3] = 0;
			bits[ind2] = 0;
			bits[ind1] = 0;
			bits[ind0] = 0;
			if (right != 0) {
				fprintf(stderr,
				    "IPL tabno %d quad %d right not zero\n",
				    tabno, quadbits);
				exit(1);
			}
			IPL[tabno][quadbits] = left;
			if (quadbits == 15 && tabno == 7) {
				printf(" 0x%08x", left);
			} else if (quadbits & 0x3) {
				printf(" 0x%08x,", left);
			} else {
				printf("\n\t0x%08x,", left);
			}
		}
		if (tabno == 7)
			printf("\n};\n");
		printf("\n");
	}

	/*
	 * Compute the right half of the same table.  I noticed this table
	 * was the same as the previous one, just by luck, so we don't
	 * actually have to do this.  Do it anyway just for a check.
	 */
	for (tabno = 0; tabno < 8; tabno++) {
		i = tabno * 4;
		ind3 = IPRbits[i] - 1;
		ind2 = IPRbits[i+1] - 1;
		ind1 = IPRbits[i+2] - 1;
		ind0 = IPRbits[i+3] - 1;
		for (quadbits = 0; quadbits < 16; quadbits++) {
			if (quadbits & (1 << 3))
				bits[ind3] = 1;
			if (quadbits & (1 << 2))
				bits[ind2] = 1;
			if (quadbits & (1 << 1))
				bits[ind1] = 1;
			if (quadbits & 1)
				bits[ind0] = 1;
			perm(bits, IP, &left, &right);
			bits[ind3] = 0;
			bits[ind2] = 0;
			bits[ind1] = 0;
			bits[ind0] = 0;
			if (left != 0) {
				fprintf(stderr,
				    "IPR tabno %d quad %d left not zero\n",
				    tabno, quadbits);
				exit(1);
			}
			if (right != IPL[tabno][quadbits]) {
				fprintf(stderr,
			"IPR tabno %d quad %d: 0x%08x not same as 0x%08x\n",
				   tabno, quadbits, right,IPL[tabno][quadbits]);
				exit(1);
			}
		}
	}

	/*
	 * Next are the FP tables
	 */
	printf("static U_LONG FP[8][16] = {");
	for (tabno = 0; tabno < 8; tabno++) {
		i = tabno * 4;
		ind3 = FPLbits[i] - 1;
		ind2 = FPLbits[i+1] - 1;
		ind1 = FPLbits[i+2] - 1;
		ind0 = FPLbits[i+3] - 1;
		for (quadbits = 0; quadbits < 16; quadbits++) {
			if (quadbits & (1 << 3))
				bits[ind3] = 1;
			if (quadbits & (1 << 2))
				bits[ind2] = 1;
			if (quadbits & (1 << 1))
				bits[ind1] = 1;
			if (quadbits & 1)
				bits[ind0] = 1;
			perm(bits, FP, &left, &right);
			bits[ind3] = 0;
			bits[ind2] = 0;
			bits[ind1] = 0;
			bits[ind0] = 0;
			if (right != 0) {
				fprintf(stderr,
				    "FPL tabno %d quad %d right not zero\n",
				    tabno, quadbits);
				exit(1);
			}
			FPL[tabno][quadbits] = left;
			if (quadbits == 15 && tabno == 7) {
				printf(" 0x%08x", left);
			} else if (quadbits & 0x3) {
				printf(" 0x%08x,", left);
			} else {
				printf("\n\t0x%08x,", left);
			}
		}
		if (tabno == 7)
			printf("\n};");
		printf("\n");
	}

	/*
	 * Right half of same set of tables.  This was symmetric too.
	 * Amazing!
	 */
	for (tabno = 0; tabno < 8; tabno++) {
		i = tabno * 4;
		ind3 = FPRbits[i] - 1;
		ind2 = FPRbits[i+1] - 1;
		ind1 = FPRbits[i+2] - 1;
		ind0 = FPRbits[i+3] - 1;
		for (quadbits = 0; quadbits < 16; quadbits++) {
			if (quadbits & (1 << 3))
				bits[ind3] = 1;
			if (quadbits & (1 << 2))
				bits[ind2] = 1;
			if (quadbits & (1 << 1))
				bits[ind1] = 1;
			if (quadbits & 1)
				bits[ind0] = 1;
			perm(bits, FP, &left, &right);
			bits[ind3] = 0;
			bits[ind2] = 0;
			bits[ind1] = 0;
			bits[ind0] = 0;
			if (left != 0) {
				fprintf(stderr,
				    "FPR tabno %d quad %d left not zero\n",
				    tabno, quadbits);
				exit(1);
			}
			if (right != FPL[tabno][quadbits]) {
				fprintf(stderr,
			"FPR tabno %d quad %d: 0x%08x not same as 0x%08x\n",
				   tabno, quadbits, right,FPL[tabno][quadbits]);
				exit(1);
			}
		}
	}
}
Commit	Line	Data
09169146 GW	1	/* omakeIPFP.c,v 3.1 1993/07/06 01:05:10 jbj Exp
	2	* makeIPFP - make fast DES IP and FP tables
	3	*
	4	* This is an older version which generated tables half the size of
	5	* the current version, but which took about double the CPU time to
	6	* compute permutations from these tables. Since the CPU spent on the
	7	* permutations is small compared to the CPU spent in the cipher code,
	8	* I may go back to the smaller tables to save the space some day.
	9	*/
	10
	11	#include <stdio.h>
	12	#include <sys/types.h>
	13
	14	#include "ntp_stdlib.h"
	15
	16	#define STREQ(a, b) ((a) == (b) && strcmp((a), (b)) == 0)
	17
	18	U_LONG IPL[8][16];
	19	U_LONG FPL[8][16];
	20
	21	char *progname;
	22	int debug;
	23
	24	static void perm P((u_char , u_char , U_LONG , U_LONG ));
	25	static void doit P((void));
	26
	27	/*
	28	* main - parse arguments and handle options
	29	*/
	30	void
	31	main(argc, argv)
	32	int argc;
	33	char *argv[];
	34	{
	35	int c;
	36	int errflg = 0;
	37	extern int optind;
	38	extern char *optarg;
	39
	40	progname = argv[0];
	41	while ((c = getopt_l(argc, argv, "d")) != EOF)
	42	switch (c) {
	43	case 'd':
	44	++debug;
	45	break;
	46	default:
	47	errflg++;
	48	break;
	49	}
	50	if (errflg) {
	51	(void) fprintf(stderr, "usage: %s [-d]\n", progname);
	52	exit(2);
	53	}
	54	doit();
	55	exit(0);
	56	}
	57
	58
	59	/*
	60	* Initial permutation table
	61	*/
	62	u_char IP[64] = {
	63	58, 50, 42, 34, 26, 18, 10, 2,
	64	60, 52, 44, 36, 28, 20, 12, 4,
65	62, 54, 46, 38, 30, 22, 14, 6,
66	64, 56, 48, 40, 32, 24, 16, 8,
67	57, 49, 41, 33, 25, 17, 9, 1,
68	59, 51, 43, 35, 27, 19, 11, 3,
69	61, 53, 45, 37, 29, 21, 13, 5,
70	63, 55, 47, 39, 31, 23, 15, 7
71	};
72
73	/*
74	* Inverse initial permutation table
75	*/
76	u_char FP[64] = {
77	40, 8, 48, 16, 56, 24, 64, 32,
78	39, 7, 47, 15, 55, 23, 63, 31,
79	38, 6, 46, 14, 54, 22, 62, 30,
80	37, 5, 45, 13, 53, 21, 61, 29,
81	36, 4, 44, 12, 52, 20, 60, 28,
82	35, 3, 43, 11, 51, 19, 59, 27,
83	34, 2, 42, 10, 50, 18, 58, 26,
84	33, 1, 41, 9, 49, 17, 57, 25
85	};
86
87
88	/*
89	* Bit order after the operation
90	*
91	* ((left & 0x55555555) << 1) \| (right & 0x55555555)
92	*/
93	u_char IPLbits[32] = {
94	2, 34, 4, 36, 6, 38, 8, 40,
95	10, 42, 12, 44, 14, 46, 16, 48,
96	18, 50, 20, 52, 22, 54, 24, 56,
97	26, 58, 28, 60, 30, 62, 32, 64
98	};
99
100
101	/*
102	* Bit order after the operation
103	*
104	* (left & 0xaaaaaaaa) \| ((right & 0xaaaaaaaa) >> 1)
105	*/
106	u_char IPRbits[32] = {
107	1, 33, 3, 35, 5, 37, 7, 39,
108	9, 41, 11, 43, 13, 45, 15, 47,
109	17, 49, 19, 51, 21, 53, 23, 55,
110	25, 57, 27, 59, 29, 61, 31, 63
111	};
112
113
114	/*
115	* Bit order after the operation
116	*
117	* ((left & 0x0f0f0f0f) << 4) \| (right & 0x0f0f0f0f)
118	*/
119	u_char FPLbits[32] = {
120	5, 6, 7, 8, 37, 38, 39, 40,
121	13, 14, 15, 16, 45, 46, 47, 48,
122	21, 22, 23, 24, 53, 54, 55, 56,
123	29, 30, 31, 32, 61, 62, 63, 64
124	};
125
126
127	/*
128	* Bit order after the operation
129	*
130	* (left & 0xf0f0f0f0) \| ((right & 0xf0f0f0f0) >> 4)
131	*/
132	u_char FPRbits[32] = {
133	1, 2, 3, 4, 33, 34, 35, 36,
134	9, 10, 11, 12, 41, 42, 43, 44,
135	17, 18, 19, 20, 49, 50, 51, 52,
136	25, 26, 27, 28, 57, 58, 59, 60
137	};
138
139
140	/*
141	* perm - do a permutation with the given table
142	*/
143	static void
144	perm(databits, permtab, leftp, rightp)
145	u_char *databits;
146	u_char *permtab;
147	U_LONG *leftp;
148	U_LONG *rightp;
149	{
150	register U_LONG left;
151	register U_LONG right;
152	register u_char *PT;
153	register u_char *bits;
154	register int i;
155
156	left = right = 0;
157	PT = permtab;
158	bits = databits;
159
160	for (i = 0; i < 32; i++) {
161	left <<= 1;
162	if (bits[PT[i]-1])
163	left \|= 1;
164	}
165
166	for (i = 32; i < 64; i++) {
167	right <<= 1;
168	if (bits[PT[i]-1])
169	right \|= 1;
170	}
171
172	*leftp = left;
173	*rightp = right;
174	}
175
176
177	/*
178	* doit - make up the tables
179	*/
180	static void
181	doit()
182	{
183	u_char bits[64];
184	U_LONG left;
185	U_LONG right;
186	int tabno;
187	int i;
188	int ind0, ind1, ind2, ind3;
189	int quadbits;
190
191	bzero((char *)bits, sizeof bits);
192
193	/*
194	* Do the rounds for the IPL table. We save the results of
195	* this as well as printing them. Note that this is the
196	* left-half table.
197	*/
198	printf("static U_LONG IP[8][16] = {");
199	for (tabno = 0; tabno < 8; tabno++) {
200	i = tabno * 4;
201	ind3 = IPLbits[i] - 1;
202	ind2 = IPLbits[i+1] - 1;
203	ind1 = IPLbits[i+2] - 1;
204	ind0 = IPLbits[i+3] - 1;
205	for (quadbits = 0; quadbits < 16; quadbits++) {
206	if (quadbits & (1 << 3))
207	bits[ind3] = 1;
208	if (quadbits & (1 << 2))
209	bits[ind2] = 1;
210	if (quadbits & (1 << 1))
211	bits[ind1] = 1;
212	if (quadbits & 1)
213	bits[ind0] = 1;
214	perm(bits, IP, &left, &right);
215	bits[ind3] = 0;
216	bits[ind2] = 0;
217	bits[ind1] = 0;
218	bits[ind0] = 0;
219	if (right != 0) {
220	fprintf(stderr,
221	"IPL tabno %d quad %d right not zero\n",
222	tabno, quadbits);
223	exit(1);
224	}
225	IPL[tabno][quadbits] = left;
226	if (quadbits == 15 && tabno == 7) {
227	printf(" 0x%08x", left);
228	} else if (quadbits & 0x3) {
229	printf(" 0x%08x,", left);
230	} else {
231	printf("\n\t0x%08x,", left);
232	}
233	}
234	if (tabno == 7)
235	printf("\n};\n");
236	printf("\n");
237	}
238
239	/*
240	* Compute the right half of the same table. I noticed this table
241	* was the same as the previous one, just by luck, so we don't
242	* actually have to do this. Do it anyway just for a check.
243	*/
244	for (tabno = 0; tabno < 8; tabno++) {
245	i = tabno * 4;
246	ind3 = IPRbits[i] - 1;
247	ind2 = IPRbits[i+1] - 1;
248	ind1 = IPRbits[i+2] - 1;
249	ind0 = IPRbits[i+3] - 1;
250	for (quadbits = 0; quadbits < 16; quadbits++) {
251	if (quadbits & (1 << 3))
252	bits[ind3] = 1;
253	if (quadbits & (1 << 2))
254	bits[ind2] = 1;
255	if (quadbits & (1 << 1))
256	bits[ind1] = 1;
257	if (quadbits & 1)
258	bits[ind0] = 1;
259	perm(bits, IP, &left, &right);
260	bits[ind3] = 0;
261	bits[ind2] = 0;
262	bits[ind1] = 0;
263	bits[ind0] = 0;
264	if (left != 0) {
265	fprintf(stderr,
266	"IPR tabno %d quad %d left not zero\n",
267	tabno, quadbits);
268	exit(1);
269	}
270	if (right != IPL[tabno][quadbits]) {
271	fprintf(stderr,
272	"IPR tabno %d quad %d: 0x%08x not same as 0x%08x\n",
273	tabno, quadbits, right,IPL[tabno][quadbits]);
274	exit(1);
275	}
276	}
277	}
278
279	/*
280	* Next are the FP tables
281	*/
282	printf("static U_LONG FP[8][16] = {");
283	for (tabno = 0; tabno < 8; tabno++) {
284	i = tabno * 4;
285	ind3 = FPLbits[i] - 1;
286	ind2 = FPLbits[i+1] - 1;
287	ind1 = FPLbits[i+2] - 1;
288	ind0 = FPLbits[i+3] - 1;
289	for (quadbits = 0; quadbits < 16; quadbits++) {
290	if (quadbits & (1 << 3))
291	bits[ind3] = 1;
292	if (quadbits & (1 << 2))
293	bits[ind2] = 1;
294	if (quadbits & (1 << 1))
295	bits[ind1] = 1;
296	if (quadbits & 1)
297	bits[ind0] = 1;
298	perm(bits, FP, &left, &right);
299	bits[ind3] = 0;
300	bits[ind2] = 0;
301	bits[ind1] = 0;
302	bits[ind0] = 0;
303	if (right != 0) {
304	fprintf(stderr,
305	"FPL tabno %d quad %d right not zero\n",
306	tabno, quadbits);
307	exit(1);
308	}
309	FPL[tabno][quadbits] = left;
310	if (quadbits == 15 && tabno == 7) {
311	printf(" 0x%08x", left);
312	} else if (quadbits & 0x3) {
313	printf(" 0x%08x,", left);
314	} else {
315	printf("\n\t0x%08x,", left);
316	}
317	}
318	if (tabno == 7)
319	printf("\n};");
320	printf("\n");
321	}
322
323	/*
324	* Right half of same set of tables. This was symmetric too.
325	* Amazing!
326	*/
327	for (tabno = 0; tabno < 8; tabno++) {
328	i = tabno * 4;
329	ind3 = FPRbits[i] - 1;
330	ind2 = FPRbits[i+1] - 1;
331	ind1 = FPRbits[i+2] - 1;
332	ind0 = FPRbits[i+3] - 1;
333	for (quadbits = 0; quadbits < 16; quadbits++) {
334	if (quadbits & (1 << 3))
335	bits[ind3] = 1;
336	if (quadbits & (1 << 2))
337	bits[ind2] = 1;
338	if (quadbits & (1 << 1))
339	bits[ind1] = 1;
340	if (quadbits & 1)
341	bits[ind0] = 1;
342	perm(bits, FP, &left, &right);
343	bits[ind3] = 0;
344	bits[ind2] = 0;
345	bits[ind1] = 0;
346	bits[ind0] = 0;
347	if (left != 0) {
348	fprintf(stderr,
349	"FPR tabno %d quad %d left not zero\n",
350	tabno, quadbits);
351	exit(1);
352	}
353	if (right != FPL[tabno][quadbits]) {
354	fprintf(stderr,
355	"FPR tabno %d quad %d: 0x%08x not same as 0x%08x\n",
356	tabno, quadbits, right,FPL[tabno][quadbits]);
357	exit(1);
358	}
359	}
360	}
361	}