home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / c / cops_104.zip / cops_104 / kuang.pl.shar / kuang.pl < prev    next >
Perl Script  |  1992-03-10  |  17KB  |  772 lines
  1. #! /usr/local/bin/perl
  2.  
  3. #
  4. # kuang - rule based analysis of Unix security
  5. #
  6. # Perl version by Steve Romig of the CIS department, The Ohio State
  7. # University, October 1990. 
  8. # 
  9. # Based on the shell script version by Dan Farmer from his COPS
  10. # package, which in turn is based on a shell version by Robert
  11. # Baldwin. 
  12. #
  13.  
  14. do 'yagrip.pl' ||
  15.   die "can't do yagrip.pl";
  16.  
  17. $options = "vdlf:D";
  18. $usage = "usage: kuang [-v] [-d] [-l] [-D] [-f filedata] [u.username|g.groupname]\n";
  19.  
  20. #
  21. # Simple Unix Kuang, a security checking program.
  22. #
  23. # This is a perl version of Dan Farmer's version of Bob Baldwin's
  24. # shell scripts. 
  25. #
  26.  
  27. #
  28. # passwd_byuid lookup a password entry by uid, return as 
  29. # (name, password, directory, shell) list.
  30. #
  31. sub passwd_byuid {
  32.     local($uid) = @_;
  33.     local($name, $passwd, $gid, $quota, $comment, $gcos, $dir, $shell);
  34.  
  35.     if (! defined($passwd_byuid_list{$uid})) {
  36.     ($name, $passwd, $t_uid, $gid, $quota, $comment, $gcos, $dir, $shell) =
  37.         getpwuid($uid);
  38.  
  39.     if ($t_uid eq "") {
  40.         return();
  41.     }
  42.  
  43.     $passwd_byuid_list{$uid} = join(':', $name, $passwd, $dir, $shell);
  44.     $passwd_byname_list{$name} = $uid;
  45.     }
  46.  
  47.     return(split(/:/, $passwd_byuid_list{$uid}));
  48. }
  49.  
  50. sub passwd_byname {
  51.     local($name) = @_;
  52.     local($passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell);
  53.  
  54.     if (! defined($passwd_byname_list{$name})) {
  55.     ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) =
  56.         getpwnam($name);
  57.  
  58.     if ($uid eq "") {
  59.         return();
  60.     }
  61.  
  62.     $passwd_byuid_list{$uid} = join(':', $name, $passwd, $dir, $shell);
  63.     $passwd_byname_list{$name} = $uid;
  64.     }
  65.  
  66.     return($passwd_byname_list{$name});
  67. }
  68.  
  69. #
  70. # group_bygid lookup a group entry by gid, return as 
  71. # (name, members) list.
  72. #
  73. sub group_bygid {
  74.     local($gid) = @_;
  75.     local($name, $t_passwd, $t_gid, $members);
  76.  
  77.     if (! defined($group_bygid_list{$gid})) {
  78.     ($name, $t_passwd, $t_gid, $members) = getgrgid($gid);
  79.  
  80.     if ($t_gid eq "") {
  81.         return();
  82.     }
  83.  
  84.     $group_bygid_list{$gid} = join(':', $name, $members);
  85.     $group_byname_list{$name} = $gid;
  86.     }
  87.  
  88.     return(split(/:/, $group_bygid_list{$gid}));
  89. }
  90.  
  91. sub group_byname {
  92.     local($name) = @_;
  93.     local($gname, $passwd, $gid, $members);
  94.  
  95.     if (! defined($group_byname_list{$name})) {
  96.     ($gname, $passwd, $gid, $members) = getgrnam($name);
  97.  
  98.     if ($gid eq "") {
  99.         printf(stderr "A group named '$name' does not exist!\n");
  100.         exit(1);
  101.         }
  102.  
  103.     $group_bygid_list{$gid} = join(':', $name, $members);
  104.     $group_byname_list{$name} = $gid;
  105.     }
  106.  
  107.     return($group_byname_list{$name});
  108. }
  109.  
  110. #
  111. # Do various initialization type things.
  112. #
  113.  
  114. sub init_kuang {
  115.     local($which, $name, $uid, $gid);
  116.     local($f_type, $f_uid, $f_gid, $f_mode, $f_name);
  117.     local($count);
  118.  
  119.     $which = "u";
  120.     $name = "root";
  121.  
  122.     #
  123.     # Deal with args...
  124.     #
  125.  
  126.     &getopt($options) ||
  127.       die $usage;
  128.  
  129.     if ($#ARGV == 0) {
  130.     ($which, $name) = split(/\./, $ARGV[0]);
  131.  
  132.     if ($name eq "") {
  133.         $name = $which;
  134.         $which = "u";
  135.     }
  136.  
  137.     if ($which ne "u" && $which ne "g") {
  138.         printf(stderr "target must be given as u.user or g.group\n");
  139.         exit(1);
  140.     }
  141.     } elsif ($#ARGV > 0) {
  142.     printf(stderr $usage);
  143.     exit(1);
  144.     }
  145.  
  146.     #
  147.     # Preload the file data...
  148.     #
  149.     if (defined($opt_f)) {
  150.     #
  151.     # If we are dumping the file data to a DBM file, nuke the existing 
  152.     # ones and open the dbm file.  Otherwise, open the DBM file
  153.      # only if they exist. 
  154.     #
  155.     $read_from_file = 1;
  156.  
  157.     if (defined($opt_D)) {    
  158.         unlink("$opt_f.dir", "$opt_f.pag");
  159.  
  160.         dbmopen(files, $opt_f, 0644) ||
  161.           die sprintf("can't open DBM file '%s'", $opt_f);
  162.     } elsif (-f "$opt_f.dir") {
  163.         dbmopen(files, $opt_f, 0644) ||
  164.           die sprintf("can't open DBM file '%s'", $opt_f);
  165.  
  166.         $read_from_file = 0;
  167.     }
  168.  
  169.     if ($read_from_file) {
  170.         open(FILEDATA, $opt_f) || 
  171.           die sprintf("kuang: can't open '%s'", $opt_f);
  172.  
  173.         $count = 0;
  174.         while (<FILEDATA>) {
  175.         $count++;
  176.  
  177.         chop;
  178.         ($f_type, $f_uid, $f_gid, $f_mode, $f_name) = split;
  179.  
  180.         if ($count % 1000 == 0) {
  181.             printf("line $count, reading entry for $f_name\n");
  182.         }
  183.         $files{$f_name} = join(' ', $f_uid, $f_gid, $f_mode);
  184.         }
  185.  
  186.         close(FILEDATA);
  187.     }
  188.     }
  189.  
  190.     if (defined($opt_D)) {
  191.     dbmclose(files);
  192.  
  193.     exit(0);
  194.     }
  195. if (defined($opt_v)) {
  196.     printf("done with files\n");
  197.     }
  198.     #
  199.     # Need some of the password and group stuff.  Suck in passwd and 
  200.     # group info, store by uid and gid in an associative array of strings
  201.     # which consist of fields corresponding to the passwd and group file 
  202.     # entries (and what the heck, we'll use : as a delimiter also...:-)
  203.     #
  204.  
  205.     $passwd_byuid_list{-1} = "OTHER:::";    # add an entry for OTHER
  206.     $passwd_byname_list{"OTHER"} = -1;
  207.  
  208.     $uids_known{-1} = "";            # we can access OTHER
  209.     %uids_new = ();
  210.  
  211.     %gids_known = ();
  212.     %gids_new = ();
  213.  
  214.     %files_new = ();
  215.  
  216.     #
  217.     # Set up initial goal: become target user or group
  218.     #
  219.     if ($which eq "u") {
  220.     $uid = &passwd_byname($name);
  221.     if ($uid ne "") {
  222.         &addto("uids", $uid, "grant u.$name do anything");
  223.     } else {
  224.         printf(stderr "There is no user with username '$name'.\n");
  225.         exit(1);
  226.     }
  227.     } else {
  228.     $gid = &group_byname($name);
  229.     if ($gid ne "") {
  230.         &addto("gids", $gid, "grant g.$name");
  231.     } else {
  232.         printf(stderr "There is no group named '$name'.\n");
  233.         exit(1);
  234.     }
  235.     }
  236. }
  237.  
  238. #
  239. # Get the home directory for this UID from the passwd file cache.
  240. #
  241. sub gethome {
  242.     local($uid) = @_;
  243.     local($tmp, $home);
  244.  
  245.     ($tmp, $tmp, $home, $tmp) = &passwd_byuid($uid);
  246.     return($home);
  247. }
  248.  
  249. #
  250. # Get the writers of the named file - return as (UID, GID, OTHER)
  251. # triplet.  Owner can always write, since he can chmod the file if he
  252. # wants. 
  253. #
  254. # (fixme) are there any problems in this sort of builtin rule?  should
  255. # we make this knowledge more explicit?
  256. #
  257. sub filewriters {
  258.     local($name) = @_;
  259.     local($tmp, $mode, $uid, $gid, $other);
  260.     
  261.     #
  262.     # Check the file cache - avoid disk lookups for performance and 
  263.     # to avoid shadows...
  264.     #
  265.     if (defined($files{$name})) {
  266.     $cache_hit++;
  267.     
  268.     ($uid, $gid, $mode) = split(/ /, $files{$name});
  269.     $mode = oct($mode);
  270.     } else {
  271.     $cache_miss++;
  272.  
  273.     if (! -e $name && $read_from_file) {
  274.         $files{$name} = "";
  275.         return;
  276.     }
  277.  
  278.     ($tmp,$tmp,$mode,$tmp,$uid,$gid) = stat(_);
  279.     if ($read_from_file) {
  280.         $files{$name} = join(' ', $uid, $gid, $mode);
  281.     }
  282.     }
  283.  
  284.     if (($mode & 020) != 020) {
  285.     $gid = "";
  286.     }
  287.     
  288.     if (($mode & 02) == 02) {
  289.     $other = 1;
  290.     } else {
  291.     $other = 0;
  292.     }
  293.  
  294.     return($uid, $gid, $other);
  295. }
  296.  
  297. #
  298. # return # of entries in given associative array.
  299. #
  300. sub sizeof {
  301.     local(*which) = @_;
  302.     local(@keywords);
  303.  
  304.     @keywords = keys %which;
  305.     return($#keywords + 1);
  306. }
  307.  
  308. #
  309. # return appropriate entry from named associative array of given type.
  310. # returns a (key, value) pair - if key is "", there was no entry.
  311. #
  312. sub getentry {
  313.     local($which, $type, $key) = @_;
  314.     local($newkey, $value);
  315.  
  316.     $newkey = "";
  317.     $value = "";
  318.  
  319.     which: {
  320.     if ($which eq "uids") {
  321.         type0: {
  322.             if ($type eq "known") {
  323.             if (defined($uids_known{$key})) {
  324.                 $newkey = $key;    $value = $uids_known{$key};
  325.             }
  326.                 last type0;
  327.             }
  328.  
  329.             if ($type eq "new") {
  330.             if (defined($uids_new{$key})) {
  331.                 $newkey = $key;    $value = $uids_new{$key};
  332.             }
  333.                 last type0;
  334.             }
  335.  
  336.             if ($type eq "pending") {
  337.             if (defined($uids_pending{$key})) {
  338.                 $newkey = $key;    $value = $uids_pending{$key};
  339.             }
  340.                 last type0;
  341.             }
  342.  
  343.             if ($type eq "old") {
  344.             if (defined($uids_old{$key})) {
  345.                 $newkey = $key;    $value = $uids_old{$key};
  346.             }
  347.                 last type0;
  348.             }
  349.  
  350.             printf(stderr "kuang: fatal error in getentry: type is wrong (%s)\n", 
  351.             $type);
  352.             exit(1);
  353.         }
  354.  
  355.         last which;
  356.         }
  357.  
  358.     if ($which eq "gids") {
  359.         type1: {
  360.             if ($type eq "known") {
  361.             if (defined($gids_known{$key})) {
  362.                 $newkey = $key;    $value = $gids_known{$key};
  363.             }
  364.                 last type1;
  365.             }
  366.  
  367.             if ($type eq "new") {
  368.             if (defined($gids_new{$key})) {
  369.                 $newkey = $key;    $value = $gids_new{$key};
  370.             }
  371.                 last type1;
  372.             }
  373.  
  374.             if ($type eq "pending") {
  375.             if (defined($gids_pending{$key})) {
  376.                 $newkey = $key;    $value = $gids_pending{$key};
  377.             }
  378.                 last type1;
  379.             }
  380.  
  381.             if ($type eq "old") {
  382.             if (defined($gids_old{$key})) {
  383.                 $newkey = $key;    $value = $gids_old{$key};
  384.             }
  385.                 last type1;
  386.             }
  387.  
  388.             printf(stderr "kuang: fatal error in getentry: type is wrong (%s)\n", 
  389.             $type);
  390.             exit(1);
  391.         }
  392.  
  393.         last which;
  394.     }
  395.  
  396.     if ($which eq "files") {
  397.         type2: {
  398.             if ($type eq "known") {
  399.             if (defined($files_known{$key})) {
  400.                 $newkey = $key;    $value = $files_known{$key};
  401.             }
  402.                 last type2;
  403.             }
  404.  
  405.             if ($type eq "new") {
  406.             if (defined($files_new{$key})) {
  407.                 $newkey = $key;    $value = $files_new{$key};
  408.             }
  409.                 last type2;
  410.             }
  411.  
  412.             if ($type eq "pending") {
  413.             if (defined($files_pending{$key})) {
  414.                 $newkey = $key;    $value = $files_pending{$key};
  415.             }
  416.                 last type2;
  417.             }
  418.  
  419.             if ($type eq "old") {
  420.             if (defined($files_old{$key})) {
  421.                 $newkey = $key;    $value = $files_old{$key};
  422.             }
  423.                 last type2;
  424.             }
  425.  
  426.             printf(stderr "kuang: fatal error in getentry: type is wrong (%s)\n", 
  427.             $type);
  428.             exit(1);
  429.         }
  430.  
  431.         last which;
  432.     }
  433.  
  434.     printf(stderr "kuang: fatal error in getentry: which is wrong (%s)\n",
  435.         $which);
  436.     exit(1);
  437.     }
  438.  
  439.     return($newkey, $value);
  440. }
  441.  
  442.  
  443. #
  444. # stores a (key, value) in the associative array of the given type.
  445. #
  446. sub putentry {
  447.     local($which, $type, $key, $value) = @_;
  448.  
  449.     which: {
  450.     if ($which eq "uids") {
  451.         type0: {
  452.             if ($type eq "known") {
  453.             $uids_known{$key} = $value;    last type0;
  454.             }
  455.  
  456.             if ($type eq "new") {
  457.             $uids_new{$key} = $value;    last type0;
  458.             }
  459.  
  460.             if ($type eq "pending") {
  461.             $uids_pending{$key} = $value;    last type0;
  462.             }
  463.  
  464.             if ($type eq "old") {
  465.             $uids_old{$key} = $value;    last type0;
  466.             }
  467.  
  468.             printf(stderr "kuang: fatal error in putentry: type is wrong (%s)\n", 
  469.             $type);
  470.             exit(1);
  471.         }
  472.  
  473.         last which;
  474.         }
  475.  
  476.     if ($which eq "gids") {
  477.         type1: {
  478.             if ($type eq "known") {
  479.             $gids_known{$key} = $value;    last type1;
  480.             }
  481.  
  482.             if ($type eq "new") {
  483.             $gids_new{$key} = $value;    last type1;
  484.             }
  485.  
  486.             if ($type eq "pending") {
  487.             $gids_pending{$key} = $value;    last type1;
  488.             }
  489.  
  490.             if ($type eq "old") {
  491.             $gids_old{$key} = $value;    last type1;
  492.             }
  493.  
  494.             printf(stderr "kuang: fatal error in putentry: type is wrong (%s)\n", 
  495.             $type);
  496.             exit(1);
  497.         }
  498.  
  499.         last which;
  500.     }
  501.  
  502.     if ($which eq "files") {
  503.         type2: {
  504.             if ($type eq "known") {
  505.             $files_known{$key} = $value;    last type2;
  506.             }
  507.  
  508.             if ($type eq "new") {
  509.             $files_new{$key} = $value;    last type2;
  510.             }
  511.  
  512.             if ($type eq "pending") {
  513.             $files_pending{$key} = $value;    last type2;
  514.             }
  515.  
  516.             if ($type eq "old") {
  517.             $files_old{$key} = $value;    last type2;
  518.             }
  519.  
  520.             printf(stderr "kuang: fatal error in putentry: type is wrong (%s)\n", 
  521.             $type);
  522.             exit(1);
  523.         }
  524.  
  525.         last which;
  526.     }
  527.  
  528.     printf(stderr "kuang: fatal error in putentry: which is wrong (%s)\n",
  529.         $which);
  530.     exit(1);
  531.     }
  532. }
  533.  
  534.  
  535. sub addto {
  536.     local($which, $key, $plan) = @_;
  537.     local($tkey, $tvalue);
  538.  
  539.     #
  540.     # See whether there's an entry for $key in the known list for the
  541.     # $which array.  If so - success, we've found a suitable breakin
  542.     # path. 
  543.     #
  544.  
  545.     ($tkey, $tvalue) = &getentry($which, "known", $key);
  546.     if ($tkey eq $key) {
  547.     printf("Success! $key $plan\n");
  548.     return;
  549.     }
  550.  
  551.     #
  552.     # Check to see if its a duplicate - if so, don't need to do anything.
  553.     #
  554.     ($tkey, $tvalue) = &getentry($which, "pending", $key);
  555.     if ($tkey eq $key) {
  556.     return;
  557.     }
  558.  
  559.     #
  560.     # Add to pending list for $which...
  561.     #
  562.     &putentry($which, "pending", $key, $plan);
  563.  
  564.     #
  565.     # Add to next goal list for $which...
  566.     #
  567.     &putentry($which, "new", $key, $plan);
  568.  
  569.     if (defined($opt_v)) {
  570.     printf("addto: $which --> $plan\n");
  571.     }
  572.  
  573.     #
  574.     # If this is a uid goal, then add the plan to the accessible list.
  575.     #
  576.     if ($which eq "uids" && $key ne "0" && defined($opt_l)) {
  577.     $accessible{$plan} = "1";
  578.     }
  579. }
  580.  
  581. #
  582. #----------------------------------------------------------------------
  583. #Main program follows...initialize and loop till we're done.
  584. #
  585.  
  586. &init_kuang();
  587.  
  588. #
  589. # While there's still something to pursue...
  590. #
  591. while (&sizeof(*uids_new) != 0 || 
  592.        &sizeof(*gids_new) != 0 || 
  593.        &sizeof(*files_new) != 0) {
  594.  
  595.     #
  596.     # Deal with uids first...
  597.     #
  598.     if (&sizeof(*uids_new) != 0) {
  599.         %uids_old = %uids_new;
  600.         %uids_new = ();
  601.  
  602.         foreach $uid (keys %uids_old) {
  603.         $plan = $uids_old{$uid};
  604.  
  605.         if (defined($opd_d)) {
  606.         printf("uids evel: $uid '$plan'\n");
  607.         }
  608.             
  609.             &addto("files", "/etc/passwd", "replace /etc/passwd $plan");
  610.             &addto("files", "/usr/lib/aliases", "replace /usr/lib/aliases $plan");
  611.  
  612.         #
  613.         # Add controlling files for this user.  There are probably 
  614.         # others (such as .logout, X tool start things and so on).
  615.         # (fixme) add other CF's...
  616.         #
  617.         $home = &gethome($uid);
  618.  
  619.         if ($home ne "") {
  620.         if ($home eq "/") {
  621.             $home = "";
  622.         }
  623.  
  624.         if (-e "$home/.rhosts") {
  625.             &addto("files", "$home/.rhosts", "write $home/.rhosts $plan");
  626.         }
  627.  
  628.         if (-e "$home/.login") {
  629.             &addto("files", "$home/.login", "replace $home/.login $plan");
  630.         }
  631.  
  632.         if (-e "$home/.logout") {
  633.             &addto("files", "$home/.logout", "replace $home/.logout $plan");
  634.         }
  635.  
  636.         if (-e "$home/.cshrc") {
  637.             &addto("files", "$home/.cshrc", "replace $home/.cshrc $plan");
  638.         }
  639.  
  640.         if (-e "$home/.profile") {
  641.             &addto("files", "$home/.profile", "replace $home/.profile $plan");
  642.         }
  643.         }
  644.  
  645.         #
  646.         # Controlling files for root...
  647.         #
  648.         if ($uid+0 == 0) {
  649.         foreach $file ("/etc/rc", "/etc/rc.boot", "/etc/rc.single", "/etc/rc.config", "/etc/rc.local", "/usr/lib/crontab", "/usr/spool/cron/crontabs") {
  650.             if (-e $file) {
  651.             &addto("files", $file, "replace $file $plan");
  652.             }
  653.         }
  654.         }
  655.  
  656.         if ($uid+0 != 0) {
  657.         &addto("files", "/etc/hosts.equiv", "replace /etc/hosts.equiv allow rlogin $plan");
  658.  
  659.         if (-s "/etc/hosts.equiv") {
  660.             &addto("files", "/etc/hosts", "replace /etc/hosts fake hostaddress allow rlogin $plan");
  661.         }
  662.         }
  663.     }
  664.     }
  665.  
  666.     #
  667.     # Deal with groups...
  668.     #
  669.     if (&sizeof(*gids_new) != 0) {
  670.         %gids_old = %gids_new;
  671.         %gids_new = ();
  672.  
  673. bar_loop:
  674.         foreach $gid (keys %gids_old) {
  675.         $plan = $gids_old{$gid};
  676.         if (defined($opt_d)) {
  677.         printf("gids eval: $gid '$plan'\n");
  678.         }
  679.             
  680.         ($gname, $members) = &group_bygid($gid);
  681.         if ($gname eq "") {
  682.         printf("There is no group with gid $gid.\n");
  683.         next bar_loop;
  684.         }
  685.  
  686. foo_loop:
  687.         foreach $uname (split(/[ \t\n]+/, $members)) {
  688.         $uid = &passwd_byname($uname);
  689.  
  690.         if ($uid eq "") {
  691.             printf(stderr "Group $gname has an unknown user $uname\n");
  692.             next foo_loop;
  693.         }
  694.  
  695.         &addto("uids", "$uid", "grant u.$uname $plan");
  696.         }
  697.  
  698.         &addto("files", "/etc/group", "replace /etc/group $plan");
  699.     }
  700.     }
  701.  
  702.     #
  703.     # Deal with files...
  704.     #
  705.     if (&sizeof(*files_new) != 0) {
  706.         %files_old = %files_new;
  707.         %files_new = ();
  708.  
  709. file_loop:
  710.         foreach $file (keys %files_old) {
  711.         $plan = $files_old{$file};
  712.         ($mode) = split(/[ \t\n]+/, $plan);
  713.  
  714.         if (defined($opt_d)) {
  715.         printf("files eval: $file '$plan'\n");
  716.         }
  717.  
  718.         ($owner, $group, $other) = &filewriters($file);
  719.  
  720.         if ($owner eq "") {
  721.         printf("%s does not exist\n", $file);
  722.         next file_loop;
  723.         }
  724.  
  725.         ($uname) = &passwd_byuid($owner);
  726.         if ($uname eq "") {
  727.         $uname = $owner;
  728.         }
  729.  
  730.         &addto("uids", $owner, "grant u.$uname $plan");
  731.  
  732.         if ($group ne "") {
  733.         ($gname, $tmp) = &group_bygid($group);
  734.  
  735.         if ($gname ne "") {
  736.             &addto("gids", $group, "grant g.$gname $plan");
  737.         } else {
  738.             printf(stderr "There is no group with gid $group.\n");
  739.         }
  740.         }
  741.  
  742.         if ($other) {
  743.         &addto("uids", -1, "grant u.OTHER $plan");
  744.         }
  745.  
  746.         if ($mode eq "replace") {
  747.         $parent = $file;
  748.         $parent =~ s|/[^/]*$||;        # strip last / and remaining
  749.  
  750.         if ($parent eq "") {        # if nothing left, use /
  751.             $parent = "/";
  752.         }
  753.  
  754.         if ($parent ne $file) {        # since $file might've been /
  755.             &addto("files", $parent, "replace $parent $plan");
  756.         }
  757.         }
  758.     }
  759.     }
  760. }
  761.  
  762. if (defined($opt_l)) {
  763.     foreach $key (keys %accessible) {
  764.     printf("$key\n");
  765.     }
  766. }
  767.  
  768. if (defined($opt_v) || $cache_hit) {
  769.     printf("File info cache hit/access ratio: %g\n", 
  770.             $cache_hit / ($cache_hit + $cache_miss));
  771.     }
  772.