home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume28 / crack / part04 < prev    next >
Encoding:
Internet Message Format  |  1992-03-18  |  56.1 KB
  1. From: aem@aber.ac.uk (Alec David Muffett)
  2. Newsgroups: comp.sources.misc
  3. Subject: v28i113: crack - The Unix Password Cracker, version 4.1, Part04/05
  4. Message-ID: <1992Mar18.143916.24004@aber.ac.uk>
  5. Date: 18 Mar 92 14:39:16 GMT
  6. Approved: aem@aber.ac.uk
  7. X-Md4-Signature: fd21f3ae9fb0b5b97354f85f58cce3dc
  8.  
  9. Submitted-by: aem@aber.ac.uk (Alec David Muffett)
  10. Posting-number: Volume 28, Issue 113
  11. Archive-name: crack/part04
  12. Environment: UNIX
  13. Supersedes: crack: Volume 25, Issue 5-9
  14.  
  15. #! /bin/sh
  16. # it by saving it into a file and typing "sh file".  To overwrite existing
  17. # files, type "sh file -c".  You can also feed this as standard input via
  18. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  19. # will see the following message at the end:
  20. #        "End of archive 4 (of 5)."
  21. # Contents:  Docs/readme.ms Sources/crack-fcrypt.c
  22. # Wrapped by aem@aberfa on Wed Mar 18 14:08:37 1992
  23. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  24. if test -f 'Docs/readme.ms' -a "${1}" != "-c" ; then 
  25.   echo shar: Will not clobber existing file \"'Docs/readme.ms'\"
  26. else
  27. echo shar: Extracting \"'Docs/readme.ms'\" \(28998 characters\)
  28. sed "s/^X//" >'Docs/readme.ms' <<'END_OF_FILE'
  29. X.de C
  30. X.ie n .B "\\$1" \\$2
  31. X.el .CW "\\$1" \\$2
  32. X..
  33. X.TL
  34. X"Crack Version 4.1"
  35. X.br
  36. XA Sensible Password Checker for Unix
  37. X.AU
  38. XAlec D.E. Muffett
  39. X.AI
  40. XUnix Software Engineer
  41. XAberystwyth, Wales, UK
  42. X.I "(aem@aber.ac.uk or alec_muffett@hicom.lut.ac.uk)"
  43. X.AB
  44. X.B Crack
  45. Xis a freely available program designed to find standard Unix
  46. Xeight-character DES encrypted passwords by standard guessing techniques
  47. Xoutlined below.  It is written to be flexible, configurable and fast,
  48. Xand to be able to make use of several networked hosts via the Berkeley
  49. X.C rsh
  50. Xprogram (or similar), where possible.
  51. X.AE
  52. X.NH 1
  53. XStatement of Intent
  54. X.LP
  55. XThis package is meant as a proving device to aid the construction of
  56. Xsecure computer systems.  Users of Crack are advised that they may get
  57. Xseverly hassled by authoritarian type sysadmin dudes if they run Crack
  58. Xwithout proper authorisation. 
  59. X.NH 1
  60. XIntroduction to Version 4.0
  61. X.LP
  62. XCrack is now into it's fourth version, and has been reworked extensively
  63. Xto provide extra functionality, and the purpose of this release is to
  64. Xconsolidate as much of this new functionality into as small a package as
  65. Xpossible.  To this end, Crack may appear to be less configurable: it has
  66. Xbeen written on the assumption that you run a fairly modern Unix, one
  67. Xwith BSD functionality, and then patched in order to run on other
  68. Xsystems.
  69. X.LP
  70. XThis, surprisingly enough, has led to neater code, and has made possible
  71. Xthe introduction of greater flexibility which supercedes many of the
  72. Xoptions that could be configured in earlier versions of Crack.  In the
  73. Xsame vein, some of the older options are now mandatory.  These, such as
  74. X.I "feedback mode"
  75. Xand
  76. X.C CRACK_PRINTOUT
  77. Xare no longer supported as options and probably never will be again.
  78. XThere is just a lot of wastage in not running with them, and too many
  79. Xdependencies in other functions to bother programming around them.
  80. X.LP
  81. XThe user interface is basically identical to the previous versions,
  82. Xalthough some people have asked about providing X-windows GUI's to
  83. XCrack, I think it would be a waste of time to do so. Crack has far
  84. Xless options than your ordinary version of
  85. X.C /bin/ls .
  86. X.NH 1
  87. XIntroduction to Version 4.1
  88. X.LP
  89. XVersion 4.1 of the Crack program is an attempt to extend the features
  90. Xintroduced in v4.0 and provide hooks for external libraries such as
  91. XMichael Glad's wonderful
  92. X.B UFC
  93. Xcrypt() implementation, which (on some platforms) can outperform my
  94. Xfcrypt() by a factor of 3.  I have also been burdened with the task of
  95. Xmaking Crack's memory handling bombproof (hah!) in the vague hope that
  96. Xit will survive running out of memory on small machines.\**
  97. X.FS
  98. X- or even on large ones. Brian Tompsett at Hull tweaked Crack v3.3
  99. Xuntil it could run to completion after filling the swapspace on each of a
  100. Xnetwork of SparcStation2's. Due to restructuring work on v4.0, I have
  101. Xhad to write my own sorting algorithm & re-implement all of his tweaks
  102. Xfrom scratch, and can only hope that I have emulated the bombproofness
  103. Xof this desirable (?) functionality.
  104. X.FE
  105. X.LP
  106. XThe extensions that I mention above regard the addition of extra
  107. Xprimitives to the dictionary processing language which permit the
  108. Xproduction of more concise dictionaries containing words, more of which
  109. Xare likely to be passwords.  The idea is to gain efficiency by removing
  110. Xsome of the dross from the generated dictionaries. 
  111. X.LP
  112. XCrack should (generally) be more disk-space efficient now that the
  113. Xprogram can spot dictionaries which have been compressed using
  114. X.I compress
  115. Xor
  116. X.I pack
  117. Xand will uncompress them on the fly as necessary (using
  118. X.I zcat
  119. Xor
  120. X.I pcat 
  121. Xrespectively).\**
  122. X.FS
  123. XNote to people who are short on memory or swap: do remember that to do
  124. Xthis Crack will have to
  125. X.I fork()
  126. X(via
  127. X.I popen() )
  128. Xand might not be able to create the uncompressing process.  Hence, if
  129. Xyou intend to swaplock your machine, don't compress the dictionaries. 
  130. XSwitch this off by editing the
  131. X.C Crack
  132. Xshellscript.
  133. X.FE
  134. X.NH 1
  135. XCrack Methodology - Part 1: Internals
  136. X.LP
  137. XCrack takes as its input a series of password files and source
  138. Xdictionaries.  It merges the dictionaries, turns the password files into
  139. Xa sorted list, and generates lists of possible passwords from the merged
  140. Xdictionary or from information gleaned about users from the password
  141. Xfile. 
  142. XIt does
  143. X.B not
  144. Xattempt to remedy the problem of allowing users to have guessable
  145. Xpasswords, and it should
  146. X.B NOT
  147. Xbe used in place of getting a really good, secure
  148. X.C passwd
  149. Xprogram replacement.\**
  150. X.FS
  151. XSee the end of ths document for more information about
  152. X.I passwd
  153. Xreplacements.
  154. X.FE
  155. X.LP
  156. XThe above paragraphs define the purpose of Crack, and embody a great
  157. Xdeal of hard work, screams of
  158. X.I Eureka! ,
  159. Xdrunkeness, and a fair amount of swearing too.  There is a lot
  160. Xof thinking, philosophy, and empirical guesswork behind the way that
  161. XCrack attacks password files, and although it is not perfect, I
  162. Xcertainly hope that Crack will out-do most of it's competitors.
  163. X.LP
  164. XCrack works by making many individual passes over the password entries
  165. Xthat you supply to it.  Each pass generates password guesses based upon
  166. Xa sequence of rules, supplied to the program by the
  167. Xuser. The rules are specified in a simplistic language in the files
  168. X.C gecos.rules
  169. Xand
  170. X.C dicts.rules ,
  171. Xto be found in the
  172. X.C Scripts
  173. Xdirectory.
  174. XThe distinction between these two files will be made clear later.
  175. X.LP
  176. XThe rules are written as a simple string of characters, with one rule to
  177. Xa line.  Blank lines, and comment lines beginning with a hash character
  178. X.B #
  179. Xare ignored.  Trailing whitespace is also ignored.  The instructions in
  180. Xthe rule are followed from left to right, and are applied to the
  181. Xdictionary words one by one, as the words are loaded.  Some simple
  182. Xpattern matching primitives are provided for selection purposes, so that
  183. Xif the dictionary word does not match the pattern, it is ignored.  This
  184. Xsaves on time and memory.  Before carrying on, I suggest that you browse
  185. Xthrough
  186. X.C Scripts/dicts.rules ,
  187. Xtake a look at the rules supplied as defaults, and try to work out what
  188. Xthey do. 
  189. X.LP
  190. XThe rules are stored in two different files for two different purposes.
  191. XRules in
  192. X.C Scripts/gecos.rules
  193. Xare applied to data generated by Crack from the pw_gecos and pw_gecos
  194. Xentries of the user's password entry.  The data fed to the gecos rules
  195. Xfor the user
  196. X.I "aem",
  197. Xwho is
  198. X.I "Alec David Muffett, Systems"
  199. Xwould be:
  200. X.I "aem",
  201. X.I "Alec",
  202. X.I "David",
  203. X.I "Muffett",
  204. X.I "Systems",
  205. Xand a series of permutations of those words, either re-ordering the
  206. Xwords and joining them together (eg:
  207. X.I "AlecMuffett" ),
  208. Xor making up new words based on initial letters of one word taken with
  209. Xthe rest of another (eg:
  210. X.I "AMuffett" ).\**
  211. X.FS
  212. X- and
  213. X.I ASystems
  214. Xand
  215. X.I DSystems ,
  216. Xand
  217. X.I MSystems ,
  218. Xetc... because Crack does not differentiate. Hence, care should be
  219. Xtaken to check for redundancy when adding new rules, so as not to waste
  220. Xtime during the gecos pass.
  221. X.FE
  222. X.LP
  223. XThe entire set of rules in gecos.rules is applied to each of these
  224. Xwords, which creates many more permutations and combinations, all of
  225. Xwhich are tested.  Hence testing the password gecos information under
  226. XCrack v4.0 and upwards takes somewhat longer than previously, but it is
  227. Xfar more thorough. 
  228. X.sp 1v
  229. X.LP
  230. XAfter a pass has been made over the data based on gecos information,
  231. XCrack makes further passes over the password data using successive rules
  232. Xfrom the
  233. X.C Scripts/dicts.rules
  234. Xby loading the whole of
  235. X.C Dicts/bigdict
  236. Xfile into memory, with the rule being applied to each word from that
  237. Xfile.  This generates a
  238. X.I "resident dictionary" ,
  239. Xwhich is sorted and uniqued so as to prevent wasting time on repetition. 
  240. XAfter each pass is completed, the memory used by the resident dictionary
  241. Xis freed up, and (hopefully) re-used when the next dictionary is loaded. 
  242. X.LP
  243. XThe
  244. X.C Dicts/bigdict
  245. Xdictionary is created by Crack by merging, sorting, and uniq'ing the
  246. Xsource dictionaries, which are to be found in the directory
  247. X.C DictSrc
  248. Xand which may also be named in the Crack shellscript, via the
  249. X.C $STDDICT
  250. Xvariable. (The default value of $STDDICT is
  251. X.C /usr/dict/words ).
  252. X.LP
  253. XThe file
  254. X.C DictSrc/bad_pws.dat
  255. Xis a dictionary which is meant to provide many of those common but
  256. Xnon-dictionary passwords, such as
  257. X.I 12345678
  258. Xor
  259. X.I qwerty .
  260. X.LP
  261. XIf you wish to provide a dictionary of your own, just copy it into the
  262. X.C DictSrc
  263. Xdirectory (use 
  264. X.C compress 
  265. Xon it if you wish to save space; Crack will unpack it whilst generating
  266. Xthe big dictionary) and then delete the contents of the
  267. X.C Dicts
  268. Xdirectory by running
  269. X.C Scripts/spotless .
  270. XYour new dictionary will be merged in on the next run. For more
  271. Xinformation on dictionary attacks, see the
  272. X.I excellent
  273. Xpaper called "Foiling the Cracker: A Survey of, and Improvements to,
  274. XPassword Security" by Daniel Klein, available from
  275. X.I "ftp.sei.cmu.edu"
  276. Xin
  277. X.I "~/pub/dvk/passwd.*" .
  278. XAlso, please read the
  279. X.C APPENDIX
  280. Xfile supplied with this distribution.\**
  281. X.FS
  282. XExtra dictionaries (those detailed in Dan Klein's paper) can be
  283. Xobtained via anonymous FTP from
  284. X.I ftp.uu.net
  285. X(137.39.1.9) as
  286. X.I ~/pub/dictionaries.tar.Z ;
  287. Xor check an
  288. X.I Archie
  289. Xdatabase for other possible sources of dictionaries.
  290. X.FE
  291. X.LP
  292. XHaving described the method of cracking, perhaps we should now
  293. Xinvestigate the algorithm used to overlay the cracking mechanism.
  294. X.NH 1
  295. XCrack Methodology - Part 2: Feedback Filters
  296. X.LP
  297. XAs is stated above, Crack permutes and loads dictionaries directly
  298. Xinto memory, sorts and uniques them, before attempting to use each of
  299. Xthe words as a guess for each users' password.  If Crack correctly
  300. Xguesses a password, it marks the user as
  301. X.I done
  302. Xand does not waste
  303. Xfurther time on trying to break that users password.
  304. X.LP
  305. XOnce Crack has finished a dictionary pass, it sweeps the list of users
  306. Xlooking for the passwords it has cracked. It stores the cracked passwords
  307. Xin both plaintext and encrypted forms in a
  308. X.I "feedback file"
  309. Xin the directory
  310. X.C Runtime .
  311. XFeedback files have names of the form
  312. X.C Runtime/F* .
  313. X.LP
  314. XThe purpose of this is so that, when Crack is next invoked, it may
  315. Xrecognise passwords that it has successfully cracked before, and filter
  316. Xthem from the input to the password cracker. This provides an
  317. X.I instant
  318. Xlist of crackable users who have not changed their passwords since the
  319. Xlast time Crack was run. This list appears in a file with name 
  320. X.C out*
  321. Xin the
  322. X.C $CRACK_OUT
  323. Xdirectory, or on
  324. X.I stdout ,
  325. Xif foreground mode is invoked (see
  326. X.I Options ,
  327. Xbelow).
  328. X.LP
  329. XIn a similar vein, when a Crack run terminates normally, it writes out
  330. Xto the feedback file all encrypted passwords that it has
  331. X.B NOT
  332. Xsucceeded in cracking.  Crack will then ignore all of these passwords
  333. Xnext time you run it.
  334. X.LP
  335. XObviously, this is not desirable if you frequently change your
  336. Xdictionaries or rules, and so there is a script provided,
  337. X.C Scripts/mrgfbk
  338. Xwhich sorts your feedback files, merges them into one, and optionally
  339. Xremoves all traces of 'uncrackable' passwords, so that your next Crack
  340. Xrun can have a go at passwords it has not succeeded in breaking before.
  341. X.LP
  342. X.C Mrgfbk
  343. Xis invoked automatically if you run
  344. X.C Scripts/spotless .
  345. X.NH 1
  346. XCrack Methodology - Part 3: Execution and Networking
  347. X.LP
  348. XEach time Crack is invoked, whether networked or not, it generates a
  349. X.I diefile
  350. Xwith a name of the form
  351. X.C Runtime/D*
  352. X(for network cracks, this file is generated by RCrack, and is of the form
  353. X.C Runtime/DR*
  354. Xwhich points to a
  355. X.B real
  356. Xdiefile, named
  357. X.C Runtime/RD* 
  358. X- see below for details).
  359. X.LP
  360. XThese diefiles contain debugging information about the job, and are
  361. Xgenerated so that all the jobs on the entire network can be called
  362. Xquickly by invoking
  363. X.C Scripts/plaster .
  364. XDiefiles delete themselves after they have been run.
  365. X.LP
  366. XAs you will read in the sections below, Crack has a
  367. X.C "-network"
  368. Xoption: This is designed to be a simple method of automatically
  369. Xspreading the load of password cracking out over several machines on a
  370. Xnetwork, preferably if they are connected by some form of networked
  371. Xfilestore.
  372. X.LP
  373. XWhen
  374. X.C "Crack -network"
  375. Xis invoked, it filters its input in the ordinary way, and then splits
  376. Xits load up amongst several machines which are specified in the file
  377. X.C Scripts/network.conf .
  378. X.LP
  379. XThis file contains a series of hostnames, power ratings, flags, etc,
  380. Xrelevant to the running of Crack on each machine.  Crack then calls
  381. X.C Scripts/RCrack
  382. Xto use the
  383. X.C rsh
  384. Xcommand (or similar) to invoke Crack on the other hosts.  See the RCrack
  385. Xscript, and the example network.conf file for details.
  386. X.NH 1
  387. XInstallation
  388. X.LP
  389. XCrack is one of those most unusual of beasties, a self-installing
  390. Xprogram.  Some people have complained about this apparent weirdness, but
  391. Xit has grown up with Crack ever since the earliest network version, when
  392. XI could not be bothered to log into several different machines with
  393. Xseveral different architectures, just in order to build the binaries. 
  394. XOnce the necessary configuration options have been set, the executables
  395. Xare created via
  396. X.C make
  397. Xby running the Crack shellscript .
  398. X.LP
  399. XCrack's configuration lies in two files, the
  400. X.C Crack
  401. Xshell script, which contains all the installation specific configuration
  402. Xdata, and the file
  403. X.C Sources/conf.h ,
  404. Xwhich contains configuration options specific to various binary platforms.
  405. X.LP
  406. XIn the Crack shellscript, you will have to edit the
  407. X.C CRACK_HOME
  408. Xvariable to the correct value.  This variable should be set to an
  409. Xabsolute path name (names relative to
  410. X.I ~username
  411. Xare OK, so long as you have some sort of
  412. X.C csh )
  413. Xthrough which the directory containing Crack may be accessed on
  414. X.B ALL
  415. Xthe machines that Crack will be run on. There is a similar variable
  416. X.C CRACK_OUT
  417. Xwhich specifies where Crack should put its output files - by default,
  418. Xthis is the same as
  419. X.C "$CRACK_HOME" .
  420. X.LP
  421. XYou will also have to edit the file
  422. X.C Sources/conf.h
  423. Xand work out which switches to enable.  Each
  424. X.C #define
  425. Xhas a small note explaining its purpose.  Where I have been in doubt about
  426. Xthe portability of certain library functions, usually I have re-written
  427. Xit, so you should be OK.  Let me know of your problems, if you have any.
  428. X.LP
  429. XIf you will be using
  430. X.C "Crack -network"
  431. Xyou will then have to generate a
  432. X.C Scripts/network.conf
  433. Xfile. This contains a list of hostnames to
  434. X.C rsh
  435. Xto, what their
  436. X.I "binary type"
  437. Xis (useful when running a network Crack on several different
  438. Xarchitectures), a guesstimate of their
  439. X.I "relative power"
  440. X(take your slowest machine as unary, and measure all others relative to
  441. Xit), and a list of per-host
  442. X.I flags
  443. Xto
  444. X.B add
  445. Xto those specified on the
  446. X.C Crack
  447. Xcommand line, when calling that host.  There is an example of such a
  448. Xfile provided in the Scripts directory - take a look at it.
  449. X.LP
  450. XIf ever you wish to specify a more precise figure as to the relative
  451. Xpower of your machines, or you are simply at a loss, play with the
  452. Xcommand
  453. X.C "make tests"
  454. Xin the source code directory.  This can provide you with the number of
  455. Xfcrypt()s that your machine can do per second, which is a number that
  456. Xyou can plug into your
  457. X.C network.conf
  458. Xas a measure of your machines' power (after rounding the value to an
  459. Xinteger).
  460. X.NH 1
  461. XUsage
  462. X.LP
  463. XOkay, so, let's assume that you have edited your
  464. X.C Crack
  465. Xscript, and your
  466. X.C Sources/conf.h
  467. Xfile, where do you go from here ?
  468. X.LP
  469. X.DS B
  470. X.fi
  471. X.C Crack
  472. X[\c
  473. X.I options ]
  474. X[\c
  475. X.I bindir ]
  476. X.C /etc/passwd
  477. X[...other passwd files]
  478. X.sp 1v
  479. X.C "Crack -network"
  480. X[\c
  481. X.I options ]
  482. X.C /etc/passwd
  483. X[...other passwd files]
  484. X.DE
  485. X.LP
  486. XWhere
  487. X.B bindir
  488. Xis the optional name of the directory where you want the binaries
  489. Xinstalled.  This is useful where you want to be able to run versions of
  490. XCrack on several different architectures. If
  491. X.B bindir
  492. Xdoes not exist, a warning will be issued, and the directory created.
  493. X.QP
  494. XNote:
  495. X.B bindir
  496. Xdefaults to the name
  497. X.C generic
  498. Xif not supplied.
  499. X.QP
  500. X.LP
  501. X.B "Notes for Yellow Pages (NIS) Users:"
  502. XI have occasional queries about how to get Crack running from a YP
  503. Xpassword file.  There are several methods, but by far the simplest is to
  504. Xgenerate a passwd format file by running:-
  505. X.DS B
  506. X.C "ypcat passwd > passwd.yp"
  507. X.DE
  508. Xand then running Crack on this file.
  509. X.NH 1
  510. XOptions
  511. X.IP "\fB-f\fP"
  512. XRuns Crack in
  513. X.I foreground
  514. Xmode, ie: the password cracker is not backgrounded, and messages appear
  515. Xon stdout and stderr as you would expect.  This option is only really
  516. Xuseful for very small password files, or when you want to put a wrapper
  517. Xscript around Crack.
  518. X.IP
  519. XForeground mode is disabled if you try running
  520. X.C "Crack -network -f"
  521. Xon the command line, because of the insensibility of
  522. X.C rsh ing
  523. Xto several machines in turn, waiting for each one to finish before
  524. Xcalling the next. However, please read the section about
  525. X.I "Network Cracking without NFS/RFS" ,
  526. Xbelow.
  527. X.IP "\fB-v\fP"
  528. XSets verbose mode, whereby Crack will print every guess it is trying on
  529. Xa per-user basis.  This is a very quick way of flooding your filestore,
  530. Xbut useful if you think something is going wrong.
  531. X.IP "\fB-m\fP"
  532. XSends mail to any user whose password you crack by invoking
  533. X.C Scripts/nastygram
  534. Xwith their username as an argument.  The reason for using the script is
  535. Xso that a degree of flexibility in the format of the mail message is
  536. Xsupplied; ie: you don't have to recompile code in order to change the
  537. Xmessage.\**
  538. X.FS
  539. XI'm uncertain about the wisdom of mailing someone like this.  If someone
  540. Xbrowses your cracked user's mail somehow, it's like a great big neon
  541. Xsign pointing at the user saying "This Is A Crackable Account - Go For
  542. XIt!".  Not to mention the false sense of security it engenders in the
  543. XSystem Manager that he's "informed" the user to change his password.
  544. XWhat if the user doesn't log on for 3 months? However, so many people
  545. Xhave wired it into their own versions of Crack, I suppose it
  546. X.B must
  547. Xbe provided... AEM
  548. X.FE
  549. X.IP "\fB-nvalue\fP"
  550. XSets the process to be
  551. X.C nice() ed
  552. Xto
  553. X.I value ,
  554. Xso, for example, the switch
  555. X.C \&-n19
  556. Xsets the Crack process to run at the lowest priority.
  557. X.IP "\fB-network\fP"
  558. XThrows Crack into network mode, in which it reads the
  559. X.C Scripts/network.conf
  560. Xfile, splits its input into chunks which are sized according to the
  561. Xpower of the target machine, and calls
  562. X.C rsh
  563. Xto run Crack on that machine.  Options for Crack running on the target
  564. Xmachine may be supplied on the command line (eg: verbose or recover
  565. Xmode), or in the network.conf file if they pertain to specific hosts
  566. X(eg:
  567. X.C nice()
  568. Xvalues).
  569. X.IP "\fB-r<pointfile>\fP"
  570. XThis is only for use when running in
  571. X.I recover
  572. Xmode.  When a running Crack starts pass 2, it periodically saves its
  573. Xstate in a
  574. X.I pointfile ,
  575. Xwith a name of the form
  576. X.C "Runtime/P.*"
  577. XThis file can be used to recover where you were should a host crash.
  578. XSimply invoke Crack in
  579. X.B exactly
  580. Xthe same manner as the last time, with the addition of the
  581. X.C "-r"
  582. Xswitch, (eg:
  583. X.C "-rRuntime/Pfred12345" )
  584. Xswitch.  Crack will startup and read the file, and jump to roughly where
  585. Xit left off.  If you are cracking a very large password file, this can
  586. Xsave oodles of time after a crash.
  587. X.IP
  588. XIf you were running a
  589. X.I network
  590. XCrack, then the jobs will again be spawned onto all the machines of the
  591. Xoriginal Crack.  The program will then check that the host it is running
  592. Xon is the same as is mentioned in the pointfile.  If it is not, it will
  593. Xquietly die.  Thus, assuming that you supply the same input data and do
  594. Xnot change your
  595. X.C network.conf
  596. Xfile, Crack should pick up where it left off.  This is a bit inelegant,
  597. Xbut it's better than nothing at the moment.
  598. X.IP
  599. XThe method of error recovery outlined above causes headaches for users
  600. Xwho want to do multiprocessing on parallel architectures.  Crack is in
  601. Xno way parallel, and because of the way it's structured (reading stdin
  602. Xfrom shellscript frontends) it is a pain to divide the work amongst
  603. Xseveral processes via
  604. X.C fork() ing.
  605. X.IP
  606. XThe hack solution to get several copies of Crack running on one machine
  607. Xwith
  608. X.I n
  609. Xprocessors at the moment is to insert
  610. X.I n
  611. Xcopies of the entry for your parallel machine into the
  612. X.C Scripts/network.conf
  613. Xfile. If you use the
  614. X.C \&-r
  615. Xoption in these circumstances however, you will get
  616. X.I n
  617. Xcopies of the recovered process running, only one of them will have the
  618. Xcorrect input data.
  619. X.IP
  620. XThe old solution to this problem (see old documentation if you are
  621. Xinterested) has been negated by the introduction of feedback mode, so
  622. Xthe best bet in this particular situation is to wait until the other
  623. Xjobs are done (and have written out lists of uncrackable passwords), and
  624. Xthen re-start the jobs from scratch.  Anyone whose password was not
  625. Xcracked on the first run will be ignored on the second, if they have not
  626. Xchanged it since.  This is inelegant, but it's the best I can do in the
  627. Xlimited time available.
  628. X.NH
  629. XSupport Scripts
  630. X.LP
  631. XThe
  632. X.C Scripts
  633. Xdirectory contains a small number of support and utility scripts, some
  634. Xof which are designed to help Crack users check their progress.
  635. XBriefly, the most useful ones are:-
  636. X.IP "\fBScripts/shadmrg\fP"
  637. XThis is a small (but hopefully readable) script for merging
  638. X.C /etc/passwd
  639. Xand
  640. X.C /etc/shadow
  641. Xon System V style shadow password systems.  It produces the merged data
  642. Xto stdout, and will need redirecting into a file before Crack can work
  643. Xon it.  The script is meant to be fairly lucid, on the grounds that I
  644. Xworry that there are many shadowing schemes out there, and perhaps not
  645. Xall have the same data format.
  646. X.IP
  647. X.B "I have not"
  648. Xwired this facility into the Crack command itself because the world does
  649. X.B NOT
  650. Xrevolve around System V yet, regardless of what some people would have
  651. Xme believe, and I believe that the lack of direct support for NIS
  652. Xoutlined above, sets a precedent.  There are just too many
  653. Xincompatibilities in shadow password schemes for me to hardwire
  654. Xanything.
  655. X.IP "\fBScripts/plaster\fP"
  656. Xwhich is named after a dumb joke, but is a simple frontend to the
  657. X.C "Runtime/D*"
  658. Xdiefiles that each copy of the password cracker generates. Invoking
  659. X.C Scripts/plaster
  660. Xwill kill off all copies of the password cracker you are running, over
  661. Xthe network or otherwise.
  662. X.IP "\fBScripts/status\fP"
  663. XThis script
  664. X.C rsh es
  665. Xto each machine mentioned in the
  666. X.C Scripts/network.conf
  667. Xfile, and provides some information about processes and uptime on that
  668. Xmachine.  This is useful when you want to find out just how well your
  669. Xpassword crackers are getting on during a
  670. X.C "Crack -network" .
  671. X.IP "\fBScripts/{clean,spotless}\fP"
  672. XThese are really just frontends to a makefile. Invoking
  673. X.C Scripts/clean
  674. Xtidies up the Crack home directory, and removes probably unwanted files,
  675. Xbut leaves the pre-processed dictionary
  676. X.C bigdict
  677. Xintact.
  678. X.C Scripts/spotless
  679. Xdoes the same as
  680. X.C Scripts/clean
  681. Xbut obliterates
  682. X.C bigdict
  683. Xand old output files too, and compresses the feedback files into one.
  684. X.IP "\fBScripts/nastygram\fP"
  685. XThis is the shellscript that is invoked by the password cracker to send
  686. Xmail to users who have guessable passwords, if the
  687. X.C -m
  688. Xoption is used. Edit it at your leisure to suit your system.
  689. X.IP "\fBScripts/guess2fbk\fP"
  690. XThis script takes your
  691. X.C out*
  692. Xfiles as arguments and reformats the 'Guessed' lines into a slightly
  693. Xmessy
  694. X.I feedback
  695. Xfile, suitable for storing with the others.
  696. X.IP
  697. XAn occasion where this might be useful is when your cracker has guessed
  698. Xmany peoples passwords, and then died for some reason (a crash?) before
  699. Xwriting out the guesses to a feedback file.  Running
  700. X.DS B
  701. X.C "Scripts/guess2fbk out* >> Runtime/F.new"
  702. X.DE
  703. Xwill save the work that has been done.
  704. X.NH 1
  705. XNetwork Cracking without NFS/RFS
  706. X.LP
  707. XFor those users who have some form of
  708. X.C rsh
  709. Xcommand, but do not have a a networked filestore running between hosts,
  710. Xthere is now a solution which will allow you to do networked cracking,
  711. Xproposed to me by Brian Tompsett at Hull.  Personally, I consider the
  712. Xidea to be potty, but it fills in missing functionality in a wonderfully
  713. Xtacky manner.
  714. X.LP
  715. XFrom the documentation above, you will note that Crack will undo the
  716. X.C "-f"
  717. X.I "(output in foreground)"
  718. Xoption, if it is invoked with the
  719. X.C "-network"
  720. Xswitch at the same time (see the
  721. X.I Options
  722. Xsection above).  This is true, but it does not apply if you specify
  723. X.C "-f"
  724. Xoption in the
  725. X.C network.conf
  726. Xfile.
  727. X.LP
  728. XThe practical upshot of doing this is that remote copies of Crack
  729. Xcan be made to read from
  730. X.I stdin
  731. Xand write to
  732. X.I stdout
  733. Xover a network link, and thus remote processing is accomplished.  I have
  734. Xtweaked Crack in such a way, therefore, that if the
  735. X.C "-f"
  736. Xoption is specified amongst the crack-flags of a host in the
  737. Xnetwork.conf, rather than backgrounding itself on the remote host, the
  738. X.C rsh
  739. Xcommand on the
  740. X.B server
  741. Xis backgrounded, and output is written directly to the files on the
  742. Xserver's filestore.
  743. X.LP
  744. XThere are restrictions upon this method, mostly involving the number of
  745. Xprocesses that a user may run on the server at any one time, and that
  746. Xyou will have to collect feedback output together manually (dropping it
  747. Xinto the
  748. X.C Runtime
  749. Xdirectory on the server).  However, it works. Also, if you try to use
  750. X.C rsh
  751. Xas another user, you will suffer problems if
  752. X.C rsh
  753. Xinsists on reading something from your terminal (eg: a password for the
  754. Xremote account).  Also, recovering using checkpointing goes out the
  755. Xwindow unless you specify the name of the pointfile as it is named
  756. Xon the remote machine.
  757. X.NH 1
  758. XUFC Support and notes on fast crypt() implementations
  759. X.LP
  760. XThe stdlib version of the
  761. X.C crypt()
  762. Xsubroutine is incredibly slow.  It is a
  763. X.I massive
  764. Xbottleneck to the execution of Crack and on typical platforms that you
  765. Xget at universities, it is rare to find a machine which will achieve
  766. Xmore than 50 standard crypt() s per second.  On low-end diskless
  767. Xworkstations, you may expect 2 or 3 per second.  It was this slowness of
  768. Xthe crypt() algorithm which originally supplied much of the security
  769. XUnix needed.\**
  770. X.FS
  771. XSee: "Password Security, A Case History" by Bob Morris & Ken Thomson, in
  772. Xthe Unix Programmer Docs.
  773. X.FE
  774. X.LP
  775. XThere are now
  776. X.B many
  777. Ximplementations of faster versions of crypt()
  778. Xto be found on the network.  The one supplied with Crack v3.2 and
  779. Xupwards is called
  780. X.C fcrypt() .
  781. XIt was originally written in May 1986 by Robert Baldwin at MIT, and is a
  782. Xgood version of the crypt() subroutine.  I received a copy from Icarus
  783. XSparry at Bath University, who had made a couple of portability
  784. Xenhancements to the code.
  785. X.LP
  786. XI rewrote most of the tables and the KeySchedule generating algorithm in
  787. Xthe original
  788. X.I fdes-init.c
  789. Xto knock 40% off the execution overhead of fcrypt() in the form that it
  790. Xwas shipped to me.  I inlined a bunch of stuff, put it into a single
  791. Xfile, got some advice from Matt Bishop and Bob Baldwin [both of whom I
  792. Xam greatly indebted to] about what to do to the
  793. X.C xform()
  794. Xroutine and to the fcrypt function itself, and tidied up some
  795. Xalgorithms.  I have also added more lookup tables and reduced several
  796. Xformula for faster use.  Fcrypt() is now barely recognisable as being
  797. Xbased on its former incarnation, and it is 3x faster.
  798. X.LP
  799. XOn a DecStation 5000/200, fcrypt() is about 16 times faster than the
  800. Xstandard crypt (your mileage may vary with other architectures and
  801. Xcompilers).  This speed puts fcrypt() into the "moderately fast" league
  802. Xof crypt implementations. 
  803. X.LP
  804. XAmongst other crypt implementations available is
  805. X.B UFC
  806. Xby Michael Glad.  UFC-crypt is a version of the crypt subroutine which
  807. Xis optimised for machines with 32-bit long integers and generally
  808. Xoutperforms my fcrypt() by a factor of between 1 and 3, for a tradeoff
  809. Xof large memory usage, and memory-cache unfriendliness.  Hooks for even
  810. Xmore optimised assembler versions of crypt() are also provided for some
  811. Xplatforms (Sun, HP, ...).  Getting UFC to work on 16 bit architectures
  812. Xis nearly impossible.
  813. X.LP
  814. XHowever, on most architectures, UFC generates a stunning increase in the
  815. Xpower of Crack, and so, from v4.1 onwards, Crack is written to
  816. Xautomatically make use of UFC if it can find it.  All that you have to
  817. Xdo is to obtain a suitable copy of UFC (preferably a version which
  818. Xmentions that it is compatible with
  819. X.C "Crack v4.1" ,
  820. Xand unpack it into a directory called
  821. X.C ufc-crypt
  822. Xin
  823. X.C $CRACK_HOME ,
  824. Xand then delete your old binaries.  UFC will then be detected, compiled,
  825. Xtested and used in preference to fcrypt() by the Crack program, wherever
  826. Xpossible.
  827. X.NH 1
  828. XConclusions
  829. X.LP
  830. XWhat can be done about brute force attacks on your password file ?
  831. X.LP
  832. XYou must get a drop-in replacement for the
  833. X.C passwd
  834. Xand
  835. X.C yppasswd
  836. Xcommands; one which will stop people from choosing bad passwords in the
  837. Xfirst place.  There are several programs to do this; Matt Bishop's
  838. X.C "passwd+"
  839. Xand Clyde Hoover's
  840. X.C "npasswd"
  841. Xprogram are good examples which are freely available.  Consult an
  842. X.B Archie
  843. Xdatabase for more details on where you can get them from.
  844. X.LP
  845. XIt would be nice if an organisation (such as
  846. X.B CERT ?)
  847. Xcould be persuaded to supply skeletons of
  848. X.I sensible
  849. Xpasswd commands for the public good, as well as an archive of security
  850. Xrelated utilities\**
  851. Xon top of the excellent
  852. X.C COPS .
  853. X.FS
  854. X.C COPS
  855. Xis available for anonymous FTP from
  856. X.I "cert.sei.cmu.edu"
  857. X(128.237.253.5) in
  858. X.I ~/cops
  859. X.FE
  860. XHowever, for Unix security to improve on a global scale, we will also
  861. Xrequire pressure on the vendors, so that programs are written correctly
  862. Xfrom the beginning.
  863. END_OF_FILE
  864. if test 28998 -ne `wc -c <'Docs/readme.ms'`; then
  865.     echo shar: \"'Docs/readme.ms'\" unpacked with wrong size!
  866. fi
  867. # end of 'Docs/readme.ms'
  868. fi
  869. if test -f 'Sources/crack-fcrypt.c' -a "${1}" != "-c" ; then 
  870.   echo shar: Will not clobber existing file \"'Sources/crack-fcrypt.c'\"
  871. else
  872. echo shar: Extracting \"'Sources/crack-fcrypt.c'\" \(24546 characters\)
  873. sed "s/^X//" >'Sources/crack-fcrypt.c' <<'END_OF_FILE'
  874. X/*
  875. X * This program is copyright Alec Muffett 1991 except for some portions of
  876. X * code in "crack-fcrypt.c" which are copyright Robert Baldwin, Icarus Sparry
  877. X * and Alec Muffett.  The author(s) disclaims all responsibility or liability
  878. X * with respect to it's usage or its effect upon hardware or computer
  879. X * systems, and maintain copyright as set out in the "LICENCE" document which
  880. X * accompanies distributions of Crack v4.0 and upwards.
  881. X */
  882. X
  883. X/*
  884. X * Misc defs for the fast password transform optimisations.
  885. X */
  886. X
  887. X#include "crack.h"
  888. X
  889. X#define    reg    register
  890. X#define    uns    unsigned
  891. X#define unsb    uns char
  892. X#define    unsl    uns long
  893. X
  894. X/*
  895. X * Types for the different ways to represent DES bit patterns.  Bits are
  896. X * always right justified within fields.  Bits which have lower indices in
  897. X * the NBS spec are stored in the vax bits with less significance (e.g., Bit
  898. X * 1 of NBS spec is stored in the bit with weight 2 ** 0 to the Vax.
  899. X */
  900. X
  901. X#define    obpb1    unsb        /* One bit per byte. */
  902. X#define sbpb6    unsb        /* Six bits per byte, 6 held. */
  903. X#define sbpb6R    unsb        /* Six bits per byte Reversed order, 6 held. */
  904. X#define    sbpb24    unsl        /* Six bits per byte, 24 held. */
  905. X#define    ebpb24    unsl        /* Eight bits per bit, 24 held. */
  906. X#define    fbpb4    unsb        /* Four bits per byte, 4 held. */
  907. X#define    fbpb4R    unsb        /* Four bits per byte Reversed order, 4 held. */
  908. X
  909. X/*
  910. X * The operation (6 * x) is often better optimised as this (for really
  911. X * braindead compilers) - AEM
  912. X */
  913. X
  914. X#ifdef BRAINDEAD6
  915. X#define SIX_TIMES(exprn)        (((exprn) << 2) + ((exprn) << 1))
  916. X#else
  917. X#define SIX_TIMES(exprn)        (6 * (exprn))
  918. X#endif                /* BRAINDEAD6 */
  919. X
  920. X/* DES transformation type... */
  921. X
  922. Xunion SDATA
  923. X{
  924. X    sbpb24 b[2];
  925. X    sbpb6 c[8];
  926. X};
  927. X#ifndef FDES_4BYTE        /* Thanks to Matt Bishop for this idea -AEM. */
  928. X#define SIZEFIX        0
  929. X#define INDIRECT(a,b)     (a)[b]
  930. X#else
  931. X#define SIZEFIX        2    /* "n" where 2^n == sizeof(sbpb24) */
  932. X#define INDIRECT(a,b)     (*((sbpb24 *)(((unsigned char *) a) + (b))))
  933. X#endif
  934. X
  935. X/*
  936. X * These used to be rather slow and frequently used functions - AEM
  937. X */
  938. X
  939. X#define TF_TO_SIXBIT(tf) \
  940. X    (sbpb24)((tf & 077L) | \
  941. X        ((tf & 07700L) << 2) | \
  942. X        ((tf & 0770000L) << 4) | \
  943. X        ((tf & 077000000L) << 6))
  944. X
  945. X#define SIXBIT_TO_TF(sb) \
  946. X    (ebpb24)((sb & 0x3fL) | \
  947. X        ((sb & 0x3f00L) >> 2) | \
  948. X        ((sb & 0x3f0000L) >> 4) | \
  949. X        ((sb & 0x3f000000L) >> 6))
  950. X
  951. X/*
  952. X * Data segment gathered into one place, try to keep this stuff long aligned
  953. X * - AEM
  954. X */
  955. X
  956. Xstatic char iobuf[16];
  957. Xstatic obpb1 crypt_block[72];    /* 72 is next multiple of 8 bytes after 66 */
  958. Xstatic sbpb24 KS[32];
  959. Xstatic sbpb24 S0H[64], S1H[64], S2H[64], S3H[64];
  960. Xstatic sbpb24 S4H[64], S5H[64], S6H[64], S7H[64];
  961. Xstatic sbpb24 S0L[64], S1L[64], S2L[64], S3L[64];
  962. Xstatic sbpb24 S4L[64], S5L[64], S6L[64], S7L[64];
  963. Xstatic sbpb24 out96[4];
  964. X
  965. X/*
  966. X * Start of the real thing
  967. X */
  968. X
  969. Xvoid
  970. Xfsetkey ()
  971. X{
  972. X    /*
  973. X     * This used to be utterly horrendous. It still is, but it's much, much,
  974. X     * smaller... (and quite a bit faster...) - AEM
  975. X     */
  976. X    static unsb KeyToKS[] =
  977. X    {
  978. X    9, 50, 33, 59, 48, 16, 32, 56, 1, 8, 18, 41, 2, 34, 25, 24,
  979. X    43, 57, 58, 0, 35, 26, 17, 40, 21, 27, 38, 53, 36, 3, 46, 29,
  980. X    4, 52, 22, 28, 60, 20, 37, 62, 14, 19, 44, 13, 12, 61, 54, 30,
  981. X    1, 42, 25, 51, 40, 8, 24, 48, 58, 0, 10, 33, 59, 26, 17, 16,
  982. X    35, 49, 50, 57, 56, 18, 9, 32, 13, 19, 30, 45, 28, 62, 38, 21,
  983. X    27, 44, 14, 20, 52, 12, 29, 54, 6, 11, 36, 5, 4, 53, 46, 22,
  984. X    50, 26, 9, 35, 24, 57, 8, 32, 42, 49, 59, 17, 43, 10, 1, 0,
  985. X    48, 33, 34, 41, 40, 2, 58, 16, 60, 3, 14, 29, 12, 46, 22, 5,
  986. X    11, 28, 61, 4, 36, 27, 13, 38, 53, 62, 20, 52, 19, 37, 30, 6,
  987. X    34, 10, 58, 48, 8, 41, 57, 16, 26, 33, 43, 1, 56, 59, 50, 49,
  988. X    32, 17, 18, 25, 24, 51, 42, 0, 44, 54, 61, 13, 27, 30, 6, 52,
  989. X    62, 12, 45, 19, 20, 11, 60, 22, 37, 46, 4, 36, 3, 21, 14, 53,
  990. X    18, 59, 42, 32, 57, 25, 41, 0, 10, 17, 56, 50, 40, 43, 34, 33,
  991. X    16, 1, 2, 9, 8, 35, 26, 49, 28, 38, 45, 60, 11, 14, 53, 36,
  992. X    46, 27, 29, 3, 4, 62, 44, 6, 21, 30, 19, 20, 54, 5, 61, 37,
  993. X    2, 43, 26, 16, 41, 9, 25, 49, 59, 1, 40, 34, 24, 56, 18, 17,
  994. X    0, 50, 51, 58, 57, 48, 10, 33, 12, 22, 29, 44, 62, 61, 37, 20,
  995. X    30, 11, 13, 54, 19, 46, 28, 53, 5, 14, 3, 4, 38, 52, 45, 21,
  996. X    51, 56, 10, 0, 25, 58, 9, 33, 43, 50, 24, 18, 8, 40, 2, 1,
  997. X    49, 34, 35, 42, 41, 32, 59, 17, 27, 6, 13, 28, 46, 45, 21, 4,
  998. X    14, 62, 60, 38, 3, 30, 12, 37, 52, 61, 54, 19, 22, 36, 29, 5,
  999. X    35, 40, 59, 49, 9, 42, 58, 17, 56, 34, 8, 2, 57, 24, 51, 50,
  1000. X    33, 18, 48, 26, 25, 16, 43, 1, 11, 53, 60, 12, 30, 29, 5, 19,
  1001. X    61, 46, 44, 22, 54, 14, 27, 21, 36, 45, 38, 3, 6, 20, 13, 52,
  1002. X    56, 32, 51, 41, 1, 34, 50, 9, 48, 26, 0, 59, 49, 16, 43, 42,
  1003. X    25, 10, 40, 18, 17, 8, 35, 58, 3, 45, 52, 4, 22, 21, 60, 11,
  1004. X    53, 38, 36, 14, 46, 6, 19, 13, 28, 37, 30, 62, 61, 12, 5, 44,
  1005. X    40, 16, 35, 25, 50, 18, 34, 58, 32, 10, 49, 43, 33, 0, 56, 26,
  1006. X    9, 59, 24, 2, 1, 57, 48, 42, 54, 29, 36, 19, 6, 5, 44, 62,
  1007. X    37, 22, 20, 61, 30, 53, 3, 60, 12, 21, 14, 46, 45, 27, 52, 28,
  1008. X    24, 0, 48, 9, 34, 2, 18, 42, 16, 59, 33, 56, 17, 49, 40, 10,
  1009. X    58, 43, 8, 51, 50, 41, 32, 26, 38, 13, 20, 3, 53, 52, 28, 46,
  1010. X    21, 6, 4, 45, 14, 37, 54, 44, 27, 5, 61, 30, 29, 11, 36, 12,
  1011. X    8, 49, 32, 58, 18, 51, 2, 26, 0, 43, 17, 40, 1, 33, 24, 59,
  1012. X    42, 56, 57, 35, 34, 25, 16, 10, 22, 60, 4, 54, 37, 36, 12, 30,
  1013. X    5, 53, 19, 29, 61, 21, 38, 28, 11, 52, 45, 14, 13, 62, 20, 27,
  1014. X    57, 33, 16, 42, 2, 35, 51, 10, 49, 56, 1, 24, 50, 17, 8, 43,
  1015. X    26, 40, 41, 48, 18, 9, 0, 59, 6, 44, 19, 38, 21, 20, 27, 14,
  1016. X    52, 37, 3, 13, 45, 5, 22, 12, 62, 36, 29, 61, 60, 46, 4, 11,
  1017. X    41, 17, 0, 26, 51, 48, 35, 59, 33, 40, 50, 8, 34, 1, 57, 56,
  1018. X    10, 24, 25, 32, 2, 58, 49, 43, 53, 28, 3, 22, 5, 4, 11, 61,
  1019. X    36, 21, 54, 60, 29, 52, 6, 27, 46, 20, 13, 45, 44, 30, 19, 62,
  1020. X    25, 1, 49, 10, 35, 32, 48, 43, 17, 24, 34, 57, 18, 50, 41, 40,
  1021. X    59, 8, 9, 16, 51, 42, 33, 56, 37, 12, 54, 6, 52, 19, 62, 45,
  1022. X    20, 5, 38, 44, 13, 36, 53, 11, 30, 4, 60, 29, 28, 14, 3, 46,
  1023. X    17, 58, 41, 2, 56, 24, 40, 35, 9, 16, 26, 49, 10, 42, 33, 32,
  1024. X    51, 0, 1, 8, 43, 34, 25, 48, 29, 4, 46, 61, 44, 11, 54, 37,
  1025. X    12, 60, 30, 36, 5, 28, 45, 3, 22, 27, 52, 21, 20, 6, 62, 38
  1026. X    };
  1027. X
  1028. X    reg int i;
  1029. X    reg unsigned long r;
  1030. X    reg unsb *k;
  1031. X
  1032. X    k = KeyToKS;
  1033. X
  1034. X    for (i = 0; i < 32; i++)
  1035. X    {
  1036. X    /* 16-bit tweaks suggested by cip_maz@fb6tcp.physik.uni-paderborn.de */
  1037. X    /* inlining speedup tweak suggested by tahorsley@csd.harris.com */
  1038. X    /* (strange addition compensates missing TF_TO_SIXBIT) */
  1039. X    r = (unsigned long) crypt_block[*(k++)];
  1040. X    r |= (unsigned long) crypt_block[*(k++)] << 1;
  1041. X    r |= (unsigned long) crypt_block[*(k++)] << 2;
  1042. X    r |= (unsigned long) crypt_block[*(k++)] << 3;
  1043. X    r |= (unsigned long) crypt_block[*(k++)] << 4;
  1044. X    r |= (unsigned long) crypt_block[*(k++)] << 5;
  1045. X    r |= (unsigned long) crypt_block[*(k++)] << (2 + 6);
  1046. X    r |= (unsigned long) crypt_block[*(k++)] << (2 + 7);
  1047. X    r |= (unsigned long) crypt_block[*(k++)] << (2 + 8);
  1048. X    r |= (unsigned long) crypt_block[*(k++)] << (2 + 9);
  1049. X    r |= (unsigned long) crypt_block[*(k++)] << (2 + 10);
  1050. X    r |= (unsigned long) crypt_block[*(k++)] << (2 + 11);
  1051. X    r |= (unsigned long) crypt_block[*(k++)] << (4 + 12);
  1052. X    r |= (unsigned long) crypt_block[*(k++)] << (4 + 13);
  1053. X    r |= (unsigned long) crypt_block[*(k++)] << (4 + 14);
  1054. X    r |= (unsigned long) crypt_block[*(k++)] << (4 + 15);
  1055. X    r |= (unsigned long) crypt_block[*(k++)] << (4 + 16);
  1056. X    r |= (unsigned long) crypt_block[*(k++)] << (4 + 17);
  1057. X    r |= (unsigned long) crypt_block[*(k++)] << (6 + 18);
  1058. X    r |= (unsigned long) crypt_block[*(k++)] << (6 + 19);
  1059. X    r |= (unsigned long) crypt_block[*(k++)] << (6 + 20);
  1060. X    r |= (unsigned long) crypt_block[*(k++)] << (6 + 21);
  1061. X    r |= (unsigned long) crypt_block[*(k++)] << (6 + 22);
  1062. X    r |= (unsigned long) crypt_block[*(k++)] << (6 + 23);
  1063. X    KS[i] = r;
  1064. X    }
  1065. X}
  1066. X
  1067. Xvoid
  1068. XXForm (saltvalue)
  1069. X    sbpb24 saltvalue;
  1070. X{
  1071. X#ifdef BIG_ENDIAN        /* Icarus Sparry, Bath - mod AEM */
  1072. X#define STEP --
  1073. X#define START &sdata.c[7]
  1074. X#define Dl sdata.b[1]
  1075. X#define Dh sdata.b[0]
  1076. X#else
  1077. X#ifdef LITTLE_ENDIAN
  1078. X#define STEP ++
  1079. X#define START &sdata.c[0]
  1080. X#define Dl sdata.b[0]
  1081. X#define Dh sdata.b[1]
  1082. X#endif
  1083. X    /* else error */
  1084. X#endif
  1085. X    union SDATA sdata;
  1086. X    reg sbpb24 Rl;
  1087. X    reg sbpb24 Rh;
  1088. X    reg sbpb24 Ll;
  1089. X    reg sbpb24 Lh;
  1090. X    reg sbpb6 *dp;
  1091. X    int loop;
  1092. X    int kloop;
  1093. X    sbpb24 *kp;
  1094. X    reg sbpb24 k;
  1095. X#ifdef FDES_8BYTE
  1096. X    reg sbpb24 tmpi;
  1097. X#endif                /* FDES_8BYTE */
  1098. X
  1099. X    Ll = Lh = Rl = Rh = 0;
  1100. X
  1101. X    for (loop = 25; loop--; /* nothing */ )
  1102. X    {
  1103. X    kp = KS;
  1104. X    for (kloop = 8; kloop--; /* nothing */ )
  1105. X    {
  1106. X        k = (Rl ^ Rh) & saltvalue;
  1107. X#ifndef FDES_8BYTE
  1108. X        Dl = (k ^ Rl ^ *kp++) << SIZEFIX;
  1109. X        Dh = (k ^ Rh ^ *kp++) << SIZEFIX;
  1110. X#else
  1111. X        /* hack to make things work better - matthew kaufman */
  1112. X        /* I haven't tried any of this - I don't have a cray... AEM */
  1113. X        tmpi = (k ^ Rl ^ *kp++);
  1114. X        sdata.c[3] = (tmpi >> 24) & 0x00ff;
  1115. X        sdata.c[2] = (tmpi >> 16) & 0x00ff;
  1116. X        sdata.c[1] = (tmpi >> 8) & 0x00ff;
  1117. X        sdata.c[0] = (tmpi) & 0x00ff;
  1118. X        tmpi = (k ^ Rh ^ *kp++);
  1119. X        sdata.c[7] = (tmpi >> 24) & 0x00ff;
  1120. X        sdata.c[6] = (tmpi >> 16) & 0x00ff;
  1121. X        sdata.c[5] = (tmpi >> 8) & 0x00ff;
  1122. X        sdata.c[4] = (tmpi) & 0x00ff;
  1123. X#endif                /* FDES_8BYTE */
  1124. X
  1125. X        dp = START;
  1126. X        Lh ^= INDIRECT (S0H, *dp);
  1127. X        Ll ^= INDIRECT (S0L, *dp STEP);
  1128. X        Lh ^= INDIRECT (S1H, *dp);
  1129. X        Ll ^= INDIRECT (S1L, *dp STEP);
  1130. X        Lh ^= INDIRECT (S2H, *dp);
  1131. X        Ll ^= INDIRECT (S2L, *dp STEP);
  1132. X        Lh ^= INDIRECT (S3H, *dp);
  1133. X        Ll ^= INDIRECT (S3L, *dp STEP);
  1134. X        Lh ^= INDIRECT (S4H, *dp);
  1135. X        Ll ^= INDIRECT (S4L, *dp STEP);
  1136. X        Lh ^= INDIRECT (S5H, *dp);
  1137. X        Ll ^= INDIRECT (S5L, *dp STEP);
  1138. X        Lh ^= INDIRECT (S6H, *dp);
  1139. X        Ll ^= INDIRECT (S6L, *dp STEP);
  1140. X        Lh ^= INDIRECT (S7H, *dp);
  1141. X        Ll ^= INDIRECT (S7L, *dp STEP);
  1142. X
  1143. X        k = (Ll ^ Lh) & saltvalue;
  1144. X#ifndef FDES_8BYTE
  1145. X        Dl = (k ^ Ll ^ *kp++) << SIZEFIX;
  1146. X        Dh = (k ^ Lh ^ *kp++) << SIZEFIX;
  1147. X#else
  1148. X        tmpi = (k ^ Ll ^ *kp++);
  1149. X        sdata.c[3] = (tmpi >> 24) & 0x00ff;
  1150. X        sdata.c[2] = (tmpi >> 16) & 0x00ff;
  1151. X        sdata.c[1] = (tmpi >> 8) & 0x00ff;
  1152. X        sdata.c[0] = (tmpi) & 0x00ff;
  1153. X        tmpi = (k ^ Lh ^ *kp++);
  1154. X        sdata.c[7] = (tmpi >> 24) & 0x00ff;
  1155. X        sdata.c[6] = (tmpi >> 16) & 0x00ff;
  1156. X        sdata.c[5] = (tmpi >> 8) & 0x00ff;
  1157. X        sdata.c[4] = (tmpi) & 0x00ff;
  1158. X#endif                /* FDES_8BYTE */
  1159. X
  1160. X        dp = START;
  1161. X        Rh ^= INDIRECT (S0H, *dp);
  1162. X        Rl ^= INDIRECT (S0L, *dp STEP);
  1163. X        Rh ^= INDIRECT (S1H, *dp);
  1164. X        Rl ^= INDIRECT (S1L, *dp STEP);
  1165. X        Rh ^= INDIRECT (S2H, *dp);
  1166. X        Rl ^= INDIRECT (S2L, *dp STEP);
  1167. X        Rh ^= INDIRECT (S3H, *dp);
  1168. X        Rl ^= INDIRECT (S3L, *dp STEP);
  1169. X        Rh ^= INDIRECT (S4H, *dp);
  1170. X        Rl ^= INDIRECT (S4L, *dp STEP);
  1171. X        Rh ^= INDIRECT (S5H, *dp);
  1172. X        Rl ^= INDIRECT (S5L, *dp STEP);
  1173. X        Rh ^= INDIRECT (S6H, *dp);
  1174. X        Rl ^= INDIRECT (S6L, *dp STEP);
  1175. X        Rh ^= INDIRECT (S7H, *dp);
  1176. X        Rl ^= INDIRECT (S7L, *dp STEP);
  1177. X    }
  1178. X
  1179. X    Ll ^= Rl;
  1180. X    Lh ^= Rh;
  1181. X    Rl ^= Ll;
  1182. X    Rh ^= Lh;
  1183. X    Ll ^= Rl;
  1184. X    Lh ^= Rh;
  1185. X    }
  1186. X
  1187. X    /*
  1188. X     * for reasons that I cannot explain, if I insert the contents of the
  1189. X     * UnXForm function right HERE, making the tweaks as necessary to avoid
  1190. X     * using out96[] to pass data, I LOSE 30% of my speed.  I don't know why.
  1191. X     * Hence, I continue to use out96[]...
  1192. X     */
  1193. X    {
  1194. X    reg sbpb24 *qp;
  1195. X    qp = out96;
  1196. X    *qp++ = Ll;
  1197. X    *qp++ = Lh;
  1198. X    *qp++ = Rl;
  1199. X    *qp++ = Rh;
  1200. X    }
  1201. X}
  1202. X
  1203. Xvoid
  1204. XUnXForm ()
  1205. X{
  1206. X    reg sbpb24 Rl;
  1207. X    reg sbpb24 Rh;
  1208. X    reg sbpb24 Ll;
  1209. X    reg sbpb24 Lh;
  1210. X    reg obpb1 *ptr;
  1211. X    reg long int mask;
  1212. X    register long int *lip;
  1213. X
  1214. X    Ll = SIXBIT_TO_TF (out96[0]);
  1215. X    Lh = SIXBIT_TO_TF (out96[1]);
  1216. X    Rl = SIXBIT_TO_TF (out96[2]);
  1217. X    Rh = SIXBIT_TO_TF (out96[3]);
  1218. X
  1219. X#ifdef BUILTIN_CLEAR
  1220. X    lip = (long int *) crypt_block;
  1221. X    for (mask = (sizeof (crypt_block) / sizeof (long int)); mask--; /* - */ )
  1222. X    {
  1223. X    *(lip++) = 0L;
  1224. X    }
  1225. X#else                /* BUILTIN_CLEAR */
  1226. X    bzero (crypt_block, 66);
  1227. X#endif                /* BUILTIN_CLEAR */
  1228. X
  1229. X    ptr = crypt_block;
  1230. X    mask = 0x000400L;
  1231. X    if (Rl & mask)
  1232. X    *ptr = 0x01;
  1233. X    ptr++;
  1234. X    if (Ll & mask)
  1235. X    *ptr = 0x01;
  1236. X    ptr++;
  1237. X    mask = 0x400000L;
  1238. X    if (Rl & mask)
  1239. X    *ptr = 0x01;
  1240. X    ptr++;
  1241. X    if (Ll & mask)
  1242. X    *ptr = 0x01;
  1243. X    ptr++;
  1244. X    mask = 0x000400L;
  1245. X    if (Rh & mask)
  1246. X    *ptr = 0x01;
  1247. X    ptr++;
  1248. X    if (Lh & mask)
  1249. X    *ptr = 0x01;
  1250. X    ptr++;
  1251. X    mask = 0x400000L;
  1252. X    if (Rh & mask)
  1253. X    *ptr = 0x01;
  1254. X    ptr++;
  1255. X    if (Lh & mask)
  1256. X    *ptr = 0x01;
  1257. X    ptr++;
  1258. X    mask = 0x000200L;
  1259. X    if (Rl & mask)
  1260. X    *ptr = 0x01;
  1261. X    ptr++;
  1262. X    if (Ll & mask)
  1263. X    *ptr = 0x01;
  1264. X    ptr++;
  1265. X    mask = 0x200000L;
  1266. X    if (Rl & mask)
  1267. X    *ptr = 0x01;
  1268. X    ptr++;
  1269. X    if (Ll & mask)
  1270. X    *ptr = 0x01;
  1271. X    ptr++;
  1272. X    mask = 0x000200L;
  1273. X    if (Rh & mask)
  1274. X    *ptr = 0x01;
  1275. X    ptr++;
  1276. X    if (Lh & mask)
  1277. X    *ptr = 0x01;
  1278. X    ptr++;
  1279. X    mask = 0x200000L;
  1280. X    if (Rh & mask)
  1281. X    *ptr = 0x01;
  1282. X    ptr++;
  1283. X    if (Lh & mask)
  1284. X    *ptr = 0x01;
  1285. X    ptr++;
  1286. X    mask = 0x000100L;
  1287. X    if (Rl & mask)
  1288. X    *ptr = 0x01;
  1289. X    ptr++;
  1290. X    if (Ll & mask)
  1291. X    *ptr = 0x01;
  1292. X    ptr++;
  1293. X    mask = 0x100000L;
  1294. X    if (Rl & mask)
  1295. X    *ptr = 0x01;
  1296. X    ptr++;
  1297. X    if (Ll & mask)
  1298. X    *ptr = 0x01;
  1299. X    ptr++;
  1300. X    mask = 0x000100L;
  1301. X    if (Rh & mask)
  1302. X    *ptr = 0x01;
  1303. X    ptr++;
  1304. X    if (Lh & mask)
  1305. X    *ptr = 0x01;
  1306. X    ptr++;
  1307. X    mask = 0x100000L;
  1308. X    if (Rh & mask)
  1309. X    *ptr = 0x01;
  1310. X    ptr++;
  1311. X    if (Lh & mask)
  1312. X    *ptr = 0x01;
  1313. X    ptr++;
  1314. X    mask = 0x000080L;
  1315. X    if (Rl & mask)
  1316. X    *ptr = 0x01;
  1317. X    ptr++;
  1318. X    if (Ll & mask)
  1319. X    *ptr = 0x01;
  1320. X    ptr++;
  1321. X    mask = 0x080000L;
  1322. X    if (Rl & mask)
  1323. X    *ptr = 0x01;
  1324. X    ptr++;
  1325. X    if (Ll & mask)
  1326. X    *ptr = 0x01;
  1327. X    ptr++;
  1328. X    mask = 0x000080L;
  1329. X    if (Rh & mask)
  1330. X    *ptr = 0x01;
  1331. X    ptr++;
  1332. X    if (Lh & mask)
  1333. X    *ptr = 0x01;
  1334. X    ptr++;
  1335. X    mask = 0x080000L;
  1336. X    if (Rh & mask)
  1337. X    *ptr = 0x01;
  1338. X    ptr++;
  1339. X    if (Lh & mask)
  1340. X    *ptr = 0x01;
  1341. X    ptr++;
  1342. X    mask = 0x000010L;
  1343. X    if (Rl & mask)
  1344. X    *ptr = 0x01;
  1345. X    ptr++;
  1346. X    if (Ll & mask)
  1347. X    *ptr = 0x01;
  1348. X    ptr++;
  1349. X    mask = 0x010000L;
  1350. X    if (Rl & mask)
  1351. X    *ptr = 0x01;
  1352. X    ptr++;
  1353. X    if (Ll & mask)
  1354. X    *ptr = 0x01;
  1355. X    ptr++;
  1356. X    mask = 0x000010L;
  1357. X    if (Rh & mask)
  1358. X    *ptr = 0x01;
  1359. X    ptr++;
  1360. X    if (Lh & mask)
  1361. X    *ptr = 0x01;
  1362. X    ptr++;
  1363. X    mask = 0x010000L;
  1364. X    if (Rh & mask)
  1365. X    *ptr = 0x01;
  1366. X    ptr++;
  1367. X    if (Lh & mask)
  1368. X    *ptr = 0x01;
  1369. X    ptr++;
  1370. X    mask = 0x000008L;
  1371. X    if (Rl & mask)
  1372. X    *ptr = 0x01;
  1373. X    ptr++;
  1374. X    if (Ll & mask)
  1375. X    *ptr = 0x01;
  1376. X    ptr++;
  1377. X    mask = 0x008000L;
  1378. X    if (Rl & mask)
  1379. X    *ptr = 0x01;
  1380. X    ptr++;
  1381. X    if (Ll & mask)
  1382. X    *ptr = 0x01;
  1383. X    ptr++;
  1384. X    mask = 0x000008L;
  1385. X    if (Rh & mask)
  1386. X    *ptr = 0x01;
  1387. X    ptr++;
  1388. X    if (Lh & mask)
  1389. X    *ptr = 0x01;
  1390. X    ptr++;
  1391. X    mask = 0x008000L;
  1392. X    if (Rh & mask)
  1393. X    *ptr = 0x01;
  1394. X    ptr++;
  1395. X    if (Lh & mask)
  1396. X    *ptr = 0x01;
  1397. X    ptr++;
  1398. X    mask = 0x000004L;
  1399. X    if (Rl & mask)
  1400. X    *ptr = 0x01;
  1401. X    ptr++;
  1402. X    if (Ll & mask)
  1403. X    *ptr = 0x01;
  1404. X    ptr++;
  1405. X    mask = 0x004000L;
  1406. X    if (Rl & mask)
  1407. X    *ptr = 0x01;
  1408. X    ptr++;
  1409. X    if (Ll & mask)
  1410. X    *ptr = 0x01;
  1411. X    ptr++;
  1412. X    mask = 0x000004L;
  1413. X    if (Rh & mask)
  1414. X    *ptr = 0x01;
  1415. X    ptr++;
  1416. X    if (Lh & mask)
  1417. X    *ptr = 0x01;
  1418. X    ptr++;
  1419. X    mask = 0x004000L;
  1420. X    if (Rh & mask)
  1421. X    *ptr = 0x01;
  1422. X    ptr++;
  1423. X    if (Lh & mask)
  1424. X    *ptr = 0x01;
  1425. X    ptr++;
  1426. X    mask = 0x000002L;
  1427. X    if (Rl & mask)
  1428. X    *ptr = 0x01;
  1429. X    ptr++;
  1430. X    if (Ll & mask)
  1431. X    *ptr = 0x01;
  1432. X    ptr++;
  1433. X    mask = 0x002000L;
  1434. X    if (Rl & mask)
  1435. X    *ptr = 0x01;
  1436. X    ptr++;
  1437. X    if (Ll & mask)
  1438. X    *ptr = 0x01;
  1439. X    ptr++;
  1440. X    mask = 0x000002L;
  1441. X    if (Rh & mask)
  1442. X    *ptr = 0x01;
  1443. X    ptr++;
  1444. X    if (Lh & mask)
  1445. X    *ptr = 0x01;
  1446. X    ptr++;
  1447. X    mask = 0x002000L;
  1448. X    if (Rh & mask)
  1449. X    *ptr = 0x01;
  1450. X    ptr++;
  1451. X    if (Lh & mask)
  1452. X    *ptr = 0x01;
  1453. X    ptr++;
  1454. X}
  1455. X
  1456. Xchar *
  1457. Xfcrypt (pw, salt)
  1458. X    char *pw;
  1459. X    char *salt;
  1460. X{
  1461. X    /* Table lookups for salts reduce fcrypt() overhead dramatically */
  1462. X    static sbpb24 salt0[] =
  1463. X    {
  1464. X    18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  1465. X    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  1466. X    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  1467. X    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 5, 6, 7, 8, 9, 10, 11, 12,
  1468. X    13, 14, 15, 16, 17,
  1469. X
  1470. X    18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  1471. X    32, 33, 34, 35, 36, 37, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
  1472. X    42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
  1473. X    58, 59, 60, 61, 62, 63, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
  1474. X    12, 13, 14, 15, 16, 17,
  1475. X
  1476. X    18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  1477. X    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  1478. X    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  1479. X    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
  1480. X
  1481. X    18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  1482. X    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  1483. X    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  1484. X    0, 1, 2, 3, 4
  1485. X    };
  1486. X    static sbpb24 salt1[] =
  1487. X    {
  1488. X    1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664,
  1489. X    1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304,
  1490. X    2368, 2432, 2496, 2560, 2624, 2688, 2752, 2816, 2880, 2944,
  1491. X    3008, 3072, 3136, 3200, 3264, 3328, 3392, 3456, 3520, 3584,
  1492. X    3648, 3712, 3776, 3840, 3904, 3968, 4032, 0, 64, 128, 192, 256,
  1493. X    320, 384, 448, 512, 576, 640, 704, 320, 384, 448, 512, 576, 640,
  1494. X    704, 768, 832, 896, 960, 1024, 1088,
  1495. X
  1496. X    1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664,
  1497. X    1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304,
  1498. X    2368, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560,
  1499. X    2624, 2688, 2752, 2816, 2880, 2944, 3008, 3072, 3136, 3200,
  1500. X    3264, 3328, 3392, 3456, 3520, 3584, 3648, 3712, 3776, 3840,
  1501. X    3904, 3968, 4032, 0, 64, 128, 192, 256, 320, 384, 448, 512, 576,
  1502. X    640, 704, 768, 832, 896, 960, 1024, 1088,
  1503. X
  1504. X    1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664,
  1505. X    1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304,
  1506. X    2368, 2432, 2496, 2560, 2624, 2688, 2752, 2816, 2880, 2944,
  1507. X    3008, 3072, 3136, 3200, 3264, 3328, 3392, 3456, 3520, 3584,
  1508. X    3648, 3712, 3776, 3840, 3904, 3968, 4032, 0, 64, 128, 192, 256,
  1509. X    320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024,
  1510. X    1088,
  1511. X
  1512. X    1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664,
  1513. X    1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304,
  1514. X    2368, 2432, 2496, 2560, 2624, 2688, 2752, 2816, 2880, 2944,
  1515. X    3008, 3072, 3136, 3200, 3264, 3328, 3392, 3456, 3520, 3584,
  1516. X    3648, 3712, 3776, 3840, 3904, 3968, 4032, 0, 64, 128, 192, 256
  1517. X    };
  1518. X
  1519. X    /* final perutation desalting */
  1520. X    static obpb1 final[] =
  1521. X    {
  1522. X    46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66,
  1523. X    67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
  1524. X    83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103,
  1525. X    104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
  1526. X    117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
  1527. X    130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
  1528. X    143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
  1529. X    156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
  1530. X    169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
  1531. X    182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
  1532. X    195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
  1533. X    208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
  1534. X    221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
  1535. X    234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
  1536. X    247, 248, 249, 250, 251, 252, 253, 254, 255,
  1537. X    /* Truncate overflow bits at 256 */
  1538. X    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
  1539. X    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  1540. X    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  1541. X    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58
  1542. X    };
  1543. X
  1544. X    reg int i, j, k;
  1545. X    reg long int *lip;
  1546. X    sbpb24 saltvalue;
  1547. X
  1548. X#ifdef BUILTIN_CLEAR
  1549. X    lip = (long int *) crypt_block;
  1550. X    for (i = (sizeof (crypt_block) / sizeof (long int)); i--; /* - */ )
  1551. X    {
  1552. X    *(lip++) = 0L;
  1553. X    }
  1554. X#else                /* BUILTIN_CLEAR */
  1555. X    bzero (crypt_block, 66);
  1556. X#endif                /* BUILTIN_CLEAR */
  1557. X
  1558. X    for (i = 0; (k = *pw) && i < 64; pw++)
  1559. X    {
  1560. X    crypt_block[i++] = (k >> 6) & 01;
  1561. X    crypt_block[i++] = (k >> 5) & 01;
  1562. X    crypt_block[i++] = (k >> 4) & 01;
  1563. X    crypt_block[i++] = (k >> 3) & 01;
  1564. X    crypt_block[i++] = (k >> 2) & 01;
  1565. X    crypt_block[i++] = (k >> 1) & 01;
  1566. X    crypt_block[i++] = (k >> 0) & 01;
  1567. X    i++;            /* have to skip one here (parity bit) */
  1568. X    }
  1569. X
  1570. X    fsetkey ( /* crypt_block */ );
  1571. X
  1572. X#ifdef BUILTIN_CLEAR
  1573. X    lip = (long int *) crypt_block;
  1574. X    for (i = (sizeof (crypt_block) / sizeof (long int)); i--; /* - */ )
  1575. X    {
  1576. X    *(lip++) = 0L;
  1577. X    }
  1578. X#else                /* BUILTIN_CLEAR */
  1579. X    bzero (crypt_block, 66);
  1580. X#endif                /* BUILTIN_CLEAR */
  1581. X
  1582. X    iobuf[0] = salt[0];
  1583. X    iobuf[1] = salt[1];
  1584. X
  1585. X    saltvalue = salt0[iobuf[0]] | salt1[iobuf[1]];
  1586. X    saltvalue = TF_TO_SIXBIT (saltvalue);
  1587. X
  1588. X    XForm (saltvalue);
  1589. X    UnXForm ();
  1590. X
  1591. X    for (i = 0; i < 11; i++)
  1592. X    {
  1593. X    k = 0;
  1594. X
  1595. X    for (j = 0; j < 6; j++)
  1596. X    {
  1597. X        k = (k << 1) | crypt_block[SIX_TIMES (i) + j];
  1598. X    }
  1599. X    iobuf[i + 2] = final[k];
  1600. X    }
  1601. X
  1602. X    iobuf[i + 2] = 0;
  1603. X
  1604. X    if (iobuf[1] == 0)
  1605. X    {
  1606. X    iobuf[1] = iobuf[0];
  1607. X    }
  1608. X    return (iobuf);
  1609. X}
  1610. X/********* INITIALISATION ROUTINES *********/
  1611. X
  1612. Xfbpb4
  1613. XlookupS (tableno, t6bits)
  1614. X    unsl tableno;
  1615. X    sbpb6R t6bits;
  1616. X{
  1617. X    static fbpb4R S[8][64] =
  1618. X    {
  1619. X    14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
  1620. X    0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
  1621. X    4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
  1622. X    15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
  1623. X
  1624. X    15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
  1625. X    3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
  1626. X    0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
  1627. X    13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
  1628. X
  1629. X    10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
  1630. X    13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
  1631. X    13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
  1632. X    1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
  1633. X
  1634. X    7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
  1635. X    13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
  1636. X    10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
  1637. X    3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
  1638. X
  1639. X    2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
  1640. X    14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
  1641. X    4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
  1642. X    11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
  1643. X
  1644. X    12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
  1645. X    10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
  1646. X    9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
  1647. X    4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
  1648. X
  1649. X    4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
  1650. X    13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
  1651. X    1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
  1652. X    6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
  1653. X
  1654. X    13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
  1655. X    1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
  1656. X    7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
  1657. X    2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11,
  1658. X    };
  1659. X    sbpb6 fixed6bits;
  1660. X    fbpb4R r;
  1661. X    fbpb4 fixedr;
  1662. X
  1663. X    fixed6bits = (((t6bits >> 0) & 01) << 5) +
  1664. X    (((t6bits >> 1) & 01) << 3) +
  1665. X    (((t6bits >> 2) & 01) << 2) +
  1666. X    (((t6bits >> 3) & 01) << 1) +
  1667. X    (((t6bits >> 4) & 01) << 0) +
  1668. X    (((t6bits >> 5) & 01) << 4);
  1669. X
  1670. X    r = S[tableno][fixed6bits];
  1671. X
  1672. X    fixedr = (((r >> 3) & 01) << 0) +
  1673. X    (((r >> 2) & 01) << 1) +
  1674. X    (((r >> 1) & 01) << 2) +
  1675. X    (((r >> 0) & 01) << 3);
  1676. X
  1677. X    return (fixedr);
  1678. X}
  1679. X
  1680. Xvoid
  1681. Xinit (tableno, lowptr, highptr)
  1682. X    unsl tableno;
  1683. X    sbpb24 *lowptr, *highptr;
  1684. X{
  1685. X
  1686. X    static unsb P[] =
  1687. X    {
  1688. X    15, 6, 19, 20,
  1689. X    28, 11, 27, 16,
  1690. X    0, 14, 22, 25,
  1691. X    4, 17, 30, 9,
  1692. X    1, 7, 23, 13,
  1693. X    31, 26, 2, 8,
  1694. X    18, 12, 29, 5,
  1695. X    21, 10, 3, 24,
  1696. X    };
  1697. X
  1698. X    static unsb E[] =
  1699. X    {
  1700. X    31, 0, 1, 2, 3, 4,
  1701. X    3, 4, 5, 6, 7, 8,
  1702. X    7, 8, 9, 10, 11, 12,
  1703. X    11, 12, 13, 14, 15, 16,
  1704. X    15, 16, 17, 18, 19, 20,
  1705. X    19, 20, 21, 22, 23, 24,
  1706. X    23, 24, 25, 26, 27, 28,
  1707. X    27, 28, 29, 30, 31, 0,
  1708. X    };
  1709. X
  1710. X    static obpb1 tmp32[32];
  1711. X    static obpb1 tmpP32[32];
  1712. X    static obpb1 tmpE[48];
  1713. X
  1714. X    int j, k, i;
  1715. X    int tablenoX4;
  1716. X    reg sbpb24 spare24;
  1717. X
  1718. X    tablenoX4 = tableno * 4;
  1719. X
  1720. X    for (j = 0; j < 64; j++)
  1721. X    {
  1722. X    k = lookupS (tableno, j);
  1723. X
  1724. X    for (i = 0; i < 32; i++)
  1725. X    {
  1726. X        tmp32[i] = 0;
  1727. X    }
  1728. X
  1729. X    for (i = 0; i < 4; i++)
  1730. X    {
  1731. X        tmp32[tablenoX4 + i] = (k >> i) & 01;
  1732. X    }
  1733. X
  1734. X    for (i = 0; i < 32; i++)
  1735. X    {
  1736. X        tmpP32[i] = tmp32[P[i]];
  1737. X    }
  1738. X
  1739. X    for (i = 0; i < 48; i++)
  1740. X    {
  1741. X        tmpE[i] = tmpP32[E[i]];
  1742. X    }
  1743. X
  1744. X    lowptr[j] = 0L;
  1745. X    highptr[j] = 0L;
  1746. X
  1747. X    for (i = 0; i < 24; i++)
  1748. X    {
  1749. X        lowptr[j] |= (unsigned long) tmpE[i] << i;
  1750. X    }
  1751. X
  1752. X    for (k = 0, i = 24; i < 48; i++, k++)
  1753. X    {
  1754. X        highptr[j] |= (unsigned long) tmpE[i] << k;
  1755. X    }
  1756. X
  1757. X    spare24 = lowptr[j];    /* to allow for macro expansion */
  1758. X    lowptr[j] = TF_TO_SIXBIT (spare24);
  1759. X
  1760. X    spare24 = highptr[j];    /* to allow for macro expansion */
  1761. X    highptr[j] = TF_TO_SIXBIT (spare24);
  1762. X    }
  1763. X}
  1764. X
  1765. X
  1766. Xint
  1767. Xinit_des ()
  1768. X{
  1769. X    init (0L, S0L, S0H);
  1770. X    init (1L, S1L, S1H);
  1771. X    init (2L, S2L, S2H);
  1772. X    init (3L, S3L, S3H);
  1773. X    init (4L, S4L, S4H);
  1774. X    init (5L, S5L, S5H);
  1775. X    init (6L, S6L, S6H);
  1776. X    init (7L, S7L, S7H);
  1777. X    return (0);
  1778. X}
  1779. END_OF_FILE
  1780. if test 24546 -ne `wc -c <'Sources/crack-fcrypt.c'`; then
  1781.     echo shar: \"'Sources/crack-fcrypt.c'\" unpacked with wrong size!
  1782. fi
  1783. # end of 'Sources/crack-fcrypt.c'
  1784. fi
  1785. echo shar: End of archive 4 \(of 5\).
  1786. cp /dev/null ark4isdone
  1787. MISSING=""
  1788. for I in 1 2 3 4 5 ; do
  1789.     if test ! -f ark${I}isdone ; then
  1790.     MISSING="${MISSING} ${I}"
  1791.     fi
  1792. done
  1793. if test "${MISSING}" = "" ; then
  1794.     echo You have unpacked all 5 archives.
  1795.     rm -f ark[1-9]isdone
  1796. else
  1797.     echo You still need to unpack the following archives:
  1798.     echo "        " ${MISSING}
  1799. fi
  1800. ##  End of shell archive.
  1801. exit 0
  1802. exit 0 # Just in case...
  1803.