alo@kampi.hut.fi (Antti Louko) (03/10/89)
Submitted by: alo@kampi.hut.fi (Antti Louko)
Posting-number: Volume 18, Issue 8
Archive-name: des-no-usa/Part02
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 2 (of 2)."
# Contents: tables/Makefile lib/spe-table.h lib/eight.h lib/ip.h
# lib/ksched.c lib/des.h lib/fp.h lib/des-private.h lib/des-data.c
# lib/Makerules lib/des-expand.c lib/des-fun.c lib/des-perms.c
# lib/ecb-encrypt.c lib/GNUmakefile lib/cbc-encrypt.c
# lib/cbc-cksum.c lib/des-reverse.c lib/pcbc-encrypt.c
# lib/string-to-key.c lib/des-hash.c lib/alo-getpass.c
# lib/alo-getline.c lib/read-passwd.c lib/des-hex.c lib/Makefile
# Wrapped by kre@munnari on Fri Mar 10 18:29:45 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'tables/Makefile' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'tables/Makefile'\"
else
echo shar: Extracting \"'tables/Makefile'\" \(580 characters\)
sed "s/^X//" >'tables/Makefile' <<'END_OF_FILE'
X#
X# kludged standard make Makefile - derived from GNU makefile .. kre
X#
XSOURCES= eight.make fp.make ip.make spe-table.make
XHS= ../lib/eight.h ../lib/fp.h ../lib/ip.h ../lib/spe-table.h
XPRINT= enscript
XPRINTFILES= mk-ip $(SOURCES)
X
Xall: $(HS)
X
Xclean:
X @echo "These files can be removed: $(HS)"
X @echo $(HS) > REMOVABLE
X
X../lib/eight.h: eight.make
X ./eight.make > ../lib/eight.h
X
X../lib/fp.h: fp.make
X ./fp.make > ../lib/fp.h
X
X../lib/ip.h: ip.make
X ./ip.make > ../lib/ip.h
X
X../lib/spe-table.h: spe-table.make
X ./spe-table.make > ../lib/spe-table.h
X
Xprint:
X $(PRINT) $(PRINTFILES)
END_OF_FILE
if test 580 -ne `wc -c <'tables/Makefile'`; then
echo shar: \"'tables/Makefile'\" unpacked with wrong size!
fi
# end of 'tables/Makefile'
fi
if test -f 'lib/spe-table.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/spe-table.h'\"
else
echo shar: Extracting \"'lib/spe-table.h'\" \(12288 characters\)
sed "s/^X//" >'lib/spe-table.h' <<'END_OF_FILE'
X0x20022000,
X0x20000000,
X0x00000000,
X0x20022000,
X0x00000000,
X0x20022000,
X0x20000000,
X0x00000000,
X0x20022000,
X0x20022000,
X0x20000000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x20000000,
X0x20000000,
X0x00000000,
X0x00022000,
X0x20022000,
X0x20022000,
X0x20000000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00022000,
X0x20022000,
X0x20000000,
X0x00022000,
X0x00022000,
X0x20000000,
X0x00000000,
X0x00000000,
X0x20022000,
X0x00022000,
X0x20000000,
X0x20022000,
X0x20000000,
X0x00022000,
X0x00022000,
X0x20000000,
X0x00022000,
X0x20022000,
X0x00000000,
X0x20022000,
X0x00000000,
X0x00000000,
X0x20000000,
X0x20022000,
X0x20022000,
X0x20000000,
X0x00022000,
X0x00000000,
X0x00022000,
X0x20000000,
X0x00000000,
X0x20000000,
X0x00000000,
X0x00022000,
X0x20022000,
X0x00000000,
X0x20000000,
X0x00022000,
X0x20022000,
X0x00000802,
X0x00000002,
X0x08000800,
X0x08000802,
X0x00000800,
X0x08000002,
X0x08000002,
X0x08000800,
X0x08000002,
X0x00000802,
X0x00000802,
X0x08000000,
X0x08000800,
X0x00000800,
X0x00000000,
X0x08000002,
X0x00000002,
X0x08000000,
X0x00000800,
X0x00000002,
X0x08000802,
X0x00000802,
X0x08000000,
X0x00000800,
X0x08000000,
X0x00000000,
X0x00000002,
X0x08000802,
X0x00000000,
X0x08000800,
X0x08000802,
X0x00000000,
X0x00000000,
X0x08000802,
X0x00000800,
X0x08000002,
X0x00000802,
X0x00000002,
X0x08000000,
X0x00000800,
X0x08000802,
X0x00000000,
X0x00000002,
X0x08000800,
X0x08000002,
X0x08000000,
X0x08000800,
X0x00000802,
X0x08000802,
X0x00000002,
X0x00000802,
X0x08000800,
X0x00000800,
X0x08000000,
X0x08000002,
X0x00000000,
X0x00000002,
X0x00000800,
X0x08000800,
X0x00000802,
X0x08000000,
X0x08000802,
X0x00000000,
X0x08000002,
X0x02200004,
X0x00000000,
X0x02200000,
X0x00000000,
X0x00000004,
X0x02200004,
X0x02200000,
X0x02200000,
X0x02200000,
X0x00000004,
X0x00000004,
X0x02200000,
X0x00000004,
X0x02200000,
X0x00000000,
X0x00000004,
X0x00000000,
X0x02200004,
X0x00000004,
X0x02200000,
X0x02200004,
X0x00000000,
X0x00000000,
X0x00000004,
X0x02200004,
X0x02200004,
X0x02200000,
X0x00000004,
X0x00000000,
X0x00000000,
X0x02200004,
X0x02200004,
X0x00000004,
X0x02200000,
X0x02200000,
X0x02200004,
X0x02200004,
X0x00000004,
X0x00000004,
X0x00000000,
X0x00000000,
X0x02200004,
X0x00000000,
X0x00000004,
X0x02200000,
X0x00000000,
X0x02200004,
X0x02200004,
X0x02200000,
X0x02200000,
X0x00000000,
X0x00000004,
X0x00000004,
X0x02200004,
X0x02200000,
X0x00000000,
X0x00000004,
X0x00000000,
X0x02200004,
X0x02200000,
X0x02200004,
X0x00000004,
X0x00000000,
X0x02200000,
X0x01100004,
X0x00000000,
X0x00000004,
X0x01100004,
X0x01100000,
X0x00000000,
X0x01100000,
X0x00000004,
X0x00000000,
X0x01100004,
X0x00000000,
X0x01100000,
X0x00000004,
X0x01100004,
X0x01100004,
X0x00000000,
X0x00000004,
X0x01100000,
X0x01100004,
X0x00000000,
X0x00000004,
X0x01100000,
X0x00000000,
X0x00000004,
X0x01100000,
X0x00000004,
X0x01100004,
X0x01100000,
X0x01100000,
X0x00000004,
X0x00000000,
X0x01100004,
X0x00000004,
X0x01100004,
X0x01100000,
X0x00000004,
X0x01100004,
X0x00000004,
X0x01100000,
X0x00000000,
X0x01100000,
X0x00000000,
X0x00000004,
X0x01100004,
X0x00000000,
X0x01100000,
X0x00000004,
X0x01100000,
X0x01100004,
X0x00000000,
X0x00000000,
X0x01100000,
X0x00000000,
X0x01100004,
X0x00000004,
X0x01100004,
X0x01100004,
X0x00000004,
X0x00000000,
X0x01100000,
X0x01100000,
X0x00000000,
X0x01100004,
X0x00000004,
X0x00000000,
X0x10000400,
X0x00000400,
X0x00000400,
X0x10000000,
X0x00000000,
X0x00000400,
X0x10000400,
X0x00000400,
X0x10000000,
X0x10000000,
X0x00000000,
X0x10000400,
X0x00000400,
X0x00000000,
X0x10000000,
X0x00000000,
X0x10000000,
X0x10000400,
X0x00000400,
X0x00000400,
X0x10000400,
X0x10000000,
X0x00000000,
X0x10000000,
X0x00000400,
X0x10000400,
X0x10000000,
X0x10000400,
X0x00000000,
X0x00000000,
X0x10000400,
X0x10000400,
X0x00000400,
X0x00000000,
X0x10000000,
X0x00000400,
X0x10000000,
X0x10000000,
X0x00000400,
X0x00000000,
X0x10000400,
X0x10000400,
X0x10000000,
X0x10000000,
X0x00000000,
X0x10000400,
X0x00000000,
X0x10000400,
X0x00000000,
X0x00000000,
X0x10000400,
X0x10000000,
X0x00000400,
X0x00000400,
X0x10000400,
X0x00000400,
X0x00000000,
X0x10000000,
X0x00000400,
X0x00000000,
X0x10000400,
X0x00000400,
X0x10000000,
X0x04011000,
X0x00011001,
X0x00000000,
X0x04011000,
X0x04000001,
X0x00011000,
X0x04011000,
X0x00000001,
X0x00011000,
X0x00000001,
X0x00011001,
X0x04000000,
X0x04011001,
X0x04000000,
X0x04000000,
X0x04011001,
X0x00000000,
X0x04000001,
X0x00011001,
X0x00000000,
X0x04000000,
X0x04011001,
X0x00000001,
X0x04011000,
X0x04011001,
X0x00011000,
X0x04000001,
X0x00011001,
X0x00000001,
X0x00000000,
X0x00011000,
X0x04000001,
X0x00011001,
X0x00000000,
X0x04000000,
X0x00000001,
X0x04000000,
X0x04000001,
X0x00011001,
X0x04011000,
X0x00000000,
X0x00011001,
X0x00000001,
X0x04011001,
X0x04000001,
X0x00011000,
X0x04011001,
X0x04000000,
X0x04000001,
X0x04011000,
X0x00011000,
X0x04011001,
X0x00000001,
X0x00011000,
X0x04011000,
X0x00000001,
X0x00011000,
X0x00000000,
X0x04011001,
X0x04000000,
X0x04011000,
X0x04000001,
X0x00000000,
X0x00011001,
X0x00040002,
X0x00040000,
X0x00000002,
X0x00040002,
X0x00000000,
X0x00000000,
X0x00040002,
X0x00000002,
X0x00040000,
X0x00000002,
X0x00000000,
X0x00040002,
X0x00000002,
X0x00040002,
X0x00000000,
X0x00000000,
X0x00000002,
X0x00040000,
X0x00040000,
X0x00000002,
X0x00040000,
X0x00040002,
X0x00000000,
X0x00040000,
X0x00040002,
X0x00000000,
X0x00000002,
X0x00040000,
X0x00040000,
X0x00000002,
X0x00040002,
X0x00000000,
X0x00000002,
X0x00040002,
X0x00000000,
X0x00000002,
X0x00040000,
X0x00040000,
X0x00000002,
X0x00000000,
X0x00040002,
X0x00000000,
X0x00040000,
X0x00000002,
X0x00000000,
X0x00000002,
X0x00040000,
X0x00040000,
X0x00000000,
X0x00040002,
X0x00040002,
X0x00000000,
X0x00040002,
X0x00000002,
X0x00040000,
X0x00040002,
X0x00000002,
X0x00040000,
X0x00000000,
X0x00040002,
X0x00040002,
X0x00000000,
X0x00000002,
X0x00040000,
X0x20000110,
X0x00040000,
X0x20000000,
X0x20040110,
X0x00000000,
X0x00040110,
X0x20040000,
X0x20000110,
X0x00040110,
X0x20040000,
X0x00040000,
X0x20000000,
X0x20040000,
X0x20000110,
X0x00000110,
X0x00040000,
X0x20040110,
X0x00000110,
X0x00000000,
X0x20000000,
X0x00000110,
X0x20040000,
X0x00040110,
X0x00000000,
X0x20000000,
X0x00000000,
X0x20000110,
X0x00040110,
X0x00040000,
X0x20040110,
X0x20040110,
X0x00000110,
X0x20040110,
X0x20000000,
X0x00000110,
X0x20040000,
X0x00000110,
X0x00040000,
X0x20000000,
X0x00040110,
X0x20040000,
X0x00000000,
X0x00000000,
X0x20000110,
X0x00000000,
X0x20040110,
X0x00040110,
X0x00000000,
X0x00040000,
X0x20040110,
X0x20000110,
X0x00000110,
X0x20040110,
X0x20000000,
X0x00040000,
X0x20000110,
X0x20000110,
X0x00000110,
X0x00040110,
X0x20040000,
X0x20000000,
X0x00040000,
X0x20040000,
X0x00040110,
X0x00000000,
X0x04000000,
X0x00011000,
X0x04011008,
X0x04000008,
X0x00011000,
X0x04011008,
X0x04000000,
X0x04000000,
X0x00000008,
X0x00000008,
X0x04011000,
X0x00011008,
X0x04000008,
X0x04011000,
X0x00000000,
X0x04011000,
X0x00000000,
X0x04000008,
X0x00011008,
X0x00011000,
X0x04011008,
X0x00000000,
X0x00000008,
X0x00000008,
X0x00011008,
X0x04011008,
X0x04000008,
X0x04000000,
X0x00011000,
X0x00011008,
X0x04011000,
X0x04011000,
X0x00011008,
X0x04000008,
X0x04000000,
X0x04000000,
X0x00000008,
X0x00000008,
X0x00011000,
X0x00000000,
X0x04011000,
X0x04011008,
X0x00000000,
X0x04011008,
X0x00000000,
X0x00011000,
X0x04000008,
X0x00011008,
X0x00011000,
X0x00000000,
X0x04011008,
X0x04000008,
X0x04011000,
X0x00011008,
X0x04000000,
X0x04011000,
X0x04000008,
X0x00011000,
X0x00011008,
X0x00000008,
X0x04011008,
X0x04000000,
X0x00000008,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00022000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00022000,
X0x00000000,
X0x00000000,
X0x00000000,
X0x00022000,
X0x00022000,
X0x00000110,
X0x00000110,
X0x00000000,
X0x00080000,
X0x00000110,
X0x00080000,
X0x00080110,
X0x00000000,
X0x00080110,
X0x00080110,
X0x00080000,
X0x00000000,
X0x00080000,
X0x00000110,
X0x00000000,
X0x00080110,
X0x00000000,
X0x00080110,
X0x00000110,
X0x00000000,
X0x00080000,
X0x00000110,
X0x00080000,
X0x00000110,
X0x00080110,
X0x00000000,
X0x00000000,
X0x00080110,
X0x00000110,
X0x00080000,
X0x00080110,
X0x00080000,
X0x00080110,
X0x00000000,
X0x00080000,
X0x00080110,
X0x00080000,
X0x00000110,
X0x00000000,
X0x00080000,
X0x00000000,
X0x00080000,
X0x00000110,
X0x00000000,
X0x00000110,
X0x00080110,
X0x00080000,
X0x00000110,
X0x00080110,
X0x00080000,
X0x00000000,
X0x00080110,
X0x00000110,
X0x00000000,
X0x00080110,
X0x00000000,
X0x00080000,
X0x00000110,
X0x00080110,
X0x00080000,
X0x00000000,
X0x00080110,
X0x00000110,
X0x00000110,
X0x02200000,
X0x00000008,
X0x00000000,
X0x02200008,
X0x00000008,
X0x00000000,
X0x02200000,
X0x00000008,
X0x00000000,
X0x02200008,
X0x00000008,
X0x02200000,
X0x02200000,
X0x02200000,
X0x02200008,
X0x00000008,
X0x00000008,
X0x02200000,
X0x02200008,
X0x00000000,
X0x00000000,
X0x00000000,
X0x02200008,
X0x02200008,
X0x02200008,
X0x02200008,
X0x02200000,
X0x00000000,
X0x00000000,
X0x00000008,
X0x00000008,
X0x02200000,
X0x00000000,
X0x02200000,
X0x02200000,
X0x00000008,
X0x02200008,
X0x00000008,
X0x00000000,
X0x02200000,
X0x02200000,
X0x00000000,
X0x02200008,
X0x00000008,
X0x00000008,
X0x02200008,
X0x00000008,
X0x00000000,
X0x02200008,
X0x00000008,
X0x00000008,
X0x02200000,
X0x02200000,
X0x02200008,
X0x00000008,
X0x00000000,
X0x00000000,
X0x02200000,
X0x02200000,
X0x02200008,
X0x02200008,
X0x00000000,
X0x00000000,
X0x02200008,
X0x01100000,
X0x00000800,
X0x00000800,
X0x00000001,
X0x01100801,
X0x01100001,
X0x01100800,
X0x00000000,
X0x00000000,
X0x00000801,
X0x00000801,
X0x01100000,
X0x00000001,
X0x01100800,
X0x01100000,
X0x00000801,
X0x00000801,
X0x01100000,
X0x01100001,
X0x01100801,
X0x00000000,
X0x00000800,
X0x00000001,
X0x01100800,
X0x01100001,
X0x01100801,
X0x01100800,
X0x00000001,
X0x01100801,
X0x01100001,
X0x00000800,
X0x00000000,
X0x01100801,
X0x01100000,
X0x01100001,
X0x00000801,
X0x01100000,
X0x00000800,
X0x00000000,
X0x01100001,
X0x00000801,
X0x01100801,
X0x01100800,
X0x00000000,
X0x00000800,
X0x00000001,
X0x00000001,
X0x00000800,
X0x00000000,
X0x00000801,
X0x00000800,
X0x01100800,
X0x00000801,
X0x01100000,
X0x01100801,
X0x00000000,
X0x01100800,
X0x00000001,
X0x01100001,
X0x01100801,
X0x00000001,
X0x01100800,
X0x01100000,
X0x01100001,
X0x00000000,
X0x00000000,
X0x00000400,
X0x10000400,
X0x10000400,
X0x10000000,
X0x00000000,
X0x00000000,
X0x00000400,
X0x10000400,
X0x10000000,
X0x00000400,
X0x10000000,
X0x00000400,
X0x00000400,
X0x10000000,
X0x10000400,
X0x00000000,
X0x10000000,
X0x10000400,
X0x00000000,
X0x00000400,
X0x10000400,
X0x00000000,
X0x10000400,
X0x10000000,
X0x00000400,
X0x10000000,
X0x10000000,
X0x10000400,
X0x00000000,
X0x00000400,
X0x10000000,
X0x00000400,
X0x10000400,
X0x10000000,
X0x00000000,
X0x00000000,
X0x00000400,
X0x10000400,
X0x10000400,
X0x10000000,
X0x00000000,
X0x00000000,
X0x00000000,
X0x10000400,
X0x10000000,
X0x00000400,
X0x00000000,
X0x10000400,
X0x00000400,
X0x00000000,
X0x10000000,
X0x00000000,
X0x10000400,
X0x00000400,
X0x00000400,
X0x10000000,
X0x10000000,
X0x10000400,
X0x10000400,
X0x00000400,
X0x00000400,
X0x10000000,
X0x00000220,
X0x08000000,
X0x08000220,
X0x00000000,
X0x08000000,
X0x00000220,
X0x00000000,
X0x08000220,
X0x00000220,
X0x00000000,
X0x08000000,
X0x08000220,
X0x08000220,
X0x08000220,
X0x00000220,
X0x00000000,
X0x08000000,
X0x08000220,
X0x00000220,
X0x08000000,
X0x08000220,
X0x00000220,
X0x00000000,
X0x08000000,
X0x00000000,
X0x00000000,
X0x08000220,
X0x00000220,
X0x00000000,
X0x08000000,
X0x08000000,
X0x00000220,
X0x00000000,
X0x08000000,
X0x00000220,
X0x08000220,
X0x08000220,
X0x00000000,
X0x00000000,
X0x08000000,
X0x00000220,
X0x08000220,
X0x08000000,
X0x00000220,
X0x08000000,
X0x00000220,
X0x00000220,
X0x08000000,
X0x08000220,
X0x00000000,
X0x00000000,
X0x00000220,
X0x08000000,
X0x08000220,
X0x08000220,
X0x00000000,
X0x00000220,
X0x08000000,
X0x08000220,
X0x00000000,
X0x00000000,
X0x00000220,
X0x08000000,
X0x08000220,
X0x00080220,
X0x00080220,
X0x00000000,
X0x00000000,
X0x00080000,
X0x00000220,
X0x00080220,
X0x00080220,
X0x00000000,
X0x00080000,
X0x00000220,
X0x00000000,
X0x00000220,
X0x00080000,
X0x00080000,
X0x00080220,
X0x00000000,
X0x00000220,
X0x00000220,
X0x00080000,
X0x00080220,
X0x00080000,
X0x00000000,
X0x00000220,
X0x00080000,
X0x00000220,
X0x00080000,
X0x00080220,
X0x00000220,
X0x00000000,
X0x00080220,
X0x00000000,
X0x00000220,
X0x00000000,
X0x00080000,
X0x00080220,
X0x00000000,
X0x00080000,
X0x00000000,
X0x00000220,
X0x00080220,
X0x00080000,
X0x00080000,
X0x00000220,
X0x00080220,
X0x00000000,
X0x00000220,
X0x00080000,
X0x00080220,
X0x00000220,
X0x00080220,
X0x00080000,
X0x00000220,
X0x00000000,
X0x00080000,
X0x00080220,
X0x00000000,
X0x00080220,
X0x00000220,
X0x00000000,
X0x00080000,
X0x00080220,
X0x00000000,
X0x00000220,
END_OF_FILE
if test 12288 -ne `wc -c <'lib/spe-table.h'`; then
echo shar: \"'lib/spe-table.h'\" unpacked with wrong size!
fi
# end of 'lib/spe-table.h'
fi
if test -f 'lib/eight.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/eight.h'\"
else
echo shar: Extracting \"'lib/eight.h'\" \(1536 characters\)
sed "s/^X//" >'lib/eight.h' <<'END_OF_FILE'
X0000,
X0200,
X0100,
X0300,
X0040,
X0240,
X0140,
X0340,
X0020,
X0220,
X0120,
X0320,
X0060,
X0260,
X0160,
X0360,
X0010,
X0210,
X0110,
X0310,
X0050,
X0250,
X0150,
X0350,
X0030,
X0230,
X0130,
X0330,
X0070,
X0270,
X0170,
X0370,
X0004,
X0204,
X0104,
X0304,
X0044,
X0244,
X0144,
X0344,
X0024,
X0224,
X0124,
X0324,
X0064,
X0264,
X0164,
X0364,
X0014,
X0214,
X0114,
X0314,
X0054,
X0254,
X0154,
X0354,
X0034,
X0234,
X0134,
X0334,
X0074,
X0274,
X0174,
X0374,
X0002,
X0202,
X0102,
X0302,
X0042,
X0242,
X0142,
X0342,
X0022,
X0222,
X0122,
X0322,
X0062,
X0262,
X0162,
X0362,
X0012,
X0212,
X0112,
X0312,
X0052,
X0252,
X0152,
X0352,
X0032,
X0232,
X0132,
X0332,
X0072,
X0272,
X0172,
X0372,
X0006,
X0206,
X0106,
X0306,
X0046,
X0246,
X0146,
X0346,
X0026,
X0226,
X0126,
X0326,
X0066,
X0266,
X0166,
X0366,
X0016,
X0216,
X0116,
X0316,
X0056,
X0256,
X0156,
X0356,
X0036,
X0236,
X0136,
X0336,
X0076,
X0276,
X0176,
X0376,
X0001,
X0201,
X0101,
X0301,
X0041,
X0241,
X0141,
X0341,
X0021,
X0221,
X0121,
X0321,
X0061,
X0261,
X0161,
X0361,
X0011,
X0211,
X0111,
X0311,
X0051,
X0251,
X0151,
X0351,
X0031,
X0231,
X0131,
X0331,
X0071,
X0271,
X0171,
X0371,
X0005,
X0205,
X0105,
X0305,
X0045,
X0245,
X0145,
X0345,
X0025,
X0225,
X0125,
X0325,
X0065,
X0265,
X0165,
X0365,
X0015,
X0215,
X0115,
X0315,
X0055,
X0255,
X0155,
X0355,
X0035,
X0235,
X0135,
X0335,
X0075,
X0275,
X0175,
X0375,
X0003,
X0203,
X0103,
X0303,
X0043,
X0243,
X0143,
X0343,
X0023,
X0223,
X0123,
X0323,
X0063,
X0263,
X0163,
X0363,
X0013,
X0213,
X0113,
X0313,
X0053,
X0253,
X0153,
X0353,
X0033,
X0233,
X0133,
X0333,
X0073,
X0273,
X0173,
X0373,
X0007,
X0207,
X0107,
X0307,
X0047,
X0247,
X0147,
X0347,
X0027,
X0227,
X0127,
X0327,
X0067,
X0267,
X0167,
X0367,
X0017,
X0217,
X0117,
X0317,
X0057,
X0257,
X0157,
X0357,
X0037,
X0237,
X0137,
X0337,
X0077,
X0277,
X0177,
X0377,
END_OF_FILE
if test 1536 -ne `wc -c <'lib/eight.h'`; then
echo shar: \"'lib/eight.h'\" unpacked with wrong size!
fi
# end of 'lib/eight.h'
fi
if test -f 'lib/ip.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/ip.h'\"
else
echo shar: Extracting \"'lib/ip.h'\" \(2816 characters\)
sed "s/^X//" >'lib/ip.h' <<'END_OF_FILE'
Xif (R & 0x02000000) L_result |= 0x00000001;
Xif (R & 0x00020000) L_result |= 0x00000002;
Xif (R & 0x00000200) L_result |= 0x00000004;
Xif (R & 0x00000002) L_result |= 0x00000008;
Xif (L & 0x02000000) L_result |= 0x00000010;
Xif (L & 0x00020000) L_result |= 0x00000020;
Xif (L & 0x00000200) L_result |= 0x00000040;
Xif (L & 0x00000002) L_result |= 0x00000080;
Xif (R & 0x08000000) L_result |= 0x00000100;
Xif (R & 0x00080000) L_result |= 0x00000200;
Xif (R & 0x00000800) L_result |= 0x00000400;
Xif (R & 0x00000008) L_result |= 0x00000800;
Xif (L & 0x08000000) L_result |= 0x00001000;
Xif (L & 0x00080000) L_result |= 0x00002000;
Xif (L & 0x00000800) L_result |= 0x00004000;
Xif (L & 0x00000008) L_result |= 0x00008000;
Xif (R & 0x20000000) L_result |= 0x00010000;
Xif (R & 0x00200000) L_result |= 0x00020000;
Xif (R & 0x00002000) L_result |= 0x00040000;
Xif (R & 0x00000020) L_result |= 0x00080000;
Xif (L & 0x20000000) L_result |= 0x00100000;
Xif (L & 0x00200000) L_result |= 0x00200000;
Xif (L & 0x00002000) L_result |= 0x00400000;
Xif (L & 0x00000020) L_result |= 0x00800000;
Xif (R & 0x80000000) L_result |= 0x01000000;
Xif (R & 0x00800000) L_result |= 0x02000000;
Xif (R & 0x00008000) L_result |= 0x04000000;
Xif (R & 0x00000080) L_result |= 0x08000000;
Xif (L & 0x80000000) L_result |= 0x10000000;
Xif (L & 0x00800000) L_result |= 0x20000000;
Xif (L & 0x00008000) L_result |= 0x40000000;
Xif (L & 0x00000080) L_result |= 0x80000000;
Xif (R & 0x01000000) R_result |= 0x00000001;
Xif (R & 0x00010000) R_result |= 0x00000002;
Xif (R & 0x00000100) R_result |= 0x00000004;
Xif (R & 0x00000001) R_result |= 0x00000008;
Xif (L & 0x01000000) R_result |= 0x00000010;
Xif (L & 0x00010000) R_result |= 0x00000020;
Xif (L & 0x00000100) R_result |= 0x00000040;
Xif (L & 0x00000001) R_result |= 0x00000080;
Xif (R & 0x04000000) R_result |= 0x00000100;
Xif (R & 0x00040000) R_result |= 0x00000200;
Xif (R & 0x00000400) R_result |= 0x00000400;
Xif (R & 0x00000004) R_result |= 0x00000800;
Xif (L & 0x04000000) R_result |= 0x00001000;
Xif (L & 0x00040000) R_result |= 0x00002000;
Xif (L & 0x00000400) R_result |= 0x00004000;
Xif (L & 0x00000004) R_result |= 0x00008000;
Xif (R & 0x10000000) R_result |= 0x00010000;
Xif (R & 0x00100000) R_result |= 0x00020000;
Xif (R & 0x00001000) R_result |= 0x00040000;
Xif (R & 0x00000010) R_result |= 0x00080000;
Xif (L & 0x10000000) R_result |= 0x00100000;
Xif (L & 0x00100000) R_result |= 0x00200000;
Xif (L & 0x00001000) R_result |= 0x00400000;
Xif (L & 0x00000010) R_result |= 0x00800000;
Xif (R & 0x40000000) R_result |= 0x01000000;
Xif (R & 0x00400000) R_result |= 0x02000000;
Xif (R & 0x00004000) R_result |= 0x04000000;
Xif (R & 0x00000040) R_result |= 0x08000000;
Xif (L & 0x40000000) R_result |= 0x10000000;
Xif (L & 0x00400000) R_result |= 0x20000000;
Xif (L & 0x00004000) R_result |= 0x40000000;
Xif (L & 0x00000040) R_result |= 0x80000000;
END_OF_FILE
if test 2816 -ne `wc -c <'lib/ip.h'`; then
echo shar: \"'lib/ip.h'\" unpacked with wrong size!
fi
# end of 'lib/ip.h'
fi
if test -f 'lib/ksched.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/ksched.c'\"
else
echo shar: Extracting \"'lib/ksched.c'\" \(2314 characters\)
sed "s/^X//" >'lib/ksched.c' <<'END_OF_FILE'
X#include "des-private.h"
X
Xconst static char PC1[] = {
X 56,48,40,32,24,16, 8,
X 0,57,49,41,33,25,17,
X 9, 1,58,50,42,34,26,
X 18,10, 2,59,51,43,35,
X 62,54,46,38,30,22,14,
X 6,61,53,45,37,29,21,
X 13, 5,60,52,44,36,28,
X 20,12, 4,27,19,11, 3,
X};
X
Xconst static char PC2[] = {
X 13,16,10,23, 0, 4,
X 2,27,14, 5,20, 9,
X 22,18,11, 3,25, 7,
X 15, 6,26,19,12, 1,
X 40,51,30,36,46,54,
X 29,39,50,44,32,47,
X 43,48,38,55,33,52,
X 45,41,49,35,28,31,
X };
X
Xconst static char LS[] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
X
Xconst static int shift_arr[] = {
X 0x1, 0x2, 0x4, 0x8,
X 0x10, 0x20, 0x40, 0x80,
X 0x100, 0x200, 0x400, 0x800,
X 0x1000, 0x2000, 0x4000, 0x8000,
X 0x10000, 0x20000, 0x40000, 0x80000,
X 0x100000, 0x200000, 0x400000, 0x800000,
X 0x1000000, 0x2000000, 0x4000000, 0x8000000,
X 0x10000000, 0x20000000, 0x40000000, 0x80000000,
X};
X
X/* Key schedule calculation could be done with precomputed inline code
X similarly to 64-bit permutation calculation, but it would take about
X 18kbytes of code space */
X
X/* The least significant bit of key->data[0] is bit # 1 in
X DES-sepcification etc. */
X
Xdes_set_key(key,schedule)
X
XC_Block *key;
XKey_schedule *schedule;
X
X{
X des_u_long *kp;
X des_u_long Result_0;
X des_u_long Result_1;
X des_u_long sa = 0;
X des_u_long *Input;
X int i;
X int j;
X int Tmp;
X int result_bit;
X int side;
X int column;
X int result_side;
X#if BIG_ENDIAN
X C_Block t;
X#endif
X
X#if BIG_ENDIAN
X des_reverse(key,&t);
X Input = (des_u_long*)(t.data);
X#else
X Input = (des_u_long*)key->data;
X#endif
X kp = schedule->data;
X for(i = 0; i < 16; i++) {
X sa += LS[i];
X Result_0 = Result_1 = 0;
X result_side = 0;
X for(j = 0; j < 48; j++) {
X Tmp = PC2[j];
X side = (Tmp >= 28);
X column = (Tmp + sa) % 28;
X column = PC1[column + side*28];
X if (column >= 32) {
X side = 1;
X column -= 32;
X } else {
X side = 0;
X }
X if (j >= 24) {
X result_side = 1;
X result_bit = j-24;
X } else {
X result_bit = j;
X }
X result_bit = (result_bit/6)*8 + (result_bit%6);
X if (Input[side] & shift_arr[column]) {
X if (result_side) {
X Result_1 |= shift_arr[result_bit];
X } else {
X Result_0 |= shift_arr[result_bit];
X }
X }
X }
X *kp++ = Result_0; *kp++ = Result_1;
X }
X}
END_OF_FILE
if test 2314 -ne `wc -c <'lib/ksched.c'`; then
echo shar: \"'lib/ksched.c'\" unpacked with wrong size!
fi
# end of 'lib/ksched.c'
fi
if test -f 'lib/des.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des.h'\"
else
echo shar: Extracting \"'lib/des.h'\" \(713 characters\)
sed "s/^X//" >'lib/des.h' <<'END_OF_FILE'
X#ifndef DES_PUBLIC
X#define DES_PUBLIC 1
Xtypedef unsigned char des_u_char; /* This should be a 8-bit unsigned type */
Xtypedef unsigned long des_u_long; /* This should be a 32-bit unsigned type */
X
Xtypedef struct {
X des_u_char data[8];
X} C_Block;
X
Xtypedef struct {
X des_u_long data[32];
X} Key_schedule;
X
X#define DES_ENCRYPT 0x0000
X#define DES_DECRYPT 0x0001
X#define DES_NOIPERM 0x0100
X#define DES_NOFPERM 0x0200
X
Xdes_u_long des_cbc_cksum();
X
Xextern int des_hash_inited;
Xextern Key_schedule des_hash_key1;
Xextern Key_schedule des_hash_key2;
Xextern const C_Block des_zero_block;
X
X#define DES_HASH_INIT() (des_hash_inited ? 0 : des_hash_init())
X
Xextern char *alo_getpass();
Xextern char *alo_read_password();
X
X#endif
END_OF_FILE
if test 713 -ne `wc -c <'lib/des.h'`; then
echo shar: \"'lib/des.h'\" unpacked with wrong size!
fi
# end of 'lib/des.h'
fi
if test -f 'lib/fp.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/fp.h'\"
else
echo shar: Extracting \"'lib/fp.h'\" \(2816 characters\)
sed "s/^X//" >'lib/fp.h' <<'END_OF_FILE'
Xif (R & 0x00000080) L_result |= 0x00000001;
Xif (L & 0x00000080) L_result |= 0x00000002;
Xif (R & 0x00008000) L_result |= 0x00000004;
Xif (L & 0x00008000) L_result |= 0x00000008;
Xif (R & 0x00800000) L_result |= 0x00000010;
Xif (L & 0x00800000) L_result |= 0x00000020;
Xif (R & 0x80000000) L_result |= 0x00000040;
Xif (L & 0x80000000) L_result |= 0x00000080;
Xif (R & 0x00000040) L_result |= 0x00000100;
Xif (L & 0x00000040) L_result |= 0x00000200;
Xif (R & 0x00004000) L_result |= 0x00000400;
Xif (L & 0x00004000) L_result |= 0x00000800;
Xif (R & 0x00400000) L_result |= 0x00001000;
Xif (L & 0x00400000) L_result |= 0x00002000;
Xif (R & 0x40000000) L_result |= 0x00004000;
Xif (L & 0x40000000) L_result |= 0x00008000;
Xif (R & 0x00000020) L_result |= 0x00010000;
Xif (L & 0x00000020) L_result |= 0x00020000;
Xif (R & 0x00002000) L_result |= 0x00040000;
Xif (L & 0x00002000) L_result |= 0x00080000;
Xif (R & 0x00200000) L_result |= 0x00100000;
Xif (L & 0x00200000) L_result |= 0x00200000;
Xif (R & 0x20000000) L_result |= 0x00400000;
Xif (L & 0x20000000) L_result |= 0x00800000;
Xif (R & 0x00000010) L_result |= 0x01000000;
Xif (L & 0x00000010) L_result |= 0x02000000;
Xif (R & 0x00001000) L_result |= 0x04000000;
Xif (L & 0x00001000) L_result |= 0x08000000;
Xif (R & 0x00100000) L_result |= 0x10000000;
Xif (L & 0x00100000) L_result |= 0x20000000;
Xif (R & 0x10000000) L_result |= 0x40000000;
Xif (L & 0x10000000) L_result |= 0x80000000;
Xif (R & 0x00000008) R_result |= 0x00000001;
Xif (L & 0x00000008) R_result |= 0x00000002;
Xif (R & 0x00000800) R_result |= 0x00000004;
Xif (L & 0x00000800) R_result |= 0x00000008;
Xif (R & 0x00080000) R_result |= 0x00000010;
Xif (L & 0x00080000) R_result |= 0x00000020;
Xif (R & 0x08000000) R_result |= 0x00000040;
Xif (L & 0x08000000) R_result |= 0x00000080;
Xif (R & 0x00000004) R_result |= 0x00000100;
Xif (L & 0x00000004) R_result |= 0x00000200;
Xif (R & 0x00000400) R_result |= 0x00000400;
Xif (L & 0x00000400) R_result |= 0x00000800;
Xif (R & 0x00040000) R_result |= 0x00001000;
Xif (L & 0x00040000) R_result |= 0x00002000;
Xif (R & 0x04000000) R_result |= 0x00004000;
Xif (L & 0x04000000) R_result |= 0x00008000;
Xif (R & 0x00000002) R_result |= 0x00010000;
Xif (L & 0x00000002) R_result |= 0x00020000;
Xif (R & 0x00000200) R_result |= 0x00040000;
Xif (L & 0x00000200) R_result |= 0x00080000;
Xif (R & 0x00020000) R_result |= 0x00100000;
Xif (L & 0x00020000) R_result |= 0x00200000;
Xif (R & 0x02000000) R_result |= 0x00400000;
Xif (L & 0x02000000) R_result |= 0x00800000;
Xif (R & 0x00000001) R_result |= 0x01000000;
Xif (L & 0x00000001) R_result |= 0x02000000;
Xif (R & 0x00000100) R_result |= 0x04000000;
Xif (L & 0x00000100) R_result |= 0x08000000;
Xif (R & 0x00010000) R_result |= 0x10000000;
Xif (L & 0x00010000) R_result |= 0x20000000;
Xif (R & 0x01000000) R_result |= 0x40000000;
Xif (L & 0x01000000) R_result |= 0x80000000;
END_OF_FILE
if test 2816 -ne `wc -c <'lib/fp.h'`; then
echo shar: \"'lib/fp.h'\" unpacked with wrong size!
fi
# end of 'lib/fp.h'
fi
if test -f 'lib/des-private.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des-private.h'\"
else
echo shar: Extracting \"'lib/des-private.h'\" \(619 characters\)
sed "s/^X//" >'lib/des-private.h' <<'END_OF_FILE'
X#include "des.h"
X#ifndef DES_PRIVATE
X#define DES_PRIVATE 1
X
X#ifdef mc68000
X#define BIG_ENDIAN 1
X#endif
X
X#ifdef sparc
X#define BIG_ENDIAN 1
X#endif
X
X#ifdef interdata
X#define BIG_ENDIAN 1
X#endif
X
X/* turns out this is useless, its too late, and not seen everywhere .. kre */
X#if (!__STDC__)
X#define const
X#endif
X
Xextern const des_u_long des_spe_table[];
X
X#define copy_N(from,to,type) (*((type*)&(to)) = *((type*)&(from)))
X#define copy8(from,to) copy_N(from,to,C_Block)
X#define copy4(from,to) copy_N(from,to,des_u_long)
X#define lval_N(from,type) (*((type*)&(from)))
X#define val4(variable) lval_N(variable,des_u_long)
X
X#endif
END_OF_FILE
if test 619 -ne `wc -c <'lib/des-private.h'`; then
echo shar: \"'lib/des-private.h'\" unpacked with wrong size!
fi
# end of 'lib/des-private.h'
fi
if test -f 'lib/des-data.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des-data.c'\"
else
echo shar: Extracting \"'lib/des-data.c'\" \(129 characters\)
sed "s/^X//" >'lib/des-data.c' <<'END_OF_FILE'
X#include "des-private.h"
X
Xconst C_Block des_zero_block = {{0}};
X
Xconst des_u_long des_spe_table[] = {
X#include "spe-table.h"
X};
END_OF_FILE
if test 129 -ne `wc -c <'lib/des-data.c'`; then
echo shar: \"'lib/des-data.c'\" unpacked with wrong size!
fi
# end of 'lib/des-data.c'
fi
if test -f 'lib/Makerules' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/Makerules'\"
else
echo shar: Extracting \"'lib/Makerules'\" \(560 characters\)
sed "s/^X//" >'lib/Makerules' <<'END_OF_FILE'
XCC:= gcc
XCFLAGS:= -O #SUN -msoft-float
XPRINT:= enscript
X
XMAINTOPS:= all clean print s-files
X.PHONY: $(MAINTOPS)
X
Xifdef PRINTFILES
Xprint:
X $(PRINT) $(PRINTFILES)
Xendif
X
Xifdef LMAINTOPS
X$(LMAINTOPS): %: %-local
X
X.PHONY: $(addsuffix -local,$(LMAINTOPS))
Xendif
X
Xifneq ($(origin SUBDIRS),file)
XSUBDIRS:=
Xendif
X
Xifdef SUBDIRS
X$(MAINTOPS):
X for i in $(SUBDIRS); do $(MAKE) -C $$i $@; done
Xelse
X$(MAINTOPS):
Xendif
X
Xifdef SUBDIRS
X$(SUBDIRS):
X $(MAKE) -C $@
Xendif
X
Xifneq ($(origin S_FILES),file)
XS_FILES:=
Xendif
X
Xs-files: $(S_FILES)
X
X%.s: %.c
X $(CC) -S $(CFLAGS) $^
END_OF_FILE
if test 560 -ne `wc -c <'lib/Makerules'`; then
echo shar: \"'lib/Makerules'\" unpacked with wrong size!
fi
# end of 'lib/Makerules'
fi
if test -f 'lib/des-expand.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des-expand.c'\"
else
echo shar: Extracting \"'lib/des-expand.c'\" \(1643 characters\)
sed "s/^X//" >'lib/des-expand.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X/* Expand 32-bit input block according to E-permutation so that each
X output-byte contains 6 bits of output data */
X
Xint
Xdes_expand(ibuf,obuf)
X
Xdes_u_char *ibuf,*obuf;
X
X{
X des_u_long L;
X des_u_char *p;
X int i;
X
X#if BIG_ENDIAN
X copy4(ibuf[0],L);
X p = obuf+3;
X *p = L;
X L >>= 3; *--p = L;
X L >>= 4; *--p = L;
X L >>= 4; *--p = L;
X p = obuf+7;
X L >>= 4; *p = L;
X L >>= 4; *--p = L;
X L >>= 4; *--p = L;
X L >>= 4; *--p = L;
X obuf[3] <<= 1;
X *p |= obuf[3] << 4;
X L >>= 4; obuf[3] |= L;
X#else
X copy4(ibuf[0],L);
X p = obuf;
X *p++ = L;
X L >>= 3; *p++ = L;
X L >>= 4; *p++ = L;
X L >>= 4; *p++ = L;
X L >>= 4; *p++ = L;
X L >>= 4; *p++ = L;
X L >>= 4; *p++ = L;
X L >>= 4; *p = L;
X obuf[0] <<= 1;
X *p |= obuf[0] << 4;
X L >>= 4; obuf[0] |= L;
X#endif
X val4(obuf[0]) &= 0x3f3f3f3f;
X val4(obuf[4]) &= 0x3f3f3f3f;
X}
X
X/* Unexpand 8 6-bit bytes into one 32-bit block */
X
Xdes_u_long
Xdes_unexpand(ibuf)
X
Xdes_u_char *ibuf;
X
X{
X des_u_long L;
X des_u_char *p;
X int i;
X
X#if BIG_ENDIAN
X p = ibuf+4;
X L = *p++; /* 27 .. */
X L = (L << 4) | *p++; /* 23 .. */
X L = (L << 4) | *p++; /* 19 .. */
X L = (L << 4) | *p; /* 15 .. */
X p = ibuf;
X L = (L << 4) | *p++; /* 11 .. */
X L = (L << 4) | *p++; /* 7 .. */
X L = (L << 4) | *p++; /* 3 .. */
X L = (L << 3) | (*p >> 1); /* 0 .. */
X#else
X p = ibuf+8;
X L = *--p; /* 27 .. */
X L = (L << 4) | *--p; /* 23 .. */
X L = (L << 4) | *--p; /* 19 .. */
X L = (L << 4) | *--p; /* 15 .. */
X L = (L << 4) | *--p; /* 11 .. */
X L = (L << 4) | *--p; /* 7 .. */
X L = (L << 4) | *--p; /* 3 .. */
X L = (L << 3) | (*--p >> 1); /* 0 .. */
X#endif
X return L;
X}
X
END_OF_FILE
if test 1643 -ne `wc -c <'lib/des-expand.c'`; then
echo shar: \"'lib/des-expand.c'\" unpacked with wrong size!
fi
# end of 'lib/des-expand.c'
fi
if test -f 'lib/des-fun.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des-fun.c'\"
else
echo shar: Extracting \"'lib/des-fun.c'\" \(1389 characters\)
sed "s/^X//" >'lib/des-fun.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X#if BIG_ENDIAN
X#define P_IND(x) (((x)&04) | (3-((x)&03)))
X#else
X#define P_IND(x) (x)
X#endif
X
X/* This function performs f()-function in a slightly modified form. It
X starts with data which has gone through E-permutation and produces
X data which is already E-permuted for the next iteration. */
X
Xdes_fun(R,schedule,ki)
X
Xdes_u_long *R;
XKey_schedule *schedule;
Xint ki;
X
X{
X des_u_long *keyptr = &schedule->data[ki*2];
X des_u_char s[8];
X des_u_char *p;
X des_u_long F[2];
X des_u_long R0,R1;
X int i;
X
X copy8(R[0],F[0]);
X F[0] ^= keyptr[0];
X F[1] ^= keyptr[1];
X p = (des_u_char*)F;
X R0 = R1 = 0;
X i = 0;
X R0 ^= des_spe_table[i++*64 + p[P_IND(0)]];
X R1 ^= des_spe_table[i++*64 + p[P_IND(0)]];
X R0 ^= des_spe_table[i++*64 + p[P_IND(1)]];
X R1 ^= des_spe_table[i++*64 + p[P_IND(1)]];
X R0 ^= des_spe_table[i++*64 + p[P_IND(2)]];
X R1 ^= des_spe_table[i++*64 + p[P_IND(2)]];
X R0 ^= des_spe_table[i++*64 + p[P_IND(3)]];
X R1 ^= des_spe_table[i++*64 + p[P_IND(3)]];
X R0 ^= des_spe_table[i++*64 + p[P_IND(4)]];
X R1 ^= des_spe_table[i++*64 + p[P_IND(4)]];
X R0 ^= des_spe_table[i++*64 + p[P_IND(5)]];
X R1 ^= des_spe_table[i++*64 + p[P_IND(5)]];
X R0 ^= des_spe_table[i++*64 + p[P_IND(6)]];
X R1 ^= des_spe_table[i++*64 + p[P_IND(6)]];
X R0 ^= des_spe_table[i++*64 + p[P_IND(7)]];
X R1 ^= des_spe_table[i++*64 + p[P_IND(7)]];
X R[0] = R0;
X R[1] = R1;
X}
END_OF_FILE
if test 1389 -ne `wc -c <'lib/des-fun.c'`; then
echo shar: \"'lib/des-fun.c'\" unpacked with wrong size!
fi
# end of 'lib/des-fun.c'
fi
if test -f 'lib/des-perms.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des-perms.c'\"
else
echo shar: Extracting \"'lib/des-perms.c'\" \(603 characters\)
sed "s/^X//" >'lib/des-perms.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X/* des_do_iperm and des_do_fperm use precomputed inline code to make
X 64-bit permutation. This is the fastest method that I know of to make
X this on microVAX II */
X
Xdes_do_iperm(ibuf,obuf)
X
Xdes_u_long *ibuf,*obuf;
X
X{
X des_u_long L,R,L_result,R_result;
X L_result = R_result = 0;
X L = ibuf[0]; R = ibuf[1];
X#include "ip.h"
X obuf[0] = L_result; obuf[1] = R_result;
X}
X
Xdes_do_fperm(ibuf,obuf)
X
Xdes_u_long *ibuf,*obuf;
X
X{
X des_u_long L,R,L_result,R_result;
X L_result = R_result = 0;
X L = ibuf[0]; R = ibuf[1];
X#include "fp.h"
X obuf[0] = L_result; obuf[1] = R_result;
X}
X
END_OF_FILE
if test 603 -ne `wc -c <'lib/des-perms.c'`; then
echo shar: \"'lib/des-perms.c'\" unpacked with wrong size!
fi
# end of 'lib/des-perms.c'
fi
if test -f 'lib/ecb-encrypt.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/ecb-encrypt.c'\"
else
echo shar: Extracting \"'lib/ecb-encrypt.c'\" \(1199 characters\)
sed "s/^X//" >'lib/ecb-encrypt.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X/* input data is not modified. output is written after input has been
X read */
X
X/* The least significant bit of input->data[0] is bit # 1 in
X DES-sepcification etc. */
X
Xint
Xdes_ecb_encrypt(input,output,schedule,mode)
X
XC_Block *input;
XC_Block *output;
XKey_schedule *schedule;
Xint mode;
X
X{
X C_Block ibuf;
X des_u_long L[2],R[2];
X des_u_long Lnext[2],Rnext[2];
X int i;
X int encrypt;
X
X#if BIG_ENDIAN
X des_reverse(input,&ibuf);
X if (!(mode & DES_NOIPERM)) {
X des_do_iperm(&ibuf,&ibuf);
X }
X#else
X if (!(mode & DES_NOIPERM)) {
X des_do_iperm(input,&ibuf);
X } else {
X copy8(*input,ibuf);
X }
X#endif
X encrypt = !(mode & DES_DECRYPT);
X des_expand(&ibuf.data[0],&L[0]);
X des_expand(&ibuf.data[4],&R[0]);
X for(i = 0; i < 16; i++) {
X copy8(*R,*Lnext);
X des_fun(R,schedule,encrypt ? i : 15 - i);
X R[0] ^= L[0];
X R[1] ^= L[1];
X copy8(*Lnext,*L);
X }
X
X val4(ibuf.data[0]) = des_unexpand(R);
X val4(ibuf.data[4]) = des_unexpand(L);
X#if BIG_ENDIAN
X if (!(mode & DES_NOFPERM))
X des_do_fperm(&ibuf,&ibuf);
X des_reverse(&ibuf,output);
X#else
X if (!(mode & DES_NOFPERM))
X des_do_fperm(&ibuf,output);
X else
X copy8(ibuf,*output);
X#endif
X}
END_OF_FILE
if test 1199 -ne `wc -c <'lib/ecb-encrypt.c'`; then
echo shar: \"'lib/ecb-encrypt.c'\" unpacked with wrong size!
fi
# end of 'lib/ecb-encrypt.c'
fi
if test -f 'lib/GNUmakefile' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/GNUmakefile'\"
else
echo shar: Extracting \"'lib/GNUmakefile'\" \(474 characters\)
sed "s/^X//" >'lib/GNUmakefile' <<'END_OF_FILE'
XLMAINTOPS:= all clean
XLIBNAME:= libdes.a
XRPAR:=)
XLPAR:=(
XSOURCES:= $(wildcard *.c)
XOBJS:= $(addsuffix .o,$(basename $(SOURCES)))
XS_FILES:= $(addsuffix .s,$(basename $(SOURCES)))
XARS:= $(addprefix $(LIBNAME)$(LPAR),$(addsuffix $(RPAR),$(OBJS)))
XPRINTFILES:= des-private.h des.h $(SOURCES)
X
X.PHONY: all
X
Xall-local: $(LIBNAME)(__.SYMDEF) $(OBJS)
X
Xinclude Makerules
X
Xclean-local:
X rm -f $(LIBNAME) $(OBJS)
X
X$(LIBNAME)(%.o): %.o
X
X$(LIBNAME)(__.SYMDEF): $(ARS)
X ranlib $(LIBNAME)
END_OF_FILE
if test 474 -ne `wc -c <'lib/GNUmakefile'`; then
echo shar: \"'lib/GNUmakefile'\" unpacked with wrong size!
fi
# end of 'lib/GNUmakefile'
fi
if test -f 'lib/cbc-encrypt.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/cbc-encrypt.c'\"
else
echo shar: Extracting \"'lib/cbc-encrypt.c'\" \(974 characters\)
sed "s/^X//" >'lib/cbc-encrypt.c' <<'END_OF_FILE'
X#include "des-private.h"
X
Xint
Xdes_cbc_encrypt(input,output,length,schedule,ivec,mode)
X
XC_Block *input;
XC_Block *output;
Xint length;
XKey_schedule *schedule;
XC_Block *ivec;
Xint mode;
X
X{
X C_Block vbuf;
X C_Block ibuf;
X C_Block V2;
X int decrypt;
X int i;
X
X decrypt = (mode & DES_DECRYPT);
X if (ivec) {
X vbuf = *ivec;
X } else {
X vbuf = des_zero_block;
X }
X for (; length > 0; length -= 8, input++,output++) {
X if (length < 8) {
X ibuf = *input;
X for(i = length; i < 8; i++)
X ibuf.data[i] = 0;
X input = &ibuf;
X }
X if (decrypt) {
X V2 = *input;
X } else {
X val4(input->data[0]) ^= val4(vbuf.data[0]);
X val4(input->data[4]) ^= val4(vbuf.data[4]);
X }
X des_ecb_encrypt(input,output,schedule,mode);
X if (decrypt) {
X val4(output->data[0]) ^= val4(vbuf.data[0]);
X val4(output->data[4]) ^= val4(vbuf.data[4]);
X vbuf = V2;
X } else {
X vbuf = *output;
X }
X }
X if (ivec) {
X *ivec = vbuf;
X }
X}
END_OF_FILE
if test 974 -ne `wc -c <'lib/cbc-encrypt.c'`; then
echo shar: \"'lib/cbc-encrypt.c'\" unpacked with wrong size!
fi
# end of 'lib/cbc-encrypt.c'
fi
if test -f 'lib/cbc-cksum.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/cbc-cksum.c'\"
else
echo shar: Extracting \"'lib/cbc-cksum.c'\" \(628 characters\)
sed "s/^X//" >'lib/cbc-cksum.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X/* des_cbc_cksum computes a cryptographical checksum of input data */
X
Xdes_u_long
Xdes_cbc_cksum(input,output,length,schedule,ivec,mode)
X
XC_Block *input;
XC_Block *output;
Xint length;
XKey_schedule *schedule;
XC_Block *ivec;
Xint mode;
X
X{
X C_Block vbuf;
X C_Block ibuf;
X C_Block V2;
X int l;
X
X if (!ivec) {
X vbuf = *ivec;
X } else {
X vbuf = des_zero_block;
X val4(vbuf.data[0]) = val4(vbuf.data[4]) = 0;
X }
X for (; length > 0; length -= 8, input++) {
X l = (length > 8) ? 8 : length;
X des_cbc_encrypt(input,output,l,schedule,&vbuf,DES_ENCRYPT);
X }
X return val4(output->data[4]);
X}
END_OF_FILE
if test 628 -ne `wc -c <'lib/cbc-cksum.c'`; then
echo shar: \"'lib/cbc-cksum.c'\" unpacked with wrong size!
fi
# end of 'lib/cbc-cksum.c'
fi
if test -f 'lib/des-reverse.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des-reverse.c'\"
else
echo shar: Extracting \"'lib/des-reverse.c'\" \(290 characters\)
sed "s/^X//" >'lib/des-reverse.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X/* des_reverse reverses bytes of 64-bit block within 32-bit words. */
X
Xdes_reverse(ib,ob)
X
Xdes_u_char *ib;
Xdes_u_char *ob;
X
X{
X ob[3] = *ib++;
X ob[2] = *ib++;
X ob[1] = *ib++;
X ob[0] = *ib++;
X ob[7] = *ib++;
X ob[6] = *ib++;
X ob[5] = *ib++;
X ob[4] = *ib++;
X}
END_OF_FILE
if test 290 -ne `wc -c <'lib/des-reverse.c'`; then
echo shar: \"'lib/des-reverse.c'\" unpacked with wrong size!
fi
# end of 'lib/des-reverse.c'
fi
if test -f 'lib/pcbc-encrypt.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/pcbc-encrypt.c'\"
else
echo shar: Extracting \"'lib/pcbc-encrypt.c'\" \(1306 characters\)
sed "s/^X//" >'lib/pcbc-encrypt.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X/* This is modified cbc-algorithm as specified in kerberos manual page */
X
Xint
Xdes_pcbc_encrypt(input,output,length,schedule,ivec,mode)
X
XC_Block *input;
XC_Block *output;
Xint length;
XKey_schedule *schedule;
XC_Block *ivec;
Xint mode;
X
X{
X C_Block vbuf;
X C_Block ibuf;
X C_Block V2;
X int decrypt;
X int i;
X
X decrypt = (mode & DES_DECRYPT);
X if (ivec) {
X vbuf = *ivec;
X } else {
X vbuf = des_zero_block;
X }
X for (; length > 0; length -= 8, input++,output++) {
X if (length < 8) {
X ibuf = *input;
X for(i = length; i < 8; i++)
X ibuf.data[i] = 0;
X input = &ibuf;
X }
X if (decrypt) {
X V2 = *input;
X } else {
X V2 = *input;
X val4(input->data[0]) ^= val4(vbuf.data[0]);
X val4(input->data[4]) ^= val4(vbuf.data[4]);
X }
X des_ecb_encrypt(input,output,schedule,mode);
X if (decrypt) {
X val4(output->data[0]) ^= val4(vbuf.data[0]);
X val4(output->data[4]) ^= val4(vbuf.data[4]);
X val4(vbuf.data[0]) = val4(V2.data[0]) ^ val4(output->data[0]);
X val4(vbuf.data[4]) = val4(V2.data[4]) ^ val4(output->data[4]);
X } else {
X val4(vbuf.data[0]) = val4(V2.data[0]) ^ val4(output->data[0]);
X val4(vbuf.data[4]) = val4(V2.data[4]) ^ val4(output->data[4]);
X }
X }
X if (ivec) {
X *ivec = vbuf;
X }
X}
END_OF_FILE
if test 1306 -ne `wc -c <'lib/pcbc-encrypt.c'`; then
echo shar: \"'lib/pcbc-encrypt.c'\" unpacked with wrong size!
fi
# end of 'lib/pcbc-encrypt.c'
fi
if test -f 'lib/string-to-key.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/string-to-key.c'\"
else
echo shar: Extracting \"'lib/string-to-key.c'\" \(646 characters\)
sed "s/^X//" >'lib/string-to-key.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X/* This is supposed to be a one-way string-to-key function. If someone
X finds this to be easily reversible, please tell me, too */
X
Xstring_to_key(asckey,key)
X
Xchar *asckey;
XC_Block *key;
X
X{
X char *p;
X int i;
X C_Block k1,k2;
X
X DES_HASH_INIT();
X
X for(i = 0; i < 8; i++) {
X k1.data[i] = k2.data[i] = 0;
X }
X for(i = 0, p = asckey; *p; p++, i++) {
X i %= 8;
X k1.data[i] |= *p;
X k2.data[i] |= *p;
X des_ecb_encrypt(&k1,&k1,&des_hash_key1,DES_ENCRYPT);
X des_ecb_encrypt(&k2,&k2,&des_hash_key2,DES_ENCRYPT);
X }
X for(i = 0; i < 8; i++) {
X key->data[i] = k1.data[i] ^ k2.data[i];
X }
X return 0;
X}
END_OF_FILE
if test 646 -ne `wc -c <'lib/string-to-key.c'`; then
echo shar: \"'lib/string-to-key.c'\" unpacked with wrong size!
fi
# end of 'lib/string-to-key.c'
fi
if test -f 'lib/des-hash.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des-hash.c'\"
else
echo shar: Extracting \"'lib/des-hash.c'\" \(571 characters\)
sed "s/^X//" >'lib/des-hash.c' <<'END_OF_FILE'
X#include "des-private.h"
X
X/* des_hash_init prepares two key schedules to be used with
X hash-function calculation by des algorithm */
X
Xstatic unsigned char hash_key1[8] =
X { 0x9a, 0xd3, 0xbc, 0x24, 0x10, 0xe2, 0x8f, 0x0e };
Xstatic unsigned char hash_key2[8] =
X { 0xe2, 0x95, 0x14, 0x33, 0x59, 0xc3, 0xec, 0xa8 };
X
XKey_schedule des_hash_key1;
XKey_schedule des_hash_key2;
X
Xint des_hash_inited;
X
Xdes_hash_init()
X
X{
X if (des_hash_inited)
X return 0;
X des_set_key(hash_key1,&des_hash_key1);
X des_set_key(hash_key2,&des_hash_key2);
X des_hash_inited = 1;
X return 0;
X}
END_OF_FILE
if test 571 -ne `wc -c <'lib/des-hash.c'`; then
echo shar: \"'lib/des-hash.c'\" unpacked with wrong size!
fi
# end of 'lib/des-hash.c'
fi
if test -f 'lib/alo-getpass.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/alo-getpass.c'\"
else
echo shar: Extracting \"'lib/alo-getpass.c'\" \(877 characters\)
sed "s/^X//" >'lib/alo-getpass.c' <<'END_OF_FILE'
X#include <sys/types.h>
X#include <sys/file.h>
X#ifdef BSD
X#include <sgtty.h>
X#endif
X#include <stdio.h>
X
Xextern char *alo_getline();
X
Xchar *
Xalo_getpass(prompt)
X
Xchar *prompt;
X
X{
X struct sgttyb t_old;
X FILE *tf;
X int tf0;
X FILE *of = stderr;
X int ef;
X char *r;
X
X if ((tf0 = open("/dev/tty",O_RDWR,0)) != -1) {
X if (!(tf = fdopen(tf0,"r"))) {
X close(tf0);
X return 0;
X }
X } else {
X tf = 0;
X }
X if (!tf)
X tf = stdin;
X fputs(prompt,of);
X fflush(of);
X#ifdef BSD
X ioctl(fileno(tf),TIOCGETP,&t_old);
X ef = t_old.sg_flags & ECHO;
X t_old.sg_flags &= ~ECHO;
X ioctl(fileno(tf),TIOCSETP,&t_old);
X#endif
X r = alo_getline(tf);
X#ifdef BSD
X if (r)
X fputs("\n",of);
X ioctl(fileno(tf),TIOCGETP,&t_old);
X t_old.sg_flags &= ~ECHO;
X t_old.sg_flags |= ef;
X ioctl(fileno(tf),TIOCSETP,&t_old);
X#endif
X if (tf != stdin)
X fclose(tf);
X return r;
X}
END_OF_FILE
if test 877 -ne `wc -c <'lib/alo-getpass.c'`; then
echo shar: \"'lib/alo-getpass.c'\" unpacked with wrong size!
fi
# end of 'lib/alo-getpass.c'
fi
if test -f 'lib/alo-getline.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/alo-getline.c'\"
else
echo shar: Extracting \"'lib/alo-getline.c'\" \(705 characters\)
sed "s/^X//" >'lib/alo-getline.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xextern char *malloc();
Xextern char *realloc();
X
X#define ISIZE 100
X
Xchar *
Xalo_getline(f)
X
XFILE *f;
X
X{
X int l = 0;
X char *r = 0;
X char *p = 0;
X char *ep;
X int c;
X int e = 0;
X
X for(;;) {
X c = getc(f);
X if (c == EOF || c == '\n') {
X if (c == EOF && !p)
X return 0;
X e = 1;
X } else if (c == 0) {
X c = '\n';
X }
X if (r == 0) {
X l = ISIZE;
X if (!(r = malloc(l)))
X return 0;
X p = r;
X ep = r+l-3;
X }
X if (p >= ep) {
X int o;
X l += ISIZE;
X o = p - r;
X if (!(r = realloc(r,l)))
X return 0;
X p = r + o;
X ep = r+l-3;
X }
X if (e) {
X *p++ = 0;
X *p = c;
X return r;
X }
X *p++ = c;
X }
X}
END_OF_FILE
if test 705 -ne `wc -c <'lib/alo-getline.c'`; then
echo shar: \"'lib/alo-getline.c'\" unpacked with wrong size!
fi
# end of 'lib/alo-getline.c'
fi
if test -f 'lib/read-passwd.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/read-passwd.c'\"
else
echo shar: Extracting \"'lib/read-passwd.c'\" \(712 characters\)
sed "s/^X//" >'lib/read-passwd.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xextern char *alo_getpass();
X
Xchar *
Xalo_read_password(prompt,verify)
X
Xchar *prompt;
Xint verify;
X
X{
X char *p1,*p2;
X int again;
X int n;
X
X p1 = 0;
X p2 = 0;
X again = 1;
X n = 10;
X while (again) {
X if (p1) free(p1);
X if (p2) free(p2);
X if (!(p1 = alo_getpass(prompt)))
X return 0;
X if (verify) {
X if (!(p2 = alo_getpass("Verify: "))) {
X free(p1);
X return 0;
X }
X if (strcmp(p1,p2)) {
X n--;
X if (n <= 0) {
X fprintf(stderr,"Too many mismatches\n");
X if (p1) free(p1);
X if (p2) free(p2);
X return 0;
X } else {
X fprintf(stderr,"Mismatch\n");
X }
X } else {
X again = 0;
X }
X } else {
X again = 0;
X }
X }
X if (p2) free(p2);
X return p1;
X}
END_OF_FILE
if test 712 -ne `wc -c <'lib/read-passwd.c'`; then
echo shar: \"'lib/read-passwd.c'\" unpacked with wrong size!
fi
# end of 'lib/read-passwd.c'
fi
if test -f 'lib/des-hex.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/des-hex.c'\"
else
echo shar: Extracting \"'lib/des-hex.c'\" \(555 characters\)
sed "s/^X//" >'lib/des-hex.c' <<'END_OF_FILE'
X#include "des.h"
X
Xdes_key_to_hex(k,h)
X
XC_Block *k;
Xchar *h;
X
X{
X int i;
X
X for(i = 0; i < 8; i++) {
X sprintf(&h[i*2],"%02x",k->data[i]);
X }
X}
X
Xdes_hex_to_key(h,k)
X
Xchar *h;
XC_Block *k;
X
X{
X int i,j,a,c;
X
X for(i = 0; i < 8; i++) {
X a = 0;
X for(j = 0; j < 2; j++) {
X c = *h++;
X if (c >= '0' && c <= '9') {
X c -= '0';
X } else if (c >= 'a' && c <= 'f') {
X c -= ('a' - 10);
X } else if (c >= 'A' && c <= 'F') {
X c -= ('A' - 10);
X } else {
X return -1;
X }
X a = a * 16 + c;
X }
X k->data[i] = a;
X }
X return 0;
X}
END_OF_FILE
if test 555 -ne `wc -c <'lib/des-hex.c'`; then
echo shar: \"'lib/des-hex.c'\" unpacked with wrong size!
fi
# end of 'lib/des-hex.c'
fi
if test -f 'lib/Makefile' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'lib/Makefile'\"
else
echo shar: Extracting \"'lib/Makefile'\" \(789 characters\)
sed "s/^X//" >'lib/Makefile' <<'END_OF_FILE'
X#
X# kludged standard make Makefile - adapted from GNU make version .. kre
X#
XCFLAGS= -DBSD -O -Dconst= #SUN -msoft-float
XPRINT= enscript
XLIBNAME= libdes.a
XSOURCES= alo-getline.c alo-getpass.c cbc-cksum.c cbc-encrypt.c \
X des-data.c des-expand.c des-fun.c des-hash.c des-hex.c \
X des-perms.c des-reverse.c ecb-encrypt.c ksched.c \
X pcbc-encrypt.c read-passwd.c string-to-key.c
XOBJS= alo-getline.o alo-getpass.o cbc-cksum.o cbc-encrypt.o \
X des-data.o des-expand.o des-fun.o des-hash.o des-hex.o \
X des-perms.o des-reverse.o ecb-encrypt.o ksched.o \
X pcbc-encrypt.o read-passwd.o string-to-key.o
XPRINTFILES= des-private.h des.h $(SOURCES)
X
Xall: $(LIBNAME)
X
X$(LIBNAME): $(OBJS)
X ar ru $(LIBNAME) $?
X ranlib $(LIBNAME)
X
Xclean:
X rm -f $(LIBNAME) $(OBJS)
X
Xprint:
X $(PRINT) $(PRINTFILES)
END_OF_FILE
if test 789 -ne `wc -c <'lib/Makefile'`; then
echo shar: \"'lib/Makefile'\" unpacked with wrong size!
fi
# end of 'lib/Makefile'
fi
echo shar: End of archive 2 \(of 2\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked both archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0