home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3356 < prev    next >
Encoding:
Internet Message Format  |  1991-05-17  |  59.6 KB
  1. From: df@sei.cmu.edu (Dan Farmer)
  2. Newsgroups: alt.sources
  3. Subject: alpha perl-cops, part 1 of 3
  4. Message-ID: <25550@as0c.sei.cmu.edu>
  5. Date: 17 May 91 04:46:08 GMT
  6.  
  7. Submitted-by: df@death.cert.sei.cmu.edu
  8. Archive-name: alpha p-cops/part01
  9.  
  10. #!/bin/sh
  11. # This is alpha p-cops, a shell archive (produced by shar 3.49)
  12. # To extract the files from this archive, save it to a file, remove
  13. # everything above the "!/bin/sh" line above, and type "sh file_name".
  14. #
  15. # made 05/17/1991 04:38 UTC by df@death.cert.sei.cmu.edu
  16. # Source directory /usr/users/df/COPS/perl
  17. #
  18. # existing files will NOT be overwritten unless -c is specified
  19. #
  20. # This is part 1 of a multipart archive                                    
  21. # do not concatenate these parts, unpack them in order with /bin/sh        
  22. #
  23. # This shar contains:
  24. # length  mode       name
  25. # ------ ---------- ------------------------------------------
  26. #   7064 -rwx------ p-cops.alpha/ftp.chk
  27. #   1776 -rwx------ p-cops.alpha/get-cf
  28. #   1292 -rwx------ p-cops.alpha/chk_strings
  29. #   3559 -rwx------ p-cops.alpha/chk_strings.pl
  30. #   2129 -rwx------ p-cops.alpha/cops.cf
  31. #   2399 -rwx------ p-cops.alpha/cron.chk
  32. #   6390 -rwx------ p-cops.alpha/cops
  33. #    463 -rwx------ p-cops.alpha/fgrep.pl
  34. #    413 -rwx------ p-cops.alpha/file_mode.pl
  35. #    398 -rwx------ p-cops.alpha/file_owner.pl
  36. #   2739 -rwx------ p-cops.alpha/dev.chk
  37. #    902 -rwx------ p-cops.alpha/getopts.pl
  38. #   2960 -rwx------ p-cops.alpha/glob.pl
  39. #   5060 -rwx------ p-cops.alpha/group.chk
  40. #    444 -rwx------ p-cops.alpha/hostname.pl
  41. #   1591 -rwx------ p-cops.alpha/is_able.chk
  42. #   1603 -rwx------ p-cops.alpha/is_able.lst
  43. #   2835 -rwx------ p-cops.alpha/is_able.pl
  44. #  14688 -rwx------ p-cops.alpha/kuang
  45. #   4413 -rwx------ p-cops.alpha/misc.chk
  46. #   6730 -rw------- p-cops.alpha/kuang.1
  47. #  10420 -rwx------ p-cops.alpha/pass.cache.pl
  48. #   6684 -rwx------ p-cops.alpha/pass.chk
  49. #   5989 -rwx------ p-cops.alpha/passwd.chk
  50. #    677 -rwx------ p-cops.alpha/pathconf.pl
  51. #    644 -rwx------ p-cops.alpha/pathconf.sh
  52. #   1014 -rwx------ p-cops.alpha/rc.chk
  53. #   3296 -rwx------ p-cops.alpha/reconfig.pl
  54. #   2048 -rwx------ p-cops.alpha/user.chk
  55. #    653 -rwx------ p-cops.alpha/stat.pl
  56. #    229 -rwx------ p-cops.alpha/suckline.pl
  57. #   4477 -rwx------ p-cops.alpha/suid.chk
  58. #   5959 -rwx------ p-cops.alpha/root.chk
  59. #   4848 -rwx------ p-cops.alpha/README.perl
  60. #   6206 -rwx------ p-cops.alpha/root.chk.old
  61. #   9306 -rw------- p-cops.alpha/README.kuang
  62. #      0 -rwx------ p-cops.alpha/suid.stop
  63. #   9915 -rw------- p-cops.alpha/pwgrid.pl
  64. #   6147 -rwx------ p-cops.alpha/root.chk.new
  65. #   2768 -rw------- p-cops.alpha/rules.pl
  66. #
  67. if test -r _shar_seq_.tmp; then
  68.     echo 'Must unpack archives in sequence!'
  69.     echo Please unpack part `cat _shar_seq_.tmp` next
  70.     exit 1
  71. fi
  72. # ============= p-cops.alpha/ftp.chk ==============
  73. if test ! -d 'p-cops.alpha'; then
  74.     echo 'x - creating directory p-cops.alpha'
  75.     mkdir 'p-cops.alpha'
  76. fi
  77. if test -f 'p-cops.alpha/ftp.chk' -a X"$1" != X"-c"; then
  78.     echo 'x - skipping p-cops.alpha/ftp.chk (File already exists)'
  79.     rm -f _shar_wnt_.tmp
  80. else
  81. > _shar_wnt_.tmp
  82. echo 'x - extracting p-cops.alpha/ftp.chk (Text)'
  83. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/ftp.chk' &&
  84. #!/bin/sh  # need to mention perl here to avoid recursion
  85. #
  86. #  Usage: ftp.chk
  87. #
  88. #   This shell script checks to see if you've set up (mainly anonymous)
  89. # ftp correctly.  There seems to be some different types of ftp's 
  90. # around; for instance, some allow "chmod" -- and if the home dir is 
  91. # owned by "ftp", you're toast.  So I've tried to err on the side of
  92. # safety...
  93. #
  94. #   See the man page for a more detailed description, here's what this
  95. # checks for:
  96. #
  97. # - User ftp exists in the password file.
  98. # - root (or all root equivalents) are in ftpusers file.
  99. # - Home directory for ftp should exist, and not be /
  100. # - The ~ftp/etc/{passwd|group} should not be the same as the real ones.
  101. # - Various critical files/directories should exist, and have correct
  102. #   permissions and owners; variables "$primary" and "$secondary" can be set
  103. # to whomever you want owning the files:
  104. #
  105. #  File/Dir          Perms           Owner      Other
  106. #  =========         ======          ======     ======
  107. #  ~ftp              non-w.w.        root
  108. #           or
  109. #  ~ftp              555             ftp    if no chmod command exists
  110. #
  111. #     All of these are ftp owned iff no chmod exists...
  112. #
  113. #  ~ftp/bin          non-w.w.        root/ftp
  114. #  ~ftp/bin/ls       111             root/ftp
  115. #  ~ftp/etc          non-w.w.        root/ftp
  116. #  ~ftp/etc/passwd   non-w.w.        root/ftp   0 size or nonexistant
  117. #  ~ftp/etc/group    non-w.w.        root/ftp   0 size or nonexistant
  118. #  ~ftp/pub          non-w.w.        root/ftp
  119. #  ~ftp/incoming     world-writable  root/ftp   This can be set to "pub"
  120. #  ~ftp/.rhosts      non-w.w.        root       0 size, is optional
  121. #  ~ftp/*            non-w.w.                   other dirs/files in ~ftp
  122. #
  123. #
  124. #  NOTE:
  125. # 
  126. # if you know where perl is and your system groks #!, put its
  127. # pathname at the top to make this a tad faster.
  128. #
  129. # the following magic is from the perl man page
  130. # and should work to get us to run with perl 
  131. # even if invoked as an sh or csh or foosh script.
  132. # notice we don't use full path cause we don't
  133. # know where the user has perl on their system.
  134. #
  135. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  136. & eval 'exec perl -S $0 $argv:q'
  137. X    if $running_under_some_stupid_shell_instead_of_perl;
  138. X
  139. require 'is_able.pl';
  140. require 'file_mode.pl';
  141. require 'glob.pl';
  142. require 'fgrep.pl';
  143. require 'pass.cache.pl';
  144. require 'file_owner.pl';
  145. require 'pathconf.pl';
  146. X
  147. $CMP="/bin/cmp" unless defined $CMP;
  148. X
  149. package ftp;
  150. X
  151. #   Primary and secondary owners of the ftp files/dirs; if you *don't* have
  152. # chmod, you can probably change the secondary owner to "ftp".  If you have
  153. # chmod in your ftp, definitely have secondary to some other account (root
  154. # is fine for this.)
  155. local($primary)="root" unless defined $primary;
  156. local($secondary)="ftp" unless defined $secondary;
  157. X
  158. # some might have this as ftpd; is the account in /etc/passwd
  159. local($ftpuid)="ftp";
  160. X
  161. # system files
  162. local($ftpusers)="/etc/ftpusers";
  163. local($passwd)="/etc/passwd" unless defined $PASSWD;
  164. local($group)="/etc/group" unless defined $GROUP;
  165. X
  166. #   ftp's home:
  167. $ftproot = &'uname2dir($ftpuid);
  168. $anonymous = $ftproot ne '';
  169. X
  170. local($ftprhosts)="$ftproot/.rhosts";
  171. local($ftpbin)="$ftproot/bin";
  172. local($ftpls)="$ftpbin/ls";
  173. local($ftpetc)="$ftproot/etc";
  174. local($ftppasswd)="$ftpetc/passwd";
  175. local($ftpgroup)="$ftpetc/group";
  176. X
  177. local($W) = 'Warning!   ' unless defined $W;
  178. X
  179. #   the pub/incoming stuff; by default, pub is *not* world writable, incoming
  180. # is; if you want pub to be world writable, just change incoming to "pub"
  181. local($incoming)="pub";
  182. X
  183. @crit_files=($ftpgroup,
  184. X         $ftppasswd,
  185. X         $ftpls);
  186. X
  187. if (-s $ftpusers) {
  188. X    # check to see if root (or root equivalents) is in ftpusers file
  189. X    @all_roots = split(" ", $'uid2names{0});
  190. X    if (@all_roots ne "") {
  191. X    for $i (@all_roots) {
  192. X        if (length($user2passwd{$i}) == 13 && ! &'fgrep($ftpusers, "^$i$")) {
  193. X        print "Warning!  $i should be in $ftpusers!\n";
  194. X        }
  195. X    }
  196. X    }
  197. }
  198. X
  199. #  do the anonymous ftp checking stuff now?
  200. die unless $anonymous;
  201. X
  202. #   if the user ftp doesn't exist, no-anon stuff....
  203. # if $TEST -z $ftproot -a "$anonymous" = "yes" ; then
  204. X
  205. die "${W}Need user $ftpuid for anonymous ftp to work!\n" if ($ftpuid eq "");
  206. X
  207. #   if the user ftp doesn't exist, no-anon stuff....
  208. if (! -d $ftproot || $ftproot eq "") {
  209. X    die "${W}Home directory for ftp doesn\'t exist!\n";
  210. }
  211. if ($ftproot eq "/") {
  212. X    print "${W}$ftproot ftp\'s home directory should not be \"/\"!\n";
  213. }
  214. X
  215. #   want to check all the critical files and directories for correct
  216. # ownership.  Some versions of ftp don't need much of anything... no 
  217. # etc directory or password/group files.
  218. #   others need etc directory & password/group files.  Experiment.
  219. #
  220. push(@crit_files, $ftpbin, $ftpetc);
  221. for $i (@crit_files) {
  222. X    $owner = &'Owner($i);
  223. X
  224. X    if ($owner eq 'BOGUS') {
  225. X    print "${W}Critical anon-ftp file $i is missing!\n";
  226. X    next;
  227. X    }
  228. X
  229. X    $owner = $'uid2names{$owner};
  230. X
  231. X    if ($owner ne $primary && $owner ne $secondary) {
  232. X    print "${W}$i should be owned by $primary or $secondary, not $owner!\n";
  233. X    }
  234. }
  235. X
  236. #  Don't want the passwd and group files to be the real ones!
  237. if (&'Owner($ftppasswd) ne 'BOGUS' &&
  238. X    $passwd ne $ftppasswd && 
  239. X    system "$CMP -s $passwd $ftppasswd") 
  240. {
  241. X    print "${W}$ftppasswd and $passwd are the same!\n";
  242. }
  243. X
  244. if (&'Owner($ftpgroup) ne 'BOGUS' &&
  245. X    $group ne $ftpgroup && 
  246. X    system "$CMP -s $passwd $ftpgroup") 
  247. {
  248. X    print "${W}$ftpgroup and $group are the same!\n";
  249. }
  250. X
  251. #   ftproot is special; if owned by root; should be !world writable;
  252. # if owned by ftp, should be mode 555
  253. X
  254. if (&'Owner($ftproot) ne BOGUS) {
  255. X    $owner = $'uid2names{&'Owner($ftproot)};
  256. X    $perms=&'Mode($ftproot);
  257. X    if ($owner ne $primary && $owner ne $secondary) {
  258. X    print "${W}$ftproot should be owned by $primary or $secondary, not $owner!\n";
  259. X    }
  260. X
  261. X    # ftp-root should not be world-writable:
  262. X    &'is_able($ftproot, "w", "w");
  263. X
  264. X    # if ftp owns root-dir, then mode should be 555:
  265. X    if ($owner eq $ftpuid && $perms ne 00555) {
  266. X    print "${W}$ftproot should be mode 555!\n";
  267. X    }
  268. }
  269. X
  270. #
  271. # check the .rhosts file:
  272. if (-f $ftprhosts) {
  273. X    if (-s $ftprhosts) {
  274. X    print "${W}$ftprhosts should be be empty!\n";
  275. X    }
  276. X    $owner=$'uid2names{&'Owner($ftprhosts)};
  277. X    if ($owner ne $primary && $owner ne $secondary) {
  278. X    print "${W}$ftprhosts should be owned by $primary or $secondary!\n";
  279. X    }
  280. }
  281. X
  282. # finally, some permissions of miscellaneous files:
  283. if (($perms=&'Mode($ftpls)) & 0666) {
  284. X    printf "${W}Incorrect permissions (%04o) on $ftpls!\n", $perms;
  285. }
  286. X
  287. if (($perms=&'Mode($ftppasswd)) & 0333) {
  288. X    printf "${W}Incorrect permissions (%04o) on $ftppasswd!\n", $perms;
  289. }
  290. X
  291. X
  292. if (($perms=&'Mode($ftpgroup)) & 0333) {
  293. X    printf "${W}Incorrect permissions (%04o) on $ftpgroup!\n", $perms;
  294. }
  295. X
  296. #   Finally, the ~ftp/{pub|incoming|whatever} stuff:
  297. opendir(FTPDIR, $ftproot) || die "can't opendir $ftproot: $!";
  298. X
  299. @all_dirs=grep(-d, readdir(FTPDIR));
  300. X
  301. local($is_able'silent) = 1;  
  302. for $i (@all_dirs) {
  303. X    if ($i ne $incoming && &'is_able($ftproot . "/$i", "w", "w")) {
  304. X    print "${W}Anon-ftp directory $i is World Writable!\n";
  305. X    }
  306. }
  307. X
  308. 1;
  309. # end of script
  310. SHAR_EOF
  311. chmod 0700 p-cops.alpha/ftp.chk ||
  312. echo 'restore of p-cops.alpha/ftp.chk failed'
  313. Wc_c="`wc -c < 'p-cops.alpha/ftp.chk'`"
  314. test 7064 -eq "$Wc_c" ||
  315.     echo 'p-cops.alpha/ftp.chk: original size 7064, current size' "$Wc_c"
  316. rm -f _shar_wnt_.tmp
  317. fi
  318. # ============= p-cops.alpha/get-cf ==============
  319. if test -f 'p-cops.alpha/get-cf' -a X"$1" != X"-c"; then
  320.     echo 'x - skipping p-cops.alpha/get-cf (File already exists)'
  321.     rm -f _shar_wnt_.tmp
  322. else
  323. > _shar_wnt_.tmp
  324. echo 'x - extracting p-cops.alpha/get-cf (Text)'
  325. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/get-cf' &&
  326. #! /usr/local/bin/perl
  327. X
  328. @dot_files = (
  329. X    ".login", ".logout", ".cshrc",            # csh, cshe or tcsh
  330. X    ".profile",                        # ksh, sh
  331. X    ".env",                        # ksh
  332. X    ".alias", ".aliases",                # common for all shells
  333. X    "user.ps", ".user.ps", "tools.ps", ".tools.ps",
  334. X    "startup.ps", ".startup.ps",            # NeWS
  335. X    ".mgrc",                        # MGR
  336. X    ".X11init", ".awmrc", ".twmrc", ".xinitrc",        # X11
  337. X    ".emacs"                        # emacs
  338. );
  339. X
  340. %seen = {};
  341. X
  342. open(HOST, "/bin/hostname |") || die "can't get the hostname";
  343. chop($hostname=<HOST>);
  344. close(HOST);
  345. X
  346. user_loop:
  347. X    for (($name,$passwd,$uid,$gid,$quota,$comment,$gcos,$dir,$shell) = getpwent();
  348. X         $name ne "";
  349. X         ($name,$passwd,$uid,$gid,$quota,$comment,$gcos,$dir,$shell) = getpwent()) {
  350. X
  351. X    #
  352. X    # If the user has a home directory on this server, get the info 
  353. X    # about the directory, his CF's and so on.
  354. X    #
  355. X    if ($dir =~ m,^/n/$hostname/,) {
  356. X        if (! -d $dir) {
  357. X        printf(stderr "home directory '%s' for user '%s' doesn't exist.\n",
  358. X            $dir,
  359. X            $name);
  360. X        next user_loop;
  361. X        }
  362. X
  363. X        ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
  364. X                    $atime,$mtime,$ctime,$blksize,$blocks)
  365. X                        = stat(_);
  366. X        $mode = $mode & 07777;
  367. X
  368. X        &spit_it_out("d", $uid, $gid, $mode, $dir);
  369. X
  370. X        foreach $file (@dot_files) {
  371. X        $path = "$dir/$file";
  372. X
  373. X        if (-f $path) {
  374. X            ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
  375. X                        $atime,$mtime,$ctime,$blksize,$blocks)
  376. X                            = stat(_);
  377. X            $mode = $mode & 07777;
  378. X
  379. X            &spit_it_out("f", $uid, $gid, $mode, $dir);
  380. X        }
  381. X        }
  382. X    }
  383. X    }
  384. X
  385. X
  386. X
  387. X
  388. sub spit_it_out {
  389. X    local($type, $uid, $gid, $mode, $name) = @_;
  390. X
  391. X    if (defined($seen{$name})) {
  392. X    return;
  393. X    }
  394. X
  395. X    printf("%s %d %d 0%o %s\n", $type, $uid, $gid, $mode, $name);
  396. X    $seen{$name} = 1;
  397. }
  398. X
  399. SHAR_EOF
  400. chmod 0700 p-cops.alpha/get-cf ||
  401. echo 'restore of p-cops.alpha/get-cf failed'
  402. Wc_c="`wc -c < 'p-cops.alpha/get-cf'`"
  403. test 1776 -eq "$Wc_c" ||
  404.     echo 'p-cops.alpha/get-cf: original size 1776, current size' "$Wc_c"
  405. rm -f _shar_wnt_.tmp
  406. fi
  407. # ============= p-cops.alpha/chk_strings ==============
  408. if test -f 'p-cops.alpha/chk_strings' -a X"$1" != X"-c"; then
  409.     echo 'x - skipping p-cops.alpha/chk_strings (File already exists)'
  410.     rm -f _shar_wnt_.tmp
  411. else
  412. > _shar_wnt_.tmp
  413. echo 'x - extracting p-cops.alpha/chk_strings (Text)'
  414. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/chk_strings' &&
  415. #!/bin/sh  # need to mention perl here to avoid recursion
  416. #
  417. #  Usage: chk_strings filename
  418. #
  419. #  This will check pathnames inside executable files for writability,
  420. # The big string "@ignores" is a list of files that are ignored by
  421. # this; you can set it to whatever you want -- default is:
  422. # '^/tmp/?' and '^/(var|usr)/tmp/?'
  423. # 
  424. #  No program root EVER runs should be show up here.
  425. #
  426. # NOTE:
  427. #   If you know where perl is and your system groks #!, put its
  428. # pathname at the top to make this a tad faster.
  429. #
  430. # the following magic is from the perl man page
  431. # and should work to get us to run with perl 
  432. # even if invoked as an sh or csh or foosh script.
  433. # notice we don't use full path cause we don't
  434. # know where the user has perl on their system.
  435. #
  436. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  437. & eval 'exec perl -S $0 $argv:q'
  438. X    if $running_under_some_stupid_shell_instead_of_perl;
  439. X
  440. package main;
  441. X
  442. $| = 1;
  443. X
  444. require 'getopts.pl';
  445. require 'chk_strings.pl';
  446. X
  447. die "Usage: $0 [-fr] file ...\n" unless &Getopts('rd') && @ARGV;
  448. X
  449. package chk_strings;
  450. X
  451. $debug = $'opt_d;
  452. $recurse = $'opt_r;
  453. @ignores = ( '^/tmp/?', '^/(var|usr)/tmp/?' )
  454. X    unless defined @ignores;
  455. X
  456. #%paths = ();  # faster than local
  457. X
  458. for (@'ARGV) { 
  459. X    (warn("$0: $_: $!\n"), next) unless -e;
  460. X    &'chk_strings($_); 
  461. } 
  462. SHAR_EOF
  463. chmod 0700 p-cops.alpha/chk_strings ||
  464. echo 'restore of p-cops.alpha/chk_strings failed'
  465. Wc_c="`wc -c < 'p-cops.alpha/chk_strings'`"
  466. test 1292 -eq "$Wc_c" ||
  467.     echo 'p-cops.alpha/chk_strings: original size 1292, current size' "$Wc_c"
  468. rm -f _shar_wnt_.tmp
  469. fi
  470. # ============= p-cops.alpha/chk_strings.pl ==============
  471. if test -f 'p-cops.alpha/chk_strings.pl' -a X"$1" != X"-c"; then
  472.     echo 'x - skipping p-cops.alpha/chk_strings.pl (File already exists)'
  473.     rm -f _shar_wnt_.tmp
  474. else
  475. > _shar_wnt_.tmp
  476. echo 'x - extracting p-cops.alpha/chk_strings.pl (Text)'
  477. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/chk_strings.pl' &&
  478. #
  479. #  This is a big one.  Support routines to check for strings 
  480. # that look like pathnames and make sure they're not writable.
  481. # Will recurse if $recurse is set.  the shell version can't do
  482. # this (yet).  call &ignore with list of regexps that you don't
  483. # care about.  (or set @ignores)
  484. #
  485. # originally by Tom Christiansen <tchrist@convex.com>
  486. # since hacked on by parties various and sundry.
  487. X
  488. require 'is_able.pl';
  489. require 'file_mode.pl';
  490. require 'pathconf.pl';
  491. X
  492. package chk_strings;
  493. X
  494. X
  495. $'STRINGS = $'STRINGS || '/usr/ucb/strings';
  496. X
  497. for ( '/dev/null', '/dev/tty' ) {
  498. X    $seen{$_}++;
  499. } 
  500. X
  501. sub main'chk_strings {
  502. X    local($ARGV) = @_;
  503. X    local($_);
  504. X    local($word);
  505. X    local(*STRINGS);  # XXX: might run out of fd's on deep recursion!  -tchrist
  506. X    local(%paths, $text); 
  507. X    local($STRINGS) = "$'STRINGS $ARGV |";
  508. X
  509. X    &ignore(@ignores) if defined @ignores && !$already_ignored;
  510. X
  511. X    $STRINGS="< $ARGV", $text=1 if -T $ARGV;
  512. X    print "Opening via: $STRINGS\n" if $debug;
  513. X
  514. X    open (STRINGS, $STRINGS); 
  515. X    while (<STRINGS>) { 
  516. X    next unless m#/#;   # was m#/.*/#;
  517. #---------------------------------------------------------------------------
  518. # Comments and modifications by Martin Foord (maf%dbsm.oz.au@munnari.oz.au).
  519. X    #s/#.*$// if $text;  # strip out comments if -T file
  520. X    # Comments start in the shell at the beginning of a word or at the
  521. X    # beggining of a line
  522. X    if ($text) {
  523. X        s/\s+#.*$//;
  524. X        s/^#.*$//;
  525. X    }
  526. X
  527. X    # Get rid of semicolons, they can hang around on filenames ...
  528. X    s/;//g;
  529. #---------------------------------------------------------------------------
  530. X
  531. X    s/"([^"]*)"/ $1 /g;
  532. X    s/'([^']*)'/ $1 /g;
  533. X    # See my comments below on how to deal with this stuff ... (line 64).
  534. X    #s/`([^`]*)`/ $1 /g;
  535. X
  536. X
  537. X    s!([<>])\s+/!$1/!g;  # "> /foo" goes to ">foo";
  538. X
  539. X    s/=/ /g;  # warning -- mangled files with = in them
  540. X    for $word (split) {
  541. X        if ($word =~ m#:/#) {
  542. X        @paths{split(/:/, $word)} = ();
  543. X        } elsif ($word =~ m#^[<>]?/#) {
  544. X        print "push $word\n" if $debug;
  545. X        $paths{$word}++;
  546. X        }
  547. X    }
  548. X    }
  549. X    close (STRINGS);
  550. X    push(@files, $ARGV);
  551. X
  552. X    for (keys %paths) {
  553. X    s/\)$//;
  554. X    s/^\(//;
  555. X    s#^/+#/#;
  556. X    s#^(/.*)/$#$1#;        # get rid of trailing slash
  557. X
  558. #---------------------------------------------------------------------------
  559. # Comments and modifications by Martin Foord (maf%dbsm.oz.au@munnari.oz.au).
  560. X    # It's best to evaluate what's in backquotes rather than remove them
  561. X    # as in the substitution above, due to files which
  562. X    # look like this /var/yp/`domainname` (eg in my /etc/rc.local).
  563. X    s`\`(.+)\``$1`; # eval what's in backquotes.
  564. X    chop if /\n$/;    # fang off \n if there ...
  565. #---------------------------------------------------------------------------
  566. X    next if &ignored($_);
  567. X    s/^[<>]//;
  568. X    next if $_ eq '';
  569. X    next unless !$seen{$_}++ && -e && !-S _;
  570. X    print "checking $_\n" if $debug;
  571. X    if ($how = &'is_writable($_)) {
  572. X        print "Warning!  File $_ (inside ",
  573. X            join(' inside ', reverse @files), ") is _World_ $how!\n";
  574. X    } elsif ($recurse && (&'Mode($_) & 0111) && -f _) {
  575. X         print "recursing $_\n" if $debug;
  576. X         &'chk_strings($_);   
  577. X    } 
  578. X    }
  579. X     pop(@files);
  580. } 
  581. X
  582. sub ignore {
  583. X    local($_);
  584. X    local($prog);
  585. X
  586. X    $already_ignored = 1;
  587. X
  588. X    $prog = <<'EOCODE';
  589. X
  590. sub ignored {
  591. X    local($return) = 1;
  592. X    local($prog);
  593. X    local($_) = @_;
  594. X    {
  595. EOCODE
  596. X    for (@_) {
  597. X    $prog .= "\tlast if m\201${_}\201;\n";
  598. X    } 
  599. X    $prog .= <<'EOCODE';
  600. X    $return = 0;
  601. X    }
  602. X    print "$_ IGNORED\n" if $debug && $return;
  603. X    $return;
  604. }
  605. EOCODE
  606. X    
  607. X    print $prog if $debug;
  608. X    eval $prog;
  609. X    die $@ if $@;
  610. } 
  611. X
  612. sub ignored {}; # in case they never ignore anything
  613. X
  614. 1;
  615. SHAR_EOF
  616. chmod 0700 p-cops.alpha/chk_strings.pl ||
  617. echo 'restore of p-cops.alpha/chk_strings.pl failed'
  618. Wc_c="`wc -c < 'p-cops.alpha/chk_strings.pl'`"
  619. test 3559 -eq "$Wc_c" ||
  620.     echo 'p-cops.alpha/chk_strings.pl: original size 3559, current size' "$Wc_c"
  621. rm -f _shar_wnt_.tmp
  622. fi
  623. # ============= p-cops.alpha/cops.cf ==============
  624. if test -f 'p-cops.alpha/cops.cf' -a X"$1" != X"-c"; then
  625.     echo 'x - skipping p-cops.alpha/cops.cf (File already exists)'
  626.     rm -f _shar_wnt_.tmp
  627. else
  628. > _shar_wnt_.tmp
  629. echo 'x - extracting p-cops.alpha/cops.cf (Text)'
  630. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/cops.cf' &&
  631. #
  632. # COPS CONFIGURATION FILE
  633. #
  634. # put user variables here: anything beginning with /^\s*[$@%&]/ will be eval'd
  635. # in general, variables in package main are for cops itself, whereas
  636. # those with package qualifiers are for a particular chk routine or
  637. # for auxiliary routines.
  638. X
  639. # COPS  main variables follow...
  640. $NMAIL         = 0;         # send mail instead of generating reports
  641. $ONLY_DIFF     = 0;          # only send diff from last time
  642. $SECURE_USERS   = "root";     # user to receive mailed report
  643. $C2             = 0;        # Sun c2 security package
  644. X
  645. # these don't really work for pass.cache yet
  646. $IGNORE_YP    = 0;
  647. $PASSWD        = '/etc/passwd';
  648. $GROUP        = '/etc/group';
  649. X
  650. ###############################################################
  651. # many things call &chk_strings (including {cron,misc,rc,root}.chk)
  652. # the following two variable settings affects its behaviour...
  653. # this one says to ignore warnings about paths matching these regexps
  654. X
  655. @chk_strings'ignores = ( '^/tmp/?', '^/(var|usr)/tmp/?' );
  656. X
  657. # this will take a bit longer, but can find dangerous things much better
  658. # the shell cops can't do this.... sigh
  659. X
  660. $chk_strings'recurse = 0;
  661. X
  662. # if we want stat failure warnings from is_able...
  663. X
  664. $is_able'noisy = 0;  
  665. X
  666. ###############################################################
  667. # finally the checks to execute.  these can also all be run 
  668. # stand-alone from the shell.
  669. X
  670. # first test the security of the root account
  671. root.chk
  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. # exaustive tests for things that shouldn't be readable/writable etc
  680. is_able.chk
  681. X
  682. # check for insecuities in /etc/rc*
  683. rc.chk
  684. X
  685. # and in cron
  686. cron.chk
  687. X
  688. # some consistency and idiocy (null or trivial passwds) in /etc/passwd
  689. passwd.chk
  690. pass.chk
  691. X
  692. # consistency checks in /etc/group
  693. group.chk
  694. X
  695. # make sure user accounts don't have trojanable dot files
  696. user.chk
  697. X
  698. # check ftp security
  699. $ftp'primary = "root";
  700. $ftp'secondary = "ftp";
  701. ftp.chk
  702. X
  703. # and anything else we forgot
  704. X
  705. # Sys V types use /etc/servers here:
  706. $misc'inetd = "/etc/inetd";
  707. misc.chk
  708. X
  709. # Kuang!
  710. kuang
  711. X
  712. # SUID checking
  713. # suid.chk
  714. SHAR_EOF
  715. chmod 0700 p-cops.alpha/cops.cf ||
  716. echo 'restore of p-cops.alpha/cops.cf failed'
  717. Wc_c="`wc -c < 'p-cops.alpha/cops.cf'`"
  718. test 2129 -eq "$Wc_c" ||
  719.     echo 'p-cops.alpha/cops.cf: original size 2129, current size' "$Wc_c"
  720. rm -f _shar_wnt_.tmp
  721. fi
  722. # ============= p-cops.alpha/cron.chk ==============
  723. if test -f 'p-cops.alpha/cron.chk' -a X"$1" != X"-c"; then
  724.     echo 'x - skipping p-cops.alpha/cron.chk (File already exists)'
  725.     rm -f _shar_wnt_.tmp
  726. else
  727. > _shar_wnt_.tmp
  728. echo 'x - extracting p-cops.alpha/cron.chk (Text)'
  729. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/cron.chk' &&
  730. #!/bin/sh  # need to mention perl here to avoid recursion
  731. #
  732. #  Usage: cron.chk.pl [-rd]
  733. #
  734. #  This checks pathnames and files inside the cron files /usr/lib/crontab
  735. # for writability.
  736. #
  737. #  Mechanism:  The commands inside the file /usr/lib/crontab are executed
  738. # by root.  This perl script uses chk_strings.pl for chking for writable
  739. # files/dirs.
  740. #
  741. #  cron.chk.pl will try to find a file in /usr/lib/crontab first (bsd),
  742. # and then if it isn't there, it will look in the any alternate
  743. # possible locations next -- right now, /usr/spool/cron/crontab -- to
  744. # see if a directory exists, and, if it does, it checks all the cron
  745. # files in turn.
  746. #
  747. #  WARNING!
  748. #
  749. #  Spurious messages can occur; a more stringent method (if perhaps less
  750. # careful of a check) would be to test just the 6th field, instead of
  751. # all the fields after the fifth.  Also throwing away /tmp, etc. could
  752. # be a mistake.
  753. #
  754. #  NOTE:
  755. # if you know where perl is and your system groks #!, put its
  756. # pathname at the top to make this a tad faster.
  757. #
  758. # the following magic is from the perl man page
  759. # and should work to get us to run with perl 
  760. # even if invoked as an sh or csh or foosh script.
  761. # notice we don't use full path cause we don't
  762. # know where the user has perl on their system.
  763. #
  764. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  765. & eval 'exec perl -S $0 $argv:q'
  766. X    if $running_under_some_stupid_shell_instead_of_perl;
  767. X
  768. package main;
  769. X
  770. require 'getopts.pl';
  771. require 'glob.pl';
  772. require 'chk_strings.pl';
  773. require 'pathconf.pl';
  774. X
  775. # should also add args to override default crontab locations
  776. die "Usage: $0 [-rd]\n" unless &Getopts('rd') && !@ARGV;
  777. X
  778. $chk_strings'debug = $opt_d;
  779. $chk_strings'recurse = $opt_r;
  780. X
  781. package cron_chk;
  782. X
  783. #  Possible location of crontab file:
  784. $cron = "/usr/lib/crontab";
  785. #  alternate reality locations of crontab file:
  786. @alt_cron = ("/usr/spool/cron/crontabs");
  787. X
  788. if ( ! -s $cron) {
  789. X    for (@alt_cron) {
  790. X    # are there ever multiple crontab directories?
  791. X    (@crons = &'glob("$_/*")), last if -d;
  792. X    }
  793. X    die "No crontabs?\n" if ! @crons;
  794. }
  795. @crons = ($cron) unless @crons;
  796. X
  797. # ignore /tmp /dev/null and tty stuff
  798. # &'chk_strings ignores all of above
  799. # STILL NEED to ignore stuff after `>'
  800. #   when we add @ignore stuff to &'chk_strings
  801. X
  802. # finally, do the checking -- maybe for one, maybe for lots of cron-ites:
  803. for (@crons) {
  804. X    if (! -e) {
  805. X    warn "$0: $_: $!\n";
  806. X    next;
  807. X    }
  808. X    &'chk_strings($_);
  809. }
  810. X
  811. 1;
  812. SHAR_EOF
  813. chmod 0700 p-cops.alpha/cron.chk ||
  814. echo 'restore of p-cops.alpha/cron.chk failed'
  815. Wc_c="`wc -c < 'p-cops.alpha/cron.chk'`"
  816. test 2399 -eq "$Wc_c" ||
  817.     echo 'p-cops.alpha/cron.chk: original size 2399, current size' "$Wc_c"
  818. rm -f _shar_wnt_.tmp
  819. fi
  820. # ============= p-cops.alpha/cops ==============
  821. if test -f 'p-cops.alpha/cops' -a X"$1" != X"-c"; then
  822.     echo 'x - skipping p-cops.alpha/cops (File already exists)'
  823.     rm -f _shar_wnt_.tmp
  824. else
  825. > _shar_wnt_.tmp
  826. echo 'x - extracting p-cops.alpha/cops (Text)'
  827. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/cops' &&
  828. #!/bin/sh  # need to mention perl here to avoid recursion
  829. #
  830. #  Usage: cops [-v] [-c config file] [-s secure_dir] [architecture]
  831. #
  832. #  This will change into the $SECURE/architecture directory, suck lots
  833. # of info and configuration stuff out of "cops.cf", and runs all of the
  834. # security programs in that file.  If any of the programs find any 
  835. # security problems, it either sends mail to everyone in the $SECURE_USERS
  836. # list (see "cops.cf"), or saves the results in a file 
  837. # $SECURE/architecture/hostname.  It then destroys all temporary files, 
  838. # and exits the program.  Programs that are run (besides this one):
  839. #
  840. #    root.chk    dev.chk        group.chk
  841. #    rc.chk        passwd.chk    is_able.chk
  842. #    pass.chk     user.chk    cron.chk
  843. #    misc.chk    ftp.chk
  844. #
  845. #  This -v (verbose) flag prints out the name each program to 
  846. # the results file as it is executed.  The -s and -c flags allow you
  847. # to specify the $SECURE directory and $CONFIG file, respectively.
  848. # 
  849. # NOTE:
  850. #   If you know where perl is and your system groks #!, put its
  851. # pathname at the top to make this a tad faster.
  852. #
  853. # the following magic is from the perl man page
  854. # and should work to get us to run with perl 
  855. # even if invoked as an sh or csh or foosh script.
  856. # notice we don't use full path cause we don't
  857. # know where the user has perl on their system.
  858. #
  859. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  860. & eval 'exec perl -S $0 $argv:q'
  861. X    if $running_under_some_stupid_shell_instead_of_perl;
  862. X
  863. ######################################
  864. # perl COPS main driver.
  865. # tchrist@convex.com
  866. ######################################
  867. X
  868. # security sanity settings
  869. #
  870. $ENV{'IFS'} = '' if $ENV{'IFS'};
  871. $ENV{'PATH'} = '/bin:/usr/bin:/usr/ucb';
  872. $| = 1;
  873. umask 077;
  874. X
  875. #
  876. # Getopts stuff
  877. $usage = "Usage: $0 [-v] [-c config_file] [-s secure_dir] architecture\n";
  878. require 'getopts.pl';
  879. # Process the command args; Either specify verbose or an alternate config file:
  880. die $usage unless &Getopts('vc:s:');
  881. X
  882. if (defined($opt_v)) { $verbose = $opt_v;}
  883. else { $verbose = 0; }
  884. X
  885. if (defined($opt_s)) { $SECURE = $LIBCOPS = $opt_s; }
  886. else { $SECURE = $LIBCOPS = '.'; }
  887. X
  888. if (defined($opt_c)) { $CONFIG = $opt_c; }
  889. else {$CONFIG = "$SECURE/cops.cf"; }
  890. X
  891. if (@ARGV > 1) {
  892. X    die $usage;
  893. } elsif (@ARGV == 1) {
  894. X    $SECURE = shift;
  895. X    die "Architecture directory $SECURE does not exist\n" unless -d $SECURE;
  896. X    chdir($SECURE) || die "can't cd to $SECURE: $!";
  897. X    exec './cops';
  898. } 
  899. X
  900. # internal cops stuff needed
  901. require "$LIBCOPS/pathconf.pl";
  902. require "$LIBCOPS/is_able.pl";
  903. X
  904. chmod 0700, $SECURE;  
  905. chdir ($SECURE) || die "Error -- Security directory $SECURE doesn't exist";
  906. X
  907. #  Read stuff to do from the config file
  908. die "$0: Can't trust $CONFIG to reconfig!"     if &'is_writable($CONFIG);
  909. open CONFIG || die "can't open $CONFIG: $!";
  910. X
  911. &argh unless -s $CONFIG;
  912. X
  913. &init_result;
  914. X
  915. while (<CONFIG>) {
  916. X    next if /^\s*#/;
  917. X    next if /^\s*$/;
  918. X
  919. X    if (/^\s*[\$&\@\%]/) {  #  reset a config variable
  920. X    s/#.*//;
  921. X    eval;
  922. X    warn "Bad config variable at line $. of $CONFIG:\n\t$_\t$@\n" if $@;
  923. X    next;
  924. X    } 
  925. X
  926. X    # must be a program to run
  927. X    chop;
  928. X    s/#.*//;
  929. X    s/;$//;
  930. X    @ARGV=split;
  931. X    $program = shift;
  932. X    if ($verbose) { print "\n******* $program *******\n\n"; }
  933. X    &flush;
  934. X    &run("$LIBCOPS/$program");
  935. X    &flush;
  936. X
  937. } 
  938. X
  939. &save_result;
  940. X
  941. &argh unless $ran_something;
  942. X
  943. Xexit 0;
  944. X
  945. ######################################################################
  946. sub run {
  947. X    local($module) = @_;
  948. X    local($status);
  949. X    local($0) = $module; # so it shows up in ps
  950. X    local($!);
  951. X
  952. X
  953. X    $ran_something++;
  954. X
  955. X    open(STDERR, $COPS_ERRORS ? ">&STDOUT" : ">/dev/null");
  956. X
  957. X    unless ($status = do $module) {
  958. X    if ($@) {
  959. X        warn "cops: unexpected exit from $module:\n\t-> $@\n";
  960. X    } elsif ($! != 0) {
  961. X        warn "cops: couldn't run $module: $!\n";
  962. X    } else {
  963. X        warn "cops: $module returned $status\n";
  964. X    } 
  965. X    }
  966. X
  967. X    # hack for kuang, who doesn't write to STDOUT (yet!)
  968. X    $SUCCESS = "$SECURE/Success";
  969. X    if ($module =~ /^kuang/ && -e $SUCCESS) {
  970. X    if (open SUCCESS) {
  971. X        print while <SUCCESS>;  # STDOUT is $REPORT
  972. X        close SUCCESS;
  973. X        unlink $SUCCESS;
  974. X    } else {
  975. X        warn "can't open $SUCCESS: $!";
  976. X    } 
  977. X    } 
  978. }
  979. ######################################################################
  980. sub init_result {
  981. X    $REPORT = "$SECURE/result.$$";  # global!
  982. X    open (REPORT, ">$REPORT") || die "can't create $REPORT: $!";
  983. X
  984. X    # assume dups work
  985. X    open (STDOUT, ">&REPORT");
  986. X    open (SAVERR, ">&STDERR");
  987. X    open (STDERR, ">&STDOUT");
  988. X
  989. X    ($sec, $min, $hour, $mday, $mon, $year,
  990. X    $wday, $yday, $isdst) = localtime(time);
  991. X
  992. X    $name = sprintf("%s_%s_%s", $year + 1900, 
  993. X    (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec)[$mon],
  994. X    $mday);
  995. X
  996. X    $host =  ( -x '/bin/hostname'   && `/bin/hostname` ) 
  997. X      || ( -x '/bin/uname'      && `/bin/uname -n` )
  998. X      || ( -x '/usr/bin/uuname' && `/usr/bin/uuname -l`)
  999. X      || 'Amnesiac!';
  1000. X
  1001. X    chop $host;
  1002. X    $host =~ s/\..*//;
  1003. X
  1004. X    print "ATTENTION:\nSecurity report for ", `date`;
  1005. X    print "\nfrom host $host, $name\n\n";
  1006. X    $report = $name;
  1007. X
  1008. X    &flush;
  1009. }
  1010. ######################################################################
  1011. sub save_result {
  1012. X    open(STDERR, ">&SAVERR");
  1013. X
  1014. X    close REPORT || die "can't close $REPORT: $!";
  1015. X
  1016. X    $dir = "$SECURE/$host";
  1017. X    $report = $dir . "/" . $report;
  1018. X
  1019. X    mkdir($dir,0700) unless -d $dir;
  1020. X
  1021. X    if ($NMAIL) {
  1022. X    system "$MAIL $SECURE_USERS < $REPORT"
  1023. X        unless $ONLY_DIFF && !&different($dir, $REPORT);
  1024. X    } else {
  1025. #    rename ($REPORT, $dir . "/" . $name) ||
  1026. #        die "can't put $REPORT into $dir/$name: $!";
  1027. X    rename ($REPORT, $report) ||
  1028. X        die "can't put $REPORT into $report: $!";
  1029. X    }
  1030. X    unlink $REPORT;
  1031. } 
  1032. X
  1033. ######################################################################
  1034. sub different {
  1035. X    local($dir, $FILE1) = @_;
  1036. X    local($FILE2, $f1, $f2, $_);
  1037. X
  1038. X    open (LS, "$LS -t $dir |");
  1039. X    chop($FILE2 = <LS>);
  1040. X    close(LS); # snuff it out
  1041. X
  1042. X
  1043. X    return 1 if !$FILE2 || -s $FILE1 != -s $FILE2;
  1044. X
  1045. X    open FILE1 || die "can't open $FILE1: $!";
  1046. X    open FILE2 || die "can't open $FILE2: $!";
  1047. X
  1048. X    for (1..5) {
  1049. X    $_ = <FILE1>;
  1050. X    $_ = <FILE2>;
  1051. X    } 
  1052. X
  1053. X    while ( ($f1 = <FILE1>), ($f2 = <FILE2>) ) {
  1054. X    last if $f1 ne $f2;
  1055. X    } 
  1056. X
  1057. X    close FILE1;
  1058. X    close FILE2;
  1059. X
  1060. X    defined($f1) || defined($f2);
  1061. } 
  1062. X
  1063. ######################################################################
  1064. sub flush {
  1065. X    local($old) = $|;
  1066. X    $| = 1;
  1067. X    print '';
  1068. X    $| = $old;
  1069. } 
  1070. X
  1071. sub argh {
  1072. X    die "Argh -- Can't find anything in $CONFIG\n";
  1073. }
  1074. SHAR_EOF
  1075. chmod 0700 p-cops.alpha/cops ||
  1076. echo 'restore of p-cops.alpha/cops failed'
  1077. Wc_c="`wc -c < 'p-cops.alpha/cops'`"
  1078. test 6390 -eq "$Wc_c" ||
  1079.     echo 'p-cops.alpha/cops: original size 6390, current size' "$Wc_c"
  1080. rm -f _shar_wnt_.tmp
  1081. fi
  1082. # ============= p-cops.alpha/fgrep.pl ==============
  1083. if test -f 'p-cops.alpha/fgrep.pl' -a X"$1" != X"-c"; then
  1084.     echo 'x - skipping p-cops.alpha/fgrep.pl (File already exists)'
  1085.     rm -f _shar_wnt_.tmp
  1086. else
  1087. > _shar_wnt_.tmp
  1088. echo 'x - extracting p-cops.alpha/fgrep.pl (Text)'
  1089. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/fgrep.pl' &&
  1090. #
  1091. #  Just a quick perl fgrep...
  1092. #
  1093. package fgrep;
  1094. X
  1095. sub main'fgrep {
  1096. X    local($file, @exprs) = @_;
  1097. X    local(@list);
  1098. X
  1099. X    if (open file) {
  1100. X    $code = "while (<file>) {\n\tchop;\n";
  1101. X    for (@exprs) {
  1102. X        $code .= "\tpush(\@list, \$_), next if m\201${_}\201;\n";
  1103. X    } 
  1104. X    $code .= "}\n";
  1105. X    warn "fgrep code is $code" if $debug;
  1106. X    eval $code;
  1107. X    warn "fgrep @exprs $file: $@\n" if $@;
  1108. X    } elsif ($debug) {
  1109. X    warn "main'fgrep: can't open $file: $!\n";
  1110. X    } 
  1111. X
  1112. X    @list;
  1113. } 
  1114. X
  1115. 1;
  1116. SHAR_EOF
  1117. chmod 0700 p-cops.alpha/fgrep.pl ||
  1118. echo 'restore of p-cops.alpha/fgrep.pl failed'
  1119. Wc_c="`wc -c < 'p-cops.alpha/fgrep.pl'`"
  1120. test 463 -eq "$Wc_c" ||
  1121.     echo 'p-cops.alpha/fgrep.pl: original size 463, current size' "$Wc_c"
  1122. rm -f _shar_wnt_.tmp
  1123. fi
  1124. # ============= p-cops.alpha/file_mode.pl ==============
  1125. if test -f 'p-cops.alpha/file_mode.pl' -a X"$1" != X"-c"; then
  1126.     echo 'x - skipping p-cops.alpha/file_mode.pl (File already exists)'
  1127.     rm -f _shar_wnt_.tmp
  1128. else
  1129. > _shar_wnt_.tmp
  1130. echo 'x - extracting p-cops.alpha/file_mode.pl (Text)'
  1131. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/file_mode.pl' &&
  1132. #
  1133. #  This retrieves a possibly cached mode on file.
  1134. # If it returns "BOGUS", it means that the stat failed.
  1135. #
  1136. # tchrist@convx.com
  1137. X
  1138. package main;
  1139. require 'stat.pl';
  1140. X
  1141. package file_mode;
  1142. X
  1143. sub main'Mode {
  1144. X    local($file) = @_;
  1145. X
  1146. X    if (!defined $modes{$file}) {
  1147. X       if (&'Stat($file)) {
  1148. X           $modes{$file} = $'st_mode;
  1149. X       } else {
  1150. X           $modes{$file} = 'BOGUS';
  1151. X       }
  1152. X    }
  1153. X    $modes{$file};
  1154. }
  1155. SHAR_EOF
  1156. chmod 0700 p-cops.alpha/file_mode.pl ||
  1157. echo 'restore of p-cops.alpha/file_mode.pl failed'
  1158. Wc_c="`wc -c < 'p-cops.alpha/file_mode.pl'`"
  1159. test 413 -eq "$Wc_c" ||
  1160.     echo 'p-cops.alpha/file_mode.pl: original size 413, current size' "$Wc_c"
  1161. rm -f _shar_wnt_.tmp
  1162. fi
  1163. # ============= p-cops.alpha/file_owner.pl ==============
  1164. if test -f 'p-cops.alpha/file_owner.pl' -a X"$1" != X"-c"; then
  1165.     echo 'x - skipping p-cops.alpha/file_owner.pl (File already exists)'
  1166.     rm -f _shar_wnt_.tmp
  1167. else
  1168. > _shar_wnt_.tmp
  1169. echo 'x - extracting p-cops.alpha/file_owner.pl (Text)'
  1170. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/file_owner.pl' &&
  1171. #
  1172. #   This retrieves possibly cached owner of a file.
  1173. # If it returns "BOGUS", it means that the stat failed.
  1174. X
  1175. package main;
  1176. require 'stat.pl';
  1177. X
  1178. package file_owner;
  1179. X
  1180. sub main'Owner {
  1181. X    local($file) = @_;
  1182. X
  1183. X    if (!defined $owners{$file}) {
  1184. X       if (&'Stat($file)) {
  1185. X           $owners{$file} = $'st_uid;
  1186. X       } else {
  1187. X           $owners{$file} = 'BOGUS';
  1188. X       }
  1189. X    }
  1190. X    $owners{$file};
  1191. }
  1192. SHAR_EOF
  1193. chmod 0700 p-cops.alpha/file_owner.pl ||
  1194. echo 'restore of p-cops.alpha/file_owner.pl failed'
  1195. Wc_c="`wc -c < 'p-cops.alpha/file_owner.pl'`"
  1196. test 398 -eq "$Wc_c" ||
  1197.     echo 'p-cops.alpha/file_owner.pl: original size 398, current size' "$Wc_c"
  1198. rm -f _shar_wnt_.tmp
  1199. fi
  1200. # ============= p-cops.alpha/dev.chk ==============
  1201. if test -f 'p-cops.alpha/dev.chk' -a X"$1" != X"-c"; then
  1202.     echo 'x - skipping p-cops.alpha/dev.chk (File already exists)'
  1203.     rm -f _shar_wnt_.tmp
  1204. else
  1205. > _shar_wnt_.tmp
  1206. echo 'x - extracting p-cops.alpha/dev.chk (Text)'
  1207. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/dev.chk' &&
  1208. #!/bin/sh  # need to mention perl here to avoid recursion
  1209. #
  1210. #  dev.chk [-g]
  1211. #
  1212. #   This shell script checks the permissions of all devs listed in the
  1213. # file /etc/fstab (the "mount" command would be a preferable way of
  1214. # getting the file system name, but the syntax of the output is variable
  1215. # from machine to machine), and flags them if they are readable by using
  1216. # the "is_readable" command.  It also checks for unrestricted NFS
  1217. # mountings.  By default, dev_check will flag devs only if world readable
  1218. # or writable.  The -g option tells it to print out devs that are also
  1219. # group readable/writable.
  1220. #   As an aside, the fact that NFS mounted dirs are world readable isn't
  1221. # a big deal, but they shouldn't be world writable.  So do two checks here,
  1222. # instead of one.
  1223. #
  1224. #  Two types of /etc/fstab formats I've seen so far:
  1225. #
  1226. # "old" --
  1227. #  spec:file:type:freq:passno:name:options
  1228. #      NFS are indicated by an "@"
  1229. #
  1230. # "new" --
  1231. #  fsname dir type opts freq passno
  1232. #      NFS are indicated by an ":"
  1233. #
  1234. #  NOTE:
  1235. # 
  1236. # if you know where perl is and your system groks #!, put its
  1237. # pathname at the top to make this a tad faster.
  1238. #
  1239. # the following magic is from the perl man page
  1240. # and should work to get us to run with perl 
  1241. # even if invoked as an sh or csh or foosh script.
  1242. # notice we don't use full path cause we don't
  1243. # know where the user has perl on their system.
  1244. #
  1245. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  1246. & eval 'exec perl -S $0 $argv:q'
  1247. X    if $running_under_some_stupid_shell_instead_of_perl;
  1248. X
  1249. #
  1250. #  dev.chk [-g]
  1251. # 
  1252. # tchrist@convx.com
  1253. #
  1254. X
  1255. require 'is_able.pl';
  1256. X
  1257. $MTAB    = '/etc/fstab' unless defined $MTAB;
  1258. $EXPORTS = '/etc/exports' unless defined $EXPORTS;
  1259. $TAB_STYLE = 'new' unless defined $TAB_STYLE;  # or 'old'  
  1260. X
  1261. &usage if @ARGV > 1;
  1262. X
  1263. sub usage { die "Usage: $0 [-g]\n"; }
  1264. X
  1265. if (@ARGV == 1) {
  1266. X    if ($ARGV[0] eq '-g') {
  1267. X    $group++;
  1268. X    } else {
  1269. X    &usage;
  1270. X    } 
  1271. } 
  1272. X
  1273. X
  1274. open MTAB || die "can't open $MTAB: $!";
  1275. X
  1276. while (<MTAB>) {
  1277. X    next if /^#/;
  1278. X    chop;
  1279. X    if ($TAB_STYLE eq 'new') {
  1280. X    ($dev, $fs) = split;
  1281. X    next unless $fs;
  1282. X    if ($dev =~ /:/) {
  1283. X        push(@nfs_devs, $fs);
  1284. X    } else {
  1285. X        push(@local_devs, $dev);
  1286. X    } 
  1287. X    } else {
  1288. X    ($dev, $fs) = split(/:/);
  1289. X    next unless $fs;
  1290. X    if ($dev =~ /@/) {
  1291. X        push(@nfs_devs, $fs);
  1292. X    } else {
  1293. X        push(@local_devs, $dev);
  1294. X    } 
  1295. X    } 
  1296. X
  1297. } 
  1298. X
  1299. if (open EXPORTS) {
  1300. X    while (<EXPORTS>) {
  1301. X    next if /^\s*#/;
  1302. X    next if /\S\s+\S/;
  1303. X    chop;
  1304. X    printf "Warning!  NFS file system $_ exported with no restrictions.\n";
  1305. X    } 
  1306. } 
  1307. X
  1308. # WARNING: we may hang if server down....
  1309. #
  1310. for (@nfs_devs, @local_devs) {
  1311. X    &is_able($_, 'w', 'w');
  1312. X    next unless $group;
  1313. X    &is_able($_, 'g', 'w');
  1314. } 
  1315. X
  1316. for (@local_devs) {
  1317. X    &is_able($_, 'w', 'r');
  1318. X    next unless $group;
  1319. X    &is_able($_, 'g', 'r');
  1320. } 
  1321. X
  1322. 1;
  1323. SHAR_EOF
  1324. chmod 0700 p-cops.alpha/dev.chk ||
  1325. echo 'restore of p-cops.alpha/dev.chk failed'
  1326. Wc_c="`wc -c < 'p-cops.alpha/dev.chk'`"
  1327. test 2739 -eq "$Wc_c" ||
  1328.     echo 'p-cops.alpha/dev.chk: original size 2739, current size' "$Wc_c"
  1329. rm -f _shar_wnt_.tmp
  1330. fi
  1331. # ============= p-cops.alpha/getopts.pl ==============
  1332. if test -f 'p-cops.alpha/getopts.pl' -a X"$1" != X"-c"; then
  1333.     echo 'x - skipping p-cops.alpha/getopts.pl (File already exists)'
  1334.     rm -f _shar_wnt_.tmp
  1335. else
  1336. > _shar_wnt_.tmp
  1337. echo 'x - extracting p-cops.alpha/getopts.pl (Text)'
  1338. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/getopts.pl' &&
  1339. ;# getopts.pl - a better getopt.pl
  1340. X
  1341. ;# Usage:
  1342. ;#      do Getopts('a:bc');  # -a takes arg. -b & -c not. Sets opt_* as a
  1343. ;#                           #  side effect.
  1344. X
  1345. sub Getopts {
  1346. X    local($argumentative) = @_;
  1347. X    local(@args,$_,$first,$rest,$errs);
  1348. X    local($[) = 0;
  1349. X
  1350. X    @args = split( / */, $argumentative );
  1351. X    while(($_ = $ARGV[0]) =~ /^-(.)(.*)/) {
  1352. X    ($first,$rest) = ($1,$2);
  1353. X    $pos = index($argumentative,$first);
  1354. X    if($pos >= $[) {
  1355. X        if($args[$pos+1] eq ':') {
  1356. X        shift(@ARGV);
  1357. X        if($rest eq '') {
  1358. X            $rest = shift(@ARGV);
  1359. X        }
  1360. X        eval "\$opt_$first = \$rest;";
  1361. X        }
  1362. X        else {
  1363. X        eval "\$opt_$first = 1";
  1364. X        if($rest eq '') {
  1365. X            shift(@ARGV);
  1366. X        }
  1367. X        else {
  1368. X            $ARGV[0] = "-$rest";
  1369. X        }
  1370. X        }
  1371. X    }
  1372. X    else {
  1373. X        print STDERR "Unknown option: $first\n";
  1374. X        ++$errs;
  1375. X        if($rest ne '') {
  1376. X        $ARGV[0] = "-$rest";
  1377. X        }
  1378. X        else {
  1379. X        shift(@ARGV);
  1380. X        }
  1381. X    }
  1382. X    }
  1383. X    $errs == 0;
  1384. }
  1385. X
  1386. 1;
  1387. SHAR_EOF
  1388. chmod 0700 p-cops.alpha/getopts.pl ||
  1389. echo 'restore of p-cops.alpha/getopts.pl failed'
  1390. Wc_c="`wc -c < 'p-cops.alpha/getopts.pl'`"
  1391. test 902 -eq "$Wc_c" ||
  1392.     echo 'p-cops.alpha/getopts.pl: original size 902, current size' "$Wc_c"
  1393. rm -f _shar_wnt_.tmp
  1394. fi
  1395. # ============= p-cops.alpha/glob.pl ==============
  1396. if test -f 'p-cops.alpha/glob.pl' -a X"$1" != X"-c"; then
  1397.     echo 'x - skipping p-cops.alpha/glob.pl (File already exists)'
  1398.     rm -f _shar_wnt_.tmp
  1399. else
  1400. > _shar_wnt_.tmp
  1401. echo 'x - extracting p-cops.alpha/glob.pl (Text)'
  1402. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/glob.pl' &&
  1403. #
  1404. #  This does shell or perl globbing without resorting
  1405. # to the shell -- we were having problems with the shell blowing
  1406. # up with extra long pathnames and lots of file names.  set $glob'debug 
  1407. # for trace information.
  1408. #
  1409. # tom christiansen <tchrist@convex.com>
  1410. X
  1411. package glob;
  1412. X
  1413. sub main'glob { 
  1414. X    local($expr) = @_;
  1415. X    local(@files);
  1416. X
  1417. X    $? = 0;
  1418. X    open(SAVERR, ">&STDERR"); close(STDERR);  # suppress args too long
  1419. X    @files = <${expr}>;
  1420. X    if ($?) {
  1421. X    print SAVERR "shell glob blew up on $expr\n" if $debug;
  1422. X    @files = &SHglob($expr);
  1423. X    }
  1424. X    open (STDERR, ">&SAVERR");
  1425. X    # if (@files == 1 && $files[0] eq $expr) { @files = ''; } # sh foo
  1426. X    @files;
  1427. }
  1428. X
  1429. sub main'SHglob {
  1430. X    local($expr) = @_;
  1431. X    local(@retlist) = ();
  1432. X    local($dir);
  1433. X
  1434. X    printf "SHglob: globbing $expr\n" if $debug;
  1435. X
  1436. X    $expr =~ s/([.{+\\])/\\$1/g;
  1437. X    $expr =~ s/\*/.*/g;
  1438. X    $expr =~ s/\?/./g;
  1439. X
  1440. X    for $dir (split(' ',$expr)) {
  1441. X    push(@retlist, &main'REglob($dir));
  1442. X    } 
  1443. X
  1444. X    return sort @retlist;
  1445. } 
  1446. X
  1447. sub main'REglob {
  1448. X    local($path) = @_;
  1449. X    local($_);
  1450. X    local(@retlist) = ();
  1451. X    local($root,$expr,$pos);
  1452. X    local($relative) = 0;
  1453. X    local(@dirs);
  1454. X    local($user);
  1455. X
  1456. X    $haveglobbed = 0;
  1457. X
  1458. X    @dirs = split(/\/+/, $path);
  1459. X
  1460. X    if ($dirs[$[] =~ m!~(.*)!) {
  1461. X    $dirs[$[] = &homedir($1);
  1462. X    return @retlist unless $dirs[$[];
  1463. X    } elsif ($dirs[$[] eq '') {
  1464. X    $dirs[$[] = '/' unless $dirs[$[] =~ m!^\.{1,2}$!;
  1465. X    } else {
  1466. X    unshift(@dirs, '.');
  1467. X    $relative = 1;
  1468. X    } 
  1469. X
  1470. X    printf "REglob: globbing %s\n", join('/',@dirs) if $debug;
  1471. X
  1472. X    @retlist = &expand(@dirs);
  1473. X
  1474. X    for (@retlist) {
  1475. X    if ($relative) {
  1476. X        s!^\./!!o;
  1477. X    }
  1478. X    s!/{2,}!/!g;
  1479. X    } 
  1480. X
  1481. X    return sort @retlist;
  1482. }
  1483. X
  1484. sub expand {
  1485. X    local($dir, $thisdir, @rest) = @_;
  1486. X    local($nextdir);
  1487. X    local($_);
  1488. X    local(@retlist) = ();
  1489. X    local(*DIR);
  1490. X
  1491. X    unless ($haveglobbed || $thisdir =~ /([^\\]?)[?.*{[+\\]/ && $1 ne '\\') {
  1492. X    @retlist = ($thisdir);
  1493. X    } else {
  1494. X    unless (opendir(DIR,$dir)) {
  1495. X        warn "glob: can't opendir $dir: $!\n" if $debug;
  1496. X    } else {
  1497. X        @retlist = grep(/^$thisdir$/,readdir(DIR));
  1498. X        @retlist = grep(!/^\./, @retlist) unless $thisdir =~ /^\\\./;
  1499. X        $haveglobbed++;
  1500. X    } 
  1501. X    closedir DIR;
  1502. X    } 
  1503. X
  1504. X    for (@retlist) {
  1505. X    $_ = $dir . '/' . $_;
  1506. X    }
  1507. X
  1508. X    if ($nextdir = shift @rest) {
  1509. X    local(@newlist) = ();
  1510. X    for (@retlist) {
  1511. X        push(@newlist,&expand($_,$nextdir,@rest));
  1512. X    } 
  1513. X    @retlist = @newlist;
  1514. X    } 
  1515. X
  1516. X    return @retlist;
  1517. } 
  1518. X
  1519. sub homedir {
  1520. X    local($user) = @_;
  1521. X    local(@pwent);
  1522. X    # global %homedir
  1523. X
  1524. X    if (!$user) {
  1525. X    return $ENV{'HOME'}         if $ENV{'HOME'};
  1526. X    ($user = $ENV{'USER'})      || 
  1527. X        ($user = getlogin)         || 
  1528. X        (($user) = getpwnam($>));
  1529. X    warn "glob'homedir: who are you, user #$>?" unless $user;
  1530. X    return '/';
  1531. X    } 
  1532. X    unless (defined $homedir{$user}) {
  1533. X    if (@pwent = getpwnam($user)) {
  1534. X        $homedir{$user} = $pwent[$#pwent - 1];
  1535. X    } else {
  1536. X        warn "glob'homedir: who are you, user #$>?" unless $user;
  1537. X        $homedir{$user} = '/';
  1538. X    }
  1539. X    }
  1540. X    return $homedir{$user};
  1541. } 
  1542. X
  1543. X
  1544. 1;
  1545. SHAR_EOF
  1546. chmod 0700 p-cops.alpha/glob.pl ||
  1547. echo 'restore of p-cops.alpha/glob.pl failed'
  1548. Wc_c="`wc -c < 'p-cops.alpha/glob.pl'`"
  1549. test 2960 -eq "$Wc_c" ||
  1550.     echo 'p-cops.alpha/glob.pl: original size 2960, current size' "$Wc_c"
  1551. rm -f _shar_wnt_.tmp
  1552. fi
  1553. # ============= p-cops.alpha/group.chk ==============
  1554. if test -f 'p-cops.alpha/group.chk' -a X"$1" != X"-c"; then
  1555.     echo 'x - skipping p-cops.alpha/group.chk (File already exists)'
  1556.     rm -f _shar_wnt_.tmp
  1557. else
  1558. > _shar_wnt_.tmp
  1559. echo 'x - extracting p-cops.alpha/group.chk (Text)'
  1560. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/group.chk' &&
  1561. #!/bin/sh  # need to mention perl here to avoid recursion
  1562. #
  1563. #   group.chk.pl
  1564. #
  1565. #  Check group file -- /etc/group -- for incorrect number of fields,
  1566. # duplicate groups, non-alphanumeric group names, and non-numeric group
  1567. # id's.
  1568. #
  1569. #   Mechanism:  Group.check uses awk to ensure that each line of the group
  1570. # has 4 fields, as well as examining each line for any duplicate groups or
  1571. # any duplicate user id's in a given group by using "sort -u" to ferret
  1572. # out any duplications.  It also checks to make sure that the password
  1573. # field (the second one) is a "*", meaning the group has no password (a
  1574. # group password is usually not necessary because each member listed on 
  1575. # the line has all the privilages that the group has.)  All results are
  1576. # echoed to standard output.  Finally it ensures that the group names
  1577. # are alphanumeric, that the group id's are numeric, and that there are
  1578. # no blank lines.  For yellow pages groups, it does the same checking,
  1579. # but in order to get a listing of all members of the groups, it does a
  1580. # "ypcat group".
  1581. #
  1582. #   The /etc/group file has a very specific format, making the task
  1583. # fairly simple.  Normally it has lines with 4 fields, each field
  1584. # separated by a colon (:).  The first field is the group name, the second
  1585. # field is the encrypted password (an asterix (*) means the group has no
  1586. # password, otherwise the first two characters are the salt), the third
  1587. # field is the group id number, and the fourth field is a list of user
  1588. # ids in the group.  If a line begins with a plus sign (+), it is a yellow
  1589. # pages entry.  See group(5) for more information.
  1590. #
  1591. # NOTE:
  1592. #   If you know where perl is and your system groks #!, put its
  1593. # pathname at the top to make this a tad faster.
  1594. #
  1595. # the following magic is from the perl man page
  1596. # and should work to get us to run with perl 
  1597. # even if invoked as an sh or csh or foosh script.
  1598. # notice we don't use full path cause we don't
  1599. # know where the user has perl on their system.
  1600. #
  1601. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  1602. & eval 'exec perl -S $0 $argv:q'
  1603. X    if $running_under_some_stupid_shell_instead_of_perl;
  1604. X
  1605. # should get below config stuff from cops.cf file
  1606. package main;
  1607. X
  1608. die "Usage: $0\n" if @ARGV;
  1609. X
  1610. require 'pathconf.pl';
  1611. X
  1612. #   Used for Sun C2 security group file.  FALSE (default) will flag
  1613. # valid C2 group syntax as an error, TRUE attempts to validate it.
  1614. # Thanks to Pete Troxell for pointing this out.
  1615. #
  1616. # moved to cops.cf
  1617. X
  1618. $etc_group=$GROUP || '/etc/group';
  1619. X
  1620. package group_chk;
  1621. X
  1622. $yptmp = "./yptmp.$$";
  1623. X
  1624. # Testing $etc_group for potential problems....
  1625. open (Group, "< $'etc_group") || warn "$0: Can't open $'etc_group: $!\n";
  1626. &chk_group_file_format('Group');
  1627. close Group;
  1628. X
  1629. # Testing ypcat group for potential problems
  1630. $yp=0;
  1631. if (-s $'YPCAT && -x _) {
  1632. X    system("$'YPCAT group >$yptmp 2>/dev/null");  
  1633. X    if (-s $yptmp) {
  1634. X       open(YGroup, "$'YPCAT group |") || die "$0: Can't popen $'YPCAT: $!\n";
  1635. X       &chk_group_file_format('YGroup');
  1636. X       close(YGroup);
  1637. X       $yp=1;
  1638. X   }
  1639. }
  1640. X
  1641. # usage: &chk_group_file_format('Filehandle-name');
  1642. # skips over lines that begin with "+:"
  1643. # It really should check for correct yellow pages syntax....
  1644. #
  1645. # this routine checks lines read from a filehandle for potential format
  1646. # problems .. should be matching group(5)
  1647. #
  1648. # checks for duplicate users in a group as it reads the lines instead
  1649. # of after (as the original shell script does)
  1650. X
  1651. sub chk_group_file_format {
  1652. X    local($file) = @_;
  1653. X    local($W) = "Warning!  $file file,";
  1654. X
  1655. X    while (<$file>) {
  1656. X    next if /^\+:/;
  1657. X    print "$W line $., is blank\n" if /^\s*$/;
  1658. X    split(/:/);
  1659. X    $groups{$_[0]}++;   # keep track of dups
  1660. X    print "$W line $., does not have 4 fields: $_" if (@_ != 4);
  1661. X    print "$W line $., nonalphanumeric group name: $_"
  1662. X        if $_[0] !~ /^[A-Za-z0-9-]+$/;
  1663. X    if ($_[1] && $_[1] ne '*') {
  1664. X        if ( ! $C2 || $yp ) {
  1665. X        print "$W line $., group has password: $_"
  1666. X            if length($_[1]) == 13;
  1667. X        } else {
  1668. X        print "$W line $., group has invalid field for C2:\n$_"
  1669. X            if $_[1] ne "#\$$_[0]";
  1670. X        }
  1671. X    }
  1672. X    print "$W line $., nonnumeric group id: $_" if $_[2] !~ /^\d+$/;
  1673. X
  1674. X    # look for duplicate users in a group
  1675. X    # kinda ugly, but it works .. and I have too much other work right
  1676. X    # now to clean it up.  maybe later.. ;-)
  1677. X    chop($_[3]);    # down here, 'cos split gets rid of final null fields
  1678. X    @users = sort split(/\s*,\s*/, $_[3]);
  1679. X    # %users = # of times user is in group, $dup_user = duplicate found
  1680. X    undef %users;  $dup_user=0;
  1681. X    grep(!$users{$_}++, @users);
  1682. X    for (keys %users) {
  1683. X        (print "Warning!  Group $_[0] has duplicate user(s):\n"),
  1684. X        $dup_user=1 if !$dup_user && $users{$_} > 1;
  1685. X        print "$_ " if $users{$_} > 1;
  1686. X    }
  1687. X    print "\n" if $dup_user;
  1688. X
  1689. X    }
  1690. X    # find duplicate group names 
  1691. X    # not the best way, but it works..
  1692. X    # boy, this is ugly too .. but, not as bad as above.. :)
  1693. X    $dup_warned = 0;
  1694. X    for (sort keys %groups) {
  1695. X    (print "Warning!  Duplicate Group(s) found in $file:\n"), $dup_warned++
  1696. X        if !$dup_warned && $groups{$_} > 1;
  1697. X    print "$_ " if $groups{$_} > 1;
  1698. X    }
  1699. X    print "\n" if $dup_warned;
  1700. }
  1701. X
  1702. unlink $yptmp;
  1703. X
  1704. 1;
  1705. # end
  1706. SHAR_EOF
  1707. chmod 0700 p-cops.alpha/group.chk ||
  1708. echo 'restore of p-cops.alpha/group.chk failed'
  1709. Wc_c="`wc -c < 'p-cops.alpha/group.chk'`"
  1710. test 5060 -eq "$Wc_c" ||
  1711.     echo 'p-cops.alpha/group.chk: original size 5060, current size' "$Wc_c"
  1712. rm -f _shar_wnt_.tmp
  1713. fi
  1714. # ============= p-cops.alpha/hostname.pl ==============
  1715. if test -f 'p-cops.alpha/hostname.pl' -a X"$1" != X"-c"; then
  1716.     echo 'x - skipping p-cops.alpha/hostname.pl (File already exists)'
  1717.     rm -f _shar_wnt_.tmp
  1718. else
  1719. > _shar_wnt_.tmp
  1720. echo 'x - extracting p-cops.alpha/hostname.pl (Text)'
  1721. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/hostname.pl' &&
  1722. #
  1723. # file: hostname.pl
  1724. # usage: $hostname = &'hostname;
  1725. #
  1726. # purpose: get hostname -- try method until we get an answer 
  1727. #    or return "Amnesiac!"
  1728. #
  1729. X
  1730. package hostname;
  1731. X
  1732. sub main'hostname {
  1733. X    if (!defined $hostname) {
  1734. X    $hostname =  ( -x '/bin/hostname'   && `/bin/hostname` ) 
  1735. X          || ( -x '/bin/uname'      && `/bin/uname -n` )
  1736. X          || ( -x '/usr/bin/uuname' && `/usr/bin/uuname -l`)
  1737. X          || 'Amnesiac!';
  1738. X    chop $hostname;
  1739. X    }
  1740. X    $hostname;
  1741. }
  1742. X
  1743. 1;
  1744. SHAR_EOF
  1745. chmod 0700 p-cops.alpha/hostname.pl ||
  1746. echo 'restore of p-cops.alpha/hostname.pl failed'
  1747. Wc_c="`wc -c < 'p-cops.alpha/hostname.pl'`"
  1748. test 444 -eq "$Wc_c" ||
  1749.     echo 'p-cops.alpha/hostname.pl: original size 444, current size' "$Wc_c"
  1750. rm -f _shar_wnt_.tmp
  1751. fi
  1752. # ============= p-cops.alpha/is_able.chk ==============
  1753. if test -f 'p-cops.alpha/is_able.chk' -a X"$1" != X"-c"; then
  1754.     echo 'x - skipping p-cops.alpha/is_able.chk (File already exists)'
  1755.     rm -f _shar_wnt_.tmp
  1756. else
  1757. > _shar_wnt_.tmp
  1758. echo 'x - extracting p-cops.alpha/is_able.chk (Text)'
  1759. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/is_able.chk' &&
  1760. #!/bin/sh  # need to mention perl here to avoid recursion
  1761. #
  1762. #  is_able.chk
  1763. #
  1764. #   This shell script checks the permissions of all files and directories
  1765. # listed in the configuration file "is_able.lst", and prints warning messages
  1766. # according to the status of files.  You can specify world or group readability
  1767. # or writeability.  See the config file for the format of the configuration
  1768. # file.
  1769. #
  1770. #   Mechanism:  This shell script parses each line from the configure file
  1771. # and uses the "is_able.pl" program to check if any of
  1772. # the directories in question are writable by world/group.
  1773. #
  1774. # NOTE:
  1775. #   If you know where perl is and your system groks #!, put its
  1776. # pathname at the top to make this a tad faster.
  1777. #
  1778. # the following magic is from the perl man page
  1779. # and should work to get us to run with perl 
  1780. # even if invoked as an sh or csh or foosh script.
  1781. # notice we don't use full path cause we don't
  1782. # know where the user has perl on their system.
  1783. #
  1784. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' 
  1785. & eval 'exec perl -S $0 $argv:q'
  1786. X    if $running_under_some_stupid_shell_instead_of_perl;
  1787. require 'is_able.pl';
  1788. require 'file_mode.pl';
  1789. require 'glob.pl';
  1790. X
  1791. if ($ARGV[0] eq '-d') {
  1792. X    shift;
  1793. X    $debug = $glob'debug = 1;  # maybe should turn off glob'debug afterwards
  1794. }
  1795. X
  1796. unshift (@ARGV, "is_able.lst" ) unless @ARGV;
  1797. X
  1798. while (<>) {
  1799. X    next if /^\s*#/;
  1800. X    split;
  1801. X    next unless @_ == 3;
  1802. X    ($file, $x, $y) = @_;
  1803. X    @files = $file =~ /[\[?*]/ ? &'glob($file) : ($file);
  1804. X    for $file (@files) {
  1805. X    print STDERR "is_able $file $x $y\n" if $debug;
  1806. X    &'is_able($file, $x, $y);
  1807. X    }
  1808. }
  1809. X
  1810. 1;
  1811. SHAR_EOF
  1812. chmod 0700 p-cops.alpha/is_able.chk ||
  1813. echo 'restore of p-cops.alpha/is_able.chk failed'
  1814. Wc_c="`wc -c < 'p-cops.alpha/is_able.chk'`"
  1815. test 1591 -eq "$Wc_c" ||
  1816.     echo 'p-cops.alpha/is_able.chk: original size 1591, current size' "$Wc_c"
  1817. rm -f _shar_wnt_.tmp
  1818. fi
  1819. # ============= p-cops.alpha/is_able.lst ==============
  1820. if test -f 'p-cops.alpha/is_able.lst' -a X"$1" != X"-c"; then
  1821.     echo 'x - skipping p-cops.alpha/is_able.lst (File already exists)'
  1822.     rm -f _shar_wnt_.tmp
  1823. else
  1824. > _shar_wnt_.tmp
  1825. echo 'x - extracting p-cops.alpha/is_able.lst (Text)'
  1826. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/is_able.lst' &&
  1827. #  This lists any/all sensitive files the administration wants to ensure
  1828. # non-read/writability of.  Comments are lines starting with a "#".
  1829. #
  1830. # USE FULL PATHNAMES!
  1831. #
  1832. #   Lines are of the format:
  1833. #
  1834. # /path/to/{dir|file}    World/Group    Read/Write/Both
  1835. #
  1836. # as above        {w|g}        {r|w|b}
  1837. #
  1838. /            w        w
  1839. /etc            w        w
  1840. /usr            w        w
  1841. /bin            w        w
  1842. /dev            w        w
  1843. /usr/bin        w        w
  1844. /usr/etc        w        w
  1845. /usr/adm        w        w
  1846. /usr/lib        w        w
  1847. /usr/spool        w        w
  1848. /usr/spool/mail        w        w
  1849. /usr/spool/news        w        w
  1850. /usr/spool/uucp        w        w
  1851. /usr/spool/at        w        w
  1852. /usr/local        w        w
  1853. /usr/local/bin        w        w
  1854. /usr/local/lib        w        w
  1855. /usr/users        w        w
  1856. /Mail            w        w
  1857. X
  1858. # some Un*x's put shadowpass stuff here:
  1859. /etc/security        w        r
  1860. X
  1861. # /.login /.profile /.cshrc /.rhosts
  1862. /.*            w        w
  1863. X
  1864. #   I think everything in /etc should be !world-writable, as a rule; but
  1865. # if you're selecting individual files, do at *least* these:
  1866. #   /etc/passwd /etc/group /etc/inittab /etc/rc /etc/rc.local /etc/rc.boot
  1867. #   /etc/hosts.equiv /etc/profile /etc/syslog.conf /etc/export /etc/utmp
  1868. #   /etc/wtmp
  1869. /etc/*            w        w
  1870. X
  1871. /bin/*            w        w
  1872. /usr/bin/*        w        w
  1873. /usr/etc/*        w        w
  1874. /usr/adm/*        w        w
  1875. /usr/lib/*        w        w
  1876. /usr/local/lib/*    w        w
  1877. /usr/local/bin/*    w        w
  1878. /usr/etc/yp*        w        w
  1879. /usr/etc/yp/*        w        w
  1880. X
  1881. # individual files:
  1882. /usr/lib/crontab    w        b
  1883. /usr/lib/aliases    w        w
  1884. /usr/lib/sendmail    w        w
  1885. /usr/spool/uucp/L.sys    w        b
  1886. X
  1887. #  NEVER want these readable!
  1888. /dev/kmem        w        b
  1889. /dev/mem        w        b
  1890. X
  1891. #   Optional List of assorted files that shouldn't be
  1892. # write/readable (mix 'n match; add to the list as desired):
  1893. /usr/adm/sulog        w        r
  1894. /.netrc            w        b
  1895. # HP-UX and others:
  1896. /etc/btmp        w        b
  1897. /etc/securetty        w        b
  1898. # Sun-fun
  1899. /dev/drum        w        b
  1900. /dev/nit        w        b
  1901. SHAR_EOF
  1902. chmod 0700 p-cops.alpha/is_able.lst ||
  1903. echo 'restore of p-cops.alpha/is_able.lst failed'
  1904. Wc_c="`wc -c < 'p-cops.alpha/is_able.lst'`"
  1905. test 1603 -eq "$Wc_c" ||
  1906.     echo 'p-cops.alpha/is_able.lst: original size 1603, current size' "$Wc_c"
  1907. rm -f _shar_wnt_.tmp
  1908. fi
  1909. # ============= p-cops.alpha/is_able.pl ==============
  1910. if test -f 'p-cops.alpha/is_able.pl' -a X"$1" != X"-c"; then
  1911.     echo 'x - skipping p-cops.alpha/is_able.pl (File already exists)'
  1912.     rm -f _shar_wnt_.tmp
  1913. else
  1914. > _shar_wnt_.tmp
  1915. echo 'x - extracting p-cops.alpha/is_able.pl (Text)'
  1916. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/is_able.pl' &&
  1917. #
  1918. #  (This takes the place of the C program is_able.c, BTW.)
  1919. # 
  1920. #  is_able filename {w|g|s|S}       {r|w|B|b|s}
  1921. #      (world/group/SUID/SGID   read/write/{read&write}/{suid&write}/s[ug]id)
  1922. # 
  1923. #     The second arg of {r|w} determines whether a file is (group or world
  1924. #   depending on the first arg of {w|g}) writable/readable, or if it is
  1925. #   SUID/SGID (first arg, either s or S, respectively), and prints out a
  1926. #   short message to that effect.
  1927. # 
  1928. #  So:
  1929. #     is_able w w        # checks if world writable
  1930. #     is_able g r        # checks if group readable
  1931. #     is_able s s        # checks if SUID
  1932. #     is_able S b        # checks if world writable and SGID
  1933. X
  1934. package main;
  1935. require 'file_mode.pl';
  1936. X
  1937. package is_able;
  1938. X
  1939. # package statics
  1940. #
  1941. %wg = ( 
  1942. X    'w', 00006,
  1943. X    'g', 00060,
  1944. X    's', 04000,
  1945. X    'S', 02000,
  1946. X       );
  1947. X
  1948. %rwb= (
  1949. X    'r', 00044,
  1950. X    'w', 00022,
  1951. X    'B', 00066,
  1952. X    'b', 04022,
  1953. X    's', 06000,
  1954. X      );
  1955. X
  1956. $silent = 0;  # for suppressing diagnostic messages
  1957. X
  1958. X
  1959. sub main'is_able {
  1960. X    local($file, $wg, $rwb) = @_;
  1961. X
  1962. X    local ( 
  1963. X       $mode,             # file mode
  1964. X           $piece,            # 1 directory component
  1965. X       @pieces,             # all the pieces
  1966. X       @dirs,             # all the directories
  1967. X       $p,                 # punctuation; (*) mean writable
  1968. X                       #       due to writable parent
  1969. X       $retval,            # true if vulnerable
  1970. X       $[                # paranoia
  1971. X      );
  1972. X
  1973. X    &usage, return undef    if @_ != 3 || $file eq '';
  1974. X
  1975. X    &usage, return undef    unless defined $wg{$wg} && defined $rwb{$rwb};
  1976. X
  1977. X    if (&'Mode($file) eq 'BOGUS' && $noisy) {
  1978. X    warn "is_able: can't stat $file: $!\n";
  1979. X    return undef;
  1980. X    }
  1981. X
  1982. X    $retval = 0;
  1983. X
  1984. X    if ($rwb{$rwb} & $rwb{'w'}) {
  1985. X    @pieces = split(m#/#, $file);
  1986. X    for ($i = 1; $i <= $#pieces; $i++) {
  1987. X        push(@dirs, join('/', @pieces[0..$i]));
  1988. X    }
  1989. X    } else {
  1990. X    @dirs = ( $file );
  1991. X    } 
  1992. X
  1993. X    for $piece ( reverse @dirs ) {
  1994. X
  1995. X    next unless $mode = &'Mode($piece);
  1996. X    next if $mode eq 'BOGUS';
  1997. X
  1998. X    next unless $mode &= 07777 & $wg{$wg} & $rwb{$rwb};
  1999. X
  2000. X    $retval = 1;
  2001. X
  2002. X    $p = $piece eq $file ? '!' : '! (*)';
  2003. X
  2004. X    $parent_is_writable = $p eq '! (*)'; # for later
  2005. X
  2006. X    next if $silent; # for &is_writable
  2007. X
  2008. X    print "Warning!  $file is group readable$p\n"    if $mode & 00040; 
  2009. X    print "Warning!  $file is _World_ readable$p\n"    if $mode & 00004; 
  2010. X    print "Warning!  $file is group writable$p\n"    if $mode & 00020; 
  2011. X    print "Warning!  $file is _World_ writable$p\n"    if $mode & 00002; 
  2012. X    print "Warning!  $file is SUID!\n"        if $mode & 04000; 
  2013. X    print "Warning!  $file is SGID!\n"        if $mode & 02000; 
  2014. X
  2015. X    last if $piece ne $file;  # only complain on first writable parent
  2016. X    }
  2017. X    $retval;
  2018. }
  2019. X
  2020. sub main'is_writable {
  2021. X    local($silent) = 1;
  2022. X    &'is_able($_[0], 'w', 'w') 
  2023. X    ? $parent_is_writable 
  2024. X         ? "writable (*)"
  2025. X         : "writable" 
  2026. X    : 0;
  2027. } 
  2028. X
  2029. sub main'is_readable {
  2030. X    local($silent) = 1;
  2031. X    &'is_able($_[0], 'w', 'r');
  2032. }
  2033. X
  2034. sub usage { 
  2035. X    warn <<EOF;
  2036. Usage: is_able file {w|g|S|s} {r|w|B|b|s}
  2037. X (not: is_able @_)
  2038. EOF
  2039. }
  2040. X
  2041. 1;
  2042. SHAR_EOF
  2043. chmod 0700 p-cops.alpha/is_able.pl ||
  2044. echo 'restore of p-cops.alpha/is_able.pl failed'
  2045. Wc_c="`wc -c < 'p-cops.alpha/is_able.pl'`"
  2046. test 2835 -eq "$Wc_c" ||
  2047.     echo 'p-cops.alpha/is_able.pl: original size 2835, current size' "$Wc_c"
  2048. rm -f _shar_wnt_.tmp
  2049. fi
  2050. # ============= p-cops.alpha/kuang ==============
  2051. if test -f 'p-cops.alpha/kuang' -a X"$1" != X"-c"; then
  2052.     echo 'x - skipping p-cops.alpha/kuang (File already exists)'
  2053.     rm -f _shar_wnt_.tmp
  2054. else
  2055. > _shar_wnt_.tmp
  2056. echo 'x - extracting p-cops.alpha/kuang (Text)'
  2057. sed 's/^X//' << 'SHAR_EOF' > 'p-cops.alpha/kuang' &&
  2058. #! /usr/local/bin/perl
  2059. X
  2060. #
  2061. # kuang - rule based analysis of Unix security
  2062. #
  2063. # Perl version by Steve Romig of the CIS department, The Ohio State
  2064. # University, October 1990. 
  2065. # 
  2066. # Based on the shell script version by Dan Farmer from his COPS
  2067. # package, which in turn is based on a shell version by Robert
  2068. # Baldwin. 
  2069. #
  2070. #-----------------------------------------------------------------------------
  2071. # Players:
  2072. #    romig    Steve Romig, romig@cis.ohio-state.edu
  2073. #    tjt    Tim Tessin, tjt@cirrus.com
  2074. #
  2075. # History:
  2076. # 4/25/91  tjt, romig    Various fixes to filewriters (better messages about 
  2077. #            permission problems) and don't update the DBM cache 
  2078. #            with local file info.
  2079. # 11/1/90  romig    Major rewrite - generic lists, nuking get_entry 
  2080. #            and put_entry, moved rules to separate file.
  2081. #
  2082. X
  2083. #
  2084. # Options
  2085. #
  2086. # -l        list uid's that can access the given target, directly
  2087. #        or indirectly
  2088. # -d        debug
  2089. # -v         verbose
  2090. #
  2091. # -k file    load the list of known CO's
  2092. # -f file    preload file information from the named file.
  2093. # -p file    preload passwd info from the named file.
  2094. # -P        preload passwd info from ypcat + /etc/passwd
  2095. # -g group    preload group info from the named file.
  2096. # -G        preload group info from ypcat + /etc/group
  2097. # 
  2098. X
  2099. $options = "ldvk:p:g:f:PG";
  2100. $usage = "usage: kuang [-l] [-d] [-v] [-k known] [-f file] [-P] [-G] [-p passwd] [-g group] [u.username|g.groupname]\n";
  2101. X
  2102. $add_files_to_cache = 1;        # Whether to update the %files cache
  2103. X                    # with local file info or not.
  2104. X
  2105. #
  2106. # Terminology:
  2107. #
  2108. #   An "op" is an operation, such as uid, gid, write, or replace. 
  2109. #   'uid' means to gain access to some uid, 'gid' means to gain access 
  2110. #   to some gid.  'write' and 'replace' refer to files - replace means
  2111. #   that we can delete a file and replace it with a new one somehow
  2112. #   (for example, if we could write the directory it is in).
  2113. #
  2114. #   An object is a uid, gid or pathname.  
  2115. #
  2116. #   A Controlling Operation (CO) is a (operation, object) pair
  2117. #   represented as "op object": "uid 216" (become uid 216) or "replace
  2118. #   /.rhosts" (replace file /.rhosts).  These are represented
  2119. #   internally as "c value", where "c" is a character representing an
  2120. SHAR_EOF
  2121. true || echo 'restore of p-cops.alpha/kuang failed'
  2122. fi
  2123. echo 'End of alpha p-cops part 1'
  2124. echo 'File p-cops.alpha/kuang is continued in part 2'
  2125. echo 2 > _shar_seq_.tmp
  2126. exit 0
  2127.