home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume40 / libdes / part03 < prev    next >
Internet Message Format  |  1993-10-14  |  56KB
  1. From: eay@psych.psy.uq.oz.au (Eric Young)
  2. Newsgroups: comp.sources.misc
  3. Subject: v40i010: libdes - DES encryption library, Part03/05
  4. Date: 14 Oct 1993 18:01:55 +0100
  5. Sender: aem@aber.ac.uk
  6. Approved: aem@aber.ac.uk
  7. Message-ID: <29k0m3$1m9@uk-usenet.uk.sun.com>
  8. X-Md4-Signature: 02fc2c5412d63c26bc4187d027d3c8c0
  9.  
  10. Submitted-by: eay@psych.psy.uq.oz.au (Eric Young)
  11. Posting-number: Volume 40, Issue 10
  12. Archive-name: libdes/part03
  13. Environment: C
  14. Supersedes: libdes: Volume 29, Issue 43-46
  15.  
  16. #! /bin/sh
  17. # into a shell via "sh file" or similar.  To overwrite existing files,
  18. # type "sh file -c".
  19. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  20. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  21. # Contents:  VERSION cbc_cksm.c des_crypt.man des_locl.h read_pwd.c
  22. #   sk.h spr.h testdes.pl
  23. # Wrapped by alecm@uk-usenet on Wed Oct 13 10:33:49 1993
  24. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  25. echo If this archive is complete, you will see the following message:
  26. echo '          "shar: End of archive 3 (of 5)."'
  27. if test -f 'VERSION' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'VERSION'\"
  29. else
  30.   echo shar: Extracting \"'VERSION'\" \(6824 characters\)
  31.   sed "s/^X//" >'VERSION' <<'END_OF_FILE'
  32. XRelease apon comp.sources.misc
  33. XVersion 3.01 08/10/93
  34. X    Added des_3cbc_encrypt()
  35. X
  36. XVersion 3.00 07/10/93
  37. X    Fixed up documentation.
  38. X    quad_cksum definitly compatable with MIT's now.
  39. X
  40. XVersion 2.30 24/08/93
  41. X    Tripple DES now defaults to tripple cbc but can do tripple ecb
  42. X     with the -b flag.
  43. X    Fixed some MSDOS uuen/uudecoding problems, thanks to
  44. X    Added prototypes.
  45. X    
  46. XVersion 2.22 29/06/93
  47. X    Fixed a bug in des_is_weak_key() which stopped it working :-(
  48. X    thanks to engineering@MorningStar.Com.
  49. X
  50. XVersion 2.21 03/06/93
  51. X    des(1) with no arguments gives quite a bit of help.
  52. X    Added -c (generate ckecksum) flag to des(1).
  53. X    Added -3 (tripple DES) flag to des(1).
  54. X    Added cfb and ofb routines to the library.
  55. X
  56. XVersion 2.20 11/03/93
  57. X    Added -u (uuencode) flag to des(1).
  58. X    I have been playing with byte order in quad_cksum to make it
  59. X     compatible with MIT's version.  All I can say is aviod this
  60. X     function if possible since MIT's output is endian dependent.
  61. X
  62. XVersion 2.12 14/10/92
  63. X    Added MSDOS specific macro in ecb_encrypt which gives a %70
  64. X     speed up when the code is compiled with turbo C.
  65. X
  66. XVersion 2.11 12/10/92
  67. X    Speedup in set_key (recoding of PC-1)
  68. X     I now do it in 47 simple operations, down from 60.
  69. X     Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov)
  70. X     for motivating me to look for a faster system :-)
  71. X     The speedup is probably less that 1% but it is still 13
  72. X     instructions less :-).
  73. X
  74. XVersion 2.10 06/10/92
  75. X    The code now works on the 64bit ETA10 and CRAY without modifications or
  76. X     #defines.  I believe the code should work on any machine that
  77. X     defines long, int or short to be 8 bytes long.
  78. X    Thanks to Shabbir J. Safdar (shabby@mentor.cc.purdue.edu)
  79. X     for helping me fix the code to run on 64bit machines (he had
  80. X     access to an ETA10).
  81. X    Thanks also to John Fletcher <john_fletcher@lccmail.ocf.llnl.gov>
  82. X     for testing the routines on a CRAY.
  83. X    read_password.c has been renamed to read_passwd.c
  84. X    string_to_key.c has been renamed to string2key.c
  85. X
  86. XVersion 2.00 14/09/92
  87. X    Made mods so that the library should work on 64bit CPU's.
  88. X    Removed all my uchar and ulong defs.  To many different
  89. X     versions of unix define them in their header files in too many
  90. X     different combinations :-)
  91. X    IRIX - Sillicon Graphics mods (mostly in read_password.c).
  92. X     Thanks to Andrew Daviel (advax@erich.triumf.ca)
  93. X
  94. XVersion 1.99 26/08/92
  95. X    Fixed a bug or 2 in enc_read.c
  96. X    Fixed a bug in enc_write.c
  97. X    Fixed a pseudo bug in fcrypt.c (very obscure).
  98. X
  99. XVersion 1.98 31/07/92
  100. X    Support for the ETA10.  This is a strange machine that defines
  101. X    longs and ints as 8 bytes and shorts as 4 bytes.
  102. X    Since I do evil things with long * that assume that they are 4
  103. X    bytes.  Look in the Makefile for the option to compile for
  104. X    this machine.  quad_cksum appears to have problems but I
  105. X    will don't have the time to fix it right now, and this is not
  106. X    a function that uses DES and so will not effect the main uses
  107. X    of the library.
  108. X
  109. XVersion 1.97 20/05/92 eay
  110. X    Fixed the Imakefile and made some changes to des.h to fix some
  111. X    problems when building this package with Kerberos v 4.
  112. X
  113. XVersion 1.96 18/05/92 eay
  114. X    Fixed a small bug in string_to_key() where problems could
  115. X    occur if des_check_key was set to true and the string
  116. X    generated a weak key.
  117. X
  118. XPatch2 posted to comp.sources.misc
  119. XVersion 1.95 13/05/92 eay
  120. X    Added an alternative version of the D_ENCRYPT macro in
  121. X    ecb_encrypt and fcrypt.  Depending on the compiler, one version or the
  122. X    other will be faster.  This was inspired by 
  123. X    Dana How <how@isl.stanford.edu>, and her pointers about doing the
  124. X    *(ulong *)((uchar *)ptr+(value&0xfc))
  125. X    vs
  126. X    ptr[value&0x3f]
  127. X    to stop the C compiler doing a <<2 to convert the long array index.
  128. X
  129. XVersion 1.94 05/05/92 eay
  130. X    Fixed an incompatibility between my string_to_key and the MIT
  131. X     version.  When the key is longer than 8 chars, I was wrapping
  132. X     with a different method.  To use the old version, define
  133. X     OLD_STR_TO_KEY in the makefile.  Thanks to
  134. X     viktor@newsu.shearson.com (Viktor Dukhovni).
  135. X
  136. XVersion 1.93 28/04/92 eay
  137. X    Fixed the VMS mods so that echo is now turned off in
  138. X     read_password.  Thanks again to brennan@coco.cchs.su.oz.AU.
  139. X    MSDOS support added.  The routines can be compiled with
  140. X     Turbo C (v2.0) and MSC (v5.1).  Make sure MSDOS is defined.
  141. X
  142. XPatch1 posted to comp.sources.misc
  143. XVersion 1.92 13/04/92 eay
  144. X    Changed D_ENCRYPT so that the rotation of R occurs outside of
  145. X     the loop.  This required rotating all the longs in sp.h (now
  146. X     called spr.h). Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
  147. X    speed.c has been changed so it will work without SIGALRM.  If
  148. X     times(3) is not present it will try to use ftime() instead.
  149. X
  150. XVersion 1.91 08/04/92 eay
  151. X    Added -E/-D options to des(1) so it can use string_to_key.
  152. X    Added SVR4 mods suggested by witr@rwwa.COM
  153. X    Added VMS mods suggested by brennan@coco.cchs.su.oz.AU.  If
  154. X    anyone knows how to turn of tty echo in VMS please tell me or
  155. X    implement it yourself :-).
  156. X    Changed FILE *IN/*OUT to *DES_IN/*DES_OUT since it appears VMS
  157. X    does not like IN/OUT being used.
  158. X
  159. XLibdes posted to comp.sources.misc
  160. XVersion 1.9 24/03/92 eay
  161. X    Now contains a fast small crypt replacement.
  162. X    Added des(1) command.
  163. X    Added des_rw_mode so people can use cbc encryption with
  164. X    enc_read and enc_write.
  165. X
  166. XVersion 1.8 15/10/91 eay
  167. X    Bug in cbc_cksum.
  168. X    Many thanks to Keith Reynolds (keithr@sco.COM) for pointing this
  169. X    one out.
  170. X
  171. XVersion 1.7 24/09/91 eay
  172. X    Fixed set_key :-)
  173. X    set_key is 4 times faster and takes less space.
  174. X    There are a few minor changes that could be made.
  175. X
  176. XVersion 1.6 19/09/1991 eay
  177. X    Finally go IP and FP finished.
  178. X    Now I need to fix set_key.
  179. X    This version is quite a bit faster that 1.51
  180. X
  181. XVersion 1.52 15/06/1991 eay
  182. X    20% speedup in ecb_encrypt by changing the E bit selection
  183. X    to use 2 32bit words.  This also required modification of the
  184. X    sp table.  There is still a way to speedup the IP and IP-1
  185. X    (hints from outer@sq.com) still working on this one :-(.
  186. X
  187. XVersion 1.51 07/06/1991 eay
  188. X    Faster des_encrypt by loop unrolling
  189. X    Fixed bug in quad_cksum.c (thanks to hughes@logos.ucs.indiana.edu)
  190. X
  191. XVersion 1.50 28/05/1991 eay
  192. X    Optimized the code a bit more for the sparc.  I have improved the
  193. X    speed of the inner des_encrypt by speeding up the initial and
  194. X    final permutations.
  195. X
  196. XVersion 1.40 23/10/1990 eay
  197. X    Fixed des_random_key, it did not produce a random key :-(
  198. X
  199. XVersion 1.30  2/10/1990 eay
  200. X    Have made des_quad_cksum the same as MIT's, the full package
  201. X    should be compatible with MIT's
  202. X    Have tested on a DECstation 3100
  203. X    Still need to fix des_set_key (make it faster).
  204. X    Does des_cbc_encrypts at 70.5k/sec on a 3100.
  205. X
  206. XVersion 1.20 18/09/1990 eay
  207. X    Fixed byte order dependencies.
  208. X    Fixed (I hope) all the word alignment problems.
  209. X    Speedup in des_ecb_encrypt.
  210. X
  211. XVersion 1.10 11/09/1990 eay
  212. X    Added des_enc_read and des_enc_write.
  213. X    Still need to fix des_quad_cksum.
  214. X    Still need to document des_enc_read and des_enc_write.
  215. X
  216. XVersion 1.00 27/08/1990 eay
  217. END_OF_FILE
  218.   if test 6824 -ne `wc -c <'VERSION'`; then
  219.     echo shar: \"'VERSION'\" unpacked with wrong size!
  220.   fi
  221.   # end of 'VERSION'
  222. fi
  223. if test -f 'cbc_cksm.c' -a "${1}" != "-c" ; then 
  224.   echo shar: Will not clobber existing file \"'cbc_cksm.c'\"
  225. else
  226.   echo shar: Extracting \"'cbc_cksm.c'\" \(1002 characters\)
  227.   sed "s/^X//" >'cbc_cksm.c' <<'END_OF_FILE'
  228. X/* cbc_cksm.c */
  229. X/* Copyright (C) 1993 Eric Young - see README for more details */
  230. X#include "des_locl.h"
  231. X
  232. Xunsigned long des_cbc_cksum(input,output,length,schedule,ivec)
  233. Xdes_cblock *input;
  234. Xdes_cblock *output;
  235. Xlong length;
  236. Xdes_key_schedule schedule;
  237. Xdes_cblock *ivec;
  238. X    {
  239. X    register unsigned long tout0,tout1,tin0,tin1;
  240. X    register long l=length;
  241. X    unsigned long tin[2],tout[2];
  242. X    unsigned char *in,*out,*iv;
  243. X
  244. X    in=(unsigned char *)input;
  245. X    out=(unsigned char *)output;
  246. X    iv=(unsigned char *)ivec;
  247. X
  248. X    c2l(iv,tout0);
  249. X    c2l(iv,tout1);
  250. X    for (; l>0; l-=8)
  251. X        {
  252. X        if (l >= 8)
  253. X            {
  254. X            c2l(in,tin0);
  255. X            c2l(in,tin1);
  256. X            }
  257. X        else
  258. X            c2ln(in,tin0,tin1,l);
  259. X            
  260. X        tin0^=tout0;
  261. X        tin1^=tout1;
  262. X        tin[0]=tin0;
  263. X        tin[1]=tin1;
  264. X        des_encrypt((unsigned long *)tin,(unsigned long *)tout,
  265. X            schedule,DES_ENCRYPT);
  266. X        /* fix 15/10/91 eay - thanks to keithr@sco.COM */
  267. X        tout0=tout[0];
  268. X        tout1=tout[1];
  269. X        }
  270. X    if (out != NULL)
  271. X        {
  272. X        l2c(tout0,out);
  273. X        l2c(tout1,out);
  274. X        }
  275. X    tout0=tin0=tin1=tin[0]=tin[1]=tout[0]=tout[1]=0;
  276. X    return(tout1);
  277. X    }
  278. END_OF_FILE
  279.   if test 1002 -ne `wc -c <'cbc_cksm.c'`; then
  280.     echo shar: \"'cbc_cksm.c'\" unpacked with wrong size!
  281.   fi
  282.   # end of 'cbc_cksm.c'
  283. fi
  284. if test -f 'des_crypt.man' -a "${1}" != "-c" ; then 
  285.   echo shar: Will not clobber existing file \"'des_crypt.man'\"
  286. else
  287.   echo shar: Extracting \"'des_crypt.man'\" \(12459 characters\)
  288.   sed "s/^X//" >'des_crypt.man' <<'END_OF_FILE'
  289. X.TH DES_CRYPT 3 
  290. X.SH NAME
  291. Xdes_read_password, des_read_2password,
  292. Xdes_string_to_key, des_string_to_2key, des_read_pw_string,
  293. Xdes_random_key, des_set_key,
  294. Xdes_key_sched, des_ecb_encrypt, des_3ecb_encrypt, des_cbc_encrypt,
  295. Xdes_3cbc_encrypt,
  296. Xdes_pcbc_encrypt, des_cfb_encrypt, des_ofb_encrypt,
  297. Xdes_cbc_cksum, des_quad_cksum,
  298. Xdes_enc_read, des_enc_write, des_set_odd_parity,
  299. Xdes_is_weak_key, crypt \- (non USA) DES encryption
  300. X.SH SYNOPSIS
  301. X.nf
  302. X.nj
  303. X.ft B
  304. X#include <des.h>
  305. X.PP
  306. X.B int des_read_password(key,prompt,verify)
  307. Xdes_cblock *key;
  308. Xchar *prompt;
  309. Xint verify;
  310. X.PP
  311. X.B int des_read_2password(key1,key2,prompt,verify)
  312. Xdes_cblock *key1,*key2;
  313. Xchar *prompt;
  314. Xint verify;
  315. X.PP
  316. X.B int des_string_to_key(str,key)
  317. Xchar *str;
  318. Xdes_cblock *key;
  319. X.PP
  320. X.B int des_string_to_2keys(str,key1,key2)
  321. Xchar *str;
  322. Xdes_cblock *key1,*key2;
  323. X.PP
  324. X.B int des_read_pw_string(buf,length,prompt,verify)
  325. Xchar *buf;
  326. Xint length;
  327. Xchar *prompt;
  328. Xint verify;
  329. X.PP
  330. X.B int des_random_key(key)
  331. Xdes_cblock *key;
  332. X.PP
  333. X.B int des_set_key(key,schedule)
  334. Xdes_cblock *key;
  335. Xdes_key_schedule schedule;
  336. X.PP
  337. X.B int des_key_sched(key,schedule)
  338. Xdes_cblock *key;
  339. Xdes_key_schedule schedule;
  340. X.PP
  341. X.B int des_ecb_encrypt(input,output,schedule,encrypt)
  342. Xdes_cblock *input;
  343. Xdes_cblock *output;
  344. Xdes_key_schedule schedule;
  345. Xint encrypt;
  346. X.PP
  347. X.B int des_3ecb_encrypt(input,output,ks1,ks2,encrypt)
  348. Xdes_cblock *input;
  349. Xdes_cblock *output;
  350. Xdes_key_schedule ks1,ks2;
  351. Xint encrypt;
  352. X.PP
  353. X.B int des_cbc_encrypt(input,output,length,schedule,ivec,encrypt)
  354. Xdes_cblock *input;
  355. Xdes_cblock *output;
  356. Xlong length;
  357. Xdes_key_schedule schedule;
  358. Xdes_cblock *ivec;
  359. Xint encrypt;
  360. X.PP
  361. X.B int des_3cbc_encrypt(input,output,length,sk1,sk2,ivec1,ivec2,encrypt)
  362. Xdes_cblock *input;
  363. Xdes_cblock *output;
  364. Xlong length;
  365. Xdes_key_schedule sk1;
  366. Xdes_key_schedule sk2;
  367. Xdes_cblock *ivec1;
  368. Xdes_cblock *ivec2;
  369. Xint encrypt;
  370. X.PP
  371. X.B int des_pcbc_encrypt(input,output,length,schedule,ivec,encrypt)
  372. Xdes_cblock *input;
  373. Xdes_cblock *output;
  374. Xlong length;
  375. Xdes_key_schedule schedule;
  376. Xdes_cblock *ivec;
  377. Xint encrypt;
  378. X.PP
  379. X.B int des_cfb_encrypt(input,output,numbits,length,schedule,ivec,encrypt)
  380. Xunsigned char *input;
  381. Xunsigned char *output;
  382. Xint numbits;
  383. Xlong length;
  384. Xdes_key_schedule schedule;
  385. Xdes_cblock *ivec;
  386. Xint encrypt;
  387. X.PP
  388. X.B int des_ofb_encrypt(input,output,numbits,length,schedule,ivec)
  389. Xunsigned char *input,*output;
  390. Xint numbits;
  391. Xlong length;
  392. Xdes_key_schedule schedule;
  393. Xdes_cblock *ivec;
  394. X.PP
  395. X.B unsigned long des_cbc_cksum(input,output,length,schedule,ivec)
  396. Xdes_cblock *input;
  397. Xdes_cblock *output;
  398. Xlong length;
  399. Xdes_key_schedule schedule;
  400. Xdes_cblock *ivec;
  401. X.PP
  402. X.B unsigned long des_quad_cksum(input,output,length,out_count,seed)
  403. Xdes_cblock *input;
  404. Xdes_cblock *output;
  405. Xlong length;
  406. Xint out_count;
  407. Xdes_cblock *seed;
  408. X.PP
  409. X.B int des_check_key;
  410. X.PP
  411. X.B int des_enc_read(fd,buf,len,sched,iv)
  412. Xint fd;
  413. Xchar *buf;
  414. Xint len;
  415. Xdes_key_schedule sched;
  416. Xdes_cblock *iv;
  417. X.PP
  418. X.B int des_enc_write(fd,buf,len,sched,iv)
  419. Xint fd;
  420. Xchar *buf;
  421. Xint len;
  422. Xdes_key_schedule sched;
  423. Xdes_cblock *iv;
  424. X.PP
  425. X.B extern int des_rw_mode;
  426. X.PP
  427. X.B void des_set_odd_parity(key)
  428. Xdes_cblock *key;
  429. X.PP
  430. X.B int des_is_weak_key(key)
  431. Xdes_cblock *key;
  432. X.PP
  433. X.B char *crypt(passwd,salt)
  434. Xchar *passwd;
  435. Xchar *salt;
  436. X.PP
  437. X.fi
  438. X.SH DESCRIPTION
  439. XThis library contains a fast implementation of the DES encryption
  440. Xalgorithm.
  441. X.PP
  442. XThere are two phases to the use of DES encryption.
  443. XThe first is the generation of a
  444. X.I des_key_schedule
  445. Xfrom a key,
  446. Xthe second is the actual encryption.
  447. XA des key is of type
  448. X.I des_cblock.
  449. XThis type is made from 8 characters with odd parity.
  450. XThe least significant bit in the character is the parity bit.
  451. XThe key schedule is an expanded form of the key; it is used to speed the
  452. Xencryption process.
  453. X.PP
  454. X.I des_read_password
  455. Xwrites the string specified by prompt to the standard output,
  456. Xturns off echo and reads an input string from standard input
  457. Xuntil terminated with a newline.
  458. XIf verify is non-zero, it prompts and reads the input again and verifies
  459. Xthat both entered passwords are the same.
  460. XThe entered string is converted into a des key by using the
  461. X.I des_string_to_key
  462. Xroutine.
  463. XThe new key is placed in the
  464. X.I des_cblock
  465. Xthat was passed (by reference) to the routine.
  466. XIf there were no errors,
  467. X.I des_read_password
  468. Xreturns 0,
  469. X-1 is returned if there was a terminal error and 1 is returned for
  470. Xany other error.
  471. X.PP
  472. X.I des_read_2password
  473. Xoperates in the same way as
  474. X.I des_read_password
  475. Xexcept that it generates 2 keys by using the
  476. X.I des_string_to_2key
  477. Xfunction.
  478. X.PP
  479. X.I des_read_pw_string
  480. Xis called by
  481. X.I des_read_password
  482. Xto read and verify a string from a terminal device.
  483. XThe string is returned in
  484. X.I buf.
  485. XThe size of
  486. X.I buf
  487. Xis passed to the routine via the
  488. X.I length
  489. Xparameter.
  490. X.PP
  491. X.I des_string_to_key
  492. Xconverts a string into a valid des key.
  493. X.PP
  494. X.I des_string_to_2key
  495. Xconverts a string into 2 valid des keys.
  496. XThis routine is best suited for used to generate keys for use with
  497. X.I des_3ecb_encrypt.
  498. X.PP
  499. X.I des_random_key
  500. Xreturns a random key that is made of a combination of process id,
  501. Xtime and an increasing counter.
  502. X.PP
  503. XBefore a des key can be used it is converted into a
  504. X.I des_key_schedule
  505. Xvia the
  506. X.I des_set_key
  507. Xroutine.
  508. XIf the
  509. X.I des_check_key
  510. Xflag is non-zero,
  511. X.I des_set_key
  512. Xwill check that the key passed is of odd parity and is not a week or
  513. Xsemi-weak key.
  514. XIf the parity is wrong,
  515. Xthen -1 is returned.
  516. XIf the key is a weak key,
  517. Xthen -2 is returned.
  518. XIf an error is returned,
  519. Xthe key schedule is not generated.
  520. X.PP
  521. X.I des_key_sched
  522. Xis another name for the
  523. X.I des_set_key
  524. Xfunction.
  525. X.PP
  526. XThe following routines mostly operate on an input and output stream of
  527. X.I des_cblock's.
  528. X.PP
  529. X.I des_ecb_encrypt
  530. Xis the basic DES encryption routine that encrypts or decrypts a single 8-byte
  531. X.I des_cblock
  532. Xin
  533. X.I electronic code book
  534. Xmode.
  535. XIt always transforms the input data, pointed to by
  536. X.I input,
  537. Xinto the output data,
  538. Xpointed to by the
  539. X.I output
  540. Xargument.
  541. XIf the
  542. X.I encrypt
  543. Xargument is non-zero (DES_ENCRYPT),
  544. Xthe
  545. X.I input
  546. X(cleartext) is encrypted in to the
  547. X.I output
  548. X(ciphertext) using the key_schedule specified by the
  549. X.I schedule
  550. Xargument,
  551. Xpreviously set via
  552. X.I des_set_key.
  553. XIf
  554. X.I encrypt
  555. Xis zero (DES_DECRYPT),
  556. Xthe
  557. X.I input
  558. X(now ciphertext)
  559. Xis decrypted into the
  560. X.I output
  561. X(now cleartext).
  562. XInput and output may overlap.
  563. XNo meaningful value is returned.
  564. X.PP
  565. X.I des_3ecb_encrypt
  566. Xencrypts/decrypts the
  567. X.I input
  568. Xblock by using triple ecb DES encryption.
  569. XThis involves encrypting the input with 
  570. X.I ks1,
  571. Xdecryption with the key schedule
  572. X.I ks2,
  573. Xand then encryption with the first again.
  574. XThis routine greatly reduces the chances of brute force breaking of
  575. XDES and has the advantage of if
  576. X.I ks1
  577. Xand
  578. X.I ks2
  579. Xare the same, it is equivalent to just encryption using ecb mode and
  580. X.I ks1
  581. Xas the key.
  582. X.PP
  583. X.I des_cbc_encrypt
  584. Xencrypts/decrypts using the
  585. X.I cipher-block-chaining
  586. Xmode of DES.
  587. XIf the
  588. X.I encrypt
  589. Xargument is non-zero,
  590. Xthe routine cipher-block-chain encrypts the cleartext data pointed to by the
  591. X.I input
  592. Xargument into the ciphertext pointed to by the
  593. X.I output
  594. Xargument,
  595. Xusing the key schedule provided by the
  596. X.I schedule
  597. Xargument,
  598. Xand initialisation vector provided by the
  599. X.I ivec
  600. Xargument.
  601. XIf the
  602. X.I length
  603. Xargument is not an integral multiple of eight bytes, 
  604. Xthe last block is copied to a temporary area and zero filled.
  605. XThe output is always
  606. Xan integral multiple of eight bytes.
  607. XTo make multiple cbc encrypt calls on a large amount of data appear to
  608. Xbe one 
  609. X.I des_cbc_encrypt
  610. Xcall, the
  611. X.I ivec
  612. Xof subsequent calls should be the last 8 bytes of the output.
  613. X.PP
  614. X.I des_3cbc_encrypt
  615. Xencrypts/decrypts the
  616. X.I input
  617. Xblock by using triple cbc DES encryption.
  618. XThis involves encrypting the input with key schedule
  619. X.I ks1,
  620. Xdecryption with the key schedule
  621. X.I ks2,
  622. Xand then encryption with the first again.
  623. X2 initialisation vectors are required,
  624. X.I ivec1
  625. Xand
  626. X.I ivec2.
  627. XUnlike
  628. X.I des_cbc_encrypt,
  629. Xthese initialisation vectors are modified by the subroutine.
  630. XThis routine greatly reduces the chances of brute force breaking of
  631. XDES and has the advantage of if
  632. X.I ks1
  633. Xand
  634. X.I ks2
  635. Xare the same, it is equivalent to just encryption using cbc mode and
  636. X.I ks1
  637. Xas the key.
  638. X.PP
  639. X.I des_pcbc_encrypt
  640. Xencrypt/decrypts using a modified block chaining mode.
  641. XIt provides better error propagation characteristics than cbc
  642. Xencryption.
  643. X.PP
  644. X.I des_cfb_encrypt
  645. Xencrypt/decrypts using cipher feedback mode.  This method takes an
  646. Xarray of characters as input and outputs and array of characters.  It
  647. Xdoes not require any padding to 8 character groups.  Note: the ivec
  648. Xvariable is changed and the new changed value needs to be passed to
  649. Xthe next call to this function.  Since this function runs a complete
  650. XDES ecb encryption per numbits, this function is only suggested for
  651. Xuse when sending small numbers of characters.
  652. X.PP
  653. X.I des_ofb_encrypt
  654. Xencrypt using output feedback mode.  This method takes an
  655. Xarray of characters as input and outputs and array of characters.  It
  656. Xdoes not require any padding to 8 character groups.  Note: the ivec
  657. Xvariable is changed and the new changed value needs to be passed to
  658. Xthe next call to this function.  Since this function runs a complete
  659. XDES ecb encryption per numbits, this function is only suggested for
  660. Xuse when sending small numbers of characters.
  661. X.PP
  662. X.I des_cbc_cksum
  663. Xproduces an 8 byte checksum based on the input stream (via cbc encryption).
  664. XThe last 4 bytes of the checksum is returned and the complete 8 bytes is
  665. Xplaced in
  666. X.I output.
  667. X.PP
  668. X.I des_quad_cksum
  669. Xreturns a 4 byte checksum from the input bytes.
  670. XThe algorithm can be iterated over the input,
  671. Xdepending on
  672. X.I out_count,
  673. X1, 2, 3 or 4 times.
  674. XIf
  675. X.I output
  676. Xis non-NULL,
  677. Xthe 8 bytes generated by each pass are written into
  678. X.I output.
  679. X.PP
  680. X.I des_enc_write
  681. Xis used to write
  682. X.I len
  683. Xbytes
  684. Xto file descriptor
  685. X.I fd
  686. Xfrom buffer
  687. X.I buf.
  688. XThe data is encrypted via
  689. X.I pcbc_encrypt
  690. X(default) using
  691. X.I sched
  692. Xfor the key and
  693. X.I iv
  694. Xas a starting vector.
  695. XThe actual data send down
  696. X.I fd
  697. Xconsists of 4 bytes (in network byte order) containing the length of the
  698. Xfollowing encrypted data.  The encrypted data then follows, padded with random
  699. Xdata out to a multiple of 8 bytes.
  700. X.PP
  701. X.I des_enc_read
  702. Xis used to read
  703. X.I len
  704. Xbytes
  705. Xfrom file descriptor
  706. X.I fd
  707. Xinto buffer
  708. X.I buf.
  709. XThe data being read from
  710. X.I fd
  711. Xis assumed to have come from
  712. X.I des_enc_write
  713. Xand is decrypted using
  714. X.I sched
  715. Xfor the key schedule and
  716. X.I iv
  717. Xfor the initial vector.
  718. XThe
  719. X.I des_enc_read/des_enc_write
  720. Xpair can be used to read/write to files, pipes and sockets.
  721. XI have used them in implementing a version of rlogin in which all
  722. Xdata is encrypted.
  723. X.PP
  724. X.I des_rw_mode
  725. Xis used to specify the encryption mode to use with 
  726. X.I des_enc_read
  727. Xand 
  728. X.I des_end_write.
  729. XIf set to
  730. X.I DES_PCBC_MODE
  731. X(the default), des_pcbc_encrypt is used.
  732. XIf set to
  733. X.I DES_CBC_MODE
  734. Xdes_cbc_encrypt is used.
  735. XThese two routines and the variable are not part of the normal MIT library.
  736. X.PP
  737. X.I des_set_odd_parity
  738. Xsets the parity of the passed
  739. X.I key
  740. Xto odd.  This routine is not part of the standard MIT library.
  741. X.PP
  742. X.I des_is_weak_key
  743. Xreturns 1 is the passed key is a weak key (pick again :-),
  744. X0 if it is ok.
  745. XThis routine is not part of the standard MIT library.
  746. X.PP
  747. X.I crypt
  748. Xis a replacement for the normal system crypt.
  749. XIt is much faster than the system crypt.
  750. X.PP
  751. X.SH FILES
  752. X/usr/include/des.h
  753. X.br
  754. X/usr/lib/libdes.a
  755. X.PP
  756. XThe encryption routines have been tested on 16bit, 32bit and 64bit
  757. Xmachines of various endian and even works under VMS.
  758. X.PP
  759. X.SH BUGS
  760. X.PP
  761. XIf you think this manual is sparse,
  762. Xread the des_crypt(3) manual from the MIT kerberos (or bones outside
  763. Xof the USA) distribution.
  764. X.PP
  765. X.I des_cfb_encrypt
  766. Xand
  767. X.I des_ofb_encrypt
  768. Xoperates on input of 8 bits.  What this means is that if you set
  769. Xnumbits to 12, and length to 2, the first 12 bits will come from the 1st
  770. Xinput byte and the low half of the second input byte.  The second 12
  771. Xbits will have the low 8 bits taken from the 3rd input byte and the
  772. Xtop 4 bits taken from the 4th input byte.  The same holds for output.
  773. XThis function has been implemented this way because most people will
  774. Xbe using a multiple of 8 and because once you get into pulling bytes input
  775. Xbytes apart things get ugly!
  776. X.PP
  777. X.I des_read_pw_string
  778. Xis the most machine/OS dependent function and normally generates the
  779. Xmost problems when porting this code.
  780. X.PP
  781. X.I des_string_to_key
  782. Xis probably different from the MIT version since there are lots
  783. Xof fun ways to implement one-way encryption of a text string.
  784. X.PP
  785. XThe routines are optimised for 32 bit machines and so are not efficient
  786. Xon IBM PCs.
  787. X.SH AUTHOR
  788. XEric Young (eay@psych.psy.uq.oz.au),
  789. XPsychology Department,
  790. XUniversity of Queensland, Australia.
  791. END_OF_FILE
  792.   if test 12459 -ne `wc -c <'des_crypt.man'`; then
  793.     echo shar: \"'des_crypt.man'\" unpacked with wrong size!
  794.   fi
  795.   # end of 'des_crypt.man'
  796. fi
  797. if test -f 'des_locl.h' -a "${1}" != "-c" ; then 
  798.   echo shar: Will not clobber existing file \"'des_locl.h'\"
  799. else
  800.   echo shar: Extracting \"'des_locl.h'\" \(5949 characters\)
  801.   sed "s/^X//" >'des_locl.h' <<'END_OF_FILE'
  802. X/* des_locl.h */
  803. X/* Copyright (C) 1993 Eric Young - see README for more details */
  804. X#include <stdio.h>
  805. X#include "des.h"
  806. X
  807. X#if defined(__STDC__) || defined(VMS) || defined(M_XENIX) || defined(MSDOS)
  808. X#include <string.h>
  809. X#define bcopy(b1,b2,len) memcpy(b2, b1, (size_t)(len))
  810. X#define bzero(b,len) memset(b, 0, (size_t)(len))
  811. X#define bcmp(b1,b2,len) memcmp(b1, b2, (size_t)(len))
  812. X#define index(s1,char) strchr(s1,char)
  813. X#endif
  814. X
  815. X#ifdef MSDOS
  816. X#define getpid() 2
  817. X#define RAND
  818. Xextern int errno;
  819. X#define PROTO
  820. X#endif
  821. X
  822. X#ifdef __STDC__
  823. X#define PROTO
  824. X#endif
  825. X
  826. X#ifdef RAND
  827. X#define random() rand()
  828. X#define srandom(s) srand(s)
  829. X#endif
  830. X
  831. X#define ITERATIONS 16
  832. X#define HALF_ITERATIONS 8
  833. X
  834. X/* used in des_read and des_write */
  835. X#define MAXWRITE    (1024*16)
  836. X#define BSIZE        (MAXWRITE+4)
  837. X
  838. X#define c2l(c,l)    (l =((unsigned long)(*((c)++)))    , \
  839. X             l|=((unsigned long)(*((c)++)))<< 8, \
  840. X             l|=((unsigned long)(*((c)++)))<<16, \
  841. X             l|=((unsigned long)(*((c)++)))<<24)
  842. X
  843. X/* NOTE - c is not incremented as per c2l */
  844. X#define c2ln(c,l1,l2,n)    { \
  845. X            c+=n; \
  846. X            l1=l2=0; \
  847. X            switch (n) { \
  848. X            case 8: l2|=((unsigned long)(*(--(c))))<<24; \
  849. X            case 7: l2|=((unsigned long)(*(--(c))))<<16; \
  850. X            case 6: l2|=((unsigned long)(*(--(c))))<< 8; \
  851. X            case 5: l2|=((unsigned long)(*(--(c))));     \
  852. X            case 4: l1|=((unsigned long)(*(--(c))))<<24; \
  853. X            case 3: l1|=((unsigned long)(*(--(c))))<<16; \
  854. X            case 2: l1|=((unsigned long)(*(--(c))))<< 8; \
  855. X            case 1: l1|=((unsigned long)(*(--(c))));     \
  856. X                } \
  857. X            }
  858. X
  859. X#define l2c(l,c)    (*((c)++)=(unsigned char)(((l)    )&0xff), \
  860. X             *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
  861. X             *((c)++)=(unsigned char)(((l)>>16)&0xff), \
  862. X             *((c)++)=(unsigned char)(((l)>>24)&0xff))
  863. X
  864. X/* replacements for htonl and ntohl since I have no idea what to do
  865. X * when faced with machines with 8 byte longs. */
  866. X#define HDRSIZE 4
  867. X
  868. X#define n2l(c,l)    (l =((unsigned long)(*((c)++)))<<24, \
  869. X             l|=((unsigned long)(*((c)++)))<<16, \
  870. X             l|=((unsigned long)(*((c)++)))<< 8, \
  871. X             l|=((unsigned long)(*((c)++))))
  872. X
  873. X#define l2n(l,c)    (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
  874. X             *((c)++)=(unsigned char)(((l)>>16)&0xff), \
  875. X             *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
  876. X             *((c)++)=(unsigned char)(((l)    )&0xff))
  877. X
  878. X/* NOTE - c is not incremented as per l2c */
  879. X#define l2cn(l1,l2,c,n)    { \
  880. X            c+=n; \
  881. X            switch (n) { \
  882. X            case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \
  883. X            case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \
  884. X            case 6: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \
  885. X            case 5: *(--(c))=(unsigned char)(((l2)    )&0xff); \
  886. X            case 4: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \
  887. X            case 3: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \
  888. X            case 2: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \
  889. X            case 1: *(--(c))=(unsigned char)(((l1)    )&0xff); \
  890. X                } \
  891. X            }
  892. X
  893. X/* The changes to this macro may help or hinder, depending on the
  894. X * compiler and the achitecture.  gcc2 always seems to do well :-).
  895. X * Inspired by Dana How <how@isl.stanford.edu>
  896. X * DO NOT use the alternative version on machines with 8 byte longs. */
  897. X#ifdef ALT_ECB
  898. X#define D_ENCRYPT(L,R,S) \
  899. X    u=((R^s[S  ])<<2);    \
  900. X    t= R^s[S+1]; \
  901. X    t=((t>>2)+(t<<30)); \
  902. X    L^= \
  903. X    *(unsigned long *)(des_SP+0x0100+((t    )&0xfc))+ \
  904. X    *(unsigned long *)(des_SP+0x0300+((t>> 8)&0xfc))+ \
  905. X    *(unsigned long *)(des_SP+0x0500+((t>>16)&0xfc))+ \
  906. X    *(unsigned long *)(des_SP+0x0700+((t>>24)&0xfc))+ \
  907. X    *(unsigned long *)(des_SP+       ((u    )&0xfc))+ \
  908. X      *(unsigned long *)(des_SP+0x0200+((u>> 8)&0xfc))+ \
  909. X      *(unsigned long *)(des_SP+0x0400+((u>>16)&0xfc))+ \
  910. X     *(unsigned long *)(des_SP+0x0600+((u>>24)&0xfc));
  911. X#else /* original version */
  912. X#ifdef MSDOS
  913. X#define D_ENCRYPT(L,R,S)    \
  914. X    U.l=R^s[S+1]; \
  915. X    T.s[0]=((U.s[0]>>4)|(U.s[1]<<12))&0x3f3f; \
  916. X    T.s[1]=((U.s[1]>>4)|(U.s[0]<<12))&0x3f3f; \
  917. X    U.l=(R^s[S  ])&0x3f3f3f3f; \
  918. X    L^=    des_SPtrans[1][(T.c[0])]| \
  919. X        des_SPtrans[3][(T.c[1])]| \
  920. X        des_SPtrans[5][(T.c[2])]| \
  921. X        des_SPtrans[7][(T.c[3])]| \
  922. X        des_SPtrans[0][(U.c[0])]| \
  923. X        des_SPtrans[2][(U.c[1])]| \
  924. X        des_SPtrans[4][(U.c[2])]| \
  925. X        des_SPtrans[6][(U.c[3])];
  926. X#else
  927. X#define D_ENCRYPT(L,R,S)    \
  928. X    u=(R^s[S  ]); \
  929. X    t=R^s[S+1]; \
  930. X    t=((t>>4)+(t<<28)); \
  931. X    L^=    des_SPtrans[1][(t    )&0x3f]| \
  932. X        des_SPtrans[3][(t>> 8)&0x3f]| \
  933. X        des_SPtrans[5][(t>>16)&0x3f]| \
  934. X        des_SPtrans[7][(t>>24)&0x3f]| \
  935. X        des_SPtrans[0][(u    )&0x3f]| \
  936. X        des_SPtrans[2][(u>> 8)&0x3f]| \
  937. X        des_SPtrans[4][(u>>16)&0x3f]| \
  938. X        des_SPtrans[6][(u>>24)&0x3f];
  939. X#endif
  940. X#endif
  941. X
  942. X    /* IP and FP
  943. X     * The problem is more of a geometric problem that random bit fiddling.
  944. X     0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6
  945. X     8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4
  946. X    16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2
  947. X    24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0
  948. X
  949. X    32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7
  950. X    40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5
  951. X    48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3
  952. X    56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1
  953. X
  954. X    The output has been subject to swaps of the form
  955. X    0 1 -> 3 1 but the odd and even bits have been put into
  956. X    2 3    2 0
  957. X    different words.  The main trick is to remember that
  958. X    t=((l>>size)^r)&(mask);
  959. X    r^=t;
  960. X    l^=(t<<size);
  961. X    can be used to swap and move bits between words.
  962. X
  963. X    So l =  0  1  2  3  r = 16 17 18 19
  964. X            4  5  6  7      20 21 22 23
  965. X            8  9 10 11      24 25 26 27
  966. X           12 13 14 15      28 29 30 31
  967. X    becomes (for size == 2 and mask == 0x3333)
  968. X       t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
  969. X         6^20  7^21 -- --        4  5 20 21       6  7 22 23
  970. X        10^24 11^25 -- --        8  9 24 25      10 11 24 25
  971. X        14^28 15^29 -- --       12 13 28 29      14 15 28 29
  972. X
  973. X    Thanks for hints from Richard Outerbridge - he told me IP&FP
  974. X    could be done in 15 xor, 10 shifts and 5 ands.
  975. X    When I finally started to think of the problem in 2D
  976. X    I first got ~42 operations without xors.  When I remembered
  977. X    how to use xors :-) I got it to its final state.
  978. X    */
  979. X#define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
  980. X    (b)^=(t),\
  981. X    (a)^=((t)<<(n)))
  982. X
  983. END_OF_FILE
  984.   if test 5949 -ne `wc -c <'des_locl.h'`; then
  985.     echo shar: \"'des_locl.h'\" unpacked with wrong size!
  986.   fi
  987.   # end of 'des_locl.h'
  988. fi
  989. if test -f 'read_pwd.c' -a "${1}" != "-c" ; then 
  990.   echo shar: Will not clobber existing file \"'read_pwd.c'\"
  991. else
  992.   echo shar: Extracting \"'read_pwd.c'\" \(5215 characters\)
  993.   sed "s/^X//" >'read_pwd.c' <<'END_OF_FILE'
  994. X/* read_pwd.c */
  995. X/* Copyright (C) 1993 Eric Young - see README for more details */
  996. X/* 06-Apr-92 Luke Brennan    Support for VMS */
  997. X#include "des_locl.h"
  998. X#include <string.h>
  999. X#include <signal.h>
  1000. X#include <setjmp.h>
  1001. X
  1002. X#ifndef VMS
  1003. X#ifndef MSDOS
  1004. X#ifndef _IRIX
  1005. X#ifdef CRAY
  1006. X#include <termio.h>
  1007. X#define sgttyb termio
  1008. X#define sg_flags c_lflag
  1009. X#else /* !CRAY */
  1010. X#include <sgtty.h>
  1011. X#endif
  1012. X#include <sys/ioctl.h>
  1013. X#else /* _IRIX */
  1014. Xstruct  sgttyb {
  1015. X    char    sg_ispeed;              /* input speed */
  1016. X    char    sg_ospeed;              /* output speed */
  1017. X    char    sg_erase;               /* erase character */
  1018. X    char    sg_kill;                /* kill character */
  1019. X    short   sg_flags; /* mode flags */
  1020. X    };
  1021. X#endif
  1022. X#else /* MSDOS */
  1023. X#define fgets(a,b,c) noecho_fgets(a,b,c)
  1024. X#ifndef NSIG
  1025. X#define NSIG 32
  1026. X#endif
  1027. X#endif
  1028. X#else /* VMS */
  1029. X#include <ssdef.h>
  1030. X#include <iodef.h>
  1031. X#include <ttdef.h>
  1032. X#include <descrip.h>
  1033. Xstruct IOSB {
  1034. X    short iosb$w_value;
  1035. X    short iosb$w_count;
  1036. X    long  iosb$l_info;
  1037. X    };
  1038. X#endif
  1039. X
  1040. Xstatic void read_till_nl();
  1041. Xstatic int read_pw();
  1042. Xstatic void recsig();
  1043. Xstatic void pushsig();
  1044. Xstatic void popsig();
  1045. X#ifdef MSDOS
  1046. Xstatic int noecho_fgets();
  1047. X#endif
  1048. X
  1049. Xstatic void (*savsig[NSIG])();
  1050. Xstatic jmp_buf save;
  1051. X
  1052. Xint des_read_password(key,prompt,verify)
  1053. Xdes_cblock *key;
  1054. Xchar *prompt;
  1055. Xint verify;
  1056. X    {
  1057. X    int ok;
  1058. X    char buf[BUFSIZ],buff[BUFSIZ];
  1059. X
  1060. X    if ((ok=read_pw(buf,buff,BUFSIZ,prompt,verify)) == 0)
  1061. X        des_string_to_key(buf,key);
  1062. X    bzero(buf,BUFSIZ);
  1063. X    bzero(buff,BUFSIZ);
  1064. X    return(ok);
  1065. X    }
  1066. X
  1067. Xint des_read_2passwords(key1,key2,prompt,verify)
  1068. Xdes_cblock *key1;
  1069. Xdes_cblock *key2;
  1070. Xchar *prompt;
  1071. Xint verify;
  1072. X    {
  1073. X    int ok;
  1074. X    char buf[BUFSIZ],buff[BUFSIZ];
  1075. X
  1076. X    if ((ok=read_pw(buf,buff,BUFSIZ,prompt,verify)) == 0)
  1077. X        des_string_to_2keys(buf,key1,key2);
  1078. X    bzero(buf,BUFSIZ);
  1079. X    bzero(buff,BUFSIZ);
  1080. X    return(ok);
  1081. X    }
  1082. X
  1083. Xint des_read_pw_string(buf,length,prompt,verify)
  1084. Xchar *buf;
  1085. Xint length;
  1086. Xchar *prompt;
  1087. Xint verify;
  1088. X    {
  1089. X    char buff[BUFSIZ];
  1090. X    int ret;
  1091. X
  1092. X    ret=read_pw(buf,buff,(length>BUFSIZ)?BUFSIZ:length,prompt,verify);
  1093. X    bzero(buff,BUFSIZ);
  1094. X    return(ret);
  1095. X    }
  1096. X
  1097. Xstatic void read_till_nl(in)
  1098. XFILE *in;
  1099. X    {
  1100. X#define SIZE 4
  1101. X    char buf[SIZE+1];
  1102. X
  1103. X    do    {
  1104. X        fgets(buf,SIZE,in);
  1105. X        } while (index(buf,'\n') == NULL);
  1106. X    }
  1107. X
  1108. X/* return 0 if ok, 1 (or -1) otherwise */
  1109. Xstatic int read_pw(buf,buff,size,prompt,verify)
  1110. Xchar *buf,*buff;
  1111. Xint size;
  1112. Xchar *prompt;
  1113. Xint verify;
  1114. X    {
  1115. X#ifndef VMS
  1116. X#ifndef MSDOS
  1117. X    struct sgttyb tty_orig,tty_new;
  1118. X#endif /* !MSDOS */
  1119. X#else
  1120. X    struct IOSB iosb;
  1121. X    $DESCRIPTOR(terminal,"TT");
  1122. X    long tty_orig[3], tty_new[3];
  1123. X    long status;
  1124. X    unsigned short channel = 0;
  1125. X#endif
  1126. X    int ok=0;
  1127. X    char *p;
  1128. X    int ps=0;
  1129. X    FILE *tty;
  1130. X
  1131. X#ifndef MSDOS
  1132. X    if ((tty=fopen("/dev/tty","r")) == NULL)
  1133. X        tty=stdin;
  1134. X#else /* MSDOS */
  1135. X    if ((tty=fopen("con","r")) == NULL)
  1136. X        tty=stdin;
  1137. X#endif /* MSDOS */
  1138. X#ifndef VMS
  1139. X#ifdef TIOCGETP
  1140. X    if (ioctl(fileno(tty),TIOCGETP,(char *)&tty_orig) == -1)
  1141. X        return(-1);
  1142. X    bcopy(&(tty_orig),&(tty_new),sizeof(tty_orig));
  1143. X#endif
  1144. X#else /* VMS */
  1145. X    status = SYS$ASSIGN(&terminal,&channel,0,0);
  1146. X    if (status != SS$_NORMAL)
  1147. X        return(-1);
  1148. X    status=SYS$QIOW(0,channel,IO$_SENSEMODE,&iosb,0,0,tty_orig,12,0,0,0,0);
  1149. X    if ((status != SS$_NORMAL) || (iosb.iosb$w_value != SS$_NORMAL))
  1150. X        return(-1);
  1151. X#endif
  1152. X
  1153. X    if (setjmp(save))
  1154. X        {
  1155. X        ok=0;
  1156. X        goto error;
  1157. X        }
  1158. X    pushsig();
  1159. X    ps=1;
  1160. X#ifndef VMS
  1161. X#ifndef MSDOS
  1162. X    tty_new.sg_flags &= ~ECHO;
  1163. X#endif /* !MSDOS */
  1164. X#ifdef TIOCSETP
  1165. X    if (ioctl(fileno(tty),TIOCSETP,(char *)&tty_new) == -1)
  1166. X        return(-1);
  1167. X#endif
  1168. X#else /* VMS */
  1169. X    tty_new[0] = tty_orig[0];
  1170. X    tty_new[1] = tty_orig[1] | TT$M_NOECHO;
  1171. X    tty_new[2] = tty_orig[2];
  1172. X    status = SYS$QIOW(0,channel,IO$_SETMODE,&iosb,0,0,tty_new,12,0,0,0,0);
  1173. X    if ((status != SS$_NORMAL) || (iosb.iosb$w_value != SS$_NORMAL))
  1174. X        return(-1);
  1175. X#endif /* VMS */
  1176. X    ps=2;
  1177. X
  1178. X    while (!ok)
  1179. X        {
  1180. X        fputs(prompt,stderr);
  1181. X        fflush(stderr);
  1182. X
  1183. X        buf[0]='\0';
  1184. X        fgets(buf,size,tty);
  1185. X        if (feof(tty)) goto error;
  1186. X        if ((p=(char *)index(buf,'\n')) != NULL)
  1187. X            *p='\0';
  1188. X        else    read_till_nl(tty);
  1189. X        if (verify)
  1190. X            {
  1191. X            fprintf(stderr,"\nVerifying password %s",prompt);
  1192. X            fflush(stderr);
  1193. X            buff[0]='\0';
  1194. X            fgets(buff,size,tty);
  1195. X            if (feof(tty)) goto error;
  1196. X            if ((p=(char *)index(buff,'\n')) != NULL)
  1197. X                *p='\0';
  1198. X            else    read_till_nl(tty);
  1199. X                
  1200. X            if (strcmp(buf,buff) != 0)
  1201. X                {
  1202. X                fprintf(stderr,"\nVerify failure - try again\n");
  1203. X                fflush(stderr);
  1204. X                continue;
  1205. X                }
  1206. X            }
  1207. X        ok=1;
  1208. X        }
  1209. X
  1210. Xerror:
  1211. X    fprintf(stderr,"\n");
  1212. X    /* What can we do if there is an error? */
  1213. X#ifndef VMS
  1214. X#ifdef TIOCSETP
  1215. X    if (ps >= 2) ioctl(fileno(tty),TIOCSETP,(char *)&tty_orig);
  1216. X#endif
  1217. X#else /* VMS */
  1218. X    if (ps >= 2)
  1219. X        status = SYS$QIOW(0,channel,IO$_SETMODE,&iosb,0,0
  1220. X            ,tty_orig,12,0,0,0,0);
  1221. X#endif /* VMS */
  1222. X    
  1223. X    if (ps >= 1) popsig();
  1224. X    if (stdin != tty) fclose(tty);
  1225. X#ifdef VMS
  1226. X    status = SYS$DASSGN(channel);
  1227. X#endif
  1228. X    return(!ok);
  1229. X    }
  1230. X
  1231. Xstatic void pushsig()
  1232. X    {
  1233. X    int i;
  1234. X
  1235. X    for (i=0; i<NSIG; i++)
  1236. X        savsig[i]=signal(i,recsig);
  1237. X    }
  1238. X
  1239. Xstatic void popsig()
  1240. X    {
  1241. X    int i;
  1242. X
  1243. X    for (i=0; i<NSIG; i++)
  1244. X        signal(i,savsig[i]);
  1245. X    }
  1246. X
  1247. Xstatic void recsig()
  1248. X    {
  1249. X    longjmp(save,1);
  1250. X    }
  1251. X
  1252. X#ifdef MSDOS
  1253. Xstatic int noecho_fgets(buf,size,tty)
  1254. Xchar *buf;
  1255. Xint size;
  1256. XFILE *tty;
  1257. X    {
  1258. X    int i;
  1259. X    char *p;
  1260. X
  1261. X    p=buf;
  1262. X    for (;;)
  1263. X        {
  1264. X        if (size == 0)
  1265. X            {
  1266. X            *p='\0';
  1267. X            break;
  1268. X            }
  1269. X        size--;
  1270. X        i=getch();
  1271. X        if (i == '\r') i='\n';
  1272. X        *(p++)=i;
  1273. X        if (i == '\n')
  1274. X            {
  1275. X            *p='\0';
  1276. X            break;
  1277. X            }
  1278. X        }
  1279. X    }
  1280. X#endif
  1281. END_OF_FILE
  1282.   if test 5215 -ne `wc -c <'read_pwd.c'`; then
  1283.     echo shar: \"'read_pwd.c'\" unpacked with wrong size!
  1284.   fi
  1285.   # end of 'read_pwd.c'
  1286. fi
  1287. if test -f 'sk.h' -a "${1}" != "-c" ; then 
  1288.   echo shar: Will not clobber existing file \"'sk.h'\"
  1289. else
  1290.   echo shar: Extracting \"'sk.h'\" \(6350 characters\)
  1291.   sed "s/^X//" >'sk.h' <<'END_OF_FILE'
  1292. X/* sk.h */
  1293. X/* Copyright (C) 1993 Eric Young - see README for more details */
  1294. Xstatic unsigned long des_skb[8][64]={
  1295. X/* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
  1296. X0x00000000,0x00000010,0x20000000,0x20000010,
  1297. X0x00010000,0x00010010,0x20010000,0x20010010,
  1298. X0x00000800,0x00000810,0x20000800,0x20000810,
  1299. X0x00010800,0x00010810,0x20010800,0x20010810,
  1300. X0x00000020,0x00000030,0x20000020,0x20000030,
  1301. X0x00010020,0x00010030,0x20010020,0x20010030,
  1302. X0x00000820,0x00000830,0x20000820,0x20000830,
  1303. X0x00010820,0x00010830,0x20010820,0x20010830,
  1304. X0x00080000,0x00080010,0x20080000,0x20080010,
  1305. X0x00090000,0x00090010,0x20090000,0x20090010,
  1306. X0x00080800,0x00080810,0x20080800,0x20080810,
  1307. X0x00090800,0x00090810,0x20090800,0x20090810,
  1308. X0x00080020,0x00080030,0x20080020,0x20080030,
  1309. X0x00090020,0x00090030,0x20090020,0x20090030,
  1310. X0x00080820,0x00080830,0x20080820,0x20080830,
  1311. X0x00090820,0x00090830,0x20090820,0x20090830,
  1312. X/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
  1313. X0x00000000,0x02000000,0x00002000,0x02002000,
  1314. X0x00200000,0x02200000,0x00202000,0x02202000,
  1315. X0x00000004,0x02000004,0x00002004,0x02002004,
  1316. X0x00200004,0x02200004,0x00202004,0x02202004,
  1317. X0x00000400,0x02000400,0x00002400,0x02002400,
  1318. X0x00200400,0x02200400,0x00202400,0x02202400,
  1319. X0x00000404,0x02000404,0x00002404,0x02002404,
  1320. X0x00200404,0x02200404,0x00202404,0x02202404,
  1321. X0x10000000,0x12000000,0x10002000,0x12002000,
  1322. X0x10200000,0x12200000,0x10202000,0x12202000,
  1323. X0x10000004,0x12000004,0x10002004,0x12002004,
  1324. X0x10200004,0x12200004,0x10202004,0x12202004,
  1325. X0x10000400,0x12000400,0x10002400,0x12002400,
  1326. X0x10200400,0x12200400,0x10202400,0x12202400,
  1327. X0x10000404,0x12000404,0x10002404,0x12002404,
  1328. X0x10200404,0x12200404,0x10202404,0x12202404,
  1329. X/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
  1330. X0x00000000,0x00000001,0x00040000,0x00040001,
  1331. X0x01000000,0x01000001,0x01040000,0x01040001,
  1332. X0x00000002,0x00000003,0x00040002,0x00040003,
  1333. X0x01000002,0x01000003,0x01040002,0x01040003,
  1334. X0x00000200,0x00000201,0x00040200,0x00040201,
  1335. X0x01000200,0x01000201,0x01040200,0x01040201,
  1336. X0x00000202,0x00000203,0x00040202,0x00040203,
  1337. X0x01000202,0x01000203,0x01040202,0x01040203,
  1338. X0x08000000,0x08000001,0x08040000,0x08040001,
  1339. X0x09000000,0x09000001,0x09040000,0x09040001,
  1340. X0x08000002,0x08000003,0x08040002,0x08040003,
  1341. X0x09000002,0x09000003,0x09040002,0x09040003,
  1342. X0x08000200,0x08000201,0x08040200,0x08040201,
  1343. X0x09000200,0x09000201,0x09040200,0x09040201,
  1344. X0x08000202,0x08000203,0x08040202,0x08040203,
  1345. X0x09000202,0x09000203,0x09040202,0x09040203,
  1346. X/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
  1347. X0x00000000,0x00100000,0x00000100,0x00100100,
  1348. X0x00000008,0x00100008,0x00000108,0x00100108,
  1349. X0x00001000,0x00101000,0x00001100,0x00101100,
  1350. X0x00001008,0x00101008,0x00001108,0x00101108,
  1351. X0x04000000,0x04100000,0x04000100,0x04100100,
  1352. X0x04000008,0x04100008,0x04000108,0x04100108,
  1353. X0x04001000,0x04101000,0x04001100,0x04101100,
  1354. X0x04001008,0x04101008,0x04001108,0x04101108,
  1355. X0x00020000,0x00120000,0x00020100,0x00120100,
  1356. X0x00020008,0x00120008,0x00020108,0x00120108,
  1357. X0x00021000,0x00121000,0x00021100,0x00121100,
  1358. X0x00021008,0x00121008,0x00021108,0x00121108,
  1359. X0x04020000,0x04120000,0x04020100,0x04120100,
  1360. X0x04020008,0x04120008,0x04020108,0x04120108,
  1361. X0x04021000,0x04121000,0x04021100,0x04121100,
  1362. X0x04021008,0x04121008,0x04021108,0x04121108,
  1363. X/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
  1364. X0x00000000,0x10000000,0x00010000,0x10010000,
  1365. X0x00000004,0x10000004,0x00010004,0x10010004,
  1366. X0x20000000,0x30000000,0x20010000,0x30010000,
  1367. X0x20000004,0x30000004,0x20010004,0x30010004,
  1368. X0x00100000,0x10100000,0x00110000,0x10110000,
  1369. X0x00100004,0x10100004,0x00110004,0x10110004,
  1370. X0x20100000,0x30100000,0x20110000,0x30110000,
  1371. X0x20100004,0x30100004,0x20110004,0x30110004,
  1372. X0x00001000,0x10001000,0x00011000,0x10011000,
  1373. X0x00001004,0x10001004,0x00011004,0x10011004,
  1374. X0x20001000,0x30001000,0x20011000,0x30011000,
  1375. X0x20001004,0x30001004,0x20011004,0x30011004,
  1376. X0x00101000,0x10101000,0x00111000,0x10111000,
  1377. X0x00101004,0x10101004,0x00111004,0x10111004,
  1378. X0x20101000,0x30101000,0x20111000,0x30111000,
  1379. X0x20101004,0x30101004,0x20111004,0x30111004,
  1380. X/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
  1381. X0x00000000,0x08000000,0x00000008,0x08000008,
  1382. X0x00000400,0x08000400,0x00000408,0x08000408,
  1383. X0x00020000,0x08020000,0x00020008,0x08020008,
  1384. X0x00020400,0x08020400,0x00020408,0x08020408,
  1385. X0x00000001,0x08000001,0x00000009,0x08000009,
  1386. X0x00000401,0x08000401,0x00000409,0x08000409,
  1387. X0x00020001,0x08020001,0x00020009,0x08020009,
  1388. X0x00020401,0x08020401,0x00020409,0x08020409,
  1389. X0x02000000,0x0A000000,0x02000008,0x0A000008,
  1390. X0x02000400,0x0A000400,0x02000408,0x0A000408,
  1391. X0x02020000,0x0A020000,0x02020008,0x0A020008,
  1392. X0x02020400,0x0A020400,0x02020408,0x0A020408,
  1393. X0x02000001,0x0A000001,0x02000009,0x0A000009,
  1394. X0x02000401,0x0A000401,0x02000409,0x0A000409,
  1395. X0x02020001,0x0A020001,0x02020009,0x0A020009,
  1396. X0x02020401,0x0A020401,0x02020409,0x0A020409,
  1397. X/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
  1398. X0x00000000,0x00000100,0x00080000,0x00080100,
  1399. X0x01000000,0x01000100,0x01080000,0x01080100,
  1400. X0x00000010,0x00000110,0x00080010,0x00080110,
  1401. X0x01000010,0x01000110,0x01080010,0x01080110,
  1402. X0x00200000,0x00200100,0x00280000,0x00280100,
  1403. X0x01200000,0x01200100,0x01280000,0x01280100,
  1404. X0x00200010,0x00200110,0x00280010,0x00280110,
  1405. X0x01200010,0x01200110,0x01280010,0x01280110,
  1406. X0x00000200,0x00000300,0x00080200,0x00080300,
  1407. X0x01000200,0x01000300,0x01080200,0x01080300,
  1408. X0x00000210,0x00000310,0x00080210,0x00080310,
  1409. X0x01000210,0x01000310,0x01080210,0x01080310,
  1410. X0x00200200,0x00200300,0x00280200,0x00280300,
  1411. X0x01200200,0x01200300,0x01280200,0x01280300,
  1412. X0x00200210,0x00200310,0x00280210,0x00280310,
  1413. X0x01200210,0x01200310,0x01280210,0x01280310,
  1414. X/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
  1415. X0x00000000,0x04000000,0x00040000,0x04040000,
  1416. X0x00000002,0x04000002,0x00040002,0x04040002,
  1417. X0x00002000,0x04002000,0x00042000,0x04042000,
  1418. X0x00002002,0x04002002,0x00042002,0x04042002,
  1419. X0x00000020,0x04000020,0x00040020,0x04040020,
  1420. X0x00000022,0x04000022,0x00040022,0x04040022,
  1421. X0x00002020,0x04002020,0x00042020,0x04042020,
  1422. X0x00002022,0x04002022,0x00042022,0x04042022,
  1423. X0x00000800,0x04000800,0x00040800,0x04040800,
  1424. X0x00000802,0x04000802,0x00040802,0x04040802,
  1425. X0x00002800,0x04002800,0x00042800,0x04042800,
  1426. X0x00002802,0x04002802,0x00042802,0x04042802,
  1427. X0x00000820,0x04000820,0x00040820,0x04040820,
  1428. X0x00000822,0x04000822,0x00040822,0x04040822,
  1429. X0x00002820,0x04002820,0x00042820,0x04042820,
  1430. X0x00002822,0x04002822,0x00042822,0x04042822,
  1431. X};
  1432. END_OF_FILE
  1433.   if test 6350 -ne `wc -c <'sk.h'`; then
  1434.     echo shar: \"'sk.h'\" unpacked with wrong size!
  1435.   fi
  1436.   # end of 'sk.h'
  1437. fi
  1438. if test -f 'spr.h' -a "${1}" != "-c" ; then 
  1439.   echo shar: Will not clobber existing file \"'spr.h'\"
  1440. else
  1441.   echo shar: Extracting \"'spr.h'\" \(6392 characters\)
  1442.   sed "s/^X//" >'spr.h' <<'END_OF_FILE'
  1443. X/* spr.h */
  1444. X/* Copyright (C) 1993 Eric Young - see README for more details */
  1445. Xstatic unsigned long des_SPtrans[8][64]={
  1446. X/* nibble 0 */
  1447. X0x00820200, 0x00020000, 0x80800000, 0x80820200,
  1448. X0x00800000, 0x80020200, 0x80020000, 0x80800000,
  1449. X0x80020200, 0x00820200, 0x00820000, 0x80000200,
  1450. X0x80800200, 0x00800000, 0x00000000, 0x80020000,
  1451. X0x00020000, 0x80000000, 0x00800200, 0x00020200,
  1452. X0x80820200, 0x00820000, 0x80000200, 0x00800200,
  1453. X0x80000000, 0x00000200, 0x00020200, 0x80820000,
  1454. X0x00000200, 0x80800200, 0x80820000, 0x00000000,
  1455. X0x00000000, 0x80820200, 0x00800200, 0x80020000,
  1456. X0x00820200, 0x00020000, 0x80000200, 0x00800200,
  1457. X0x80820000, 0x00000200, 0x00020200, 0x80800000,
  1458. X0x80020200, 0x80000000, 0x80800000, 0x00820000,
  1459. X0x80820200, 0x00020200, 0x00820000, 0x80800200,
  1460. X0x00800000, 0x80000200, 0x80020000, 0x00000000,
  1461. X0x00020000, 0x00800000, 0x80800200, 0x00820200,
  1462. X0x80000000, 0x80820000, 0x00000200, 0x80020200,
  1463. X
  1464. X/* nibble 1 */
  1465. X0x10042004, 0x00000000, 0x00042000, 0x10040000,
  1466. X0x10000004, 0x00002004, 0x10002000, 0x00042000,
  1467. X0x00002000, 0x10040004, 0x00000004, 0x10002000,
  1468. X0x00040004, 0x10042000, 0x10040000, 0x00000004,
  1469. X0x00040000, 0x10002004, 0x10040004, 0x00002000,
  1470. X0x00042004, 0x10000000, 0x00000000, 0x00040004,
  1471. X0x10002004, 0x00042004, 0x10042000, 0x10000004,
  1472. X0x10000000, 0x00040000, 0x00002004, 0x10042004,
  1473. X0x00040004, 0x10042000, 0x10002000, 0x00042004,
  1474. X0x10042004, 0x00040004, 0x10000004, 0x00000000,
  1475. X0x10000000, 0x00002004, 0x00040000, 0x10040004,
  1476. X0x00002000, 0x10000000, 0x00042004, 0x10002004,
  1477. X0x10042000, 0x00002000, 0x00000000, 0x10000004,
  1478. X0x00000004, 0x10042004, 0x00042000, 0x10040000,
  1479. X0x10040004, 0x00040000, 0x00002004, 0x10002000,
  1480. X0x10002004, 0x00000004, 0x10040000, 0x00042000,
  1481. X
  1482. X/* nibble 2 */
  1483. X0x41000000, 0x01010040, 0x00000040, 0x41000040,
  1484. X0x40010000, 0x01000000, 0x41000040, 0x00010040,
  1485. X0x01000040, 0x00010000, 0x01010000, 0x40000000,
  1486. X0x41010040, 0x40000040, 0x40000000, 0x41010000,
  1487. X0x00000000, 0x40010000, 0x01010040, 0x00000040,
  1488. X0x40000040, 0x41010040, 0x00010000, 0x41000000,
  1489. X0x41010000, 0x01000040, 0x40010040, 0x01010000,
  1490. X0x00010040, 0x00000000, 0x01000000, 0x40010040,
  1491. X0x01010040, 0x00000040, 0x40000000, 0x00010000,
  1492. X0x40000040, 0x40010000, 0x01010000, 0x41000040,
  1493. X0x00000000, 0x01010040, 0x00010040, 0x41010000,
  1494. X0x40010000, 0x01000000, 0x41010040, 0x40000000,
  1495. X0x40010040, 0x41000000, 0x01000000, 0x41010040,
  1496. X0x00010000, 0x01000040, 0x41000040, 0x00010040,
  1497. X0x01000040, 0x00000000, 0x41010000, 0x40000040,
  1498. X0x41000000, 0x40010040, 0x00000040, 0x01010000,
  1499. X
  1500. X/* nibble 3 */
  1501. X0x00100402, 0x04000400, 0x00000002, 0x04100402,
  1502. X0x00000000, 0x04100000, 0x04000402, 0x00100002,
  1503. X0x04100400, 0x04000002, 0x04000000, 0x00000402,
  1504. X0x04000002, 0x00100402, 0x00100000, 0x04000000,
  1505. X0x04100002, 0x00100400, 0x00000400, 0x00000002,
  1506. X0x00100400, 0x04000402, 0x04100000, 0x00000400,
  1507. X0x00000402, 0x00000000, 0x00100002, 0x04100400,
  1508. X0x04000400, 0x04100002, 0x04100402, 0x00100000,
  1509. X0x04100002, 0x00000402, 0x00100000, 0x04000002,
  1510. X0x00100400, 0x04000400, 0x00000002, 0x04100000,
  1511. X0x04000402, 0x00000000, 0x00000400, 0x00100002,
  1512. X0x00000000, 0x04100002, 0x04100400, 0x00000400,
  1513. X0x04000000, 0x04100402, 0x00100402, 0x00100000,
  1514. X0x04100402, 0x00000002, 0x04000400, 0x00100402,
  1515. X0x00100002, 0x00100400, 0x04100000, 0x04000402,
  1516. X0x00000402, 0x04000000, 0x04000002, 0x04100400,
  1517. X
  1518. X/* nibble 4 */
  1519. X0x02000000, 0x00004000, 0x00000100, 0x02004108,
  1520. X0x02004008, 0x02000100, 0x00004108, 0x02004000,
  1521. X0x00004000, 0x00000008, 0x02000008, 0x00004100,
  1522. X0x02000108, 0x02004008, 0x02004100, 0x00000000,
  1523. X0x00004100, 0x02000000, 0x00004008, 0x00000108,
  1524. X0x02000100, 0x00004108, 0x00000000, 0x02000008,
  1525. X0x00000008, 0x02000108, 0x02004108, 0x00004008,
  1526. X0x02004000, 0x00000100, 0x00000108, 0x02004100,
  1527. X0x02004100, 0x02000108, 0x00004008, 0x02004000,
  1528. X0x00004000, 0x00000008, 0x02000008, 0x02000100,
  1529. X0x02000000, 0x00004100, 0x02004108, 0x00000000,
  1530. X0x00004108, 0x02000000, 0x00000100, 0x00004008,
  1531. X0x02000108, 0x00000100, 0x00000000, 0x02004108,
  1532. X0x02004008, 0x02004100, 0x00000108, 0x00004000,
  1533. X0x00004100, 0x02004008, 0x02000100, 0x00000108,
  1534. X0x00000008, 0x00004108, 0x02004000, 0x02000008,
  1535. X
  1536. X/* nibble 5 */
  1537. X0x20000010, 0x00080010, 0x00000000, 0x20080800,
  1538. X0x00080010, 0x00000800, 0x20000810, 0x00080000,
  1539. X0x00000810, 0x20080810, 0x00080800, 0x20000000,
  1540. X0x20000800, 0x20000010, 0x20080000, 0x00080810,
  1541. X0x00080000, 0x20000810, 0x20080010, 0x00000000,
  1542. X0x00000800, 0x00000010, 0x20080800, 0x20080010,
  1543. X0x20080810, 0x20080000, 0x20000000, 0x00000810,
  1544. X0x00000010, 0x00080800, 0x00080810, 0x20000800,
  1545. X0x00000810, 0x20000000, 0x20000800, 0x00080810,
  1546. X0x20080800, 0x00080010, 0x00000000, 0x20000800,
  1547. X0x20000000, 0x00000800, 0x20080010, 0x00080000,
  1548. X0x00080010, 0x20080810, 0x00080800, 0x00000010,
  1549. X0x20080810, 0x00080800, 0x00080000, 0x20000810,
  1550. X0x20000010, 0x20080000, 0x00080810, 0x00000000,
  1551. X0x00000800, 0x20000010, 0x20000810, 0x20080800,
  1552. X0x20080000, 0x00000810, 0x00000010, 0x20080010,
  1553. X
  1554. X/* nibble 6 */
  1555. X0x00001000, 0x00000080, 0x00400080, 0x00400001,
  1556. X0x00401081, 0x00001001, 0x00001080, 0x00000000,
  1557. X0x00400000, 0x00400081, 0x00000081, 0x00401000,
  1558. X0x00000001, 0x00401080, 0x00401000, 0x00000081,
  1559. X0x00400081, 0x00001000, 0x00001001, 0x00401081,
  1560. X0x00000000, 0x00400080, 0x00400001, 0x00001080,
  1561. X0x00401001, 0x00001081, 0x00401080, 0x00000001,
  1562. X0x00001081, 0x00401001, 0x00000080, 0x00400000,
  1563. X0x00001081, 0x00401000, 0x00401001, 0x00000081,
  1564. X0x00001000, 0x00000080, 0x00400000, 0x00401001,
  1565. X0x00400081, 0x00001081, 0x00001080, 0x00000000,
  1566. X0x00000080, 0x00400001, 0x00000001, 0x00400080,
  1567. X0x00000000, 0x00400081, 0x00400080, 0x00001080,
  1568. X0x00000081, 0x00001000, 0x00401081, 0x00400000,
  1569. X0x00401080, 0x00000001, 0x00001001, 0x00401081,
  1570. X0x00400001, 0x00401080, 0x00401000, 0x00001001,
  1571. X
  1572. X/* nibble 7 */
  1573. X0x08200020, 0x08208000, 0x00008020, 0x00000000,
  1574. X0x08008000, 0x00200020, 0x08200000, 0x08208020,
  1575. X0x00000020, 0x08000000, 0x00208000, 0x00008020,
  1576. X0x00208020, 0x08008020, 0x08000020, 0x08200000,
  1577. X0x00008000, 0x00208020, 0x00200020, 0x08008000,
  1578. X0x08208020, 0x08000020, 0x00000000, 0x00208000,
  1579. X0x08000000, 0x00200000, 0x08008020, 0x08200020,
  1580. X0x00200000, 0x00008000, 0x08208000, 0x00000020,
  1581. X0x00200000, 0x00008000, 0x08000020, 0x08208020,
  1582. X0x00008020, 0x08000000, 0x00000000, 0x00208000,
  1583. X0x08200020, 0x08008020, 0x08008000, 0x00200020,
  1584. X0x08208000, 0x00000020, 0x00200020, 0x08008000,
  1585. X0x08208020, 0x00200000, 0x08200000, 0x08000020,
  1586. X0x00208000, 0x00008020, 0x08008020, 0x08200000,
  1587. X0x00000020, 0x08208000, 0x00208020, 0x00000000,
  1588. X0x08000000, 0x08200020, 0x00008000, 0x00208020};
  1589. END_OF_FILE
  1590.   if test 6392 -ne `wc -c <'spr.h'`; then
  1591.     echo shar: \"'spr.h'\" unpacked with wrong size!
  1592.   fi
  1593.   # end of 'spr.h'
  1594. fi
  1595. if test -f 'testdes.pl' -a "${1}" != "-c" ; then 
  1596.   echo shar: Will not clobber existing file \"'testdes.pl'\"
  1597. else
  1598.   echo shar: Extracting \"'testdes.pl'\" \(5644 characters\)
  1599.   sed "s/^X//" >'testdes.pl' <<'END_OF_FILE'
  1600. X#!/usr/local/bin/perl
  1601. X
  1602. X# des.pl tesing code
  1603. X
  1604. Xrequire 'des.pl';
  1605. X
  1606. X$num_tests=34;
  1607. X@key_data=(
  1608. X    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1609. X    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  1610. X    0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1611. X    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
  1612. X    0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
  1613. X    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
  1614. X    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1615. X    0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10,
  1616. X    0x7C,0xA1,0x10,0x45,0x4A,0x1A,0x6E,0x57,
  1617. X    0x01,0x31,0xD9,0x61,0x9D,0xC1,0x37,0x6E,
  1618. X    0x07,0xA1,0x13,0x3E,0x4A,0x0B,0x26,0x86,
  1619. X    0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
  1620. X    0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
  1621. X    0x01,0x13,0xB9,0x70,0xFD,0x34,0xF2,0xCE,
  1622. X    0x01,0x70,0xF1,0x75,0x46,0x8F,0xB5,0xE6,
  1623. X    0x43,0x29,0x7F,0xAD,0x38,0xE3,0x73,0xFE,
  1624. X    0x07,0xA7,0x13,0x70,0x45,0xDA,0x2A,0x16,
  1625. X    0x04,0x68,0x91,0x04,0xC2,0xFD,0x3B,0x2F,
  1626. X    0x37,0xD0,0x6B,0xB5,0x16,0xCB,0x75,0x46,
  1627. X    0x1F,0x08,0x26,0x0D,0x1A,0xC2,0x46,0x5E,
  1628. X    0x58,0x40,0x23,0x64,0x1A,0xBA,0x61,0x76,
  1629. X    0x02,0x58,0x16,0x16,0x46,0x29,0xB0,0x07,
  1630. X    0x49,0x79,0x3E,0xBC,0x79,0xB3,0x25,0x8F,
  1631. X    0x4F,0xB0,0x5E,0x15,0x15,0xAB,0x73,0xA7,
  1632. X    0x49,0xE9,0x5D,0x6D,0x4C,0xA2,0x29,0xBF,
  1633. X    0x01,0x83,0x10,0xDC,0x40,0x9B,0x26,0xD6,
  1634. X    0x1C,0x58,0x7F,0x1C,0x13,0x92,0x4F,0xEF,
  1635. X    0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
  1636. X    0x1F,0x1F,0x1F,0x1F,0x0E,0x0E,0x0E,0x0E,
  1637. X    0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE,
  1638. X    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1639. X    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  1640. X    0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
  1641. X    0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10,
  1642. X    );
  1643. X
  1644. X@plain_data=(
  1645. X    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1646. X    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  1647. X    0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
  1648. X    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
  1649. X    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
  1650. X    0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
  1651. X    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1652. X    0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
  1653. X    0x01,0xA1,0xD6,0xD0,0x39,0x77,0x67,0x42,
  1654. X    0x5C,0xD5,0x4C,0xA8,0x3D,0xEF,0x57,0xDA,
  1655. X    0x02,0x48,0xD4,0x38,0x06,0xF6,0x71,0x72,
  1656. X    0x51,0x45,0x4B,0x58,0x2D,0xDF,0x44,0x0A,
  1657. X    0x42,0xFD,0x44,0x30,0x59,0x57,0x7F,0xA2,
  1658. X    0x05,0x9B,0x5E,0x08,0x51,0xCF,0x14,0x3A,
  1659. X    0x07,0x56,0xD8,0xE0,0x77,0x47,0x61,0xD2,
  1660. X    0x76,0x25,0x14,0xB8,0x29,0xBF,0x48,0x6A,
  1661. X    0x3B,0xDD,0x11,0x90,0x49,0x37,0x28,0x02,
  1662. X    0x26,0x95,0x5F,0x68,0x35,0xAF,0x60,0x9A,
  1663. X    0x16,0x4D,0x5E,0x40,0x4F,0x27,0x52,0x32,
  1664. X    0x6B,0x05,0x6E,0x18,0x75,0x9F,0x5C,0xCA,
  1665. X    0x00,0x4B,0xD6,0xEF,0x09,0x17,0x60,0x62,
  1666. X    0x48,0x0D,0x39,0x00,0x6E,0xE7,0x62,0xF2,
  1667. X    0x43,0x75,0x40,0xC8,0x69,0x8F,0x3C,0xFA,
  1668. X    0x07,0x2D,0x43,0xA0,0x77,0x07,0x52,0x92,
  1669. X    0x02,0xFE,0x55,0x77,0x81,0x17,0xF1,0x2A,
  1670. X    0x1D,0x9D,0x5C,0x50,0x18,0xF7,0x28,0xC2,
  1671. X    0x30,0x55,0x32,0x28,0x6D,0x6F,0x29,0x5A,
  1672. X    0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
  1673. X    0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
  1674. X    0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
  1675. X    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  1676. X    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1677. X    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1678. X    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF);
  1679. X
  1680. X@cipher_data=(
  1681. X    0x8C,0xA6,0x4D,0xE9,0xC1,0xB1,0x23,0xA7,
  1682. X    0x73,0x59,0xB2,0x16,0x3E,0x4E,0xDC,0x58,
  1683. X    0x95,0x8E,0x6E,0x62,0x7A,0x05,0x55,0x7B,
  1684. X    0xF4,0x03,0x79,0xAB,0x9E,0x0E,0xC5,0x33,
  1685. X    0x17,0x66,0x8D,0xFC,0x72,0x92,0x53,0x2D,
  1686. X    0x8A,0x5A,0xE1,0xF8,0x1A,0xB8,0xF2,0xDD,
  1687. X    0x8C,0xA6,0x4D,0xE9,0xC1,0xB1,0x23,0xA7,
  1688. X    0xED,0x39,0xD9,0x50,0xFA,0x74,0xBC,0xC4,
  1689. X    0x69,0x0F,0x5B,0x0D,0x9A,0x26,0x93,0x9B,
  1690. X    0x7A,0x38,0x9D,0x10,0x35,0x4B,0xD2,0x71,
  1691. X    0x86,0x8E,0xBB,0x51,0xCA,0xB4,0x59,0x9A,
  1692. X    0x71,0x78,0x87,0x6E,0x01,0xF1,0x9B,0x2A,
  1693. X    0xAF,0x37,0xFB,0x42,0x1F,0x8C,0x40,0x95,
  1694. X    0x86,0xA5,0x60,0xF1,0x0E,0xC6,0xD8,0x5B,
  1695. X    0x0C,0xD3,0xDA,0x02,0x00,0x21,0xDC,0x09,
  1696. X    0xEA,0x67,0x6B,0x2C,0xB7,0xDB,0x2B,0x7A,
  1697. X    0xDF,0xD6,0x4A,0x81,0x5C,0xAF,0x1A,0x0F,
  1698. X    0x5C,0x51,0x3C,0x9C,0x48,0x86,0xC0,0x88,
  1699. X    0x0A,0x2A,0xEE,0xAE,0x3F,0xF4,0xAB,0x77,
  1700. X    0xEF,0x1B,0xF0,0x3E,0x5D,0xFA,0x57,0x5A,
  1701. X    0x88,0xBF,0x0D,0xB6,0xD7,0x0D,0xEE,0x56,
  1702. X    0xA1,0xF9,0x91,0x55,0x41,0x02,0x0B,0x56,
  1703. X    0x6F,0xBF,0x1C,0xAF,0xCF,0xFD,0x05,0x56,
  1704. X    0x2F,0x22,0xE4,0x9B,0xAB,0x7C,0xA1,0xAC,
  1705. X    0x5A,0x6B,0x61,0x2C,0xC2,0x6C,0xCE,0x4A,
  1706. X    0x5F,0x4C,0x03,0x8E,0xD1,0x2B,0x2E,0x41,
  1707. X    0x63,0xFA,0xC0,0xD0,0x34,0xD9,0xF7,0x93,
  1708. X    0x61,0x7B,0x3A,0x0C,0xE8,0xF0,0x71,0x00,
  1709. X    0xDB,0x95,0x86,0x05,0xF8,0xC8,0xC6,0x06,
  1710. X    0xED,0xBF,0xD1,0xC6,0x6C,0x29,0xCC,0xC7,
  1711. X    0x35,0x55,0x50,0xB2,0x15,0x0E,0x24,0x51,
  1712. X    0xCA,0xAA,0xAF,0x4D,0xEA,0xF1,0xDB,0xAE,
  1713. X    0xD5,0xD4,0x4F,0xF7,0x20,0x68,0x3D,0x0D,
  1714. X    0x2A,0x2B,0xB0,0x08,0xDF,0x97,0xC2,0xF2);
  1715. X
  1716. Xprint "Doing ecb tests\n";
  1717. Xfor ($i=0; $i<$num_tests; $i++)
  1718. X    {
  1719. X    printf "Doing test $i\n";
  1720. X    $key =pack("C8",splice(@key_data   ,0,8));
  1721. X    $data=pack("C8",splice(@plain_data ,0,8));
  1722. X    $res =pack("C8",splice(@cipher_data,0,8));
  1723. X
  1724. X    @ks=  &des_set_key($key);
  1725. X    $out1= &des_ecb_encrypt(*ks,1,$data);
  1726. X    $out2= &des_ecb_encrypt(*ks,0,$out1);
  1727. X    $out3= &des_ecb_encrypt(*ks,0,$res);
  1728. X    &eprint("encryption failure",$res,$out1)
  1729. X        if ($out1 ne $res);
  1730. X    &eprint("encryption/decryption failure",$data,$out2)
  1731. X        if ($out2 ne $data);
  1732. X    &eprint("decryption failure",$data,$out3)
  1733. X        if ($data ne $out3);
  1734. X    }
  1735. Xprint "Done\n";
  1736. X
  1737. Xprint "doing speed test over 30 seconds\n";
  1738. X$SIG{'ALRM'}='done';
  1739. Xsub done {$done=1;}
  1740. X$done=0;
  1741. X
  1742. X$count=0;
  1743. X$d=pack("C8",0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef);
  1744. X@ks=  &des_set_key($d);
  1745. Xalarm(30);
  1746. X$start=(times)[0];
  1747. Xwhile (!$done)
  1748. X    {
  1749. X    $count++;
  1750. X    $d=&des_ecb_encrypt(*ks,1,$d);
  1751. X    }
  1752. X$end=(times)[0];
  1753. X$t=$end-$start;
  1754. Xprintf "$count DESs in %.2f seconds is %.2f DESs/sec or %.2f bytes/sec\n",
  1755. X    1.0*$t,1.0*$count/$t,$count*8.0/$t;
  1756. X
  1757. Xsub eprint
  1758. X    {
  1759. X    local($s,$c,$e)=@_;
  1760. X    local(@k);
  1761. X
  1762. X    @k=unpack("C8",$c);
  1763. X    printf "%02x%02x%02x%02x %02x%02x%02x%02x - ",unpack("C8",$c);
  1764. X    printf "%02x%02x%02x%02x %02x%02x%02x%02x :",unpack("C8",$e);
  1765. X    print " $s\n";
  1766. X    }
  1767. END_OF_FILE
  1768.   if test 5644 -ne `wc -c <'testdes.pl'`; then
  1769.     echo shar: \"'testdes.pl'\" unpacked with wrong size!
  1770.   fi
  1771.   # end of 'testdes.pl'
  1772. fi
  1773. echo shar: End of archive 3 \(of 5\).
  1774. cp /dev/null ark3isdone
  1775. MISSING=""
  1776. for I in 1 2 3 4 5 ; do
  1777.     if test ! -f ark${I}isdone ; then
  1778.     MISSING="${MISSING} ${I}"
  1779.     fi
  1780. done
  1781. if test "${MISSING}" = "" ; then
  1782.     echo You have unpacked all 5 archives.
  1783.     rm -f ark[1-9]isdone
  1784. else
  1785.     echo You still must unpack the following archives:
  1786.     echo "        " ${MISSING}
  1787. fi
  1788. exit 0
  1789. exit 0 # Just in case...
  1790.