Subject: v18i008: DES routines and program - free of US controls, Part02/02
From: [email-masked] (Antti Louko)
Date: 10 Mar 89 08:11:10 GMT
Newsgroups: comp.sources.unix

Submitted by: [email-masked] (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