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