home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3526 < prev    next >
Encoding:
Internet Message Format  |  1991-06-23  |  59.6 KB
  1. From: df@sei.cmu.edu (Dan Farmer)
  2. Newsgroups: alt.sources
  3. Subject: perl COPS, 2/3
  4. Message-ID: <27544@as0c.sei.cmu.edu>
  5. Date: 22 Jun 91 04:29:00 GMT
  6.  
  7. #!/bin/sh
  8. # this is p-cops.103.02 (part 2 of a multipart archive)
  9. # do not concatenate these parts, unpack them in order with /bin/sh
  10. # file beta/group.chk continued
  11. #
  12. if test ! -r _shar_seq_.tmp; then
  13.     echo 'Please unpack part 1 first!'
  14.     exit 1
  15. fi
  16. (read Scheck
  17.  if test "$Scheck" != 2; then
  18.     echo Please unpack part "$Scheck" next!
  19.     exit 1
  20.  else
  21.     exit 0
  22.  fi
  23. ) < _shar_seq_.tmp || exit 1
  24. if test ! -f _shar_wnt_.tmp; then
  25.     echo 'x - still skipping beta/group.chk'
  26. else
  27. echo 'x - continuing file beta/group.chk'
  28. sed 's/^X//' << 'SHAR_EOF' >> 'beta/group.chk' &&
  29. package main;
  30. X
  31. die "Usage: $0\n" if @ARGV;
  32. X
  33. require 'pathconf.pl';
  34. X
  35. #   Used for Sun C2 security group file.  FALSE (default) will flag
  36. # valid C2 group syntax as an error, TRUE attempts to validate it.
  37. # Thanks to Pete Troxell for pointing this out.
  38. #
  39. # moved to cops.cf
  40. X
  41. package group_chk;
  42. X
  43. $etc_group = $'GROUP || '/etc/group';
  44. X
  45. # Testing $etc_group for potential problems....
  46. open (Group, "< $etc_group") || warn "$0: Can't open $etc_group: $!\n";
  47. &chk_group_file_format('Group');
  48. close Group;
  49. X
  50. # Testing ypcat group for potential problems
  51. $yp=0;
  52. if (-s $'YPCAT && -x _) {
  53. X    open(YGroup, "$'YPCAT group 2>/dev/null |")
  54. X    || die "$0: Can't popen $'YPCAT: $!\n";
  55. X    $yp=1;
  56. X    &chk_group_file_format('YGroup');
  57. X    close(YGroup);
  58. }
  59. X
  60. # usage: &chk_group_file_format('Filehandle-name');
  61. # skips over lines that begin with "+:"
  62. # It really should check for correct yellow pages syntax....
  63. #
  64. # this routine checks lines read from a filehandle for potential format
  65. # problems .. should be matching group(5)
  66. #
  67. # checks for duplicate users in a group as it reads the lines instead
  68. # of after (as the original shell script does)
  69. X
  70. sub chk_group_file_format {
  71. X    local($file) = @_;
  72. X    local($W) = "Warning!  $file file,";
  73. X    undef %groups;
  74. X
  75. X    while (<$file>) {
  76. X    # should really check for correct YP syntax
  77. X    next if /^[-+]:/;   # skipping YP lines for now
  78. X    print "$W line $., is blank\n" if /^\s*$/;
  79. X    ($group,$pass,$gid,$users) = split(?:?);
  80. X    $groups{$group}++;   # keep track of dups
  81. X    print "$W line $., does not have 4 fields:\n\t$_" if (@_ != 4);
  82. X    print "$W line $., nonalphanumeric group name:\n\t$_"
  83. X        if $group !~ /^[A-Za-z0-9-]+$/;
  84. X    if ($pass && $pass ne '*') {
  85. X        if ( ! $C2 || $yp ) {
  86. X        print "$W line $., group has password:\n\t$_"
  87. X            if length($pass) == 13;
  88. X        } else {
  89. X        print "$W line $., group has invalid field for C2:\n\t$_"
  90. X            if $pass ne "#\$$user";
  91. X        }
  92. X    }
  93. X    print "$W line $., nonnumeric group id: $_" if $_[2] !~ /^\d+$/;
  94. X
  95. X    # look for duplicate users in a group
  96. X    # kinda ugly, but it works .. and I have too much other work right
  97. X    # now to clean it up.  maybe later.. ;-)
  98. X    chop($users);    # down here, 'cos split gets rid of final null fields
  99. X    @users = sort split(/\s*,\s*/, $users);
  100. X    # %users = # of times user is in group, $dup_user = duplicate found
  101. X    undef %users;  $dup_user=0;
  102. X    grep(!($users{$_}++) && 0, @users);
  103. X    for (keys %users) {
  104. X        (print "Warning!  Group $group has duplicate user(s):\n"),
  105. X        $dup_user=1 if !$dup_user && $users{$_} > 1;
  106. X        print "$_ " if $users{$_} > 1;
  107. X    }
  108. X    print "\n" if $dup_user;
  109. X
  110. X    }
  111. X    # find duplicate group names 
  112. X    # not the best way, but it works..
  113. X    # boy, this is ugly too .. but, not as bad as above.. :)
  114. X    $dup_warned = 0;
  115. X    for (sort keys %groups) {
  116. X    (print "Warning!  Duplicate Group(s) found in $file:\n"), $dup_warned++
  117. X        if !$dup_warned && $groups{$_} > 1;
  118. X    print "$_ " if $groups{$_} > 1;
  119. X    }
  120. X    print "\n" if $dup_warned;
  121. }
  122. X
  123. 1;
  124. # end
  125. SHAR_EOF
  126. echo 'File beta/group.chk is complete' &&
  127. chmod 0700 beta/group.chk ||
  128. echo 'restore of beta/group.chk failed'
  129. Wc_c="`wc -c < 'beta/group.chk'`"
  130. test 4819 -eq "$Wc_c" ||
  131.     echo 'beta/group.chk: original size 4819, current size' "$Wc_c"
  132. rm -f _shar_wnt_.tmp
  133. fi
  134. # ============= beta/hostname.pl ==============
  135. if test -f 'beta/hostname.pl' -a X"$1" != X"-c"; then
  136.     echo 'x - skipping beta/hostname.pl (File already exists)'
  137.     rm -f _shar_wnt_.tmp
  138. else
  139. > _shar_wnt_.tmp
  140. echo 'x - extracting beta/hostname.pl (Text)'
  141. sed 's/^X//' << 'SHAR_EOF' > 'beta/hostname.pl' &&
  142. #
  143. # file: hostname.pl
  144. # usage: $hostname = &'hostname;
  145. #
  146. # purpose: get hostname -- try method until we get an answer 
  147. #    or return "Amnesiac!"
  148. #
  149. X
  150. package hostname;
  151. X
  152. sub main'hostname {
  153. X    if (!defined $hostname) {
  154. X    $hostname =  ( -x '/bin/hostname'   && `/bin/hostname` ) 
  155. X          || ( -x '/bin/uname'      && `/bin/uname -n` )
  156. X          || ( -x '/usr/bin/uuname' && `/usr/bin/uuname -l`)
  157. X          || 'Amnesiac! ';  # trailing space is for chop
  158. X    chop $hostname;
  159. X    }
  160. X    $hostname;
  161. }
  162. X
  163. 1;
  164. SHAR_EOF
  165. chmod 0700 beta/hostname.pl ||
  166. echo 'restore of beta/hostname.pl failed'
  167. Wc_c="`wc -c < 'beta/hostname.pl'`"
  168. test 475 -eq "$Wc_c" ||
  169.     echo 'beta/hostname.pl: original size 475, current size' "$Wc_c"
  170. rm -f _shar_wnt_.tmp
  171. fi
  172. # ============= beta/is_able.chk ==============
  173. if test -f 'beta/is_able.chk' -a X"$1" != X"-c"; then
  174.     echo 'x - skipping beta/is_able.chk (File already exists)'
  175.     rm -f _shar_wnt_.tmp
  176. else
  177. > _shar_wnt_.tmp
  178. echo 'x - extracting beta/is_able.chk (Text)'
  179. sed 's/^X//' << 'SHAR_EOF' > 'beta/is_able.chk' &&
  180. #!/bin/sh -- need to mention perl here to avoid recursion
  181. 'true' || eval 'exec perl -S $0 $argv:q';
  182. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
  183. & eval 'exec /usr/bin/perl -S $0 $argv:q'
  184. X        if 0;
  185. X
  186. #
  187. #  is_able.chk
  188. #
  189. #   This shell script checks the permissions of all files and directories
  190. # listed in the configuration file "is_able.lst", and prints warning messages
  191. # according to the status of files.  You can specify world or group readability
  192. # or writeability.  See the config file for the format of the configuration
  193. # file.
  194. #
  195. #   Mechanism:  This shell script parses each line from the configure file
  196. # and uses the "is_able.pl" program to check if any of
  197. # the directories in question are writable by world/group.
  198. #
  199. X
  200. require 'is_able.pl';
  201. require 'file_mode.pl';
  202. require 'glob.pl';
  203. X
  204. if ($ARGV[0] eq '-d') {
  205. X    shift;
  206. X    $debug = $glob'debug = 1;  # maybe should turn off glob'debug afterwards
  207. }
  208. X
  209. unshift (@ARGV, "is_able.lst" ) unless @ARGV;
  210. X
  211. while (<>) {
  212. X    next if /^\s*#/;
  213. X    split;
  214. X    next unless @_ == 3;
  215. X    ($file, $x, $y) = @_;
  216. X    @files = $file =~ /[\[?*]/ ? &'glob($file) : ($file);
  217. X    for $file (@files) {
  218. X    print STDERR "is_able $file $x $y\n" if $debug;
  219. X    &'is_able($file, $x, $y);
  220. X    }
  221. }
  222. X
  223. 1;
  224. SHAR_EOF
  225. chmod 0700 beta/is_able.chk ||
  226. echo 'restore of beta/is_able.chk failed'
  227. Wc_c="`wc -c < 'beta/is_able.chk'`"
  228. test 1235 -eq "$Wc_c" ||
  229.     echo 'beta/is_able.chk: original size 1235, current size' "$Wc_c"
  230. rm -f _shar_wnt_.tmp
  231. fi
  232. # ============= beta/is_able.lst ==============
  233. if test -f 'beta/is_able.lst' -a X"$1" != X"-c"; then
  234.     echo 'x - skipping beta/is_able.lst (File already exists)'
  235.     rm -f _shar_wnt_.tmp
  236. else
  237. > _shar_wnt_.tmp
  238. echo 'x - extracting beta/is_able.lst (Text)'
  239. sed 's/^X//' << 'SHAR_EOF' > 'beta/is_able.lst' &&
  240. #  This lists any/all sensitive files the administration wants to ensure
  241. # non-read/writability of.  Comments are lines starting with a "#".
  242. #
  243. # USE FULL PATHNAMES!
  244. #
  245. #   Lines are of the format:
  246. #
  247. # /path/to/{dir|file}    World/Group    Read/Write/Both
  248. #
  249. # as above        {w|g}        {r|w|b}
  250. #
  251. /            w        w
  252. /etc            w        w
  253. /usr            w        w
  254. /bin            w        w
  255. /dev            w        w
  256. /usr/bin        w        w
  257. /usr/etc        w        w
  258. /usr/adm        w        w
  259. /usr/lib        w        w
  260. /usr/spool        w        w
  261. /usr/spool/mail        w        w
  262. /usr/spool/news        w        w
  263. /usr/spool/uucp        w        w
  264. /usr/spool/at        w        w
  265. /usr/local        w        w
  266. /usr/local/bin        w        w
  267. /usr/local/lib        w        w
  268. /usr/users        w        w
  269. /Mail            w        w
  270. X
  271. # some Un*x's put shadowpass stuff here:
  272. /etc/security        w        r
  273. X
  274. # /.login /.profile /.cshrc /.rhosts
  275. /.*            w        w
  276. X
  277. #   I think everything in /etc should be !world-writable, as a rule; but
  278. # if you're selecting individual files, do at *least* these:
  279. #   /etc/passwd /etc/group /etc/inittab /etc/rc /etc/rc.local /etc/rc.boot
  280. #   /etc/hosts.equiv /etc/profile /etc/syslog.conf /etc/export /etc/utmp
  281. #   /etc/wtmp
  282. /etc/*            w        w
  283. X
  284. /bin/*            w        w
  285. /usr/bin/*        w        w
  286. /usr/etc/*        w        w
  287. /usr/adm/*        w        w
  288. /usr/lib/*        w        w
  289. /usr/local/lib/*    w        w
  290. /usr/local/bin/*    w        w
  291. /usr/etc/yp*        w        w
  292. /usr/etc/yp/*        w        w
  293. X
  294. # individual files:
  295. /usr/lib/crontab    w        b
  296. /usr/lib/aliases    w        w
  297. /usr/lib/sendmail    w        w
  298. /usr/spool/uucp/L.sys    w        b
  299. X
  300. #  NEVER want these readable!
  301. /dev/kmem        w        b
  302. /dev/mem        w        b
  303. X
  304. #   Optional List of assorted files that shouldn't be
  305. # write/readable (mix 'n match; add to the list as desired):
  306. /usr/adm/sulog        w        r
  307. /.netrc            w        b
  308. # HP-UX and others:
  309. /etc/btmp        w        b
  310. /etc/securetty        w        b
  311. # Sun-fun
  312. /dev/drum        w        b
  313. /dev/nit        w        b
  314. SHAR_EOF
  315. chmod 0700 beta/is_able.lst ||
  316. echo 'restore of beta/is_able.lst failed'
  317. Wc_c="`wc -c < 'beta/is_able.lst'`"
  318. test 1603 -eq "$Wc_c" ||
  319.     echo 'beta/is_able.lst: original size 1603, current size' "$Wc_c"
  320. rm -f _shar_wnt_.tmp
  321. fi
  322. # ============= beta/kuang ==============
  323. if test -f 'beta/kuang' -a X"$1" != X"-c"; then
  324.     echo 'x - skipping beta/kuang (File already exists)'
  325.     rm -f _shar_wnt_.tmp
  326. else
  327. > _shar_wnt_.tmp
  328. echo 'x - extracting beta/kuang (Text)'
  329. sed 's/^X//' << 'SHAR_EOF' > 'beta/kuang' &&
  330. #!/bin/sh -- need to mention perl here to avoid recursion
  331. 'true' || eval 'exec perl -S $0 $argv:q';
  332. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
  333. & eval 'exec /usr/users/df/bin/perl.sun4 -S $0 $argv:q'
  334. X        if 0;
  335. # & eval 'exec /usr/local/bin/perl -S $0 $argv:q'
  336. #
  337. # kuang - rule based analysis of Unix security
  338. #
  339. # Perl version by Steve Romig of the CIS department, The Ohio State
  340. # University, October 1990. 
  341. # 
  342. # Based on the shell script version by Dan Farmer from his COPS
  343. # package, which in turn is based on a shell version by Robert
  344. # Baldwin. 
  345. #
  346. #-----------------------------------------------------------------------------
  347. # Players:
  348. #    romig    Steve Romig, romig@cis.ohio-state.edu
  349. #    tjt    Tim Tessin, tjt@cirrus.com
  350. #
  351. # History:
  352. # 4/25/91  tjt, romig    Various fixes to filewriters (better messages about 
  353. #            permission problems) and don't update the DBM cache 
  354. #            with local file info.
  355. # 11/1/90  romig    Major rewrite - generic lists, nuking get_entry 
  356. #            and put_entry, moved rules to separate file.
  357. #
  358. X
  359. #
  360. # Options
  361. #
  362. # -l        list uid's that can access the given target, directly
  363. #        or indirectly
  364. # -d        debug
  365. # -V         verbose
  366. #
  367. # -k file    load the list of known CO's
  368. # -f file    preload file information from the named file.
  369. # -p file    preload passwd info from the named file.
  370. # -Y        preload passwd info from ypcat + /etc/passwd
  371. # -g group    preload group info from the named file.
  372. # -G        preload group info from ypcat + /etc/group
  373. # 
  374. # NOTE:
  375. #   If you know where perl is and your system groks #!, put its
  376. # pathname at the top to make this a tad faster.
  377. #
  378. # the following magic is from the perl man page
  379. # and should work to get us to run with perl 
  380. # even if invoked as an sh or csh or foosh script.
  381. # notice we don't use full path cause we don't
  382. # know where the user has perl on their system.
  383. #
  384. X
  385. $options = "ldVk:p:g:f:YG";
  386. $usage = "usage: kuang [-l] [-d] [-v] [-k known] [-f file] [-Y] [-G] [-p passwd] [-g group] [u.username|g.groupname]\n";
  387. X
  388. $add_files_to_cache = 1;        # Whether to update the %files cache
  389. X                    # with local file info or not.
  390. X
  391. #
  392. # Terminology:
  393. #
  394. #   An "op" is an operation, such as uid, gid, write, or replace. 
  395. #   'uid' means to gain access to some uid, 'gid' means to gain access 
  396. #   to some gid.  'write' and 'replace' refer to files - replace means
  397. #   that we can delete a file and replace it with a new one somehow
  398. #   (for example, if we could write the directory it is in).
  399. #
  400. #   An object is a uid, gid or pathname.  
  401. #
  402. #   A Controlling Operation (CO) is a (operation, object) pair
  403. #   represented as "op object": "uid 216" (become uid 216) or "replace
  404. #   /.rhosts" (replace file /.rhosts).  These are represented
  405. #   internally as "c value", where "c" is a character representing an
  406. #   operation (u for uid, g for gid, r for replace, w for write) and
  407. #   value is a uid, gid or pathname.
  408. #
  409. #   A plan is a chain of CO's that are connected to each other.  If
  410. #   /.login were writeable by uid 216, we might have a plan such as:
  411. #
  412. #    uid 216 => write /.login => uid 0
  413. #
  414. #   which means (in English) "if we can become uid 216, then write 
  415. #   /.login which gives you access to uid 0 (when root next logs in)."
  416. #   Plans are represented in several ways: as arrays:
  417. #
  418. #    ("u 0", "w /.login", "u 216")
  419. #
  420. #   Note that the order is reversed.  As a string:
  421. #
  422. #    "u 0\034w /.login\034u 216"
  423. #
  424. #   The target is the object that we are trying to gain (a uid, gid or
  425. #   file, typically u.root or some other UID).
  426. #
  427. # Data Structures
  428. #
  429. #   %known        An assocc array, indexed by CO.  This lists
  430. #            the COs that we already have access to.  If we
  431. #                       find a plan that leads from a CO in the known
  432. #                       list to the target, we've succeeded in
  433. #                       finding a major security flaw.  
  434. #
  435. #   @new        An array of plans that are to be evaluated in
  436. #            the next cycle. 
  437. #
  438. #   @old        An array of plans that we are currently
  439. #            evaluating. 
  440. #
  441. #   %beendone        An assoc array that lists the plans that have
  442. #            already been tried.  Used to prevent loops.
  443. #
  444. #   @accessible        An array of the uids that can reach the
  445. #            target. 
  446. #
  447. #   %files        An assoc array, indexed by file name, contains
  448. #            cached file info.  value is of form "uid gid
  449. #            mode". 
  450. #
  451. # From pwgrid:
  452. #
  453. #   %uname2shell    Assoc array, indexed by user name, values are
  454. #            shells. 
  455. #
  456. #   %uname2dir        Assoc array, indexed by user name, values are
  457. #            home directories.
  458. #
  459. #   %uname2uid        Assoc array, indexed by name, values are uids.
  460. #            
  461. #   %uid2names        Assoc array, indexed by uid, value is list of
  462. #            user names with that uid, in form "name name
  463. #            name...". 
  464. #
  465. #   %gid2members    Assoc array, indexed by gid, value is list of
  466. #            group members (user names).
  467. #
  468. #   %gname2gid        Assoc array, indexed by group name, values are
  469. #            matching gids.
  470. #
  471. #   %gid2names        Assoc array, indexed by gid, values are
  472. #            matching group names.
  473. #
  474. X
  475. do 'yagrip.pl' ||
  476. X  die "can't do yagrip.pl";
  477. X
  478. # do 'pwgrid.pl' ||
  479. #   die "can't do pwgrid.pl";
  480. do 'pass.cache.pl' ||
  481. X  die "can't do pass.cache.pl";
  482. X
  483. do 'rules.pl' ||
  484. X  die "can't do rules.pl";
  485. X
  486. X
  487. #
  488. # Turns a string of the form "operation value" or "value" into
  489. # standard "CO" form ("operation value").  Converts user or group
  490. # names into corresponding uid and gid values. 
  491. #
  492. # Returns nothing if it isn't parseable.
  493. #
  494. X
  495. sub canonicalize {
  496. X    local($string) = @_;
  497. X    local($op, $value);
  498. X
  499. X    if ($string =~ /^([ugrw]) ([^ \t\n]+)$/) { # of form "op value"
  500. X    $op = $1;
  501. X    $value = $2;
  502. X    } elsif ($string =~ /^[^ \t\n]+$/) {       # of form "value"
  503. X        $value = $string;
  504. X    $op = "u";
  505. X    } else {
  506. X    return();
  507. X    }
  508. X
  509. X    if ($op eq "u" && $value =~ /^[^0-9]+$/) { # user name, not ID
  510. X        if (defined($uname2uid{$value})) {
  511. X        $value = $uname2uid{$value};
  512. X    } else {
  513. X        printf(stderr "There's no user named '%s'.\n", $value);
  514. X        return();
  515. X    }
  516. X    } elsif ($op eq "g" && $value =~/^[^0-9]+$/) {
  517. X    if (defined($gname2gid{$value})) {
  518. X        $value = $gname2gid{$value};
  519. X    } else {
  520. X        printf(stderr "There's no group named '%s'.\n", $value);
  521. X        return();
  522. X    }
  523. X    }
  524. X
  525. X    return($op, $value);
  526. }
  527. X
  528. X
  529. #
  530. # Preload file information from a text file or DBM database.  
  531. # If $opt_f.dir exists, then we just shadow %files from a DBM
  532. # database.  Otherwise, open the file and read the entries into 
  533. # %files.  
  534. #
  535. # $add_files_to_cache is set to 0 if we get the info from 
  536. # DBM since we wouldn't want to pollute update our DBM cache
  537. # with local file info which wouldn't apply to other hosts.
  538. #
  539. X
  540. sub preload_file_info {
  541. X    local($count, $f_type, $f_uid, $f_gid, $f_mode, $f_name);
  542. X
  543. X    if (defined($opt_d)) {
  544. X    printf("loading file info...\n");
  545. X    }
  546. X
  547. X    if (-f "$opt_f.dir") {
  548. X    $add_files_to_cache = 0;
  549. X
  550. X    dbmopen(files, $opt_f, 0644) ||
  551. X      die sprintf("can't open DBM file '%s'", $opt_f);
  552. X    } else {
  553. X    open(FILEDATA, $opt_f) || 
  554. X      die sprintf("kuang: can't open '%s'", $opt_f);
  555. X
  556. X    $count = 0;
  557. X    while (<FILEDATA>) {
  558. X        $count++;
  559. X
  560. X        chop;
  561. X        ($f_type, $f_uid, $f_gid, $f_mode, $f_name) = split;
  562. X        
  563. X        if ($count % 1000 == 0) {
  564. X        printf("line $count, reading entry for $f_name\n");
  565. X        }
  566. X        $files{$f_name} = join(' ', $f_uid, $f_gid, $f_mode);
  567. X    }
  568. X
  569. X    close(FILEDATA);
  570. X    }
  571. }
  572. X
  573. #
  574. # Preload the known information.  Reads data from a file, 1 entry per line,
  575. # each entry is a CO that we "know" can be used.
  576. #
  577. X
  578. sub preload_known_info {
  579. X    local($file_name) = @_;
  580. X    local($op, $value, $co);
  581. X
  582. X    open(FILE, $file_name) ||
  583. X      die sprintf("kuang: can't open '%s'", $file_name);
  584. X
  585. X  known_loop:
  586. X    while (<FILE>) {
  587. X    chop;
  588. X    if ((($op, $value) = &canonicalize($_)) == 2) {
  589. X        $co = sprintf("%s %s", $op, $value);
  590. X        $known{$co} = 1;
  591. X    } else {
  592. X        printf(stderr "kuang: invalid entry in known list: line %d '%s'.\n",
  593. X           $.,
  594. X           $_);
  595. X    }
  596. X    }
  597. X
  598. X    close(FILE);
  599. }
  600. X    
  601. X
  602. #
  603. # Do various initialization type things.
  604. #
  605. X
  606. sub init_kuang {
  607. X    local($which, $name, $uid, $gid);
  608. X    local($op, $value, $co);
  609. X
  610. X    #
  611. X    # Deal with args...
  612. X    #
  613. X
  614. X    &getopt($options) ||
  615. X      die $usage;
  616. X
  617. X    if ($#ARGV == -1) {
  618. X    push(@ARGV, "u root");
  619. X    }
  620. X
  621. X    #
  622. X    # Preload anything...
  623. X    #
  624. X    if (defined($opt_f)) {
  625. X    &preload_file_info();
  626. X    }
  627. X
  628. X    if (defined($opt_d)) {
  629. X    printf("load passwd info...\n");
  630. X    }
  631. X
  632. X    if (defined($opt_p)) {
  633. X    if (defined($opt_Y)) {
  634. X        printf(stderr "You can only specify one of -p or -P, not both.\n");
  635. X        exit(1);
  636. X    }
  637. X
  638. X    &load_passwd_info(0, $opt_p);
  639. X    } elsif (defined($opt_Y)) {
  640. X    &load_passwd_info(0);
  641. X    } else {
  642. X    &load_passwd_info(1);
  643. X    }
  644. X
  645. X    if (defined($opt_d)) {
  646. X    printf("load group info...\n");
  647. X    }
  648. X
  649. X    if (defined($opt_g)) {
  650. X    if (defined($opt_G)) {
  651. X        printf(stderr "You can only specify one of -g or -G, not both.\n");
  652. X        exit(1);
  653. X    }
  654. X
  655. X    &load_group_info(0, $opt_g);
  656. X    } elsif (defined($opt_G)) {
  657. X    &load_group_info(0);
  658. X    } else {
  659. X    &load_group_info(1);
  660. X    }
  661. X
  662. X    #
  663. X    # Need some of the password and group stuff.  Suck in passwd and 
  664. X    # group info, store by uid and gid in an associative array of strings
  665. X    # which consist of fields corresponding to the passwd and group file 
  666. X    # entries (and what the heck, we'll use : as a delimiter also...:-)
  667. X    #
  668. X    $uname2shell{"OTHER"} = "";
  669. X    $uname2dir{"OTHER"} = "";
  670. X    $uname2uid{"OTHER"} = -1;
  671. X    $uid2names{-1} = "OTHER";
  672. X
  673. X    $known{"u -1"} = 1;        # We can access uid OTHER
  674. X
  675. X    if (defined($opt_k)) {
  676. X    &preload_known_info($opt_k);
  677. X    }
  678. X
  679. X    #
  680. X    # Create the target list from the remaining (non-option) args...
  681. X    #
  682. X    while ($#ARGV >= 0) {
  683. X    $elt = pop(@ARGV);
  684. X    if ((($op, $value) = &canonicalize($elt)) == 2) {
  685. X        $co = sprintf("%s %s", $op, $value);
  686. X        push(@targets, $co);
  687. X    } else {
  688. X        printf(stderr "target '%s' isn't of correct form\n", $elt);
  689. X    }
  690. X    }
  691. }
  692. X
  693. X
  694. #
  695. # Call this to set things up for a new target.  Resets old, new, beendone 
  696. # and accessible.  
  697. #
  698. sub set_target {
  699. X    local($target) = @_;
  700. X
  701. X    @old = ();
  702. X    @new = ();
  703. X    %beendone = ();
  704. X    @accessible = ();
  705. # fixme: reset known?
  706. X
  707. X    if ($target =~ /^([ugrw]) ([^ \t]+)$/) {
  708. X    &addto($1, $2);
  709. X    return(0);
  710. X    } else {
  711. X    printf(stderr "kuang: bad target '%s'\n", $target);
  712. X    return(1);
  713. X    }
  714. }
  715. X
  716. #
  717. # Break a CO into an (operation, value) pair and return it.  If it
  718. # isn't in "operation value" form, return ().
  719. #
  720. sub breakup {
  721. X    local($co) = @_;
  722. X    local($operation, $value);
  723. X
  724. X    if ($co =~ /^([ugrw]) ([^ \t]+)$/) {
  725. X    $operation = $1;
  726. X    $value = $2;
  727. X    } else {
  728. X    printf(stderr "Yowza, breakup failed on '%s'\n",
  729. X        $co);
  730. X    exit(1);
  731. X    }
  732. X
  733. X    return($operation, $value);
  734. }
  735. X
  736. #
  737. # Get the writers of the named file - return as (UID, GID, OTHER)
  738. # triplet.  Owner can always write, since he can chmod the file if he
  739. # wants. 
  740. #
  741. # (fixme) are there any problems in this sort of builtin rule?  should
  742. # we make this knowledge more explicit?
  743. #
  744. sub filewriters {
  745. X    local($name) = @_;
  746. X    local($tmp, $mode, $uid, $gid, $other);
  747. X    
  748. X    #
  749. X    # Check the file cache - avoid disk lookups for performance and 
  750. X    # to avoid shadows...
  751. X    #
  752. X    if (defined($files{$name})) {
  753. X    $cache_hit++;
  754. X    
  755. X    ($uid, $gid, $mode, $tmp) = split(/ /, $files{$name});
  756. X    } else {
  757. X    $cache_miss++;
  758. X
  759. X    unless (-e $name) {
  760. X        if ($add_files_to_cache) {
  761. X        $files{$name} = "";
  762. X        }
  763. X        # ENOTDIR = 20 
  764. X        ($! == 20) && print "Warning: Illegal Path: '$name'\n";
  765. X        # EACCES = 13
  766. X        ($! == 13) && print "Warning: Permission Denied: '$name'\n";
  767. X        # all values are returned "" here.
  768. X        return;
  769. X    }
  770. X
  771. X    ($tmp,$tmp,$mode,$tmp,$uid,$gid) = stat(_);
  772. X    if ($add_files_to_cache) {
  773. X        $files{$name} = join(' ', "$uid", "$gid", "$mode");
  774. X    }
  775. X    }
  776. X
  777. X    if (($mode & 020) != 020) {
  778. X    $gid = "";
  779. X    }
  780. X    
  781. X    if (($mode & 02) == 02) {
  782. X    $other = 1;
  783. X    } else {
  784. X    $other = 0;
  785. X    }
  786. X
  787. X    return($uid, $gid, $other);
  788. }
  789. X
  790. X
  791. sub ascii_plan {
  792. X    local(@plan) = @_;
  793. X    local($op, $value, $result);
  794. X
  795. X    for ($i = $#plan; $i >= 0; $i--) {
  796. X    ($op, $value) = &breakup($plan[$i]);
  797. X
  798. X      case: 
  799. X    {
  800. X        if ($op eq "g") {
  801. X        $op = "grant gid";
  802. X        last case;
  803. X        }
  804. X
  805. X        if ($op eq "u") {
  806. X        $op = "grant uid";
  807. X        last case;
  808. X        }
  809. X
  810. X        if ($op eq "r") {
  811. X        $op = "replace";
  812. X        last case;
  813. X        }
  814. X
  815. X        if ($op eq "w") {
  816. X        $op = "write";
  817. X        last case;
  818. X        }
  819. X
  820. X        printf(stderr "Bad op '%s' in plan '%s'\n",
  821. X           $op,
  822. X           join(';', @plan));
  823. X        last case;
  824. X    }
  825. X
  826. X    $result .= "$op $value ";
  827. X    }
  828. X
  829. X    return($result);
  830. }
  831. X
  832. #
  833. # Add a plan to the list of plans to check out.
  834. #
  835. sub addto {
  836. X    local($op, $value, @plan) = @_;
  837. X    local($co);
  838. X
  839. X    $co = sprintf("%s %s",
  840. X          $op,
  841. X          $value);
  842. X
  843. X    #
  844. X    # See if the op and value is "uid root" - if so, and if the @plan 
  845. X    # isn't empty, then don't bother checking - if the target isn't root, 
  846. X    # its silly to pursue plans that require becoming root since if we can 
  847. X    # become root, we can become anything.  If the target is root, then 
  848. X    # this would be a loop anyway.
  849. X    #
  850. X    if ($op eq "u" && $value eq "0" && $#plan >= 0) {
  851. X    if (defined($opt_d)) {
  852. X        printf("addto: aborted root plan '%s'\n",
  853. X           &ascii_plan(@plan, $co));
  854. X    }
  855. X    return;
  856. X    }
  857. X
  858. X    #
  859. X    # See whether there's an entry for $co in the known list.
  860. X    # If so - success, we've found a suitable breakin plan.
  861. X    #
  862. X    # Yes, we want to check to see whether the whole Controlling Operation 
  863. X    # is one that is known to us, rather than just the object.  I
  864. X    # might have a hole that allows me to "replace /bin/foo" which is
  865. X    # somewhat different than "write /bin/foo"  
  866. X    #
  867. X    if (! defined($opt_l) && defined($known{$co})) {
  868. X    printf("Success! %s\n",
  869. X           &ascii_plan(@plan, $co));
  870. X    }
  871. X
  872. X    #
  873. X    # Check for loops -- if the new CO is part of the plan that we're
  874. X    # adding it to, this is a loop.
  875. X    #
  876. X    foreach $entry (@plan) {
  877. X    if ($entry eq $co) {
  878. X        if (defined($opt_d)) {
  879. X        printf("addto: aborted loop in plan '%s'\n",
  880. X               &ascii_plan(@plan, $co));
  881. X        }
  882. X        return;
  883. X    }
  884. X    }
  885. X
  886. X    #
  887. X    # Add this CO to the plan array...
  888. X    #
  889. X    push(@plan, $co);
  890. X
  891. X    #
  892. X    # Make an ascii version of sorts...
  893. X    #
  894. X    $text_plan = join($;, @plan);
  895. X
  896. X    #
  897. X    # Check to see if the new plan has been done.
  898. X    #
  899. X    if (defined($beendone{$text_plan})) {
  900. X    if (defined($opt_d)) {
  901. X        printf("addto: plan's been done - '%s'\n",
  902. X           &ascii_plan(@plan));
  903. X    }
  904. X    return;
  905. X    }
  906. X
  907. X    #
  908. X    # If we made it this far, its a new plan and isn't a loop.  
  909. X    #
  910. X
  911. X    #
  912. X    # Add to the beendone list...
  913. X    #
  914. X    $beendone{$text_plan} = 1;
  915. X
  916. X    #
  917. X    # Add to new plan list...
  918. X    #
  919. X    push(@new, $text_plan);
  920. X
  921. X    if (defined($opt_V)) {
  922. X    printf("addto: %s\n", 
  923. X           &ascii_plan(@plan));
  924. X    }
  925. X
  926. X    #
  927. X    # If this is a uid goal, then add the plan to the accessible list.
  928. X    #
  929. X    if ($op eq "u" && $value ne "0" && defined($opt_l)) {
  930. X    push(@accessible, $value);
  931. X    }
  932. }
  933. X
  934. #
  935. #----------------------------------------------------------------------
  936. #Main program follows...initialize and loop till we're done.
  937. #
  938. X
  939. &init_kuang();
  940. X
  941. target_loop:
  942. foreach $target (@targets) {
  943. X    if (&set_target($target)) {
  944. X    next target_loop;
  945. X    }
  946. X
  947. X    while ($#new >= 0) {
  948. X    @old = @new;
  949. X    @new = ();
  950. X
  951. X    foreach $t_plan (@old) {
  952. X        @plan = split(/\034/, $t_plan);
  953. X        ($op, $value) = &breakup($plan[$#plan]);
  954. X
  955. X        &apply_rules($op, $value, @plan);
  956. X    }
  957. X    }
  958. X
  959. X    if (defined($opt_l)) {
  960. X    foreach $elt (@accessible) {
  961. X        printf("$elt\n");
  962. X    }
  963. X    }
  964. }
  965. X
  966. if (defined($opt_d)) {
  967. X    printf("File info cache hit/access ratio: %g\n", 
  968. X           ($cache_hit + $cache_miss > 0) 
  969. X            ? $cache_hit / ($cache_hit + $cache_miss)
  970. X            : 0.0);
  971. }
  972. X
  973. 1;
  974. SHAR_EOF
  975. chmod 0700 beta/kuang ||
  976. echo 'restore of beta/kuang failed'
  977. Wc_c="`wc -c < 'beta/kuang'`"
  978. test 15363 -eq "$Wc_c" ||
  979.     echo 'beta/kuang: original size 15363, current size' "$Wc_c"
  980. rm -f _shar_wnt_.tmp
  981. fi
  982. # ============= beta/is_able.pl ==============
  983. if test -f 'beta/is_able.pl' -a X"$1" != X"-c"; then
  984.     echo 'x - skipping beta/is_able.pl (File already exists)'
  985.     rm -f _shar_wnt_.tmp
  986. else
  987. > _shar_wnt_.tmp
  988. echo 'x - extracting beta/is_able.pl (Text)'
  989. sed 's/^X//' << 'SHAR_EOF' > 'beta/is_able.pl' &&
  990. #
  991. #  (This takes the place of the C program is_able.c, BTW.)
  992. # 
  993. #  is_able filename {w|g|s|S}       {r|w|B|b|s}
  994. #      (world/group/SUID/SGID   read/write/{read&write}/{suid&write}/s[ug]id)
  995. # 
  996. #     The second arg of {r|w} determines whether a file is (group or world
  997. #   depending on the first arg of {w|g}) writable/readable, or if it is
  998. #   SUID/SGID (first arg, either s or S, respectively), and prints out a
  999. #   short message to that effect.
  1000. # 
  1001. #  So:
  1002. #     is_able w w        # checks if world writable
  1003. #     is_able g r        # checks if group readable
  1004. #     is_able s s        # checks if SUID
  1005. #     is_able S b        # checks if world writable and SGID
  1006. X
  1007. package main;
  1008. require 'file_mode.pl';
  1009. X
  1010. package is_able;
  1011. X
  1012. # package statics
  1013. #
  1014. %wg = ( 
  1015. X    'w', 00006,
  1016. X    'g', 00060,
  1017. X    's', 04000,
  1018. X    'S', 02000,
  1019. X       );
  1020. X
  1021. %rwb= (
  1022. X    'r', 00044,
  1023. X    'w', 00022,
  1024. X    'B', 00066,
  1025. X    'b', 04022,
  1026. X    's', 06000,
  1027. X      );
  1028. X
  1029. $silent = 0;  # for suppressing diagnostic messages
  1030. X
  1031. X
  1032. sub main'is_able {
  1033. X    local($file, $wg, $rwb) = @_;
  1034. X
  1035. X    local ( 
  1036. X       $mode,             # file mode
  1037. X           $piece,            # 1 directory component
  1038. X       @pieces,             # all the pieces
  1039. X       @dirs,             # all the directories
  1040. X       $p,                 # punctuation; (*) mean writable
  1041. X                       #       due to writable parent
  1042. X       $retval,            # true if vulnerable
  1043. X       $[                # paranoia
  1044. X      );
  1045. X
  1046. X    &usage, return undef    if @_ != 3 || $file eq '';
  1047. X
  1048. X    &usage, return undef    unless defined $wg{$wg} && defined $rwb{$rwb};
  1049. X
  1050. X    if (&'Mode($file) eq 'BOGUS' && $noisy) {
  1051. X    warn "is_able: can't stat $file: $!\n";
  1052. X    return undef;
  1053. X    }
  1054. X
  1055. X    $retval = 0;
  1056. X
  1057. X    if ($rwb{$rwb} & $rwb{'w'}) {
  1058. X    @pieces = split(m#/#, $file);
  1059. X    for ($i = 1; $i <= $#pieces; $i++) {
  1060. X        push(@dirs, join('/', @pieces[0..$i]));
  1061. X    }
  1062. X    } else {
  1063. X    @dirs = ( $file );
  1064. X    } 
  1065. X
  1066. X    for $piece ( reverse @dirs ) {
  1067. X
  1068. X    next unless $mode = &'Mode($piece);
  1069. X    next if $mode eq 'BOGUS';
  1070. X
  1071. X    next unless $mode &= 07777 & $wg{$wg} & $rwb{$rwb};
  1072. X
  1073. X    $retval = 1;
  1074. X
  1075. X    $p = $piece eq $file ? '!' : '! (*)';
  1076. X
  1077. X    $parent_is_writable = $p eq '! (*)'; # for later
  1078. X
  1079. X    next if $silent; # for &is_writable
  1080. X
  1081. X    print "Warning!  $file is group readable$p\n"    if $mode & 00040; 
  1082. X    print "Warning!  $file is _World_ readable$p\n"    if $mode & 00004; 
  1083. X    print "Warning!  $file is group writable$p\n"    if $mode & 00020; 
  1084. X    print "Warning!  $file is _World_ writable$p\n"    if $mode & 00002; 
  1085. X    print "Warning!  $file is SUID!\n"        if $mode & 04000; 
  1086. X    print "Warning!  $file is SGID!\n"        if $mode & 02000; 
  1087. X
  1088. X    last if $piece ne $file;  # only complain on first writable parent
  1089. X    }
  1090. X    $retval;
  1091. }
  1092. X
  1093. sub main'is_writable {
  1094. X    local($silent) = 1;
  1095. X    &'is_able($_[0], 'w', 'w') 
  1096. X    ? $parent_is_writable 
  1097. X         ? "writable (*)"
  1098. X         : "writable" 
  1099. X    : 0;
  1100. } 
  1101. X
  1102. sub main'is_readable {
  1103. X    local($silent) = 1;
  1104. X    &'is_able($_[0], 'w', 'r');
  1105. }
  1106. X
  1107. sub usage { 
  1108. X    warn <<EOF;
  1109. Usage: is_able file {w|g|S|s} {r|w|B|b|s}
  1110. X (not: is_able @_)
  1111. EOF
  1112. }
  1113. X
  1114. 1;
  1115. SHAR_EOF
  1116. chmod 0700 beta/is_able.pl ||
  1117. echo 'restore of beta/is_able.pl failed'
  1118. Wc_c="`wc -c < 'beta/is_able.pl'`"
  1119. test 2835 -eq "$Wc_c" ||
  1120.     echo 'beta/is_able.pl: original size 2835, current size' "$Wc_c"
  1121. rm -f _shar_wnt_.tmp
  1122. fi
  1123. # ============= beta/kuang.1 ==============
  1124. if test -f 'beta/kuang.1' -a X"$1" != X"-c"; then
  1125.     echo 'x - skipping beta/kuang.1 (File already exists)'
  1126.     rm -f _shar_wnt_.tmp
  1127. else
  1128. > _shar_wnt_.tmp
  1129. echo 'x - extracting beta/kuang.1 (Text)'
  1130. sed 's/^X//' << 'SHAR_EOF' > 'beta/kuang.1' &&
  1131. .TH KUANG 1 "4 October 1990"
  1132. .SH NAME
  1133. kuang \- find security problems through rule based analysis
  1134. .SH SYNOPSIS
  1135. .B kuang
  1136. .RB "[\|" \-v  "\|]"
  1137. .RB "[\|" \-d "\|]"
  1138. .RB "[\|" \-l "\|]"
  1139. .RB "[\|" \-k known"\|]"
  1140. .RB "[\|" \-f filedata "\|]"
  1141. .RB "[\|" \-P "\|]"
  1142. .RB "[\|" \-G "\|]"
  1143. .RB "[\|" \-p passwd "\|]"
  1144. .RB "[\|" \-g group "\|]"
  1145. .RB "[\|" 
  1146. .IR u.username | g.groupname "\|]"
  1147. .br
  1148. .SH DESCRIPTION
  1149. .LP
  1150. .B kuang
  1151. uses rule based analysis to examine the current security configuration
  1152. of a site and determine whether certain security problems exist.
  1153. X
  1154. .B kuang 
  1155. contains embedded rules that describe the projection model and
  1156. some of the attacker tricks used on Unix systems.  It uses these rules
  1157. to reason backward from a desired goal (such as "grant u.root"),
  1158. generating potential "attack" plans from the rules and file system
  1159. state and then evaluating them to see whether they are reachable
  1160. according to the state recorded in the password and group files and in
  1161. the ownership and modes of the file systems.
  1162. X
  1163. By default, 
  1164. .B kuang 
  1165. uses "grant u.root" as its initial goal.  You can change that by
  1166. specifying a username (u.username) or groupname (g.groupname) on the
  1167. command line.  Normally 
  1168. .B kuang
  1169. determines a plan to be successful if it determines that anyone
  1170. (u.other) can become the initial goal.  
  1171. X
  1172. The 
  1173. .B \-v
  1174. option causes 
  1175. .B kuang
  1176. to print a message about every plan added to the evaluation list.
  1177. This can help one to understand how 
  1178. .B kuang 
  1179. works.  The 
  1180. .B \-d 
  1181. option causes 
  1182. .B kuang
  1183. to print a message when it evaluates a plan to determine whether to
  1184. retain it and add onto it or ignore it.  Beware - these options will often
  1185. produce lots of output.
  1186. X
  1187. Normally 
  1188. .B kuang
  1189. only registers success when it finds that everyone on the system can
  1190. become the target uid or gid.  With the 
  1191. .B \-l
  1192. option, 
  1193. .B kuang
  1194. will list every uid that can access the goal.  This provides a more
  1195. complete picture of the state of security - you might deem it a
  1196. problem if several users can become root, even if u.other cannot.  
  1197. With the
  1198. .B \-k
  1199. option, it reads users that are known to be compromised (guessed
  1200. password, writeable startup files, or whatever) into a file, like:
  1201. X
  1202. u 216
  1203. u romig
  1204. df
  1205. g staff
  1206. X
  1207. and so on.  Then start kuang as "kuang -k known".  If you omit the u
  1208. or g, it defaults to uid.  You can give names or IDs for uids and
  1209. groups.  You can also list files.  This gets put on a list that is 
  1210. used to decide whether a plan is successful or not.  If a plan 
  1211. reaches an step that is in the known list, it succeeds.
  1212. X
  1213. One might adopt the view that each uid should only be accessible by
  1214. itself and root, and that each gid should be accessible only by the
  1215. members of that group and root.  One can then compare the expected
  1216. access list for a given uid or gid against the 
  1217. .B kuang
  1218. generated list to find security problems that 
  1219. .B kuang
  1220. wouldn't ordinarily tell you about.
  1221. X
  1222. The goals that 
  1223. .B kuang
  1224. use seem cryptic, but are really pretty straightforward.  Each goal
  1225. consists of a list of <action> <object> pairs.  Typical actions are
  1226. user, group, write and replace.  Typical objects are user names,
  1227. group names and file names.  The goal
  1228. "user root" (or u.root) means to have access to the root UID (0), or
  1229. in other words, to be able to run any program using that uid.  
  1230. Similarly,
  1231. "group staff" (or g.staff) means to have access to group staff.
  1232. The long goal
  1233. "user bill  group graphics replace /n/shoe/0/fred replace
  1234. /n/shoe/0/fred/.profile user fred group staff" means become
  1235. user bill, get access to the graphics group, replace the file
  1236. /n/shoe/0/fred, replace /n/shoe/0/fred/.profile, become fred,
  1237. grant access to the staff group.  The problem that allows this to
  1238. happen is that the /n/shoe/0 directory is writeable by the graphics
  1239. group, meaning that anyone in that group can replace the .profile file
  1240. for the fred user and gain access to that account and the groups it
  1241. belongs to when fred next logs in.  Ooops.
  1242. X
  1243. To do a thorough job, 
  1244. .B kuang 
  1245. really needs to be able to access all of
  1246. the controlling files of all users.  In some environments, home
  1247. directories are located in NFS mounted file systems where the client
  1248. doesn't have root access.  
  1249. X
  1250. The problem is that some home directories may be
  1251. protected so that group foo can read/write them, but OTHER can't.
  1252. .B kuang 
  1253. running as some user not in group foo won't be able to read or
  1254. search the directory, creating a blind spot that may hide security
  1255. problems (for example, if group foo can write that user's .login and
  1256. gain access to some other important priv...)  Running 
  1257. .B kuang
  1258. as root
  1259. won't help unless we are running on the server that exports that
  1260. file system, since root==nobody through NFS here.  Of course, then
  1261. you'll find other blind spots on other servers, meaning that you'll
  1262. never be able to see a complete picture of how things are from any
  1263. spot on the net.  Running 
  1264. .B kuang
  1265. on every machine might not even
  1266. help, since the blind spots might prevent them from seeing viable
  1267. paths to Success on any of the machines.  Sigh.
  1268. X
  1269. Soooo we've added a 
  1270. .B -f 
  1271. option that causes 
  1272. .B kuang 
  1273. to preload owner, group and mode information for a list of files.
  1274. Each line of the file should be of the form "type uid gid mode name".
  1275. .B type
  1276. is ignored by 
  1277. .B kuang.
  1278. .B uid 
  1279. and 
  1280. .B gid
  1281. are the user and group ID numbers, in decimal.
  1282. .B mode
  1283. is the permissions for the file, in octal.  And 
  1284. .B name
  1285. is the name of the file.  We've also added a program called
  1286. .B get-cf
  1287. that can be run as root on a server to create a file of the above form
  1288. for the control files for the user's with home directories on that
  1289. server.  Then you can run 
  1290. .B get-cf 
  1291. on every server as root, concatenate all the data together, and
  1292. preload it into Perl.  This will fix the shadow problems mentioned
  1293. above and should also speed things up since you won't need to do all
  1294. the file system references.
  1295. .B kuang -f file
  1296. will use a DBM database in place of a text file if file.dir exists.
  1297. X
  1298. .B Kuang
  1299. needs to read the entire password and group databases before it
  1300. starts, so that it has a complete idea of what users are in what groups
  1301. and so on.  This can be somewhat slow on systems using YP, since by
  1302. default 
  1303. .B kuang
  1304. uses the getpwent and getgrent routines to get the information (which
  1305. is tedious on a YP client).  
  1306. The 
  1307. .B -P
  1308. and 
  1309. .B -G
  1310. options cause 
  1311. .B kuang
  1312. to read /etc/passwd (/etc/group) and to use ypcat to read the rest of
  1313. the passwd (group) YP maps, which can be much faster.  In addition, 
  1314. the 
  1315. .B -p 
  1316. and 
  1317. .B -g 
  1318. options cause 
  1319. .B kuang 
  1320. to read the named files instead of /etc/passwd.
  1321. X
  1322. .SH "SEE ALSO"
  1323. "Rule Based Analysis of Computer Security", Robert W. Baldwin, MIT,
  1324. June 1987.
  1325. X
  1326. The README file that comes with 
  1327. .B kuang
  1328. describes many of the design considerations, problems and future
  1329. plans.
  1330. X
  1331. .SH NOTES
  1332. .LP
  1333. This version of 
  1334. .B kuang
  1335. is based on the shell script versions that Dan Farmer included with
  1336. the 
  1337. .B COPS 
  1338. security package, which in turn were based on code written by  Robert
  1339. Baldwin himself.
  1340. X
  1341. You should read the other documentation that should come with this
  1342. version and modify the rules in 
  1343. .B kuang
  1344. to suite your site.
  1345. X
  1346. .SH BUGS
  1347. .LP
  1348. Probably many.
  1349. X
  1350. The 
  1351. .B -P
  1352. and 
  1353. .B -G 
  1354. options don't work right if you use +@ constructions with YP.  They do
  1355. work right if you use a simple "+:" entry, however.
  1356. X
  1357. SHAR_EOF
  1358. chmod 0600 beta/kuang.1 ||
  1359. echo 'restore of beta/kuang.1 failed'
  1360. Wc_c="`wc -c < 'beta/kuang.1'`"
  1361. test 7253 -eq "$Wc_c" ||
  1362.     echo 'beta/kuang.1: original size 7253, current size' "$Wc_c"
  1363. rm -f _shar_wnt_.tmp
  1364. fi
  1365. # ============= beta/misc.chk ==============
  1366. if test -f 'beta/misc.chk' -a X"$1" != X"-c"; then
  1367.     echo 'x - skipping beta/misc.chk (File already exists)'
  1368.     rm -f _shar_wnt_.tmp
  1369. else
  1370. > _shar_wnt_.tmp
  1371. echo 'x - extracting beta/misc.chk (Text)'
  1372. sed 's/^X//' << 'SHAR_EOF' > 'beta/misc.chk' &&
  1373. #!/bin/sh -- need to mention perl here to avoid recursion
  1374. 'true' || eval 'exec perl -S $0 $argv:q';
  1375. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
  1376. & eval 'exec /usr/bin/perl -S $0 $argv:q'
  1377. X        if 0;
  1378. X
  1379. #
  1380. #  Usage: misc.chk.pl [-d]
  1381. #
  1382. # composer@chem.bu.edu
  1383. # based on original shell script
  1384. #
  1385. #  This shell script checks a variety of miscellaneous potential
  1386. # security problems that really don't belong anywhere else.
  1387. #
  1388. #  Right now this looks for to see if tftp & rexd are enabled,
  1389. # to check if the uudecode alias is in the mail alias file and
  1390. # not commented out, and if uudecode can create a SUID file.
  1391. #
  1392. #  Mechanism:  tftp.chk will try to get /etc/motd from the localhost.
  1393. # Not much too it; just connect and try to get it.  For rexd, just
  1394. # look in the /etc/inetd.conf file to see if it's enabled (e.g., not
  1395. # commented out).
  1396. #
  1397. #  Warning:  it may take a minute or so to complete the test, since tftp
  1398. # might take a while to get the test file, or it may take a while to time
  1399. # out the connection (which is what usually happens if the test fails.)
  1400. X
  1401. package main;
  1402. require 'chk_strings.pl';
  1403. require 'fgrep.pl';
  1404. require 'hostname.pl';
  1405. X
  1406. if ($ARGV[0] eq '-d') {
  1407. X    #$chk_strings'debug = 1;  # verbose debugging
  1408. X    $misc_chk'debug = 1;
  1409. X    shift;
  1410. }
  1411. X
  1412. die "Usage: $0 [-d]\n" if @ARGV > 0;
  1413. X
  1414. X
  1415. $TFTP="/usr/ucb/tftp" unless defined $TFTP;
  1416. $UUDECODE="/usr/bin/uudecode" unless defined $UUDECODE; 
  1417. X
  1418. package misc_chk;
  1419. X
  1420. # look for uudecode alias in $aliases
  1421. #$aliases="/usr/lib/aliases" if -f "/usr/lib/aliases";
  1422. $aliases = ( -f '/usr/lib/aliases' && '/usr/lib/aliases' )
  1423. X    || ( -f '/etc/aliases'       && '/etc/aliases' )
  1424. X    || 'BOGUS';
  1425. $uu="decode";
  1426. X
  1427. # look for rexd in $inetd; this file could be "/etc/servers", too!
  1428. if (!defined($inetd)) {
  1429. X    $inetd = ( -f '/etc/inetd.conf' && '/etc/inetd.conf') ||
  1430. X         ( -f '/etc/servers' && '/etc/servers') ||
  1431. X         'BOGUS';
  1432. X    }
  1433. $rexd="rexecd";
  1434. X
  1435. # tmp and target file (for tftp test)
  1436. $target="/etc/motd";
  1437. $tmp="./tmp.$$";
  1438. X
  1439. # should probably generalize routine for chking for pats in file at some point
  1440. X
  1441. #  Read from $inetd to see if daemons are running.
  1442. # Comments are lines starting with a "#", so ignore.
  1443. # Checking for rexd:
  1444. #
  1445. print "Checking for $rexd in $inetd\n" if $debug;
  1446. if (@matches = grep(!/^\s*#/, &'fgrep($inetd, $rexd))) {
  1447. X    print "Warning!  $rexd is enabled in $inetd!\n";
  1448. }
  1449. X
  1450. # Check to see if anything started inetd.conf is writable;
  1451. print "Checking for writable dirs in $inetd\n" if $debug;
  1452. &'chk_strings($inetd);
  1453. X
  1454. # Checking for uudecode alias:
  1455. print "Checking for $uu alias in $aliases\n" if $debug;
  1456. print "Warning!  $uu is enabled in $aliases!\n"
  1457. X    if &'fgrep($aliases, "^\s*$uu:");
  1458. X
  1459. # uucode stuff -- thanks to pete shipley...
  1460. print "Checking uudecode out\n" if $debug;
  1461. if (-x $'UUDECODE) {
  1462. X    open(UU, "| $'UUDECODE");
  1463. X    print UU <<EOD_;
  1464. begin 4755 ./foobar.$$
  1465. X 
  1466. end
  1467. EOD_
  1468. X    close(UU);
  1469. }
  1470. X
  1471. &'is_able($'UUDECODE,'s','s');    # check if uudecode is SUID
  1472. $is_able'silent = 1;
  1473. print "Warning!  $'UUDECODE creates setuid files!\n"
  1474. X   if &'is_able("./foobar.$$",'s','s');
  1475. $is_able'silent = 0;
  1476. unlink("./foobar.$$");
  1477. X
  1478. #  The rest is all for tftp stuff:
  1479. #
  1480. #   Get the local hostname...
  1481. $hostname = &'hostname;
  1482. X
  1483. #   Do the dirty work -- check tftp for the localhost, if it was found;
  1484. # this might take a bit, since tftp might have to time out.
  1485. X
  1486. print "Checking out tftp on $hostname\n" if $debug;
  1487. if (-x $'TFTP) {
  1488. X    open(SAVOUT, ">&STDOUT");    # suppress file not found
  1489. X    open(SAVERR, ">&STDERR");    # it's not as bad as it looks..
  1490. X    open(STDOUT, ">/dev/null") || die "Can't redirect stdout: $!\n";
  1491. X    open(STDERR, ">&STDOUT") || die "Can't dup stdout: $!\n";
  1492. X    close(STDOUT); close(STDERR);
  1493. X    open(TFTP, "| $'TFTP");
  1494. print TFTP <<_XXX_;
  1495. connect $hostname
  1496. get $target $tmp
  1497. quit
  1498. _XXX_
  1499. X    close(TFTP);
  1500. X    open(STDERR, ">&SAVERR"); close(SAVERR);
  1501. X    open(STDOUT, ">&SAVOUT"); close(SAVOUT);
  1502. } # > /dev/null 2> /dev/null
  1503. X
  1504. print "Warning!  tftp is enabled on $hostname!\n" if -s $tmp;
  1505. unlink $tmp;
  1506. X
  1507. # end of script
  1508. X
  1509. 1;
  1510. SHAR_EOF
  1511. chmod 0700 beta/misc.chk ||
  1512. echo 'restore of beta/misc.chk failed'
  1513. Wc_c="`wc -c < 'beta/misc.chk'`"
  1514. test 3967 -eq "$Wc_c" ||
  1515.     echo 'beta/misc.chk: original size 3967, current size' "$Wc_c"
  1516. rm -f _shar_wnt_.tmp
  1517. fi
  1518. # ============= beta/pass.cache.pl ==============
  1519. if test -f 'beta/pass.cache.pl' -a X"$1" != X"-c"; then
  1520.     echo 'x - skipping beta/pass.cache.pl (File already exists)'
  1521.     rm -f _shar_wnt_.tmp
  1522. else
  1523. > _shar_wnt_.tmp
  1524. echo 'x - extracting beta/pass.cache.pl (Text)'
  1525. sed 's/^X//' << 'SHAR_EOF' > 'beta/pass.cache.pl' &&
  1526. #
  1527. #   Routines for reading and caching user and group information.  These
  1528. # are used in multiple programs... it caches the info once, then hopefully
  1529. # won't be used again.
  1530. #
  1531. #  Steve Romig, May 1991.
  1532. #
  1533. # Provides a bunch of routines and a bunch of arrays.  Routines 
  1534. # (and their usage):
  1535. #
  1536. #    load_passwd_info($use_getent, $file_name)
  1537. #
  1538. #    loads user information into the %uname* and %uid* arrays 
  1539. #    (see below).  
  1540. #
  1541. #    If $use_getent is non-zero:
  1542. #        get the info via repeated 'getpwent' calls.  This can be
  1543. #        *slow* on some hosts, especially if they are running as a
  1544. #        YP (NIS) client.
  1545. #    If $use_getent is 0:
  1546. #        if $file_name is "", then get the info from reading the 
  1547. #        results of "ypcat passwd" and from /etc/passwd.  Otherwise, 
  1548. #        read the named file.  The file should be in passwd(5) 
  1549. #        format.
  1550. #
  1551. #    load_group_info($use_gentent, $file_name)
  1552. #
  1553. #    is similar to load_passwd_info.
  1554. #
  1555. # Information is stored in several convenient associative arrays:
  1556. #
  1557. #   %uname2shell    Assoc array, indexed by user name, value is 
  1558. #            shell for that user name.
  1559. #
  1560. #   %uname2dir        Assoc array, indexed by user name, value is
  1561. #            home directory for that user name.
  1562. #
  1563. #   %uname2uid        Assoc array, indexed by name, value is uid for 
  1564. #            that uid.
  1565. #            
  1566. #   %uname2passwd    Assoc array, indexed by name, value is password
  1567. #            for that user name.
  1568. #
  1569. #   %uid2names        Assoc array, indexed by uid, value is list of
  1570. #            user names with that uid, in form "name name
  1571. #            name...". 
  1572. #
  1573. #   %gid2members    Assoc array, indexed by gid, value is list of
  1574. #            group members in form "name name name..."
  1575. #
  1576. #   %gname2gid        Assoc array, indexed by group name, value is
  1577. #            matching gid.
  1578. #
  1579. #   %gid2names        Assoc array, indexed by gid, value is the
  1580. #            list of group names with that gid in form 
  1581. #            "name name name...".
  1582. #
  1583. # You can also use routines named the same as the arrays - pass the index 
  1584. # as the arg, get back the value.  If you use this, get{gr|pw}{uid|gid|nam} 
  1585. # will be used to lookup entries that aren't found in the cache.
  1586. #
  1587. # To be done:
  1588. #    probably ought to add routines to deal with full names.
  1589. #    maybe there ought to be some anal-retentive checking of password 
  1590. #    and group entries.
  1591. #    probably ought to cache get{pw|gr}{nam|uid|gid} lookups also.
  1592. #    probably ought to avoid overwriting existing entries (eg, duplicate 
  1593. #       names in password file would collide in the tables that are 
  1594. #    indexed by name).
  1595. #
  1596. # Disclaimer:
  1597. #    If you use YP and you use netgroup entries such as 
  1598. #    +@servers::::::
  1599. #    +:*:::::/usr/local/utils/messages
  1600. #    then loading the password file in with &load_passwd_info(0) will get 
  1601. #    you mostly correct YP stuff *except* that it won't do the password and 
  1602. #    shell substitutions as you'd expect.  You might want to use 
  1603. #    &load_passwd_info(1) instead to use getpwent calls to do the lookups, 
  1604. #    which would be more correct.
  1605. #
  1606. X
  1607. package main;
  1608. X
  1609. $PASSWD = '/etc/passwd' unless defined $PASSWD;
  1610. X
  1611. require 'pathconf.pl';
  1612. X
  1613. %uname2shell = ();
  1614. %uname2dir = ();
  1615. %uname2uid = ();
  1616. %uname2passwd = ();
  1617. %uid2names = ();
  1618. %gid2members = ();
  1619. %gname2gid = ();
  1620. %gid2names = ();
  1621. X
  1622. $DOMAINNAME = "/bin/domainname" unless defined $DOMAINNAME;
  1623. $YPCAT = "/bin/ypcat" unless defined $YPCAT;
  1624. X
  1625. $yptmp = "./yptmp.$$";
  1626. X
  1627. $passwd_loaded = 0;        # flags to use to avoid reloading everything
  1628. $group_loaded = 0;        # unnecessarily...
  1629. X
  1630. #
  1631. # We provide routines for getting values from the data structures as well.
  1632. # These are named after the data structures they cache their data in.  Note 
  1633. # that they will all generate password and group file lookups via getpw* 
  1634. # and getgr* if they can't find info in the cache, so they will work
  1635. # "right" even if load_passwd_info and load_group_info aren't called to 
  1636. # preload the caches.
  1637. #
  1638. # I should point out, however, that if you don't call load_*_info to preload
  1639. # the cache, uid2names, gid2names and gid2members *will not* be complete, since 
  1640. # you must read the entire password and group files to get a complete picture.
  1641. # This might be acceptable in some cases, so you can skip the load_*_info
  1642. # calls if you know what you are doing...
  1643. #
  1644. sub uname2shell {
  1645. X    local($key) = @_;
  1646. X
  1647. X    if (! defined($uname2shell{$key})) {
  1648. X    &add_pw_info(getpwnam($key));
  1649. X    }
  1650. X
  1651. X    return($uname2shell{$key});
  1652. }
  1653. X
  1654. sub uname2dir {
  1655. X    local($key) = @_;
  1656. X    local(@pw_info);
  1657. X
  1658. X    if (! defined($uname2dir{$key})) {
  1659. X    &add_pw_info(getpwnam($key));
  1660. X    }
  1661. X
  1662. X    return($uname2dir{$key});
  1663. }
  1664. X
  1665. sub uname2uid {
  1666. X    local($key) = @_;
  1667. X    local(@pw_info);
  1668. X
  1669. X    if (! defined($uname2uid{$key})) {
  1670. X    &add_pw_info(getpwnam($key));
  1671. X    }
  1672. X
  1673. X    return($uname2uid{$key});
  1674. }
  1675. X
  1676. sub uname2passwd {
  1677. X    local($key) = @_;
  1678. X    local(@pw_info);
  1679. X
  1680. X    if (! defined($uname2passwd{$key})) {
  1681. X    &add_pw_info(getpwnam($key));
  1682. X    }
  1683. X
  1684. X    return($uname2passwd{$key});
  1685. }
  1686. X
  1687. sub uid2names {
  1688. X    local($key) = @_;
  1689. X    local(@pw_info);
  1690. X
  1691. X    if (! defined($uid2names{$key})) {
  1692. X    &add_pw_info(getpwuid($key));
  1693. X    }
  1694. X
  1695. X    return($uid2names{$key});
  1696. }
  1697. X
  1698. sub gid2members {
  1699. X    local($key) = @_;
  1700. X    local(@gr_info);
  1701. X
  1702. X    if (! defined($gid2members{$key})) {
  1703. X    &add_gr_info(getgrgid($key));
  1704. X    }
  1705. X
  1706. X    return($gid2members{$key});
  1707. }
  1708. X
  1709. sub gname2gid {
  1710. X    local($key) = @_;
  1711. X    local(@gr_info);
  1712. X
  1713. X    if (! defined($gname2gid{$key})) {
  1714. X    &add_gr_info(getgrnam($key));
  1715. X    }
  1716. X
  1717. X    return($gname2gid{$key});
  1718. }
  1719. X
  1720. sub gid2names {
  1721. X    local($key) = @_;
  1722. X    local(@gr_info);
  1723. X
  1724. X    if (! defined($gid2names{$key})) {
  1725. X    &add_gr_info(getgrgid($key));
  1726. X    }
  1727. X
  1728. X    return($gid2names{$key});
  1729. }
  1730. X
  1731. #
  1732. # Update user information for the user named $name.  We cache the password, 
  1733. # uid, login group, home directory and shell.
  1734. #
  1735. X
  1736. sub add_pw_info {
  1737. X    local($name, $passwd, $uid, $gid) = @_;
  1738. X    local($dir, $shell);
  1739. X
  1740. #
  1741. # Ugh!  argh...yech...sigh.  If we use getpwent, we get back 9 elts, 
  1742. # if we parse /etc/passwd directly we get 7.  Pick off the last 2 and 
  1743. # assume that they are the $directory and $shell.  
  1744. #
  1745. X    $num = ( $#_ >= 7 ? 8 : 6 );
  1746. X    $dir = $_[$num - 1];
  1747. X    $shell = $_[$num] || '/bin/sh';
  1748. X
  1749. X
  1750. X    if ($name ne "") {
  1751. X    $uname2shell{$name} = $shell;
  1752. X    $uname2dir{$name} = $dir;
  1753. X    $uname2uid{$name} = $uid;
  1754. X    $uname2passwd{$name} = $passwd;
  1755. X
  1756. X    if ($gid ne "") {
  1757. X        # fixme: should probably check for duplicates...sigh
  1758. X
  1759. X        if (defined($gid2members{$gid})) {
  1760. X        $gid2members{$gid} .= " $name";
  1761. X        } else {
  1762. X        $gid2members{$gid} = $name;
  1763. X        }
  1764. X    }
  1765. X
  1766. X    if ($uid ne "") {
  1767. X        if (defined($uid2names{$uid})) {
  1768. X        $uid2names{$uid} .= " $name";
  1769. X        } else {
  1770. X        $uid2names{$uid} = $name;
  1771. X        }
  1772. X    }
  1773. X    }
  1774. }
  1775. X
  1776. #
  1777. # Update group information for the group named $name.  We cache the gid 
  1778. # and the list of group members.
  1779. #
  1780. X
  1781. sub add_gr_info {
  1782. X    local($name, $passwd, $gid, $members) = @_;
  1783. X
  1784. X    if ($name ne "") {
  1785. X    $gname2gid{$name} = $gid;
  1786. X
  1787. X    if ($gid ne "") {
  1788. X        if (defined($gid2names{$gid})) {
  1789. X        $gid2names{$gid} .= " $name";
  1790. X        } else {
  1791. X        $gid2names{$gid} = $name;
  1792. X        }
  1793. X
  1794. X        # fixme: should probably check for duplicates
  1795. X
  1796. X        $members = join(' ', split(/[, \t]+/, $members));
  1797. X
  1798. X        if (defined($gid2members{$gid})) {
  1799. X        $gid2members{$gid} .= " " . $members;
  1800. X        } else {
  1801. X        $gid2members{$gid} = $members;
  1802. X        }
  1803. X    }
  1804. X    }
  1805. }
  1806. X
  1807. #
  1808. # We need to suck in the entire group and password files so that we can 
  1809. # make the %uid2names, %gid2members and %gid2names lists complete.  Otherwise,
  1810. # we would just read the entries as needed with getpw* and cache the results.
  1811. # Sigh.
  1812. #
  1813. # There are several ways that we might find the info.  If $use_getent is 1, 
  1814. # then we just use getpwent and getgrent calls to read the info in.
  1815. #
  1816. # That isn't real efficient if you are using YP (especially on a YP client), so
  1817. # if $use_getent is 0, we can use ypcat to get a copy of the passwd and
  1818. # group maps in a fairly efficient manner.  If we do this we have to also read
  1819. # the local /etc/{passwd,group} files to complete our information.  If we aren't 
  1820. # using YP, we just read the local pasword and group files.
  1821. #
  1822. sub load_passwd_info {
  1823. X    local($use_getent, $file_name) = @_;
  1824. X    local(@pw_info);
  1825. X
  1826. X    if ($passwd_loaded) {
  1827. X    return;
  1828. X    }
  1829. X
  1830. X    $passwd_loaded = 1;
  1831. X
  1832. X    if ($'GET_PASSWD) {
  1833. X    open(GFILE, "$'GET_PASSWD|") || die "can't $'GET_PASSWD";
  1834. X    while (<GFILE>) {
  1835. X        chop;
  1836. X        &add_pw_info(split(/:/));
  1837. X        }
  1838. X    close(GFILE);
  1839. X    }
  1840. X    else {
  1841. X
  1842. X    if ($use_getent) {
  1843. X    #
  1844. X    # Use getpwent to get the info from the system, and add_pw_info to 
  1845. X    # cache it.
  1846. X    #
  1847. X    while (@pw_info = getpwent) {
  1848. X        &add_pw_info(@pw_info);
  1849. X    }
  1850. X
  1851. X    endpwent;
  1852. X
  1853. X    return;
  1854. X    } elsif ($file_name eq "") {
  1855. X    chop($has_yp = `$DOMAINNAME`);
  1856. X    if ($has_yp) {
  1857. X        #
  1858. X        # If we have YP (NIS), then use ypcat to get the stuff from the 
  1859. X        # map.@
  1860. X        #
  1861. X        system("$YPCAT passwd > $yptmp 2> /dev/null");
  1862. X        if (-s $yptmp) {
  1863. X            open(FILE, "$YPCAT passwd|") ||
  1864. X              die "can't 'ypcat passwd'";
  1865. X            while (<FILE>) {
  1866. X            chop;
  1867. X            &add_pw_info(split(/:/));
  1868. X                }
  1869. X            }
  1870. X        close(FILE);
  1871. X    }
  1872. X
  1873. X    #
  1874. X    # We have to read /etc/passwd no matter what...
  1875. X    #
  1876. X    $file_name = "/etc/passwd";
  1877. X    }
  1878. X
  1879. X    open(FILE, $file_name) ||
  1880. X      die "can't open $file_name";
  1881. X
  1882. X    while (<FILE>) {
  1883. X    chop;
  1884. X        
  1885. X    if ($_ !~ /^\+/) {
  1886. X        &add_pw_info(split(/:/));
  1887. X    }
  1888. X
  1889. X    # fixme: if the name matches +@name, then this is a wierd 
  1890. X    # netgroup thing, and we aren't dealing with it right.  might want
  1891. X    # to warn the poor user...suggest that he use the use_getent 
  1892. X    # method instead.
  1893. X    }
  1894. X    }
  1895. X
  1896. X    close(FILE);
  1897. }
  1898. X
  1899. sub load_group_info {
  1900. X    local($use_getent, $file_name) = @_;
  1901. X    local(@gr_info);
  1902. X
  1903. X    if ($group_loaded) {
  1904. X    return;
  1905. X    }
  1906. X
  1907. X    $group_loaded = 1;
  1908. X
  1909. X    if ($use_getent) {
  1910. X    #
  1911. X    # Use getgrent to get the info from the system, and add_gr_info to 
  1912. X    # cache it.
  1913. X    #
  1914. X    while ((@gr_info = getgrent()) != 0) {
  1915. X        &add_gr_info(@gr_info);
  1916. X    }
  1917. X
  1918. X    endgrent();
  1919. X
  1920. X    return();
  1921. X    } elsif ($file_name eq "") {
  1922. X    chop($has_yp = `$DOMAINNAME`);
  1923. X    if ($has_yp) {
  1924. X        #
  1925. X        # If we have YP (NIS), then use ypcat to get the stuff from the 
  1926. X        # map.
  1927. X        #
  1928. X        system("$YPCAT passwd > $yptmp 2> /dev/null");
  1929. X        if (-s $yptmp) {
  1930. X            open(FILE, "$YPCAT group|") ||
  1931. X              die "can't 'ypcat group'";
  1932. X            while (<FILE>) {
  1933. X            chop;
  1934. X            &add_gr_info(split(/:/));
  1935. X                }
  1936. X            close(FILE);
  1937. X        }
  1938. X    }
  1939. X
  1940. X    #
  1941. X    # We have to read /etc/group no matter what...
  1942. X    #
  1943. X    $file_name = "/etc/group";
  1944. X    }
  1945. X
  1946. X    open(FILE, $file_name) ||
  1947. X      die "can't open $file_name";
  1948. X
  1949. X    while (<FILE>) {
  1950. X    chop;
  1951. X    if ($_ !~ /^\+/) {
  1952. X        &add_gr_info(split(/:/));
  1953. X    }
  1954. X
  1955. X    # fixme: if the name matches +@name, then this is a wierd 
  1956. X    # netgroup thing, and we aren't dealing with it right.  might want
  1957. X    # to warn the poor user...suggest that he use the use_getent 
  1958. X    # method instead.
  1959. X    }
  1960. X
  1961. X    close(FILE);
  1962. }
  1963. X
  1964. # Load the password stuff -- Do NOT take this out!
  1965. &'load_passwd_info(0,$PASSWD);
  1966. X
  1967. unlink $yptmp;
  1968. X
  1969. 1;
  1970. SHAR_EOF
  1971. chmod 0700 beta/pass.cache.pl ||
  1972. echo 'restore of beta/pass.cache.pl failed'
  1973. Wc_c="`wc -c < 'beta/pass.cache.pl'`"
  1974. test 10640 -eq "$Wc_c" ||
  1975.     echo 'beta/pass.cache.pl: original size 10640, current size' "$Wc_c"
  1976. rm -f _shar_wnt_.tmp
  1977. fi
  1978. # ============= beta/pass.chk ==============
  1979. if test -f 'beta/pass.chk' -a X"$1" != X"-c"; then
  1980.     echo 'x - skipping beta/pass.chk (File already exists)'
  1981.     rm -f _shar_wnt_.tmp
  1982. else
  1983. > _shar_wnt_.tmp
  1984. echo 'x - extracting beta/pass.chk (Text)'
  1985. sed 's/^X//' << 'SHAR_EOF' > 'beta/pass.chk' &&
  1986. #!/bin/sh -- need to mention perl here to avoid recursion
  1987. 'true' || eval 'exec perl -S $0 $argv:q';
  1988. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
  1989. & eval 'exec /usr/local/bin/perl -S $0 $argv:q'
  1990. X        if 0;
  1991. X
  1992. #
  1993. #  Pass.chk -- a password guesser.  Functionally equivalent to the original
  1994. # cops password guesser.  The -P option doesn't work right now (alpha release,
  1995. # don't you know :-), since we're doing funky things with password caching,
  1996. # but this will change soon.
  1997. #
  1998. #  Usage: $0 [options] dictionary
  1999. #
  2000. #    -P pfile    password file (not working)
  2001. #    -p        print found passwords (incompatible with -M)
  2002. #       -d        check prefix/suffix of digits [0-9]
  2003. #       -g        check all words in gcos, plan, project, signature files
  2004. #    -r         reverse the word tests
  2005. #    -s         check all single chars as passwords
  2006. #    -u         output the current user being checked
  2007. #    -U         try uppercase word tests
  2008. #    -v        verbose, print advisory information
  2009. #    -x         check guess+prefix/suffix with strange chars added on
  2010. #    -0 (zero)    change all o's ("oh"'s) to 0 (zeros)
  2011. #    -m         misspell words -- chop off first and last chars,
  2012. #            if > 3 chars.  E.g. "dinner" ==> "inner" and "dinne"
  2013. #
  2014. # Originally written by Tim Tessin with lots more features, etc., etc., etc.
  2015. # I ripped out all of his extra functionality that duplicated some of the
  2016. # other cops stuff, and some things that just didn't fit, and added some
  2017. # code to finish the simulation of the old checker. -- dan
  2018. # 
  2019. X
  2020. require "getopts.pl";
  2021. require "pass.cache.pl";
  2022. $Passwd = "/etc/passwd";
  2023. @strange_things = (" ", ";", ",", ".", "!", "@", "#", "$",
  2024. X                     "%", "^", "&", "*", "(", ")", "-", "_", 
  2025. X                     "=", "+", "[", "]", "{", "}", "'", "\"",
  2026. X                     "|", "`", "~", ">", "<");
  2027. X
  2028. # can probably just do "|| &usage;" since &usage is only used once. ;-)
  2029. &Getopts("p0dgrsuUvlPm") || print STDERR "Usage: $0 -p0xdgrsuUPvm\n";
  2030. X
  2031. # sanity checks
  2032. $opt_P = $Passwd unless $opt_P;
  2033. -r $opt_P || die "Can't read passwd file $opt_P\n";
  2034. X
  2035. # unbuffer output
  2036. select (STDOUT); $| = 1;
  2037. X
  2038. $dups = 0;        # duplicate name entries
  2039. $new = 0;        # new entries
  2040. $changed = 0;        # password (and other data) changed
  2041. $deleted = 0;        # deleted entries
  2042. $updated = 0;        # data other than password changed
  2043. $nlog = 0;        # number of log entries, used for print decisions
  2044. $ntest = 0;
  2045. $ndone = 0;
  2046. X
  2047. for $uid (keys %uname2passwd) {
  2048. X    next if length($pass = $uname2passwd{$uid}) != 13;
  2049. X    next unless $pass; # shall we report null passwd's, too?  ;-)
  2050. X    if ($try = &dopwd()) {
  2051. X        $pwd = ($opt_p) ? $try : "";
  2052. X        # printf "Username: %-8s  <password guessed>  $pwd\n",$P[0];
  2053. X        printf "Warning!  $uid password Problem: Guessed: %s\t\t$pwd\n",$P[0];
  2054. X        }
  2055. X    $ndone++;
  2056. X    }
  2057. X
  2058. 1;
  2059. # end of program
  2060. X
  2061. X
  2062. ######################## Support Subroutines ###########################
  2063. # dopwd tests each password entry against several simple checks and all
  2064. # the words in the dictionaries specified.  The simple checks consists
  2065. # of trying the username as the password ('joe' accounts), words derived
  2066. # from the gecos fields (usually first and last names).
  2067. X
  2068. sub dopwd {
  2069. X    $tries = 0;
  2070. X
  2071. X    print "$uid\n" if ($opt_u);
  2072. X
  2073. X    # try user name
  2074. X    ($try = &testpwd($uid,$pass)) && return $try;
  2075. X    # try uiduid
  2076. X    if (length($uid) < 8) {
  2077. X    ($try = &testpwd($uid . $uid,$pass)) && return $try;
  2078. X    }
  2079. X
  2080. X    # do gcos field?
  2081. X    if ($opt_g) {
  2082. X    @gcos = split(/[.,& -]/,$uname2gcos{$uid});
  2083. X    foreach $i (@gcos) {
  2084. X        next unless $i;        # skip null split values
  2085. X        ($try = &testpwd($i,$pass)) && return $try;
  2086. X    }
  2087. X
  2088. X    # Try names from misc files
  2089. X    #
  2090. X    undef %words;
  2091. X    # files to check
  2092. X    @files2chk = ("/.project", "/.plan", "/.signature");
  2093. X    $home = $uname2dir{$uid};
  2094. X    for $i (@files2chk) {
  2095. X        open (FOOFILE, $home . $i);
  2096. X        while (<FOOFILE>) {
  2097. X        chop;
  2098. X        @line = split(/([.,;\s])/);
  2099. X        for $j (@line) {
  2100. X            $words{$j}=$j unless $j=~/[\s]/;
  2101. X        }
  2102. X        }
  2103. X        close FOOFILE;
  2104. X    }
  2105. X    for $k (values %words) {
  2106. X        # print "word $k\n";
  2107. X        ($try = &testpwd($k,$pass)) && return $try;
  2108. X    }
  2109. X    }
  2110. X
  2111. # do dictionaries
  2112. # save state of upper/reverse so individual dicts can temporarily
  2113. # override.
  2114. foreach $i (@ARGV) {
  2115. X    if (open (DICT,$i)) {
  2116. X        while (<DICT>) {
  2117. X            chop;
  2118. X            if ($try = &testpwd($_,$pass)) {
  2119. X                close DICT;
  2120. X                return $try;
  2121. X                }
  2122. X            }
  2123. X        close DICT;
  2124. X        }
  2125. X    }
  2126. return 0;
  2127. }
  2128. X
  2129. X
  2130. # small subroutines to help the main password cracker.  All are labeled
  2131. # p_xxx, where xxx is the identifying name.
  2132. #
  2133. X
  2134. # if leading character is upper-case, also try lower case version
  2135. sub p_lc {
  2136. X    local($try) = @_;
  2137. X    local($ntry);
  2138. X    if ( $try =~ /^[A-Z]/ ) {
  2139. X    ($ntry = $try) =~ y/A-Z/a-z/;
  2140. X    push(@total_guesses, $ntry);
  2141. X    }
  2142. }
  2143. X
  2144. # reverse check
  2145. sub p_rev {
  2146. X    local($try) = @_;
  2147. X    local($ntry);
  2148. X    $ntry = reverse $try;
  2149. X    if ($ntry ne $try) {
  2150. X    push(@total_guesses, $ntry);
  2151. X    }
  2152. }
  2153. X
  2154. # uppercase check
  2155. sub p_up {
  2156. X    local($try) = @_;
  2157. X    local($ntry);
  2158. X    ($ntry = $try) =~ y/a-z/A-Z/;
  2159. X    if ($ntry ne $try) { push(@total_guesses, $ntry); }
  2160. }
  2161. X
  2162. # testpwd checks a word to see if it matches the encrpted password
  2163. # if the word is capitalized, the lowercase version is tried as well
  2164. X
  2165. sub testpwd {
  2166. local ($try,$pass) = @_;
  2167. local (@total_guesses);
  2168. X
  2169. push(@total_guesses, $try);
  2170. X
  2171. # free (lower case) check if first letter is uppercase
  2172. &p_lc($try);
  2173. # reverse?
  2174. if ($opt_r) { &p_rev($try); }
  2175. # uppercase?
  2176. if ($opt_U) { &p_up($try); }
  2177. X
  2178. # single digit tacked on to beginning and end
  2179. if ($opt_d) {
  2180. X    if (length ($try) < 8) {
  2181. X        foreach $i ('0'..'9') {
  2182. X            $ntry = $i.$try;
  2183. X            push(@total_guesses, $ntry);
  2184. X            if ($opt_r) { &p_rev($ntry); }
  2185. X            if ($opt_U) { &p_up($ntry); }
  2186. X            }
  2187. X        foreach $i ('0'..'9') {
  2188. X            $ntry = $try.$i;
  2189. X            push(@total_guesses, $ntry);
  2190. X            if ($opt_r) { &p_rev($ntry); }
  2191. X            if ($opt_U) { &p_up($ntry); }
  2192. X            }
  2193. X        }
  2194. X    }
  2195. X
  2196. # change o's to 0's ("oh"'s to zeros)
  2197. if ($opt_0) {
  2198. X    if (($ntry = $try) =~ s/o/0/g) { push(@total_guesses, $ntry); }
  2199. X    }
  2200. X
  2201. # misspell words -- truncate first and last letter, if > 3 chars
  2202. # thanks to  William Vajk, learn@ddsw1.MCS.COM, who posted this idea.
  2203. if ($opt_m) {
  2204. X    $len = length($try);
  2205. X    if ($len > 3) {
  2206. X        ($ntry = $try) =~ s/^.//; push(@total_guesses, $ntry);
  2207. X        if ($len < 9) {
  2208. X            ($ntry = $try) =~ s/.$//; push(@total_guesses, $ntry);
  2209. X            }
  2210. X        }
  2211. X    }
  2212. X
  2213. # weird things!  Tacked on to beginning and end
  2214. if ($opt_x) {
  2215. X    if (length ($try) < 8) {
  2216. X        foreach $i (@strange_things) {
  2217. X            $ntry = $i.$try;
  2218. X            push(@total_guesses, $ntry);
  2219. X            if ($opt_r) { &p_rev($ntry); }
  2220. X            if ($opt_U) { &p_up($ntry); }
  2221. X            }
  2222. X        foreach $i (@strange_things) {
  2223. X            $ntry = $try.$i;
  2224. X            push(@total_guesses, $ntry);
  2225. X            if ($opt_r) { &p_rev($ntry); }
  2226. X            if ($opt_U) { &p_up($ntry); }
  2227. X            }
  2228. X        }
  2229. X    }
  2230. X
  2231. # do single letters, #'s, if needed
  2232. if ($opt_s && $uid ne $last_user) {
  2233. X    $last_user = $uid;
  2234. X    foreach $i (@strange_things) { push(@total_guesses,$i); }
  2235. X    foreach $i (0..9) { push(@total_guesses, $i); }
  2236. X    foreach $i (A..Z) { push(@total_guesses, $i); }
  2237. X    foreach $i (a..z) { push(@total_guesses, $i); }
  2238. X    }
  2239. X
  2240. foreach $i (@total_guesses) {
  2241. #    print "Trying \"$try\" on $uid\n" if $opt_v;
  2242. X    print "Trying \"$i\" on $uid\n" if $opt_v;
  2243. X    $epw = crypt($try,$pass);
  2244. X    ($epw eq $pass) && return $i;
  2245. X    }
  2246. undef @total_guesses;
  2247. X
  2248. return 0;
  2249. }
  2250. SHAR_EOF
  2251. chmod 0700 beta/pass.chk ||
  2252. echo 'restore of beta/pass.chk failed'
  2253. Wc_c="`wc -c < 'beta/pass.chk'`"
  2254. test 7034 -eq "$Wc_c" ||
  2255.     echo 'beta/pass.chk: original size 7034, current size' "$Wc_c"
  2256. rm -f _shar_wnt_.tmp
  2257. fi
  2258. # ============= beta/passwd ==============
  2259. if test -f 'beta/passwd' -a X"$1" != X"-c"; then
  2260.     echo 'x - skipping beta/passwd (File already exists)'
  2261.     rm -f _shar_wnt_.tmp
  2262. else
  2263. > _shar_wnt_.tmp
  2264. echo 'x - extracting beta/passwd (Text)'
  2265. sed 's/^X//' << 'SHAR_EOF' > 'beta/passwd' &&
  2266. root:/gBRyGosCTKcY:0:1:The root of all evil:/:/bin/csh
  2267. stroot:QXCAyBt4zMwoE:0:1:The root of all evil:/:/bin/csh
  2268. daemon:*:1:1::/:/bin/false
  2269. sys:*:2:2::/:/bin/false
  2270. bin:*:3:3::/bin:/bin/false
  2271. audit:*:9:9::/etc/security/audit:/bin/false
  2272. poepping:85IPml.fmT92o:74:78:Mark Poepping:/usr/users/poepping:/bin/csh
  2273. rlv:*lLHclBvJ6p6Zo:108:20:Randy Vandermolen:/usr/users/rlv:/bin/csh
  2274. georgia:nIVJdSE/TAC6U:113:78:Georgia Killcrece:/usr/users/georgia:/usr/local/bin/tcsh
  2275. SHAR_EOF
  2276. true || echo 'restore of beta/passwd failed'
  2277. fi
  2278. echo 'End of  part 2'
  2279. echo 'File beta/passwd is continued in part 3'
  2280. echo 3 > _shar_seq_.tmp
  2281. exit 0
  2282.