home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3358 < prev    next >
Encoding:
Internet Message Format  |  1991-05-17  |  59.4 KB
  1. From: df@sei.cmu.edu (Dan Farmer)
  2. Newsgroups: alt.sources
  3. Subject: alpha perl-cops, 3 of 3
  4. Message-ID: <25552@as0c.sei.cmu.edu>
  5. Date: 17 May 91 04:47:32 GMT
  6.  
  7. Submitted-by: df@death.cert.sei.cmu.edu
  8. Archive-name: alpha p-cops/part03
  9.  
  10. #!/bin/sh
  11. # this is apcops.03 (part 3 of alpha p-cops)
  12. # do not concatenate these parts, unpack them in order with /bin/sh
  13. # file p-cops.alpha/user.chk continued
  14. #
  15. if test ! -r _shar_seq_.tmp; then
  16.     echo 'Please unpack part 1 first!'
  17.     exit 1
  18. fi
  19. (read Scheck
  20.  if test "$Scheck" != 3; then
  21.     echo Please unpack part "$Scheck" next!
  22.     exit 1
  23.  else
  24.     exit 0
  25.  fi
  26. ) < _shar_seq_.tmp || exit 1
  27. if test ! -f _shar_wnt_.tmp; then
  28.     echo 'x - still skipping p-cops.alpha/user.chk'
  29. else
  30. echo 'x - continuing file p-cops.alpha/user.chk'
  31. sed 's/^X//' << 'SHAR_EOF' >> 'p-cops.alpha/user.chk' &&
  32. # even if invoked as an sh or csh or foosh script.
  33. # notice we don't use full path cause we don't
  34. # know where the user has perl on their system.
  35. #
  36. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  37. & eval 'exec perl -S $0 $argv:q'
  38. X    if $running_under_some_stupid_shell_instead_of_perl;
  39. X
  40. #
  41. # check for writable files in all user's homes
  42. #
  43. require "pass.cache.pl";
  44. require "is_able.pl";
  45. X
  46. # files checked for:
  47. @ftable = ("rhosts", "profile", "login", "logout", "cshrc",
  48. X       "bashrc", "kshrc", "tcshrc", "netrc", "forward", "dbxinit",
  49. X       "distfile", "exrc", "emacsrc", "remote", "mh_profile",
  50. X       "xinitrc", "xsession", "Xdefaults", "Xresources", "rninit");
  51. X
  52. @readables = ("netrc", "rhosts");
  53. X
  54. local(%done);
  55. X
  56. for $i (keys %uname2dir) {
  57. X    $dir = $uname2dir{$i};
  58. X    #   I don't want to hear about every file in their home dir, if 
  59. X    # is WW, but still need to check the .netrc file for readability...
  60. X    next if $done{$dir}++;
  61. X    if (-e $dir) { 
  62. X        if (&is_able($dir, "w", "w")) {
  63. X            for $r (@readables) {
  64. X                if (-s "$dir/.$r") {
  65. X                    &is_able("$dir/.$r", "w", "r");
  66. X        }
  67. X        }
  68. X            next;
  69. X    }
  70. X        for $file (@ftable) {
  71. X            $foo_file = $dir . "/.$file";
  72. X            if (-e $foo_file) {
  73. X                &is_able($foo_file, "w", "w");
  74. X                for $r (@readables) {
  75. X                    if ($file eq $r && -s $foo_file) {
  76. X                        &is_able($foo_file, "w", "r");
  77. X            }
  78. X        }
  79. X        }
  80. X    }
  81. X    }
  82. }
  83. X
  84. 1;
  85. SHAR_EOF
  86. echo 'File p-cops.alpha/user.chk is complete' &&
  87. chmod 0700 p-cops.alpha/user.chk ||
  88. echo 'restore of p-cops.alpha/user.chk failed'
  89. Wc_c="`wc -c < 'p-cops.alpha/user.chk'`"
  90. test 2048 -eq "$Wc_c" ||
  91.     echo 'p-cops.alpha/user.chk: original size 2048, current size' "$Wc_c"
  92. rm -f _shar_wnt_.tmp
  93. fi
  94. # ============= p-cops.alpha/stat.pl ==============
  95. if test -f 'p-cops.alpha/stat.pl' -a X"$1" != X"-c"; then
  96.     echo 'x - skipping p-cops.alpha/stat.pl (File already exists)'
  97.     rm -f _shar_wnt_.tmp
  98. else
  99. > _shar_wnt_.tmp
  100. echo 'x - extracting p-cops.alpha/stat.pl (Text)'
  101. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/stat.pl' &&
  102. ;# $Header: stat.pl,v 3.0.1.1 90/08/09 04:01:34 lwall Locked $
  103. ;# Usage:
  104. ;#    require 'stat.pl';
  105. ;#    @ary = stat(foo);
  106. ;#    $st_dev = @ary[$ST_DEV];
  107. ;#
  108. $ST_DEV =    0 + $[;
  109. $ST_INO =    1 + $[;
  110. $ST_MODE =    2 + $[;
  111. $ST_NLINK =    3 + $[;
  112. $ST_UID =    4 + $[;
  113. $ST_GID =    5 + $[;
  114. $ST_RDEV =    6 + $[;
  115. $ST_SIZE =    7 + $[;
  116. $ST_ATIME =    8 + $[;
  117. $ST_MTIME =    9 + $[;
  118. $ST_CTIME =    10 + $[;
  119. $ST_BLKSIZE =    11 + $[;
  120. $ST_BLOCKS =    12 + $[;
  121. X
  122. ;# Usage:
  123. ;#    require 'stat.pl';
  124. ;#    do Stat('foo');        # sets st_* as a side effect
  125. ;#
  126. sub Stat {
  127. X    ($st_dev,$st_ino,$st_mode,$st_nlink,$st_uid,$st_gid,$st_rdev,$st_size,
  128. X    $st_atime,$st_mtime,$st_ctime,$st_blksize,$st_blocks) = stat(shift(@_));
  129. }
  130. X
  131. 1;
  132. SHAR_EOF
  133. chmod 0700 p-cops.alpha/stat.pl ||
  134. echo 'restore of p-cops.alpha/stat.pl failed'
  135. Wc_c="`wc -c < 'p-cops.alpha/stat.pl'`"
  136. test 653 -eq "$Wc_c" ||
  137.     echo 'p-cops.alpha/stat.pl: original size 653, current size' "$Wc_c"
  138. rm -f _shar_wnt_.tmp
  139. fi
  140. # ============= p-cops.alpha/suckline.pl ==============
  141. if test -f 'p-cops.alpha/suckline.pl' -a X"$1" != X"-c"; then
  142.     echo 'x - skipping p-cops.alpha/suckline.pl (File already exists)'
  143.     rm -f _shar_wnt_.tmp
  144. else
  145. > _shar_wnt_.tmp
  146. echo 'x - extracting p-cops.alpha/suckline.pl (Text)'
  147. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/suckline.pl' &&
  148. #
  149. #  As title implies... :-)
  150. #
  151. sub main'suckline {
  152. X    local($file, $_) = @_;
  153. #   local($package) = caller;
  154. X
  155. #   $file =~ s/^([^']+)$/$package'$1/; 
  156. X    {
  157. X    if (s/\\\n?$//) {
  158. X        $_ .= <$file>;
  159. X        redo;
  160. X    }
  161. X    } 
  162. X    $_;
  163. }
  164. X
  165. 1;
  166. SHAR_EOF
  167. chmod 0700 p-cops.alpha/suckline.pl ||
  168. echo 'restore of p-cops.alpha/suckline.pl failed'
  169. Wc_c="`wc -c < 'p-cops.alpha/suckline.pl'`"
  170. test 229 -eq "$Wc_c" ||
  171.     echo 'p-cops.alpha/suckline.pl: original size 229, current size' "$Wc_c"
  172. rm -f _shar_wnt_.tmp
  173. fi
  174. # ============= p-cops.alpha/suid.chk ==============
  175. if test -f 'p-cops.alpha/suid.chk' -a X"$1" != X"-c"; then
  176.     echo 'x - skipping p-cops.alpha/suid.chk (File already exists)'
  177.     rm -f _shar_wnt_.tmp
  178. else
  179. > _shar_wnt_.tmp
  180. echo 'x - extracting p-cops.alpha/suid.chk (Text)'
  181. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/suid.chk' &&
  182. #!/bin/sh  # need to mention perl here to avoid recursion
  183. #
  184. #  Usage: suid.chk [-n] [-s secure_dir] [search_starting_directory]
  185. #
  186. #   Shell script intended to be run periodically by cron in order
  187. #   to spot changes in files with the suid or sgid bits set.
  188. #
  189. #    suid.chk    840919        Prentiss Riddle
  190. #
  191. #     This changes into the $SECURE directory first, then 
  192. #   uses find(1) to search the directories in $SEARCH for all
  193. #   files with the 4000 or 2000 permission bits set.  $STOP is a file
  194. #   containing "ls -gildsa" output for known setuid or setgid programs.
  195. #   Any additions or changes to this list represent potential security
  196. #   problems, so they are reported.
  197. #
  198. #  Modified 8/15/89, Dan Farmer:
  199. #    Just changed the program/doc names and some of the temp
  200. #  files to make it fit in with the rest of the programs....
  201. #  Modified 12/26/90, df
  202. #       Now flags SUID shell scripts and world writeable SUID files, too.
  203. #
  204. #  Rewritten in perl, 1/17/91, df
  205. #  Major hacks by tchrist 5/14/91
  206. #
  207. # NOTE:
  208. #   If you know where perl is and your system groks #!, put its
  209. # pathname at the top to make this a tad faster.
  210. #
  211. # the following magic is from the perl man page
  212. # and should work to get us to run with perl 
  213. # even if invoked as an sh or csh or foosh script.
  214. # notice we don't use full path cause we don't
  215. # know where the user has perl on their system.
  216. #
  217. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  218. & eval 'exec perl -S $0 $argv:q'
  219. X    if $running_under_some_stupid_shell_instead_of_perl;
  220. X
  221. require "hostname.pl";
  222. require "is_able.pl";
  223. require "file_owner.pl";
  224. require "pathconf.pl";
  225. require "chk_strings.pl";
  226. require "pass.cache.pl";
  227. package suid_chk; # name space protection
  228. $debug=0;
  229. X
  230. #
  231. # Getopts stuff
  232. $usage = "Usage: $0 [-n] [-s secure_dir] [starting_directory]\n";
  233. require 'getopts.pl';
  234. # Process the command args; Either specify verbose or an alternate config file:
  235. die $usage unless &Getopts('ns:');
  236. X
  237. $suid_dir = $'SECURE || '.';
  238. if (defined($opt_s)) { $suid_dir = $opt_s; }
  239. X
  240. # Do NFS stuff?  Yes unless opt:
  241. if (defined($opt_n)) { $skip_nfs = $opt_n; }
  242. else { $skip_nfs = 0; }
  243. X
  244. $STOP="$suid_dir/suid.stop";
  245. $TEMPOLD="$suid_dir/fsold$$";
  246. $TEMPCUR="$suid_dir/fscur$$";
  247. $TEMPNEW="$suid_dir/fsnew$$";
  248. $TEMPGON="$suid_dir/fsgon$$";
  249. $TEMPM="$suid_dir/fsm$$";
  250. X
  251. if (@ARGV > 1) { die $usage; }
  252. elsif (@ARGV == 1) { $start_dir = shift; }
  253. X
  254. # these may be terribly rash assumptions....
  255. $start_dir="/" unless defined $start_dir;
  256. $find_can_ls = 1 unless defined $find_can_ls;
  257. X
  258. $NONFS = '\( -type f -fstype nfs -prune \) -o' if $skip_nfs;  
  259. $find_ls = $find_can_ls ? '-ls' : "-exec $'LS -gilds {} \\;";
  260. X
  261. die "Error -- Security directory $suid_dir doesn't exist\n" unless -d $suid_dir;
  262. unless (-d $suid_dir) {
  263. X    mkdir($suid_dir, 0700) || die "can't mkdir $suid_dir: $!";
  264. X    } 
  265. chdir  $suid_dir || die "can't chdir $suid_dir: $!";
  266. X
  267. # find the setuid programs and sort
  268. &run("$'FIND $start_dir $NONFS -type f \\( -perm -4000 -o -perm -2000 \\) $find_ls | $'SORT > $TEMPCUR");
  269. X
  270. # compare with the sorted stop list
  271. # create stop file if needed
  272. if (! -f $STOP) { open(S,">$STOP"); close(S); }
  273. X
  274. &run("$'SORT <$STOP >$TEMPOLD");
  275. &run("$'COMM -13 $TEMPOLD $TEMPCUR | $'SORT +8 >$TEMPNEW");
  276. &run("$'COMM -23 $TEMPOLD $TEMPCUR | $'SORT +8 >$TEMPGON");
  277. X
  278. local($is_able'silent) = 1;
  279. local($chk_strings'recurse) = 0 unless defined $chk_strings'recurse;
  280. X
  281. # report changes
  282. if (-s $TEMPNEW || -s $TEMPGON) {
  283. X    if (-s $TEMPNEW) {
  284. X    die "Can't open $TEMPNEW: $!" unless open TEMPNEW;
  285. X    while (<TEMPNEW>) {
  286. X        ($file) = /(\S+)$/;
  287. X
  288. X        # don't want SUID files to be world writable!
  289. X        # although *reasonable* systems clear the bit on write
  290. X        print "Warning!  SUID file $file is _World_ writable!\n" 
  291. X        if &'is_able ($file, "w", "w"); 
  292. X            
  293. X        if (-r $file && -f _ && -T $file) {
  294. X        print "Warning!  ", &'Owner($file) ? '' : 'ROOT-owned ', 
  295. X            "SUID file $file is a non-binary, executable file!\n";
  296. X        }
  297. X
  298. X        &'chk_strings($file) if -r _;
  299. X    }
  300. X    close TEMPNEW;
  301. X    }
  302. X
  303. X    if (-s $TEMPNEW) {
  304. X    die "Can't reopen $TEMPNEW: $!" unless open TEMPNEW;
  305. X    print "\nThese files are newly setuid/setgid:\n\n";
  306. X    print while <TEMPNEW>;
  307. X    }
  308. X
  309. X    if (-s $TEMPGON) {
  310. X    die "Can't reopen $TEMPGON: $!" unless open TEMPGON;
  311. X    print "\nThese files are no longer setuid/setgid:\n\n";
  312. X    print while <TEMPGON>;
  313. X    }
  314. X
  315. }
  316. X
  317. unlink $TEMPOLD, $TEMPCUR, $TEMPNEW, $TEMPGON;
  318. X
  319. sub run {
  320. X    print "running: $_[0]\n" if $debug;
  321. X    system $_[0];
  322. X    warn "command $_[0] returned $?" if $?;
  323. } 
  324. X
  325. #  end it all....
  326. X
  327. 1;
  328. SHAR_EOF
  329. chmod 0700 p-cops.alpha/suid.chk ||
  330. echo 'restore of p-cops.alpha/suid.chk failed'
  331. Wc_c="`wc -c < 'p-cops.alpha/suid.chk'`"
  332. test 4477 -eq "$Wc_c" ||
  333.     echo 'p-cops.alpha/suid.chk: original size 4477, current size' "$Wc_c"
  334. rm -f _shar_wnt_.tmp
  335. fi
  336. # ============= p-cops.alpha/root.chk ==============
  337. if test -f 'p-cops.alpha/root.chk' -a X"$1" != X"-c"; then
  338.     echo 'x - skipping p-cops.alpha/root.chk (File already exists)'
  339.     rm -f _shar_wnt_.tmp
  340. else
  341. > _shar_wnt_.tmp
  342. echo 'x - extracting p-cops.alpha/root.chk (Text)'
  343. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/root.chk' &&
  344. #!/bin/sh  # need to mention perl here to avoid recursion
  345. #
  346. #  Usage: root.chk
  347. #
  348. #  This script checks pathnames inside root's startup files for 
  349. # writability, improper umask settings (world writable), non-root
  350. # entries in /.rhosts, writable binaries in root's path,
  351. # and to ensure that root is in /etc/ftpuser.
  352. #
  353. # Also check for a single "+" in /etc/hosts.equiv (world is trusted),
  354. # and that /bin, /etc and certain key files are root owned, so that you
  355. # can't, say, rcp from a host.equived machine and blow over the password
  356. # file... this may or may not be bad, decide for yourself.
  357. # Startup files are /.login /.cshrc /.profile
  358. #
  359. #  Mechanism:  These files contain paths and filenames that are stripped
  360. # out using "grep".  These strings are then processed by the "is_able"
  361. # program to see if they are world writable.  Strings of the form:
  362. #
  363. #    path=(/bin /usr/bin .)
  364. #        and
  365. #    PATH=/bin:/usr/bin:.:
  366. #
  367. # are checked  to ensure that "." is not in the path.  All
  368. # results are echoed to standard output.  In addition, some effort was
  369. # put into parsing out paths with multiple lines; e.g. ending in "\",
  370. # and continuing on the next line.  Also, all executable files and 
  371. # directories in there are checked for writability as well.
  372. #
  373. #  For umask stuff, simply grep for umask in startup files, and check
  374. # umask value.  For /etc/ftpuser, simple grep to check if root is in
  375. # the file.  For /etc/hosts.equiv, just check to see if "+" is alone
  376. # on a line by awking it.
  377. #
  378. #  NOTE:
  379. # if you know where perl is and your system groks #!, put its
  380. # pathname at the top to make this a tad faster.
  381. #
  382. # the following magic is from the perl man page
  383. # and should work to get us to run with perl 
  384. # even if invoked as an sh or csh or foosh script.
  385. # notice we don't use full path cause we don't
  386. # know where the user has perl on their system.
  387. #
  388. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  389. & eval 'exec perl -S $0 $argv:q'
  390. X    if $running_under_some_stupid_shell_instead_of_perl;
  391. X
  392. # rewritten in perl by tchrist@convex.com
  393. # 
  394. X
  395. # root startup/important files
  396. X
  397. require 'file_owner.pl';
  398. require 'fgrep.pl';
  399. require 'suckline.pl';
  400. require 'is_able.pl';
  401. require 'chk_strings.pl';
  402. require 'glob.pl';
  403. X
  404. package root_chk;
  405. X
  406. # use -a true if you care about non-executables
  407. # in root's path
  408. X
  409. $ARGV[0] eq '-a' && ($all_files++, shift);
  410. X
  411. die "usage: root.chk [-a]\n" if @ARGV;
  412. X
  413. $W = 'Warning! ';
  414. X
  415. $cshrc    = '/.cshrc';
  416. $profile= '/.profile';
  417. $rhosts = '/.rhosts';
  418. X
  419. $| = 1;
  420. X
  421. @big_files= ('/.login', '/.cshrc', '/.profile', '/.logout' );
  422. X
  423. # root should own *at least* these, + $big_files; you can check for all files
  424. # in /bin & /etc, or just the directories (the default.)
  425. # root_files="/bin /bin/* /etc /etc/* $big_files $rhosts"
  426. @root_files= ('/bin','/etc',@big_files,$rhosts,'/etc/passwd','/etc/group');
  427. X
  428. # misc important stuff
  429. $ftp='/etc/ftpusers';
  430. $equiv='/etc/hosts.equiv';
  431. X
  432. #   should't have anyone but root owning /bin or /etc files/directories
  433. # In case some of the critical files don't exist (/.rhost), toss away error
  434. # messages
  435. X
  436. if (@bad_files = grep (-e && &'Owner($_), @root_files)) {
  437. X    print "$W  Root does not own the following file(s):\n";
  438. X    print "\t@bad_files\n";
  439. } 
  440. X
  441. local($chk_strings'recurse) = 1 unless defined $chk_strings'recurse;
  442. X
  443. for $file (@big_files) {
  444. X    open file || next;
  445. X
  446. X    &'chk_strings($file);
  447. X
  448. X    # check for group or other writable umask
  449. X    while (<file>) {
  450. X    next if /^\s*#/;
  451. X    next unless /umask\s*(\d+)/;
  452. X    next unless ~oct($1) & 022;
  453. X    print "$W root's umask set to $1 in $file\n";
  454. X    } 
  455. } 
  456. X
  457. print "$W $ftp exists and root is not in it\n" 
  458. X    if -e $ftp && !&'fgrep($ftp,'root');
  459. X
  460. print "$W A \"+\" entry exists in $equiv!\n" if &'fgrep($equiv, '^\+$');
  461. X
  462. if (open rhosts) {
  463. X    while (<rhosts>) {
  464. X    next unless /\S+\s+(\S+)/ && $1 ne 'root';
  465. X    print "$W Non-root entry in $rhosts! $1\n";
  466. X    }
  467. } 
  468. close(rhosts);
  469. X
  470. undef @rootpath;
  471. X
  472. # checking paths...
  473. #
  474. # Get the root paths from $csh.
  475. X
  476. if (open(CSHRC, $cshrc)) {
  477. X    $path = '';
  478. X    while (<CSHRC>) {
  479. X    next if /^\s*#/;
  480. X    chop unless /\\$/;
  481. X    if (/set\s+path\s*=/) {
  482. X        $_ = &'suckline($cshrc, $_);
  483. X        s/.*set\s+path\s*=\s*//;
  484. X        s/\((.*)\)/$1/;
  485. X        s/#.*/./;
  486. X        @tmppath = grep($_ ne '', split(' '));
  487. X        for (@tmppath) { $whence{$_} .= " " . $cshrc; } 
  488. X        push(@rootpath, @tmppath);
  489. X    } 
  490. X    } 
  491. X    close(CSHRC);
  492. } 
  493. X
  494. if (open login) {
  495. X    $path = '';
  496. X    while (<cshrc>) {
  497. X    next if /^\s*#/;
  498. X    chop unless /\\$/;
  499. X    if (/set\s+path\s*=/) {
  500. X        $_ = &'suckline('login', $_);
  501. X        s/.*set\s+path\s*=\s*//;
  502. X        s/\((.*)\)/$1/;
  503. X        s/#.*/./;
  504. X        @tmppath = grep($_ ne '', split(' '));
  505. X        for (@tmppath) { $whence{$_} .= " " . $login; } 
  506. X        push(@rootpath, @tmppath);
  507. X    } 
  508. X    } 
  509. X    close(login);
  510. }
  511. X
  512. if (open profile) {
  513. X    $path = '';
  514. X    while (<profile>) {
  515. X    next if /^\s*#/;
  516. X    chop unless /\\$/;
  517. X    if (/PATH=/) {
  518. X        $_ = &'suckline('profile', $_);
  519. X        s/.*PATH=//;
  520. X        s/#.*//;
  521. X        @tmppath = split(/:/);
  522. X        for (@tmppath) { $whence{$_} .= " " . $profile; } 
  523. X        push(@rootpath, @tmppath);
  524. X    } 
  525. X    } 
  526. X    close(profile);
  527. } 
  528. X
  529. for (keys %whence) {
  530. X    $whence{$_} =~ s/^ //;
  531. X    $whence{$_} =~ s/ / and /g;
  532. } 
  533. X
  534. undef %seen;
  535. grep($seen{$_}++, @rootpath);
  536. X
  537. $is_able'silent = 1;
  538. for (keys %seen) {
  539. X    if (!-e && $_ ne ".") {
  540. X    print "$W path component $_ in $whence{$_} doesn't exist!\n";
  541. X    next;
  542. X    } 
  543. X
  544. X    if (/^\.?$/) {  # null -> dot
  545. X    print "$W \".\" (or current directory) is in root's path in $whence{$_}!\n";
  546. X    } elsif (&'is_writable($_)) {
  547. X    print "$W Directory $_ is _World_ writable and in root's path in $whence{$_}!\n";
  548. X    next;
  549. X    }
  550. X
  551. X    foreach $file (&'glob("$_/*")) {
  552. X    # can't just check -x here, as that depends on current user
  553. X    $is_executable = -f $file && (&'Mode($file) & 0111);
  554. X    if (($all_files || $is_executable) && 
  555. X            ($how = &'is_writable($file, 'w', 'w'))) {
  556. X        print "$W _World_ $how ",
  557. X            $is_executable ? 'executable' : 'file',
  558. X        " $file in root path component $_ from $whence{$_}!\n";
  559. X    } 
  560. X    }
  561. } 
  562. X
  563. $is_able'silent = 0;
  564. X
  565. 1;
  566. SHAR_EOF
  567. chmod 0700 p-cops.alpha/root.chk ||
  568. echo 'restore of p-cops.alpha/root.chk failed'
  569. Wc_c="`wc -c < 'p-cops.alpha/root.chk'`"
  570. test 5959 -eq "$Wc_c" ||
  571.     echo 'p-cops.alpha/root.chk: original size 5959, current size' "$Wc_c"
  572. rm -f _shar_wnt_.tmp
  573. fi
  574. # ============= p-cops.alpha/README.perl ==============
  575. if test -f 'p-cops.alpha/README.perl' -a X"$1" != X"-c"; then
  576.     echo 'x - skipping p-cops.alpha/README.perl (File already exists)'
  577.     rm -f _shar_wnt_.tmp
  578. else
  579. > _shar_wnt_.tmp
  580. echo 'x - extracting p-cops.alpha/README.perl (Text)'
  581. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/README.perl' &&
  582. X
  583. **ALPHA ALERT**ALPHA ALERT**ALPHA ALERT**ALPHA ALERT**ALPHA ALERT**
  584. X
  585. (Warning!  This is the alpha version of p-cops, or perl cops... beta
  586. will be forthcoming shortly...)
  587. X
  588. X  This will attempt to familiarize you with the perl version of cops.  If
  589. you have never used cops before, you can get the complete documentation,
  590. along with shell/C code, via anon-ftp, at cert.sei.cmu.edu, ~ftp/pub/cops/1.02.
  591. Ok; the main difference with this version is that (besides being written
  592. in perl) there is a config file -- "cops.cf", that is used to control the
  593. cruft inside all of the modules.  No more muss, no more fuss.  I'll try
  594. to go over the main ones here.  The only important thing you have to set in
  595. the "cops" main file (or via the "-s" flag) is the secure directory, which 
  596. by default is "."; this is where cops will look for the config file and all
  597. the programs.  Also, if something is flagged as world-writable, and the file
  598. itself is not writable, but the parent directory is, then there will be an
  599. asterix after the warning (e.g. /usr/foo/bar is World Writable! (*).)  
  600. Finally, the suid.chk program, like all the rest of the programs, is meant 
  601. to be run as a part of "cops"; it's output will go to stdout if run 
  602. standalone, or either get mailed or saved to the result file if run under 
  603. cops.  That's a bit different than the old version.  Depending on comments,
  604. I'll either keep it this way, or put in some more options.
  605. X
  606. X  As said in the config file -- "cops.cf" (a "#" sign denotes comments):
  607. X
  608. # anything beginning with /^\s*[$@%&]/ will be eval'd
  609. X
  610. X  In general, you can put variables and programs that will be run inside
  611. the config file.  Variables look startlingly like they do in normal perl
  612. (look at the "PROGRAMS" section below for more on running programs); e.g.:
  613. X
  614. $NMAIL         = 0;         # send mail instead of generating reports
  615. $ONLY_DIFF     = 0;          # only send diff from last time
  616. $SECURE_USERS   = "root";     # user to receive mailed report
  617. X
  618. X  Setting something to "0" (without quotes is fine) generally means that 
  619. the option is not used.  "1" (or non-zero values, if you feel gutsy) is 
  620. used for a positive/true/whatever value.  The variables in general should
  621. be very similar to their normal cops counterparts; in this case, setting
  622. NMAIL to 1 would mean to mail info to the user listed in SECURE_USERS.
  623. If ONLY_DIFF is 1, it will only mail reports if change has occurred.
  624. X
  625. X  In general, variables in package main are for cops itself, whereas
  626. those with package qualifiers are for a particular chk routine or
  627. for auxiliary routines.  For instance, the following lines:
  628. X
  629. # this one says to ignore warnings about paths matching these regexps
  630. @chk_strings'ignores = ( '^/tmp/?', '^/(var|usr)/tmp/?' );
  631. X
  632. X  "chk_strings" is a routine that checks for writable programs within other
  633. programs, usually executed by root, such as /etc/rc and crontab.  This line
  634. says to ignore any files that start with a "/tmp", "/var/tmp", or "/usr/tmp".
  635. If you have a file or set of files that always are returning writable that
  636. are inside your rc and cron files, then you can put exceptions here.  One
  637. possibility is that you don't care about files created by other programs,
  638. so that anything after a ">" should be ignored.  You might add something
  639. like '>.*' to ignore files like "/usr/bar/snowcone", in a line like
  640. "/foo/bar/command > /usr/bar/snowcone".
  641. X
  642. X  Next, there is a nifty option, that does recursive searching inside the
  643. files chk_strings looks at.  This is neat... get it working by setting this
  644. to 1:
  645. X
  646. $chk_strings'recurse = 1;
  647. X
  648. X  So, if you have a line like this in /etc/rc:
  649. X
  650. /usr/bin/foo > /dev/console
  651. X
  652. X  It will examine "/usr/bin/foo" for programs inside of it -- and it will
  653. keep going until it has exhausted all possibilities.  So you can get warning
  654. messages like:
  655. X
  656. Warning!  File /foo/bar (inside /usr/local/X11R4/bin/X inside /usr/local/X11R4
  657. /bin/xdm inside /etc/rc.local) is _World_ writable!
  658. X
  659. X  Fun stuff.  No one can hide, now...
  660. X
  661. PROGRAMS
  662. =========
  663. X
  664. X  Running a program within cops is easy; you just have the program with
  665. any options by itself on a line.  Semi-colons are not welcome here.
  666. E.g.:
  667. X
  668. # first test the security of the root account
  669. root.chk
  670. X
  671. X  Some variables specific to the various programs are here as well, e.g.:
  672. X
  673. # now of the various devices.  -g means to check group writability, too
  674. $MTAB    = '/etc/fstab';
  675. $EXPORTS = '/etc/exports';
  676. $TAB_STYLE = 'new';
  677. dev.chk -g 
  678. X
  679. X  This is specifying the export files, etc., and saying that you should
  680. use the "new" format style in the exports file.  Ultrix, etc. uses the
  681. old style.  Suid.chk eats up time -- consider the "-n" flag for systems
  682. that have big NFS mounted disks.  And that's it -- the rest should be very 
  683. similar to the old cops, and theoretically, should give you similar or
  684. the same results.
  685. X
  686. X  Good luck!  Send bugs, flames, etc. to df@cert.sei.cmu.edu
  687. X
  688. X -- dan
  689. SHAR_EOF
  690. chmod 0700 p-cops.alpha/README.perl ||
  691. echo 'restore of p-cops.alpha/README.perl failed'
  692. Wc_c="`wc -c < 'p-cops.alpha/README.perl'`"
  693. test 4848 -eq "$Wc_c" ||
  694.     echo 'p-cops.alpha/README.perl: original size 4848, current size' "$Wc_c"
  695. rm -f _shar_wnt_.tmp
  696. fi
  697. # ============= p-cops.alpha/root.chk.old ==============
  698. if test -f 'p-cops.alpha/root.chk.old' -a X"$1" != X"-c"; then
  699.     echo 'x - skipping p-cops.alpha/root.chk.old (File already exists)'
  700.     rm -f _shar_wnt_.tmp
  701. else
  702. > _shar_wnt_.tmp
  703. echo 'x - extracting p-cops.alpha/root.chk.old (Text)'
  704. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/root.chk.old' &&
  705. #!/bin/sh  # need to mention perl here to avoid recursion
  706. #
  707. #  Usage: root.chk
  708. #
  709. #  This script checks pathnames inside root's startup files for 
  710. # writability, improper umask settings (world writable), non-root
  711. # entries in /.rhosts, writable binaries in root's path,
  712. # and to ensure that root is in /etc/ftpuser.
  713. #
  714. # Also check for a single "+" in /etc/hosts.equiv (world is trusted),
  715. # and that /bin, /etc and certain key files are root owned, so that you
  716. # can't, say, rcp from a host.equived machine and blow over the password
  717. # file... this may or may not be bad, decide for yourself.
  718. # Startup files are /.login /.cshrc /.profile
  719. #
  720. #  Mechanism:  These files contain paths and filenames that are stripped
  721. # out using "grep".  These strings are then processed by the "is_able"
  722. # program to see if they are world writable.  Strings of the form:
  723. #
  724. #    path=(/bin /usr/bin .)
  725. #        and
  726. #    PATH=/bin:/usr/bin:.:
  727. #
  728. # are checked  to ensure that "." is not in the path.  All
  729. # results are echoed to standard output.  In addition, some effort was
  730. # put into parsing out paths with multiple lines; e.g. ending in "\",
  731. # and continuing on the next line.  Also, all executable files and 
  732. # directories in there are checked for writability as well.
  733. #
  734. #  For umask stuff, simply grep for umask in startup files, and check
  735. # umask value.  For /etc/ftpuser, simple grep to check if root is in
  736. # the file.  For /etc/hosts.equiv, just check to see if "+" is alone
  737. # on a line by awking it.
  738. #
  739. #  NOTE:
  740. # if you know where perl is and your system groks #!, put its
  741. # pathname at the top to make this a tad faster.
  742. #
  743. # the following magic is from the perl man page
  744. # and should work to get us to run with perl 
  745. # even if invoked as an sh or csh or foosh script.
  746. # notice we don't use full path cause we don't
  747. # know where the user has perl on their system.
  748. #
  749. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  750. & eval 'exec perl -S $0 $argv:q'
  751. X    if $running_under_some_stupid_shell_instead_of_perl;
  752. X
  753. # rewritten in perl by tchrist@convex.com
  754. # 
  755. X
  756. # root startup/important files
  757. X
  758. require 'file_owner.pl';
  759. require 'fgrep.pl';
  760. require 'suckline.pl';
  761. require 'is_able.pl';
  762. require 'chk_strings.pl';
  763. require 'glob.pl';
  764. X
  765. package root_chk;
  766. X
  767. # use -a true if you care about non-executables
  768. # in root's path
  769. X
  770. $ARGV[0] eq '-a' && ($all_files++, shift);
  771. X
  772. die "usage: root.chk [-a]\n" if @ARGV;
  773. X
  774. $W = 'Warning! ';
  775. X
  776. $cshrc    = '/.cshrc';
  777. $profile= '/.profile';
  778. $rhosts = '/.rhosts';
  779. X
  780. $| = 1;
  781. X
  782. @big_files= ('/.login', '/.cshrc', '/.profile', '/.logout' );
  783. X
  784. # root should own *at least* these, + $big_files; you can check for all files
  785. # in /bin & /etc, or just the directories (the default.)
  786. # root_files="/bin /bin/* /etc /etc/* $big_files $rhosts"
  787. @root_files= ('/bin','/etc',@big_files,$rhosts,'/etc/passwd','/etc/group');
  788. X
  789. # misc important stuff
  790. $ftp='/etc/ftpusers';
  791. $equiv='/etc/hosts.equiv';
  792. X
  793. #   should't have anyone but root owning /bin or /etc files/directories
  794. # In case some of the critical files don't exist (/.rhost), toss away error
  795. # messages
  796. X
  797. if (@bad_files = grep (-e && &'Owner($_), @root_files)) {
  798. X    print "$W  Root does not own the following file(s):\n";
  799. X    print "\t@bad_files\n";
  800. } 
  801. X
  802. local($chk_strings'recurse) = 1 unless defined $chk_strings'recurse;
  803. X
  804. for $file (@big_files) {
  805. X    open file || next;
  806. X
  807. X    &'chk_strings($file);
  808. X
  809. X    # check for group or other writable umask
  810. X    while (<file>) {
  811. X    next if /^\s*#/;
  812. X    next unless /umask\s*(\d+)/;
  813. X    next unless ~oct($1) & 022;
  814. X    print "$W root's umask set to $1 in $file\n";
  815. X    } 
  816. } 
  817. X
  818. print "$W $ftp exists and root is not in it\n" 
  819. X    if -e $ftp && !&'fgrep($ftp,'root');
  820. X
  821. print "$W A \"+\" entry exists in $equiv!\n" if &'fgrep($equiv, '^\+$');
  822. X
  823. if (open rhosts) {
  824. X    while (<rhosts>) {
  825. X    next unless /\S+\s+(\S+)/ && $1 ne 'root';
  826. X    print "$W Non-root entry in $rhosts! $1\n";
  827. X    }
  828. } 
  829. close(rhosts);
  830. X
  831. undef @rootpath;
  832. X
  833. # checking paths...
  834. #
  835. # Get the root paths from $csh.
  836. X
  837. if (open $cshrc) {
  838. X    $path = '';
  839. X    while (<cshrc>) {
  840. X    next if /^\s*#/;
  841. X    chop unless /\\$/;
  842. X    if (/set\s+path\s*=/) {
  843. print "FOO-3: @rootpath , $_\n";
  844. X        $_ = &'suckline(cshrc, $_);
  845. print "FOO-2: @rootpath , $_\n";
  846. X        s/.*set\s+path\s*=\s*//;
  847. X        s/\((.*)\)/$1/;
  848. X        s/#.*/./;
  849. X        @tmppath = grep($_ ne '', split(' '));
  850. print "FOO-1: @rootpath , $_\n";
  851. X        for (@tmppath) { $whence{$_} .= " " . $cshrc; } 
  852. X        push(@rootpath, @tmppath);
  853. print "FOO-0: @rootpath , $_\n";
  854. X    } 
  855. X    } 
  856. X    close(cshrc);
  857. } 
  858. X
  859. print "FOO0: @rootpath\n";
  860. X
  861. if (open login) {
  862. X    $path = '';
  863. X    while (<cshrc>) {
  864. X    next if /^\s*#/;
  865. X    chop unless /\\$/;
  866. X    if (/set\s+path\s*=/) {
  867. X        $_ = &'suckline('login', $_);
  868. X        s/.*set\s+path\s*=\s*//;
  869. X        s/\((.*)\)/$1/;
  870. X        s/#.*/./;
  871. X        @tmppath = grep($_ ne '', split(' '));
  872. X        for (@tmppath) { $whence{$_} .= " " . $login; } 
  873. X        push(@rootpath, @tmppath);
  874. X    } 
  875. X    } 
  876. X    close(login);
  877. }
  878. X
  879. print "FOO1: @rootpath\n";
  880. X
  881. if (open profile) {
  882. X    $path = '';
  883. X    while (<profile>) {
  884. X    next if /^\s*#/;
  885. X    chop unless /\\$/;
  886. X    if (/PATH=/) {
  887. X        $_ = &'suckline('profile', $_);
  888. X        s/.*PATH=//;
  889. X        s/#.*//;
  890. X        @tmppath = split(/:/);
  891. X        for (@tmppath) { $whence{$_} .= " " . $profile; } 
  892. X        push(@rootpath, @tmppath);
  893. X    } 
  894. X    } 
  895. X    close(profile);
  896. } 
  897. X
  898. print "FOO2: @rootpath\n";
  899. X
  900. for (keys %whence) {
  901. X    $whence{$_} =~ s/^ //;
  902. X    $whence{$_} =~ s/ / and /g;
  903. } 
  904. X
  905. undef %seen;
  906. grep($seen{$_}++, @rootpath);
  907. X
  908. $is_able'silent = 1;
  909. for (keys %seen) {
  910. X    print "WAK: $_\n";
  911. X    if (!-e && $_ ne ".") {
  912. X    print "$W path component $_ in $whence{$_} doesn't exist!\n";
  913. X    next;
  914. X    } 
  915. X
  916. X    if (/^\.?$/) {  # null -> dot
  917. X    print "$W \".\" (or current directory) is in root's path in $whence{$_}!\n";
  918. X    } elsif (&'is_writable($_)) {
  919. X    print "$W Directory $_ is _World_ writable and in root's path in $whence{$_}!\n";
  920. X    next;
  921. X    }
  922. X
  923. X    foreach $file (&'glob("$_/*")) {
  924. X    print "BAR: $_\n";
  925. X    # can't just check -x here, as that depends on current user
  926. X    $is_executable = -f $file && (&'Mode($file) & 0111);
  927. X    if (($all_files || $is_executable) && 
  928. X            ($how = &'is_writable($file, 'w', 'w'))) {
  929. X        print "$W _World_ $how ",
  930. X            $is_executable ? 'executable' : 'file',
  931. X        " $file in root path component $_ from $whence{$_}!\n";
  932. X    } 
  933. X    }
  934. } 
  935. X
  936. $is_able'silent = 0;
  937. X
  938. 1;
  939. SHAR_EOF
  940. chmod 0700 p-cops.alpha/root.chk.old ||
  941. echo 'restore of p-cops.alpha/root.chk.old failed'
  942. Wc_c="`wc -c < 'p-cops.alpha/root.chk.old'`"
  943. test 6206 -eq "$Wc_c" ||
  944.     echo 'p-cops.alpha/root.chk.old: original size 6206, current size' "$Wc_c"
  945. rm -f _shar_wnt_.tmp
  946. fi
  947. # ============= p-cops.alpha/README.kuang ==============
  948. if test -f 'p-cops.alpha/README.kuang' -a X"$1" != X"-c"; then
  949.     echo 'x - skipping p-cops.alpha/README.kuang (File already exists)'
  950.     rm -f _shar_wnt_.tmp
  951. else
  952. > _shar_wnt_.tmp
  953. echo 'x - extracting p-cops.alpha/README.kuang (Text)'
  954. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/README.kuang' &&
  955. This is a perl version of Dan's version of Bob Baldwin's Kuang program
  956. (originally written as some shell scripts and C programs). 
  957. X
  958. The original intent was to improve the speed of kuang, which is
  959. especially important for installations like ours with several thousand
  960. accounts and NFS things and all that.  The shell version of Kuang used
  961. C programs to add rules, get a groups members, determine the writers
  962. of a file, and so on, which really slowed things down.
  963. X
  964. X        "no" problems    /etc staff writeable
  965. X        -------------    --------------------
  966. shell kuang    2:14 (14)    12:26 (98)    0.1 p/s
  967. perl kuang    1:10 (18)     2:34 (588)    3.8 p/s
  968. X
  969. --- Steve Romig, CIS, Ohio State, October 1990
  970. X
  971. ------------------------------------------------------------------------------
  972. X
  973. Some Features
  974. ---- --------
  975. X
  976. X  Caches passwd/group file entries in an associative array for faster
  977. X  lookups.  This is particularly helpful on insecure systems using YP
  978. X  where password and group lookups are slow and you have to do alot of
  979. X  them...:-)
  980. X
  981. X  Can specify target (uid or gid) on command line.
  982. X
  983. X  Can use -l option to generate PAT for a goal.
  984. X
  985. X  Can use -f to preload file owner, group and mode info, which is
  986. X  helpful in speeding things up and in avoiding file system
  987. X  'shadows'...  See the man page for details.
  988. X
  989. Future plans, things to fix:
  990. ----------------------------
  991. X
  992. - In a large environment (like ours, 260+ machines, 30+ file systems
  993. X  on as many servers, 2000 password file entries served by YP) it
  994. X  would be nice to 'precompute' successful plans that would be common
  995. X  to all systems.  In particular, plans for becoming most of the users
  996. X  with home directories on the NFS file systems would be useful, since
  997. X  we don't really want to recheck these on each host.  You wouldn't
  998. X  want the plan to be too deep - probably shouldn't span more than 2
  999. X  uids (1 on each end: grant u.romig grant g.staff write ~foo/.login
  1000. X  grant u.foo).  I'm thinking that you could feed a list of these
  1001. X  precomputed plans to kuang and add some code that causes it to
  1002. X  splice in relevent plans where it can to short cut the planning
  1003. X  steps.  For example, if one of the plans in uids.next is something
  1004. X  like "grant u.foo ...", and I have the precomputed plan mentioned
  1005. X  above, I could splice the two: "grant u.romig grant g.staff write
  1006. X  ~foo/.login grant u.foo ..." and skip all the normal steps that
  1007. X  would've been taken to get there.
  1008. X
  1009. - Hmmm...thinking about it, it seems like some of the steps are a bit
  1010. X  too implicit...maybe the rules should be broken out a bit more.
  1011. X  That will cost in processing time, though.
  1012. X
  1013. - Would be really, really nice to be able to deal with PATH variables
  1014. X  - location of ., who can write elements of path, etc.  Basic rule is
  1015. X  "anyone who can replace anything in any of path directories or the
  1016. X  path directories themselves can become that PATH's user..."  This
  1017. X  can be really messy though - in our environment, the path for a user
  1018. X  will depend on the architecture type of the machine that he is
  1019. X  logged into, and to get the path, you'd have to read and interpret
  1020. X  his .login (including variable assignments, source's and
  1021. X  conditionals).  Urf.  One wonders whether it might be better to have
  1022. X  something running as root that su's to each username in turn and
  1023. X  gets the path that way...
  1024. X
  1025. - ignore plans that start with "uid root", unless that's the only element - root
  1026. X  can get to anything, and hopefully nothing can get to root...?
  1027. X
  1028. - remove duplicate names from uid2names and gid2names...
  1029. X
  1030. - with ~/.login world writeable - only follows group path, but not OTHER.
  1031. X
  1032. - add plans to asseccible list.
  1033. X
  1034. Done
  1035. ----
  1036. X
  1037. - Need to find all plans that lead to compromise, not just a plan.
  1038. X
  1039. - An earlier version scanned the password file looking for generally
  1040. X  accesible accounts (no password), which would be added to the
  1041. X  uids.known list (in addition to -1, "other").  I had planned on also
  1042. X  adding a password checker which would allow us to also add accounts
  1043. X  with easily guessed passwords.  Eventually I nuked the code that
  1044. X  scanned the password file to speed things up, and further reflection
  1045. X  reveals that it isn't wise to add the password scanning to kuang
  1046. X  itself.  At some point we should add a comand line option that
  1047. X  allows us to add additional uid's (or gid's?) to the uids.known
  1048. X  list.  That way the user could run some other tool to scan the
  1049. X  password file and generate a list of accessible accounts, which
  1050. X  could then be fed to kuang.  Makes it faster on clients using YP
  1051. X  since most of the password file is the same for all N clients, why
  1052. X  scan it N times.  Means that user can do smarter things to/with the
  1053. X  password file checks (list all accounts with no password or easily
  1054. X  guessed password, filter out "ok" entries (eg, sync) and etc.)
  1055. X
  1056. - We aren't dealing with uid's and gid's correctly.  If there are
  1057. X  several entries that list the same UID, but with different names,
  1058. X  directories and shells, we'll only check plans for becoming one of
  1059. X  them, rather than any of them.  Hmmm...this is easier than I
  1060. X  thought, when we evaluate some plan for granting a particular uid,
  1061. X  we need to evaluate plans for all usernames that can become that
  1062. X  uid.  Just stick a loop in there somewhere...get CF's for each of
  1063. X  username's in turn.  Bah, harder than I thought, since it'd have to
  1064. X  scan the whole password file to figure which username/home directories
  1065. X  can become which uid's.  Similarly with groups.
  1066. X
  1067. X  Current plan: by default, kuang will have to scan the whole password
  1068. X  and group files so it can be sure to get all possible ways to become
  1069. X  some uid or gid.  Internally, really need several lists:
  1070. X
  1071. X    mapping from uid to list of usernames that have that uid
  1072. X    mapping from a username to home directory, shell
  1073. X    mapping from gid to list of uids that have access to that
  1074. X      gid when they login (either member of group with that gid or
  1075. X      given as login group in passwd file)
  1076. X    mapping from gid to list of group names for that gid
  1077. X
  1078. X  Course, this means that we have to read the whole password and group
  1079. X  file, most of which will be common to many machines (like in a YP
  1080. X  environment).  We could preload the tables above from files created
  1081. X  once, containing the brunt of the YP info, and then augment that
  1082. X  withthe local passwd and group info on each host when kuang is
  1083. X  invoked, but then we need to correctly interpret funky YP things
  1084. X  like +@netgroup:::*:..., which means that the uid has a name but no
  1085. X  password here...and similarly with shell substitutions and so on.
  1086. X  Bah. 
  1087. X
  1088. - The kuang described in Baldwin's dissertation is somewhat different
  1089. X  in nature from this one.  The original computes a Privilege Access
  1090. X  Table (PAT) which describes for each uid and gid which uids have
  1091. X  access to that uid.  To assess security, we compare this against the
  1092. X  security policy for the site, which similarly describes which uid's
  1093. X  are supposed to have access to each uid and gid.  A sample SP might
  1094. X  be that each uid should be accessible only by itself and root, and
  1095. X  each gid should be accessible only to the members of that group and
  1096. X  root.  If the PAT listed additional uid's for some priv, that would
  1097. X  constitute a violation of the Security Policy for the site.
  1098. X
  1099. X  The current kuang is different.  It registers Success (a problem was
  1100. X  found) if it determines that some uid in the uids.known list (-1,
  1101. X  "other" by default) can access the target privilege.  It may find
  1102. X  along the way that extra uids can access some uid, but these aren't
  1103. X  reported as specific problems unless they are added to the
  1104. X  uids.known list. 
  1105. X
  1106. X  We could do something similar to the kuang described in the paper by
  1107. X  setting uids.known to be all the uids that aren't in the security
  1108. X  policy table for the target uid, and running kuang against the
  1109. X  target.  This would report success for each uid that could access
  1110. X  the target.  You could do similar things with groups - uids.known
  1111. X  would be all the uids that aren't members of the group...
  1112. X
  1113. X  Alternately, we could simply have kuang record the list of uids that
  1114. X  can access the target priv and print the list when its done.  That
  1115. X  way you could iterate kuang against all uids and gids and compare
  1116. X  the resulting PAT against your security policy and record the
  1117. X  differences.  You'd probably want to record the plan for each uid
  1118. X  reported also.
  1119. X
  1120. X  On our system this would mean running kuang roughly 2500
  1121. X  times to check 1 host, and we have about 300 hosts...urf...assuming
  1122. X  that each kuang invocation has to check 50 plans, that's a total of
  1123. X  125,000 plans per host, or about an hour of real time...not as bad
  1124. X  as it could be, though.
  1125. X
  1126. - It would be nice to add to the list of rules.  It would be especialy
  1127. X  nice to extract the rules from the code so that we can create site
  1128. X  specific rule files (for example, we use X11r4 here, and many users
  1129. X  have a .Xinitrc that contains shell commands that get executed when
  1130. X  they login.)
  1131. X
  1132. X  Easiest way to do this would be to extract the rules as Perl code so
  1133. X  we can take advantage of conditionals and so on, and include them
  1134. X  within the body of kuang somehow.  A sample rule in perl:
  1135. X
  1136. X    if (&shell($uid) eq "/bin/csh") {
  1137. X        &addto("files", &home($uid)."/.login", 
  1138. X            "replace .login $plan");
  1139. X    }
  1140. X
  1141. X  which simply means "if the user's shell is csh, then try to replace
  1142. X  his .login file." 
  1143. SHAR_EOF
  1144. chmod 0600 p-cops.alpha/README.kuang ||
  1145. echo 'restore of p-cops.alpha/README.kuang failed'
  1146. Wc_c="`wc -c < 'p-cops.alpha/README.kuang'`"
  1147. test 9306 -eq "$Wc_c" ||
  1148.     echo 'p-cops.alpha/README.kuang: original size 9306, current size' "$Wc_c"
  1149. rm -f _shar_wnt_.tmp
  1150. fi
  1151. # ============= p-cops.alpha/suid.stop ==============
  1152. if test -f 'p-cops.alpha/suid.stop' -a X"$1" != X"-c"; then
  1153.     echo 'x - skipping p-cops.alpha/suid.stop (File already exists)'
  1154.     rm -f _shar_wnt_.tmp
  1155. else
  1156. > _shar_wnt_.tmp
  1157. echo 'x - extracting p-cops.alpha/suid.stop (Text)'
  1158. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/suid.stop' &&
  1159. SHAR_EOF
  1160. chmod 0700 p-cops.alpha/suid.stop ||
  1161. echo 'restore of p-cops.alpha/suid.stop failed'
  1162. Wc_c="`wc -c < 'p-cops.alpha/suid.stop'`"
  1163. test 0 -eq "$Wc_c" ||
  1164.     echo 'p-cops.alpha/suid.stop: original size 0, current size' "$Wc_c"
  1165. rm -f _shar_wnt_.tmp
  1166. fi
  1167. # ============= p-cops.alpha/pwgrid.pl ==============
  1168. if test -f 'p-cops.alpha/pwgrid.pl' -a X"$1" != X"-c"; then
  1169.     echo 'x - skipping p-cops.alpha/pwgrid.pl (File already exists)'
  1170.     rm -f _shar_wnt_.tmp
  1171. else
  1172. > _shar_wnt_.tmp
  1173. echo 'x - extracting p-cops.alpha/pwgrid.pl (Text)'
  1174. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/pwgrid.pl' &&
  1175. # Routines for reading and caching user and group information.
  1176. #
  1177. # Provides a bunch of routines and a bunch of arrays.  Routines 
  1178. # (and their usage):
  1179. #
  1180. #    load_passwd_info($use_getent, $file_name)
  1181. #
  1182. #    loads user information into the %uname* and %uid* arrays 
  1183. #    (see below).  
  1184. #
  1185. #    If $use_getent is non-zero:
  1186. #        get the info via repeated 'getpwent' calls.  This can be
  1187. #        *slow* on some hosts, especially if they are running as a
  1188. #        YP (NIS) client.
  1189. #    If $use_getent is 0:
  1190. #        if $file_name is "", then get the info from reading the 
  1191. #        results of "ypcat passwd" and from /etc/passwd.  Otherwise, 
  1192. #        read the named file.  The file should be in passwd(5) 
  1193. #        format.
  1194. #
  1195. #    load_group_info($use_gentent, $file_name)
  1196. #
  1197. #    is similar to load_passwd_info.
  1198. #
  1199. # Information is stored in several convenient associative arrays:
  1200. #
  1201. #   %uname2shell    Assoc array, indexed by user name, value is 
  1202. #            shell for that user name.
  1203. #
  1204. #   %uname2dir        Assoc array, indexed by user name, value is
  1205. #            home directory for that user name.
  1206. #
  1207. #   %uname2uid        Assoc array, indexed by name, value is uid for 
  1208. #            that uid.
  1209. #            
  1210. #   %uname2passwd    Assoc array, indexed by name, value is password
  1211. #            for that user name.
  1212. #
  1213. #   %uid2names        Assoc array, indexed by uid, value is list of
  1214. #            user names with that uid, in form "name name
  1215. #            name...". 
  1216. #
  1217. #   %gid2members    Assoc array, indexed by gid, value is list of
  1218. #            group members in form "name name name..."
  1219. #
  1220. #   %gname2gid        Assoc array, indexed by group name, value is
  1221. #            matching gid.
  1222. #
  1223. #   %gid2names        Assoc array, indexed by gid, value is the
  1224. #            list of group names with that gid in form 
  1225. #            "name name name...".
  1226. #
  1227. # You can also use routines named the same as the arrays - pass the index 
  1228. # as the arg, get back the value.  If you use this, get{gr|pw}{uid|gid|nam} 
  1229. # will be used to lookup entries that aren't found in the cache.
  1230. #
  1231. # To be done:
  1232. #    probably ought to add routines to deal with full names.
  1233. #    maybe there ought to be some anal-retentive checking of password 
  1234. #    and group entries.
  1235. #    probably ought to cache get{pw|gr}{nam|uid|gid} lookups also.
  1236. #    probably ought to avoid overwriting existing entries (eg, duplicate 
  1237. #       names in password file would collide in the tables that are 
  1238. #    indexed by name).
  1239. #
  1240. # Disclaimer:
  1241. #    If you use YP and you use netgroup entries such as 
  1242. #    +@servers::::::
  1243. #    +:*:::::/usr/local/utils/messages
  1244. #    then loading the password file in with &load_passwd_info(0) will get 
  1245. #    you mostly correct YP stuff *except* that it won't do the password and 
  1246. #    shell substitutions as you'd expect.  You might want to use 
  1247. #    &load_passwd_info(1) instead to use getpwent calls to do the lookups, 
  1248. #    which would be more correct.
  1249. #
  1250. X
  1251. %uname2shell = ();
  1252. %uname2dir = ();
  1253. %uname2uid = ();
  1254. %uname2passwd = ();
  1255. %uid2names = ();
  1256. %gid2members = ();
  1257. %gname2gid = ();
  1258. %gid2names = ();
  1259. X
  1260. if (! defined($DOMAINNAME)) {
  1261. X    $DOMAINNAME = "/bin/domainname";
  1262. }
  1263. if (! defined($YPCAT)) {
  1264. X    $YPCAT = "/bin/ypcat";
  1265. }
  1266. X
  1267. $passwd_loaded = 0;        # flags to use to avoid reloading everything
  1268. $group_loaded = 0;        # unnecessarily...
  1269. X
  1270. #
  1271. # We provide routines for getting values from the data structures as well.
  1272. # These are named after the data structures they cache their data in.  Note 
  1273. # that they will all generate password and group file lookups via getpw* 
  1274. # and getgr* if they can't find info in the cache, so they will work
  1275. # "right" even if load_passwd_info and load_group_info aren't called to 
  1276. # preload the caches.
  1277. #
  1278. # I should point out, however, that if you don't call load_*_info to preload
  1279. # the cache, uid2names, gid2names and gid2members *will not* be complete, since 
  1280. # you must read the entire password and group files to get a complete picture.
  1281. # This might be acceptable in some cases, so you can skip the load_*_info
  1282. # calls if you know what you are doing...
  1283. #
  1284. sub uname2shell {
  1285. X    local($key) = @_;
  1286. X
  1287. X    if (! defined($uname2shell{$key})) {
  1288. X    &add_pw_info(getpwnam($key));
  1289. X    }
  1290. X
  1291. X    return($uname2shell{$key});
  1292. }
  1293. X
  1294. sub uname2dir {
  1295. X    local($key) = @_;
  1296. X    local(@pw_info);
  1297. X
  1298. X    if (! defined($uname2dir{$key})) {
  1299. X    &add_pw_info(getpwnam($key));
  1300. X    }
  1301. X
  1302. X    return($uname2dir{$key});
  1303. }
  1304. X
  1305. sub uname2uid {
  1306. X    local($key) = @_;
  1307. X    local(@pw_info);
  1308. X
  1309. X    if (! defined($uname2uid{$key})) {
  1310. X    &add_pw_info(getpwnam($key));
  1311. X    }
  1312. X
  1313. X    return($uname2uid{$key});
  1314. }
  1315. X
  1316. sub uname2passwd {
  1317. X    local($key) = @_;
  1318. X    local(@pw_info);
  1319. X
  1320. X    if (! defined($uname2passwd{$key})) {
  1321. X    &add_pw_info(getpwnam($key));
  1322. X    }
  1323. X
  1324. X    return($uname2passwd{$key});
  1325. }
  1326. X
  1327. sub uid2names {
  1328. X    local($key) = @_;
  1329. X    local(@pw_info);
  1330. X
  1331. X    if (! defined($uid2names{$key})) {
  1332. X    &add_pw_info(getpwuid($key));
  1333. X    }
  1334. X
  1335. X    return($uid2names{$key});
  1336. }
  1337. X
  1338. sub gid2members {
  1339. X    local($key) = @_;
  1340. X    local(@gr_info);
  1341. X
  1342. X    if (! defined($gid2members{$key})) {
  1343. X    &add_gr_info(getgrgid($key));
  1344. X    }
  1345. X
  1346. X    return($gid2members{$key});
  1347. }
  1348. X
  1349. sub gname2gid {
  1350. X    local($key) = @_;
  1351. X    local(@gr_info);
  1352. X
  1353. X    if (! defined($gname2gid{$key})) {
  1354. X    &add_gr_info(getgrnam($key));
  1355. X    }
  1356. X
  1357. X    return($gname2gid{$key});
  1358. }
  1359. X
  1360. sub gid2names {
  1361. X    local($key) = @_;
  1362. X    local(@gr_info);
  1363. X
  1364. X    if (! defined($gid2names{$key})) {
  1365. X    &add_gr_info(getgrgid($key));
  1366. X    }
  1367. X
  1368. X    return($gid2names{$key});
  1369. }
  1370. X
  1371. #
  1372. # Update user information for the user named $name.  We cache the password, 
  1373. # uid, login group, home directory and shell.
  1374. #
  1375. X
  1376. sub add_pw_info {
  1377. X    local($name, $passwd, $uid, $gid) = @_;
  1378. X    local($dir, $shell);
  1379. X
  1380. #
  1381. # Ugh!  argh...yech...sigh.  If we use getpwent, we get back 9 elts, 
  1382. # if we parse /etc/passwd directly we get 7.  Pick off the last 2 and 
  1383. # assume that they are the $directory and $shell.  
  1384. #
  1385. X    $dir = $_[$#_ - 1];
  1386. X    $shell = $_[$#_];
  1387. X
  1388. X    if ($name ne "") {
  1389. X    $uname2shell{$name} = $shell;
  1390. X    $uname2dir{$name} = $dir;
  1391. X    $uname2uid{$name} = $uid;
  1392. X    $uname2passwd{$name} = $passwd;
  1393. X
  1394. X    if ($gid ne "") {
  1395. X        # fixme: should probably check for duplicates...sigh
  1396. X
  1397. X        if (defined($gid2members{$gid})) {
  1398. X        $gid2members{$gid} .= " $name";
  1399. X        } else {
  1400. X        $gid2members{$gid} = $name;
  1401. X        }
  1402. X    }
  1403. X
  1404. X    if ($uid ne "") {
  1405. X        if (defined($uid2names{$uid})) {
  1406. X        $uid2names{$uid} .= " $name";
  1407. X        } else {
  1408. X        $uid2names{$uid} = $name;
  1409. X        }
  1410. X    }
  1411. X    }
  1412. }
  1413. X
  1414. #
  1415. # Update group information for the group named $name.  We cache the gid 
  1416. # and the list of group members.
  1417. #
  1418. X
  1419. sub add_gr_info {
  1420. X    local($name, $passwd, $gid, $members) = @_;
  1421. X
  1422. X    if ($name ne "") {
  1423. X    $gname2gid{$name} = $gid;
  1424. X
  1425. X    if ($gid ne "") {
  1426. X        if (defined($gid2names)) {
  1427. X        $gid2names{$gid} .= " $name";
  1428. X        } else {
  1429. X        $gid2names{$gid} = $name;
  1430. X        }
  1431. X
  1432. X        # fixme: should probably check for duplicates
  1433. X
  1434. X        $members = join(' ', split(/[, \t]+/, $members));
  1435. X
  1436. X        if (defined($gid2members{$gid})) {
  1437. X        $gid2members{$gid} .= " " . $members;
  1438. X        } else {
  1439. X        $gid2members{$gid} = $members;
  1440. X        }
  1441. X    }
  1442. X    }
  1443. }
  1444. X
  1445. #
  1446. # We need to suck in the entire group and password files so that we can 
  1447. # make the %uid2names, %gid2members and %gid2names lists complete.  Otherwise,
  1448. # we would just read the entries as needed with getpw* and cache the results.
  1449. # Sigh.
  1450. #
  1451. # There are several ways that we might find the info.  If $use_getent is 1, 
  1452. # then we just use getpwent and getgrent calls to read the info in.
  1453. #
  1454. # That isn't real efficient if you are using YP (especially on a YP client), so
  1455. # if $use_getent is 0, we can use ypcat to get a copy of the passwd and
  1456. # group maps in a fairly efficient manner.  If we do this we have to also read
  1457. # the local /etc/{passwd,group} files to complete our information.  If we aren't 
  1458. # using YP, we just read the local pasword and group files.
  1459. #
  1460. sub load_passwd_info {
  1461. X    local($use_getent, $file_name) = @_;
  1462. X    local(@pw_info);
  1463. X
  1464. X    if ($passwd_loaded) {
  1465. X    return;
  1466. X    }
  1467. X
  1468. X    $passwd_loaded = 1;
  1469. X
  1470. X    if ($use_getent) {
  1471. X    #
  1472. X    # Use getpwent to get the info from the system, and add_pw_info to 
  1473. X    # cache it.
  1474. X    #
  1475. X    while ((@pw_info = getpwent()) != 0) {
  1476. X        &add_pw_info(@pw_info);
  1477. X    }
  1478. X
  1479. X    endpwent();
  1480. X
  1481. X    return();
  1482. X    } elsif ($file_name eq "") {
  1483. X    chop($has_yp = `$DOMAINNAME`);
  1484. X    if ($has_yp) {
  1485. X        #
  1486. X        # If we have YP (NIS), then use ypcat to get the stuff from the 
  1487. X        # map.
  1488. X        #
  1489. X        open(FILE, "$YPCAT passwd|") ||
  1490. X          die "can't 'ypcat passwd'";
  1491. X        while (<FILE>) {
  1492. X        chop;
  1493. X        &add_pw_info(split(/:/));
  1494. X        }
  1495. X        close(FILE);
  1496. X    }
  1497. X
  1498. X    #
  1499. X    # We have to read /etc/passwd no matter what...
  1500. X    #
  1501. X    $file_name = "/etc/passwd";
  1502. X    }
  1503. X
  1504. X    open(FILE, $file_name) ||
  1505. X      die "can't open $file_name";
  1506. X
  1507. X    while (<FILE>) {
  1508. X    chop;
  1509. X        
  1510. X    if ($_ !~ /^\+/) {
  1511. X        &add_pw_info(split(/:/));
  1512. X    }
  1513. X
  1514. X    # fixme: if the name matches +@name, then this is a wierd 
  1515. X    # netgroup thing, and we aren't dealing with it right.  might want
  1516. X    # to warn the poor user...suggest that he use the use_getent 
  1517. X    # method instead.
  1518. X    }
  1519. X
  1520. X    close(FILE);
  1521. }
  1522. X
  1523. sub load_group_info {
  1524. X    local($use_getent, $file_name) = @_;
  1525. X    local(@gr_info);
  1526. X
  1527. X    if ($group_loaded) {
  1528. X    return;
  1529. X    }
  1530. X
  1531. X    $group_loaded = 1;
  1532. X
  1533. X    if ($use_getent) {
  1534. X    #
  1535. X    # Use getgrent to get the info from the system, and add_gr_info to 
  1536. X    # cache it.
  1537. X    #
  1538. X    while ((@gr_info = getgrent()) != 0) {
  1539. X        &add_gr_info(@gr_info);
  1540. X    }
  1541. X
  1542. X    endgrent();
  1543. X
  1544. X    return();
  1545. X    } elsif ($file_name eq "") {
  1546. X    chop($has_yp = `$DOMAINNAME`);
  1547. X    if ($has_yp) {
  1548. X        #
  1549. X        # If we have YP (NIS), then use ypcat to get the stuff from the 
  1550. X        # map.
  1551. X        #
  1552. X        open(FILE, "$YPCAT group|") ||
  1553. X          die "can't 'ypcat group'";
  1554. X        while (<FILE>) {
  1555. X        chop;
  1556. X        &add_gr_info(split(/:/));
  1557. X        }
  1558. X        close(FILE);
  1559. X    }
  1560. X
  1561. X    #
  1562. X    # We have to read /etc/group no matter what...
  1563. X    #
  1564. X    $file_name = "/etc/group";
  1565. X    }
  1566. X
  1567. X    open(FILE, $file_name) ||
  1568. X      die "can't open $file_name";
  1569. X
  1570. X    while (<FILE>) {
  1571. X    chop;
  1572. X    if ($_ !~ /^\+/) {
  1573. X        &add_gr_info(split(/:/));
  1574. X    }
  1575. X
  1576. X    # fixme: if the name matches +@name, then this is a wierd 
  1577. X    # netgroup thing, and we aren't dealing with it right.  might want
  1578. X    # to warn the poor user...suggest that he use the use_getent 
  1579. X    # method instead.
  1580. X    }
  1581. X
  1582. X    close(FILE);
  1583. }
  1584. X
  1585. 1;
  1586. X
  1587. SHAR_EOF
  1588. chmod 0600 p-cops.alpha/pwgrid.pl ||
  1589. echo 'restore of p-cops.alpha/pwgrid.pl failed'
  1590. Wc_c="`wc -c < 'p-cops.alpha/pwgrid.pl'`"
  1591. test 9915 -eq "$Wc_c" ||
  1592.     echo 'p-cops.alpha/pwgrid.pl: original size 9915, current size' "$Wc_c"
  1593. rm -f _shar_wnt_.tmp
  1594. fi
  1595. # ============= p-cops.alpha/root.chk.new ==============
  1596. if test -f 'p-cops.alpha/root.chk.new' -a X"$1" != X"-c"; then
  1597.     echo 'x - skipping p-cops.alpha/root.chk.new (File already exists)'
  1598.     rm -f _shar_wnt_.tmp
  1599. else
  1600. > _shar_wnt_.tmp
  1601. echo 'x - extracting p-cops.alpha/root.chk.new (Text)'
  1602. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/root.chk.new' &&
  1603. #!/bin/sh  # need to mention perl here to avoid recursion
  1604. #
  1605. #  Usage: root.chk
  1606. #
  1607. #  This script checks pathnames inside root's startup files for 
  1608. # writability, improper umask settings (world writable), non-root
  1609. # entries in /.rhosts, writable binaries in root's path,
  1610. # and to ensure that root is in /etc/ftpuser.
  1611. #
  1612. # Also check for a single "+" in /etc/hosts.equiv (world is trusted),
  1613. # and that /bin, /etc and certain key files are root owned, so that you
  1614. # can't, say, rcp from a host.equived machine and blow over the password
  1615. # file... this may or may not be bad, decide for yourself.
  1616. # Startup files are /.login /.cshrc /.profile
  1617. #
  1618. #  Mechanism:  These files contain paths and filenames that are stripped
  1619. # out using "grep".  These strings are then processed by the "is_able"
  1620. # program to see if they are world writable.  Strings of the form:
  1621. #
  1622. #    path=(/bin /usr/bin .)
  1623. #        and
  1624. #    PATH=/bin:/usr/bin:.:
  1625. #
  1626. # are checked  to ensure that "." is not in the path.  All
  1627. # results are echoed to standard output.  In addition, some effort was
  1628. # put into parsing out paths with multiple lines; e.g. ending in "\",
  1629. # and continuing on the next line.  Also, all executable files and 
  1630. # directories in there are checked for writability as well.
  1631. #
  1632. #  For umask stuff, simply grep for umask in startup files, and check
  1633. # umask value.  For /etc/ftpuser, simple grep to check if root is in
  1634. # the file.  For /etc/hosts.equiv, just check to see if "+" is alone
  1635. # on a line by awking it.
  1636. #
  1637. #  NOTE:
  1638. # if you know where perl is and your system groks #!, put its
  1639. # pathname at the top to make this a tad faster.
  1640. #
  1641. # the following magic is from the perl man page
  1642. # and should work to get us to run with perl 
  1643. # even if invoked as an sh or csh or foosh script.
  1644. # notice we don't use full path cause we don't
  1645. # know where the user has perl on their system.
  1646. #
  1647. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  1648. & eval 'exec perl -S $0 $argv:q'
  1649. X    if $running_under_some_stupid_shell_instead_of_perl;
  1650. X
  1651. # rewritten in perl by tchrist@convex.com
  1652. # 
  1653. X
  1654. # root startup/important files
  1655. X
  1656. require 'file_owner.pl';
  1657. require 'fgrep.pl';
  1658. require 'suckline.pl';
  1659. require 'is_able.pl';
  1660. require 'chk_strings.pl';
  1661. require 'glob.pl';
  1662. X
  1663. package root_chk;
  1664. X
  1665. # use -a true if you care about non-executables
  1666. # in root's path
  1667. X
  1668. $ARGV[0] eq '-a' && ($all_files++, shift);
  1669. X
  1670. die "usage: root.chk [-a]\n" if @ARGV;
  1671. X
  1672. $W = 'Warning! ';
  1673. X
  1674. $cshrc    = '/.cshrc';
  1675. $profile= '/.profile';
  1676. $rhosts = '/.rhosts';
  1677. X
  1678. $| = 1;
  1679. X
  1680. @big_files= ('/.login', '/.cshrc', '/.profile', '/.logout' );
  1681. X
  1682. # root should own *at least* these, + $big_files; you can check for all files
  1683. # in /bin & /etc, or just the directories (the default.)
  1684. # root_files="/bin /bin/* /etc /etc/* $big_files $rhosts"
  1685. @root_files= ('/bin','/etc',@big_files,$rhosts,'/etc/passwd','/etc/group');
  1686. X
  1687. # misc important stuff
  1688. $ftp='/etc/ftpusers';
  1689. $equiv='/etc/hosts.equiv';
  1690. X
  1691. #   should't have anyone but root owning /bin or /etc files/directories
  1692. # In case some of the critical files don't exist (/.rhost), toss away error
  1693. # messages
  1694. X
  1695. if (@bad_files = grep (-e && &'Owner($_), @root_files)) {
  1696. X    print "$W  Root does not own the following file(s):\n";
  1697. X    print "\t@bad_files\n";
  1698. } 
  1699. X
  1700. local($chk_strings'recurse) = 1 unless defined $chk_strings'recurse;
  1701. X
  1702. for $file (@big_files) {
  1703. X    open file || next;
  1704. X
  1705. X    &'chk_strings($file);
  1706. X
  1707. X    # check for group or other writable umask
  1708. X    while (<file>) {
  1709. X    next if /^\s*#/;
  1710. X    next unless /umask\s*(\d+)/;
  1711. X    next unless ~oct($1) & 022;
  1712. X    print "$W root's umask set to $1 in $file\n";
  1713. X    } 
  1714. } 
  1715. X
  1716. print "$W $ftp exists and root is not in it\n" 
  1717. X    if -e $ftp && !&'fgrep($ftp,'root');
  1718. X
  1719. print "$W A \"+\" entry exists in $equiv!\n" if &'fgrep($equiv, '^\+$');
  1720. X
  1721. if (open rhosts) {
  1722. X    while (<rhosts>) {
  1723. X    next unless /\S+\s+(\S+)/ && $1 ne 'root';
  1724. X    print "$W Non-root entry in $rhosts! $1\n";
  1725. X    }
  1726. } 
  1727. close(rhosts);
  1728. X
  1729. undef @rootpath;
  1730. X
  1731. # checking paths...
  1732. #
  1733. # Get the root paths from $csh.
  1734. X
  1735. print "FOO-4:\n";
  1736. if (open(CSHRC, $cshrc)) {
  1737. X    $path = '';
  1738. X    while (<CSHRC>) {
  1739. X    print "FOO-3: $_\n";
  1740. X    next if /^\s*#/;
  1741. X    chop unless /\\$/;
  1742. X    if (/set\s+path\s*=/) {
  1743. X      print "FOO-2: $_\n";
  1744. X        $_ = &'suckline($cshrc, $_);
  1745. X        s/.*set\s+path\s*=\s*//;
  1746. X        s/\((.*)\)/$1/;
  1747. X        s/#.*/./;
  1748. X        @tmppath = grep($_ ne '', split(' '));
  1749. X        for (@tmppath) { $whence{$_} .= " " . $cshrc; } 
  1750. X        push(@rootpath, @tmppath);
  1751. X    } 
  1752. X    } 
  1753. X    close(CSHRC);
  1754. } 
  1755. X
  1756. print "FOO0: @rootpath\n";
  1757. X
  1758. if (open login) {
  1759. X    $path = '';
  1760. X    while (<cshrc>) {
  1761. X    next if /^\s*#/;
  1762. X    chop unless /\\$/;
  1763. X    if (/set\s+path\s*=/) {
  1764. X        $_ = &'suckline('login', $_);
  1765. X        s/.*set\s+path\s*=\s*//;
  1766. X        s/\((.*)\)/$1/;
  1767. X        s/#.*/./;
  1768. X        @tmppath = grep($_ ne '', split(' '));
  1769. X        for (@tmppath) { $whence{$_} .= " " . $login; } 
  1770. X        push(@rootpath, @tmppath);
  1771. X    } 
  1772. X    } 
  1773. X    close(login);
  1774. }
  1775. X
  1776. print "FOO1: @rootpath\n";
  1777. X
  1778. if (open profile) {
  1779. X    $path = '';
  1780. X    while (<profile>) {
  1781. X    next if /^\s*#/;
  1782. X    chop unless /\\$/;
  1783. X    if (/PATH=/) {
  1784. X        $_ = &'suckline('profile', $_);
  1785. X        s/.*PATH=//;
  1786. X        s/#.*//;
  1787. X        @tmppath = split(/:/);
  1788. X        for (@tmppath) { $whence{$_} .= " " . $profile; } 
  1789. X        push(@rootpath, @tmppath);
  1790. X    } 
  1791. X    } 
  1792. X    close(profile);
  1793. } 
  1794. X
  1795. print "FOO2: @rootpath\n";
  1796. X
  1797. for (keys %whence) {
  1798. X    $whence{$_} =~ s/^ //;
  1799. X    $whence{$_} =~ s/ / and /g;
  1800. } 
  1801. X
  1802. undef %seen;
  1803. grep($seen{$_}++, @rootpath);
  1804. X
  1805. $is_able'silent = 1;
  1806. for (keys %seen) {
  1807. X    print "WAK: $_\n";
  1808. X    if (!-e && $_ ne ".") {
  1809. X    print "$W path component $_ in $whence{$_} doesn't exist!\n";
  1810. X    next;
  1811. X    } 
  1812. X
  1813. X    if (/^\.?$/) {  # null -> dot
  1814. X    print "$W \".\" (or current directory) is in root's path in $whence{$_}!\n";
  1815. X    } elsif (&'is_writable($_)) {
  1816. X    print "$W Directory $_ is _World_ writable and in root's path in $whence{$_}!\n";
  1817. X    next;
  1818. X    }
  1819. X
  1820. X    foreach $file (&'glob("$_/*")) {
  1821. X    print "BAR: $_\n";
  1822. X    # can't just check -x here, as that depends on current user
  1823. X    $is_executable = -f $file && (&'Mode($file) & 0111);
  1824. X    if (($all_files || $is_executable) && 
  1825. X            ($how = &'is_writable($file, 'w', 'w'))) {
  1826. X        print "$W _World_ $how ",
  1827. X            $is_executable ? 'executable' : 'file',
  1828. X        " $file in root path component $_ from $whence{$_}!\n";
  1829. X    } 
  1830. X    }
  1831. } 
  1832. X
  1833. $is_able'silent = 0;
  1834. X
  1835. 1;
  1836. SHAR_EOF
  1837. chmod 0700 p-cops.alpha/root.chk.new ||
  1838. echo 'restore of p-cops.alpha/root.chk.new failed'
  1839. Wc_c="`wc -c < 'p-cops.alpha/root.chk.new'`"
  1840. test 6147 -eq "$Wc_c" ||
  1841.     echo 'p-cops.alpha/root.chk.new: original size 6147, current size' "$Wc_c"
  1842. rm -f _shar_wnt_.tmp
  1843. fi
  1844. # ============= p-cops.alpha/rules.pl ==============
  1845. if test -f 'p-cops.alpha/rules.pl' -a X"$1" != X"-c"; then
  1846.     echo 'x - skipping p-cops.alpha/rules.pl (File already exists)'
  1847.     rm -f _shar_wnt_.tmp
  1848. else
  1849. > _shar_wnt_.tmp
  1850. echo 'x - extracting p-cops.alpha/rules.pl (Text)'
  1851. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/rules.pl' &&
  1852. sub apply_rules {
  1853. X    local($op, $value, @plan) = @_;
  1854. X
  1855. X    printf("eval($op $value): %s\n", &ascii_plan(@plan)) if $opt_d;
  1856. X
  1857. X    #
  1858. X    # apply UID attack rules...
  1859. X    #
  1860. X    if ($op eq "u") {
  1861. X    #
  1862. X    # If we can replace /etc/passwd or /usr/lib/aliases, we can grant 
  1863. X    # any uid. 
  1864. X    #
  1865. X    &addto("r", "/etc/passwd", @plan);
  1866. X        &addto("r", "/usr/lib/aliases", @plan);
  1867. X        &addto("r", "/etc/aliases", @plan);
  1868. X
  1869. X    #
  1870. X    # Check CF's for all usernames with this uid.
  1871. X    #
  1872. uname_loop:
  1873. X    foreach $uname (split(/ /, $uid2names{$value})) {
  1874. X        $home = $uname2dir{$uname};
  1875. X
  1876. X        next uname_loop unless $home;
  1877. X
  1878. X        if ($home eq "/") {
  1879. X        $home = "";
  1880. X        }
  1881. X        &addto("r", "$home/.rhosts", @plan);
  1882. X        &addto("r", "$home/.login", @plan);
  1883. X        &addto("r", "$home/.logout", @plan);
  1884. X        &addto("r", "$home/.cshrc", @plan);
  1885. X        &addto("r", "$home/.profile", @plan);
  1886. X    }
  1887. X
  1888. X    #
  1889. X    # Controlling files for root...
  1890. X    #
  1891. X    @rootlist = ( 
  1892. X        "/etc/rc", "/etc/rc.boot", "/etc/rc.single", 
  1893. X        "/etc/rc.config", "/etc/rc.local", "/usr/lib/crontab",
  1894. X        "/usr/spool/cron/crontabs",
  1895. X        );
  1896. X
  1897. X    if ($value eq "0") {
  1898. X        foreach $file (@rootlist) {
  1899. X            &addto("r", $file, @plan);
  1900. X        }
  1901. X        # Experimental!
  1902. X        # you can remove this if desired - tjt
  1903. X        #do "rc.prog";
  1904. X    }
  1905. X
  1906. X    #
  1907. X    # Other CFs for non-root folks...
  1908. X    #
  1909. X    if ($value ne "0") {
  1910. X        &addto("r", "/etc/hosts.equiv", @plan);
  1911. X        if (-s "/etc/hosts.equiv") {
  1912. X        &addto("r", "/etc/hosts", @plan);
  1913. X        }
  1914. X    }
  1915. X
  1916. X    #
  1917. X    # Plans for attacking GIDs...
  1918. X    #
  1919. X    } elsif ($op eq "g") {    # apply gid attack rules
  1920. X
  1921. X    #
  1922. X    # If we can replace /etc/group we can become any group
  1923. X    #                  
  1924. X        &addto("r", "/etc/group", @plan);
  1925. X
  1926. X    #
  1927. X    # If we can grant any member of a group we can grant that group
  1928. X    #
  1929. member_loop:
  1930. X    foreach $uname (split(/ /, $gid2members{$value})) {
  1931. X        if (! defined($uname2uid{$uname})) {
  1932. X        printf(stderr "group '%s' member '%s' doesn't exist.\n",
  1933. X            $value,
  1934. X            $uname);
  1935. X        next member_loop;
  1936. X        }
  1937. X
  1938. X        &addto("u", $uname2uid{$uname}, @plan);
  1939. X    }
  1940. X
  1941. X    #
  1942. X    # Plans for attacking files...
  1943. X    #
  1944. X
  1945. X    } elsif ($op eq "r" || $op eq "w") {
  1946. X
  1947. X        ($owner, $group, $other) = &filewriters($value);
  1948. X
  1949. X    &addto("u", $owner, @plan) if ($owner ne "");
  1950. X    &addto("g", $group, @plan) if ($group ne "");
  1951. X    &addto("u", "-1", @plan) if ($other);
  1952. X
  1953. X    #
  1954. X    # If the goal is to replace the file, check the parent directory...
  1955. X    #
  1956. X    if ($op eq "r") {
  1957. X        $parent = $value;
  1958. X        $parent =~ s#/[^/]*$##;     # strip last / and remaining stuff
  1959. X
  1960. X        if ($parent eq "") {
  1961. X        $parent = "/";
  1962. X        }
  1963. X
  1964. X        if ($parent ne $value) {
  1965. X        &addto("r", $parent, @plan);
  1966. X        }
  1967. X    }
  1968. X
  1969. X    } else {            # wow, bad $type of object!
  1970. X    printf(stderr "kuang: bad op in apply_rules!\n");
  1971. X    printf(stderr "op '%s' value '%s' plan '%s'\n",
  1972. X        $op,
  1973. X        $value,
  1974. X        &ascii_plan(@plan));
  1975. X    exit(1);
  1976. X    }
  1977. }
  1978. X
  1979. 1;
  1980. X
  1981. SHAR_EOF
  1982. chmod 0600 p-cops.alpha/rules.pl ||
  1983. echo 'restore of p-cops.alpha/rules.pl failed'
  1984. Wc_c="`wc -c < 'p-cops.alpha/rules.pl'`"
  1985. test 2768 -eq "$Wc_c" ||
  1986.     echo 'p-cops.alpha/rules.pl: original size 2768, current size' "$Wc_c"
  1987. rm -f _shar_wnt_.tmp
  1988. fi
  1989. rm -f _shar_seq_.tmp
  1990. echo You have unpacked the last part
  1991. exit 0
  1992.