home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / c / cops_104.zip / cops_104 / perl / pass.chk < prev    next >
Text File  |  1992-03-10  |  7KB  |  275 lines
  1. #!/bin/sh -- need to mention perl here to avoid recursion
  2. 'true' || eval 'exec perl -S $0 $argv:q';
  3. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
  4. & eval 'exec /usr/local/bin/perl -S $0 $argv:q'
  5.         if 0;
  6.  
  7. #
  8. #  Pass.chk -- a password guesser.  Functionally equivalent to the original
  9. # cops password guesser.  The -P option doesn't work right now (alpha release,
  10. # don't you know :-), since we're doing funky things with password caching,
  11. # but this will change soon.
  12. #
  13. #  Usage: $0 [options] dictionary
  14. #
  15. #    -P pfile    password file (not working)
  16. #    -p        print found passwords (incompatible with -M)
  17. #       -d        check prefix/suffix of digits [0-9]
  18. #       -g        check all words in gcos, plan, project, signature files
  19. #    -r         reverse the word tests
  20. #    -s         check all single chars as passwords
  21. #    -u         output the current user being checked
  22. #    -U         try uppercase word tests
  23. #    -v        verbose, print advisory information
  24. #    -x         check guess+prefix/suffix with strange chars added on
  25. #    -0 (zero)    change all o's ("oh"'s) to 0 (zeros)
  26. #    -1 (one)    change all i's to 1 (ones)
  27. #    -m         misspell words -- chop off first and last chars,
  28. #            if > 3 chars.  E.g. "dinner" ==> "inner" and "dinne"
  29. #
  30. # Originally written by Tim Tessin with lots more features, etc., etc., etc.
  31. # I ripped out all of his extra functionality that duplicated some of the
  32. # other cops stuff, and some things that just didn't fit, and added some
  33. # code to finish the simulation of the old checker. -- dan
  34. # 
  35.  
  36. require "getopts.pl";
  37. # can probably just do "|| &usage;" since &usage is only used once. ;-)
  38. &Getopts("p0dgrsuUv1P:mx") || print STDERR "Usage: $0 -p0xdgrsuUPvm\n";
  39.  
  40. # diff password file?
  41. if (defined($opt_P)) { $'GET_PASSWD = "/bin/cat $opt_P"; }
  42. require "pass.cache.pl";
  43.  
  44. $Passwd = "/etc/passwd";
  45. @strange_things = (" ", ";", ",", ".", "!", "@", "#", "$",
  46.                      "%", "^", "&", "*", "(", ")", "-", "_", 
  47.                      "=", "+", "[", "]", "{", "}", "'", "\"",
  48.                      "|", "`", "~", ">", "<");
  49.  
  50. # unbuffer output
  51. select (STDOUT); $| = 1;
  52.  
  53. $dups = 0;        # duplicate name entries
  54. $new = 0;        # new entries
  55. $changed = 0;        # password (and other data) changed
  56. $deleted = 0;        # deleted entries
  57. $updated = 0;        # data other than password changed
  58. $nlog = 0;        # number of log entries, used for print decisions
  59. $ntest = 0;
  60. $ndone = 0;
  61.  
  62. for $uid (keys %uname2passwd) {
  63.     next if length($pass = $uname2passwd{$uid}) != 13;
  64.     next unless $pass; # shall we report null passwd's, too?  ;-)
  65.     if ($try = &dopwd()) {
  66.         $pwd = ($opt_p) ? $try : "";
  67.         # printf "Username: %-8s  <password guessed>  $pwd\n",$P[0];
  68.         printf "Warning!  $uid password Problem: Guessed: %s\t\t$pwd\n",$P[0];
  69.         }
  70.     $ndone++;
  71.     }
  72.  
  73. 1;
  74. # end of program
  75.  
  76.  
  77. ######################## Support Subroutines ###########################
  78. # dopwd tests each password entry against several simple checks and all
  79. # the words in the dictionaries specified.  The simple checks consists
  80. # of trying the username as the password ('joe' accounts), words derived
  81. # from the gecos fields (usually first and last names).
  82.  
  83. sub dopwd {
  84.     $tries = 0;
  85.  
  86.     print "$uid\n" if ($opt_u);
  87.  
  88.     # try user name
  89.     ($try = &testpwd($uid,$pass)) && return $try;
  90.     # try uiduid
  91.     if (length($uid) < 8) {
  92.     ($try = &testpwd($uid . $uid,$pass)) && return $try;
  93.     }
  94.  
  95.     # do gcos field?
  96.     if ($opt_g) {
  97.     @gcos = split(/[.,& -]/,$uname2gcos{$uid});
  98.     foreach $i (@gcos) {
  99.         next unless $i;        # skip null split values
  100.         ($try = &testpwd($i,$pass)) && return $try;
  101.     }
  102.  
  103.     # Try names from misc files
  104.     #
  105.     undef %words;
  106.     # files to check
  107.     @files2chk = ("/.project", "/.plan", "/.signature");
  108.     $home = $uname2dir{$uid};
  109.     for $i (@files2chk) {
  110.         open (FOOFILE, $home . $i);
  111.         while (<FOOFILE>) {
  112.         chop;
  113.         @line = split(/([.,;\s])/);
  114.         for $j (@line) {
  115.             $words{$j}=$j unless $j=~/[\s]/;
  116.         }
  117.         }
  118.         close FOOFILE;
  119.     }
  120.     for $k (values %words) {
  121.         # print "word $k\n";
  122.         ($try = &testpwd($k,$pass)) && return $try;
  123.     }
  124.     }
  125.  
  126. # do dictionaries
  127. # save state of upper/reverse so individual dicts can temporarily
  128. # override.
  129. foreach $i (@ARGV) {
  130.     if (open (DICT,$i)) {
  131.         while (<DICT>) {
  132.             chop;
  133.             if ($try = &testpwd($_,$pass)) {
  134.                 close DICT;
  135.                 return $try;
  136.                 }
  137.             }
  138.         close DICT;
  139.         }
  140.     }
  141. return 0;
  142. }
  143.  
  144.  
  145. # small subroutines to help the main password cracker.  All are labeled
  146. # p_xxx, where xxx is the identifying name.
  147. #
  148.  
  149. # if leading character is upper-case, also try lower case version
  150. sub p_lc {
  151.     local($try) = @_;
  152.     local($ntry);
  153.     if ( $try =~ /^[A-Z]/ ) {
  154.     ($ntry = $try) =~ y/A-Z/a-z/;
  155.     push(@total_guesses, $ntry);
  156.     }
  157. }
  158.  
  159. # reverse check
  160. sub p_rev {
  161.     local($try) = @_;
  162.     local($ntry);
  163.     $ntry = reverse $try;
  164.     if ($ntry ne $try) {
  165.     push(@total_guesses, $ntry);
  166.     }
  167. }
  168.  
  169. # uppercase check
  170. sub p_up {
  171.     local($try) = @_;
  172.     local($ntry);
  173.     ($ntry = $try) =~ y/a-z/A-Z/;
  174.     if ($ntry ne $try) { push(@total_guesses, $ntry); }
  175. }
  176.  
  177. # testpwd checks a word to see if it matches the encrpted password
  178. # if the word is capitalized, the lowercase version is tried as well
  179.  
  180. sub testpwd {
  181. local ($try,$pass) = @_;
  182. local (@total_guesses);
  183.  
  184. push(@total_guesses, $try);
  185.  
  186. # free (lower case) check if first letter is uppercase
  187. &p_lc($try);
  188. # reverse?
  189. if ($opt_r) { &p_rev($try); }
  190. # uppercase?
  191. if ($opt_U) { &p_up($try); }
  192.  
  193. # single digit tacked on to beginning and end
  194. if ($opt_d) {
  195.     if (length ($try) < 8) {
  196.         foreach $i ('0'..'9') {
  197.             $ntry = $i.$try;
  198.             push(@total_guesses, $ntry);
  199.             if ($opt_r) { &p_rev($ntry); }
  200.             if ($opt_U) { &p_up($ntry); }
  201.             }
  202.         foreach $i ('0'..'9') {
  203.             $ntry = $try.$i;
  204.             push(@total_guesses, $ntry);
  205.             if ($opt_r) { &p_rev($ntry); }
  206.             if ($opt_U) { &p_up($ntry); }
  207.             }
  208.         }
  209.     }
  210.  
  211. # change o's to 0's ("oh"'s to zeros)
  212. if ($opt_0) {
  213.     if (($ntry = $try) =~ s/o/0/g) { push(@total_guesses, $ntry); }
  214.     }
  215. if ($opt_1) {
  216.     if (($ntry = $try) =~ s/i/1/g) { push(@total_guesses, $ntry); }
  217.     }
  218.  
  219. # misspell words -- truncate first and last letter, if > 3 chars
  220. # thanks to  William Vajk, learn@ddsw1.MCS.COM, who posted this idea.
  221. if ($opt_m) {
  222.     $len = length($try);
  223.     if ($len > 3) {
  224.         ($ntry = $try) =~ s/^.//; push(@total_guesses, $ntry);
  225.         if ($len < 9) {
  226.             ($ntry = $try) =~ s/.$//; push(@total_guesses, $ntry);
  227.             }
  228.         }
  229.     }
  230.  
  231. # weird things!  Tacked on to beginning and end
  232. if ($opt_x) {
  233.     if (length ($try) < 8) {
  234.         foreach $i (@strange_things) {
  235.             $ntry = $i.$try;
  236.             push(@total_guesses, $ntry);
  237.             if ($opt_r) { &p_rev($ntry); }
  238.             if ($opt_U) { &p_up($ntry); }
  239.             }
  240.         foreach $i (@strange_things) {
  241.             $ntry = $try.$i;
  242.             push(@total_guesses, $ntry);
  243.             if ($opt_r) { &p_rev($ntry); }
  244.             if ($opt_U) { &p_up($ntry); }
  245.             }
  246.         }
  247.     }
  248.  
  249. # do single letters, #'s, if needed
  250. if ($opt_s && $uid ne $last_user) {
  251.     $last_user = $uid;
  252.     foreach $i (@strange_things) { push(@total_guesses,$i); }
  253.     foreach $i (0..9) { push(@total_guesses, $i); }
  254.     foreach $i (A..Z) { push(@total_guesses, $i); }
  255.     foreach $i (a..z) { push(@total_guesses, $i); }
  256.     }
  257.  
  258. if ($opt_v) {
  259.     foreach $i (@total_guesses) {
  260.         print "Trying \"$i\" on $uid\n";
  261.         $epw = crypt($i,$pass);
  262.         ($epw eq $pass) && return $i;
  263.         }
  264.     }
  265. else {
  266.     foreach $i (@total_guesses) {
  267.         $epw = crypt($i,$pass);
  268.         ($epw eq $pass) && return $i;
  269.         }
  270.     }
  271. undef @total_guesses;
  272.  
  273. return 0;
  274. }
  275.