home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / metasploit / msfupdate < prev    next >
Encoding:
Text File  |  2006-06-30  |  19.7 KB  |  777 lines
  1. #!/usr/bin/perl
  2. ###############
  3.  
  4. require 5.6.0;
  5. use strict;
  6. use vars qw{$SSL_SUPPORT};
  7.  
  8. use FindBin qw{$RealBin};
  9. use lib "$RealBin/lib";
  10. use Digest::Perl::MD5 qw{md5_hex};
  11.  
  12. use Getopt::Std;
  13. use IO::Socket;
  14. use IO::Select;
  15. use POSIX;
  16.  
  17. no utf8;
  18. no locale;
  19.  
  20. my $VERSION      = '$Revision: 1.45 $';
  21. my $FRAMEWORK    = '2.6';
  22. my ($REV)        = $VERSION =~ m/\$Revisio.:\s+([^\s]+)/;
  23.  
  24. my $UPDATE_HOST  = 'metasploit.com';
  25. my $UPDATE_PATH  = '/projects/Framework/updates/msfupdate.html';
  26. my $SSL_VERIFIED = 0;
  27. my $SSL_ISSUER   = '/C=US/ST=Texas/L=San Antonio/O=The Metasploit Project/OU=Development/CN=Metasploit CA/emailAddress=cacert@metasploit.com';
  28. my $SSL_CERTS    = "$RealBin/docs";
  29. my $OPSYS        = $^O;
  30.  
  31. select(STDOUT); $|++;
  32.  
  33. # Check for buggy versions of perl with utf-8 locale set
  34. BrokenUTF8();
  35.  
  36. # Determine if SSL support is enabled
  37. BEGIN
  38. {
  39.     if (eval "require Net::SSLeay")
  40.     {
  41.         Net::SSLeay->import();
  42.         Net::SSLeay::load_error_strings();
  43.         Net::SSLeay::SSLeay_add_ssl_algorithms();
  44.         Net::SSLeay::randomize();
  45.         $SSL_SUPPORT++;
  46.     }
  47. }
  48.  
  49. my %opts;
  50. getopts('hrvusmaxfOp:', \%opts);
  51.  
  52. if ($opts{v}) {
  53.     print "Msfupdate Version: $REV\n";
  54.     print "Framework Version: $FRAMEWORK\n";
  55.     exit(0);
  56. }
  57.  
  58. if ($opts{h} || (! $opts{m} && ! $opts{r} && ! $opts{u} && ! $opts{U})) {
  59.     Usage();
  60. }
  61.  
  62. if ($opts{O}) {
  63.    $OPSYS = 'paranoid';
  64. }
  65.  
  66. chdir($RealBin);
  67.  
  68. my $proxy = $opts{'p'};
  69. my ($old_data, $now_data, $new_data);
  70. my ($old, $now, $new);
  71. my ($mod, $upx, $upd);
  72.  
  73. print "\n";
  74. print "+ -- --=[ msfupdate v$FRAMEWORK [revision $REV]\n\n";
  75. print "[*] Calculating local file checksums, please wait...\n";
  76. $now_data = ScanFiles('.');
  77. print "\n";
  78.  
  79. if (! -r '.current') {
  80.     WriteFile('.current', $now_data);
  81.     $old_data = $now_data;
  82. } 
  83. else {
  84.     $old_data = ReadFile('.current');
  85. }
  86.  
  87. if ($opts{r}) {
  88.     print "[*] The local file hash has been rebuilt\n";
  89.     WriteFile('.current', $now_data);
  90.     exit(0);
  91. }
  92.  
  93. # Allow the user to disable SSL mode entirely
  94. if ($opts{f}) {
  95.     $SSL_SUPPORT = 0;
  96. }
  97.  
  98. # Display a big nasty warning for non-SSL unless -x is specified
  99. if ($opts{u} || $opts{U}) {
  100.     if (! $opts{x} && ! $SSL_SUPPORT) {
  101.         print "[*] WARNING: The Net::SSLeay module is not installed. The update\n";
  102.         print "    process will fall back to plain HTTP, this may allow a \n";
  103.         print "    malicious attacker to inject hostile code into your system.\n";
  104.         print "\n";
  105.         print "Continue anyways (yes or no) ";
  106.         
  107.         my $resp;
  108.         while ($resp !~ /yes|no/i) {
  109.             print "> ";
  110.             $resp = <STDIN>;
  111.             chomp($resp);
  112.         }
  113.         print "\n";
  114.         
  115.         if ($resp !~ /yes/i) {
  116.             print "[*] The update process has been cancelled\n";
  117.             exit(0);
  118.         }
  119.     }
  120.     
  121.     $new_data = DownloadFile($UPDATE_HOST, "$UPDATE_PATH/.current", $proxy);
  122. }
  123.  
  124. $now = Hashit($now_data);
  125. $old = Hashit($old_data);
  126. $new = Hashit($new_data);
  127.  
  128. $mod = Diff($old, $now);
  129. $upx = Diff($old, $new);
  130. $upd = Diff($now, $new);
  131.  
  132. if ($opts{m}) {
  133.     if (! keys(%{$mod})) {
  134.         print "[*] No modifications since the last update\n";
  135.         exit(0);
  136.     }
  137.     
  138.     print "[*] Modifications since the last update:\n";
  139.     foreach (sort keys(%{$mod})) {
  140.         print "\t".$mod->{$_}."\t$_\n";
  141.     }
  142.     print "\n";
  143.     exit(0);
  144. }
  145.  
  146. # Strip this list down to just modifications
  147. foreach (keys(%{$mod})) {
  148.     if ($mod->{$_} ne 'Mod') {
  149.         delete($mod->{$_});
  150.     }
  151. }
  152.  
  153. if (! $new_data) {
  154.     print "[*] Could not obtain the current version information from the update server\n";
  155.     exit(0);
  156. }
  157.  
  158. my $mver = CheckVersion();
  159.  
  160. if ( ($opts{u} || $opts{U}) && ! $mver) {
  161.     print "[*] Could not determine the current Framework version.\n";
  162.     exit(0);
  163. }
  164.  
  165. if ($mver && $mver ne $FRAMEWORK) {
  166.  
  167.     if (! $opts{U}) {
  168.         print "[*] Version $mver of the Metasploit Framework is now available.\n";
  169.         print "    - http://metasploit.com/projects/Framework/downloads.html\n\b\n";
  170.     }
  171.     else {
  172.         print "[*] Starting upgrade process for version $mver...\n\n";
  173.     }
  174. }
  175.  
  176. if ($opts{U} && $mver && $mver eq $FRAMEWORK) {
  177.     print "[*] No version upgrade is necessary.\n";
  178.     exit(0);
  179. }
  180.  
  181. # Upgrade to a new major release version...
  182. if ($opts{U}) {
  183.   
  184.     my $backupdir = 'backup_'. $FRAMEWORK;
  185.     
  186.     print "[*] WARNING: You are about to upgrade to a new major version of the\n";
  187.     print "    Metasploit Framework. This process involves removing the current\n";
  188.     print "    installation and downloading the new version, one file at a time.\n";
  189.     print "    This process is slow and somewhat prone to failure. If you encounter\n";
  190.     print "    any problems during the download, you *should* be able to simply\n";
  191.     print "    restart msfupdate with the -u parameter\n\n";
  192.     
  193.     print "    If you have modified any of the files in the Framework directory,\n";
  194.     print "    these will be saved to $backupdir. The same applies for any modules\n";
  195.     print "    that you have added to this Framework installation. After the update\n";
  196.     print "    is complete, you should be able to copy these modules from the\n";
  197.     print "    backup directory ($backupdir) into the appropriate directories\n";
  198.     print "    in the new installation.\n\n";
  199.  
  200.     print "    If you are using FreeBSD or any other operating that maintains a\n";
  201.     print "    package for the Framework, we recommend that you use the system\n";
  202.     print "    package manager to upgrade\n\n";
  203.     
  204.     print "    Please type 'yes' to initiate the upgrade process.\n";
  205.     print "Continue? (yes or no) ";
  206.     
  207.     my $resp;
  208.     while ($resp !~ /yes|no/i) {
  209.         print "> ";
  210.         $resp = <STDIN>;
  211.         chomp($resp);
  212.     }
  213.     if ($resp =~ /no/i) {
  214.         exit(0);
  215.     }
  216.     
  217.     delete($now->{'./msfupdate'});
  218.     delete($new->{'./msfupdate'});
  219.     delete($mod->{'./msfupdate'});
  220.     delete($upd->{'./msfupdate'});
  221.  
  222.     print "[*] Backing up modified files to $backupdir...\n";
  223.     
  224.     # Backup framework files that the user modified
  225.     foreach my $file (keys %{$mod} ) {
  226.         print "    --- MOD $file\n";
  227.         my $data = ReadFile($file);
  228.         WriteFile($backupdir .'/'. $file , $data);
  229.     }
  230.     
  231.     # Backup files that the user created
  232.     foreach my $file (keys %{$upd} ) {
  233.         next if $upd->{$file} ne 'Del';
  234.         print "    --- USR $file\n";
  235.         my $data = ReadFile($file);
  236.         WriteFile($backupdir .'/'. $file , $data);
  237.     }   
  238.     
  239.     print "[*] Removing the current installation...\n";
  240.  
  241.     # Do not remove these files since we need them to update...
  242.     my %docs_save = ('./docs/7f8d5320.0' => 1, './docs/cacert.pem' => 1);
  243.  
  244.     # Remove all files that are part of the framework
  245.     foreach my $file (keys %{$now}) {
  246.         next if exists($docs_save{$file});
  247.         unlink($file);
  248.     }
  249.  
  250.     # Remove all directories but 'docs'
  251.     foreach my $dir (split(/\n/, ScanDirs('.', 0))) {
  252.         next if $dir eq './docs';
  253.         system("rm", "-rf", $dir);
  254.     }
  255.     
  256.     # Bump up the framework version
  257.     $FRAMEWORK = $mver;
  258.     
  259.     # Download the file list for the new framework version
  260.     $new_data = DownloadFile($UPDATE_HOST, "$UPDATE_PATH/.current", $proxy);
  261.  
  262.     # Rebuild the tables
  263.     $new = Hashit($new_data);
  264.     $now = {};
  265.     $old = {};
  266.  
  267.     $mod = Diff($old, $now);
  268.     $upx = Diff($old, $new);
  269.     $upd = Diff($now, $new);
  270.     
  271.     # Configure some options
  272.     $opts{a}++;
  273. }
  274.  
  275.  
  276.  
  277.  
  278. # They modified something, ask them what they want to do with it
  279. if (! $opts{a} && keys(%{$mod})) {  
  280.     print "[*] You have modified the following Framework components:\n\n";
  281.     foreach (sort(keys(%{$mod}))) {
  282.         print "\t".$_."\n";
  283.     }
  284.     print "\n";
  285.     print "    Would you like to preserve these changes? If you say no, all\n";
  286.     print "    local modifications will be overwritten by the update process.\n";
  287.     print "\n";
  288.     print "Preserve modifications (yes or no) ";
  289.     my $resp;
  290.     while ($resp !~ /yes|no/i) {
  291.         print "> ";
  292.         $resp = <STDIN>;
  293.         chomp($resp);
  294.     }
  295.     if ($resp =~ /no/i) {
  296.         $mod = {};
  297.     }
  298.     print "\n";
  299. }
  300.  
  301. foreach (keys(%{$upd})) {
  302.     # Do not remove user-created files
  303.     if ($upd->{$_} eq 'Del') {
  304.         delete($upd->{$_});
  305.     }
  306.  
  307.     # Ignore updates we already have
  308.     if ($now->{$_} eq $new->{$_}) {
  309.         delete($upd->{$_});
  310.     }    
  311. }
  312.  
  313.  
  314. # Ignore locally modified files when -a is supplied
  315. if ($opts{a}) {
  316.     $mod = {};
  317. }
  318.  
  319. # After all of this stuff, this is what we have
  320. # - $mod is a table of anything the user wants to keep
  321. # - $upd is a table of everything online new or updated
  322.  
  323.  
  324. # The plan of attack is:
  325. # - Iterate through each item in $upd, if there is a match in
  326. #   $mod, we print a message and ignore the download for it.
  327. #   We will delete anything with the Del status set in this
  328. #   table. 
  329. # - Once we have identified an update, we try to download it.
  330. #   If an error occurs, either because the download fails or
  331. #   the md5 does no match.
  332. #
  333. # - After all files have been processed, we rebuild the local
  334. #   .current file and get ready for the next update.
  335. #
  336.  
  337. if (! keys(%{$upd})) {
  338.     print "[*] No new updates are available\n";
  339.     exit(0);
  340. }
  341.  
  342. print "[*] Online Update Task Summary\n\n";
  343. foreach my $entry (sort keys(%{$upd})) {
  344.     next if $opts{U};
  345.     
  346.     if ($mod->{$entry}) {
  347.         print "\tIgnore: $entry\n";
  348.     }
  349.     else {
  350.         print "\tUpdate: $entry\n";
  351.     }
  352. }
  353. print "\n";
  354.  
  355. exit(0) if $opts{s};
  356.  
  357. if (! $opts{a}) {
  358.     print "Continue? (yes or no) ";
  359.     my $resp;
  360.     while ($resp !~ /yes|no/i) {
  361.         print "> ";
  362.         $resp = <STDIN>;
  363.         chomp($resp);
  364.     }
  365.     print "\n";
  366.     if ($resp !~ /yes/i) {
  367.         exit(0);
  368.     }
  369. }
  370.  
  371. my @tasks = sort(keys(%{$upd}));
  372.  
  373. # Force msfupdate to downloaded first...
  374. if ($opts{U}) {
  375.     unshift(@tasks, './msfupdate');
  376.     unshift(@tasks, './lib/Digest/Perl/MD5.pm');
  377. }
  378.  
  379. my $upd_tot = scalar(@tasks);
  380. my $upd_cur = 0;
  381.  
  382. print "\n";
  383. print "[*] Starting online update of $upd_tot file(s)...\n\n";
  384. foreach my $entry (@tasks) {
  385.     if ($mod->{$entry}) {
  386.         next;
  387.     } 
  388.     my $data = DownloadFile($UPDATE_HOST, "$UPDATE_PATH/$entry", $proxy);
  389.     if ($new->{$entry} ne md5_hex($data)) {
  390.         print "$entry: ". $new->{$entry} ." != ". md5_hex($data) ."\n";
  391.         my $errmsg = $data ? 'checksum mismatch' : 'download failed';
  392.         print "[*] Failed to update $entry: $errmsg\n";
  393.         next;
  394.     }
  395.     
  396.     # overwrite the local file O_o
  397.     WriteFile($entry, $data);
  398.     
  399.     # set it executable since we dont track permissions
  400.     chmod(0755, $entry);
  401.     
  402.     printf("[%.4d/%.4d - 0x%.6x bytes] $entry\n", ++$upd_cur, $upd_tot, length($data));
  403. }
  404.  
  405. print "\n";
  406. print "[*] Regenerating local file database\n";
  407. $now_data = ScanFiles('.');
  408. WriteFile('.current', $now_data);
  409.  
  410.  
  411. sub Usage { 
  412.     print STDERR "  Usage: $0 [options]>\n";
  413.     print STDERR "Options:\n";
  414.     print STDERR "         -h             You're looking at me baby\n";
  415.     print STDERR "         -v             Display version information\n";
  416.     print STDERR "         -u             Perform an online update via metasploit.com\n";
  417.     print STDERR "         -s             Only display update tasks, do not actually download\n";
  418.     print STDERR "         -m             Show any files locally modified since last update\n";
  419.     print STDERR "         -a             Do not prompt, default to overwrite all files\n";
  420.     print STDERR "         -x             Do not require confirmation for non-SSL updates\n";
  421.     print STDERR "         -f             Disable ssl support entirely, use with -x to avoid warnings\n";
  422.     print STDERR "         -O             Removes the operating system name from the user agent\n";
  423.     print STDERR "         -p             Specifies a proxy: <http|socks4>:<hostname>:<port>\n";
  424.     
  425.     # Too buggy and dangerous to use
  426.     # print STDERR "         -U             Upgrade to a new major revision of the Framework\n";
  427.     # Developer options
  428.     # print STDERR "         -r             Rebuild the local version database (internal only)\n";
  429.     print "\n";
  430.     exit(0);
  431. }
  432.  
  433. sub ScanFiles {
  434.     my $dir = shift;
  435.     my $res;
  436.     my $hwn;
  437.     
  438.     opendir ($hwn, $dir) || return;
  439.     
  440.     while (defined(my $entry = readdir($hwn))) {
  441.         my $path = "$dir/$entry";
  442.  
  443.         # ignore all symlinks
  444.         next if -l $path;
  445.         
  446.         # ignore all leading dot files   
  447.         next if $entry =~ /^\./;
  448.         
  449.         # ignore the backup directories
  450.         next if $entry =~ /^backup_/;
  451.         
  452.         # recurse into directories
  453.         if (-d $path) {
  454.             $res .= ScanFiles($path);
  455.         } 
  456.         elsif (-f $path) {
  457.             $res .= HashFile($path)."\t$path\n";;
  458.         }
  459.     }
  460.     closedir($hwn);
  461.     return $res;   
  462. }
  463.  
  464. sub ScanDirs {
  465.     my $dir = shift;
  466.     my $dep = @_ ? shift() : 0;
  467.     my $res;
  468.     my $hwn;
  469.     
  470.     return if $dep == -1;
  471.     opendir ($hwn, $dir) || return;
  472.     
  473.     while (defined(my $entry = readdir($hwn))) {
  474.         my $path = "$dir/$entry";
  475.         
  476.         # ignore all symlinks
  477.         next if -l $path; 
  478.         
  479.         # ignore the backup directories
  480.         next if $entry =~ /^backup_/;
  481.         
  482.         # ignore all leading dot files   
  483.         next if $entry =~ /^\./;
  484.          
  485.         # recurse into directories
  486.         if (-d $path) {
  487.             $res .= "$path\n";
  488.             $res .= ScanDirs($path, $dep - 1);
  489.         }
  490.     }
  491.     closedir($hwn);
  492.     return $res;   
  493. }
  494.  
  495.  
  496.  
  497. sub CheckVersion {
  498.     my $data = DownloadFile($UPDATE_HOST, $UPDATE_PATH, $proxy);
  499.     my ($vers, $mtime) = split(/\s+/, $data);
  500.     return $vers;
  501. }
  502.  
  503. sub DownloadFile {
  504.     my $host = shift;
  505.     my $path = shift;
  506.     my $prox = shift;
  507.     
  508.     my $port = $SSL_SUPPORT ? 443 : 80;
  509.     my $data;
  510.     
  511.     $path = EscapeURI($path);
  512.     
  513.     my ($proxy_type, $proxy_host, $proxy_port);
  514.     if ($prox =~ m/^(socks4|http):([^:]+):(\d+)/) {
  515.         ($proxy_type, $proxy_host, $proxy_port) = ($1, $2, $3);
  516.     }
  517.     
  518.     if ($prox && ! $proxy_host) {
  519.         print STDERR "[*] Invalid proxy format ($prox), please use one of the following:\n";
  520.         print STDERR "\tSOCKS: socks4:<hostname|ip address>:<port>\n";
  521.         print STDERR "\t HTTP:   http:<hostname|ip address>:<port>\n\n";
  522.         exit(0);
  523.     }
  524.     
  525.     
  526.     my $sock = IO::Socket::INET->new
  527.     (
  528.         PeerAddr    => $proxy_host || $host,
  529.         PeerPort    => $proxy_port || $port,
  530.         Proto       => 'tcp',
  531.     );
  532.     
  533.     if (! $sock) {
  534.         print STDERR "[*] Could not connect to $host: $!\n";
  535.         exit(0);
  536.     }
  537.     
  538.     if ($proxy_type eq 'http') {
  539.         $sock->send("CONNECT ".$host.":".$port." HTTP/1.0\r\n\r\n");
  540.         
  541.         # Look for the HTTP response message from the Proxy server
  542.         my $sel = IO::Select->new($sock);
  543.         my $resp = '';
  544.         
  545.         if ($sel->can_read(5)) {
  546.             while (my $line = <$sock>)  {
  547.                 last if $line eq "\r\n";
  548.                 $resp .= $line;
  549.             }
  550.         } else {
  551.             print STDERR "[*] No reply received from the HTTP proxy\n";
  552.             exit(0);
  553.         }
  554.         
  555.         if ($resp !~ /HTTP\/1\.\d\s+2/) {
  556.             foreach my $line (split(/\r\n/, $resp)) {
  557.                 $line =~ s/\r|\n//g;
  558.                 $line =~ s/\e//g;
  559.                 print STDERR "[*] Proxy: " . $line . "\n";
  560.             }
  561.             print STDERR "[*] Connection failed\n";
  562.             exit(0);
  563.         }
  564.     }
  565.     
  566.     if ($proxy_type eq 'socks4') {
  567.         $sock->send("\x04\x01".pack('n',$port).gethostbyname($host)."\x00");
  568.         $sock->recv(my $res, 8);
  569.         
  570.         if (! $res || ($res && ord(substr($res,1,1)) != 90)) {
  571.             print STDERR "[*] Failed to established connection through socks4 proxy $proxy_host\n";
  572.             if (length($res)) {
  573.                 print STDERR "[*] Response: ". unpack("H*", $res) ."\n";
  574.             }
  575.             exit(0);
  576.         }    
  577.     }
  578.     
  579.     my $req = 
  580.         "GET $path HTTP/1.0\r\n".
  581.         "Host: ".$host.":".$port."\r\n".
  582.         "User-Agent: msfupdate/$REV $FRAMEWORK ($OPSYS)\r\n\r\n";
  583.     
  584.     if ($SSL_SUPPORT) { 
  585.     
  586.         # Reset the verified flag
  587.         $SSL_VERIFIED = 0;
  588.  
  589.         # Create SSL Context
  590.         my $ctx = Net::SSLeay::CTX_new();
  591.        
  592.         # Tell SSL to use the certificate in the docs directory 
  593.         Net::SSLeay::CTX_load_verify_locations($ctx, '', $SSL_CERTS);
  594.         
  595.         # Configure the SSL call-back to prevent MiTM
  596.         Net::SSLeay::CTX_set_verify($ctx, &Net::SSLeay::VERIFY_PEER, \&SSLVerify);
  597.                 
  598.         # Configure session for maximum interoperability
  599.         Net::SSLeay::CTX_set_options($ctx, &Net::SSLeay::OP_ALL);
  600.         
  601.         # Create a new SSL object with context
  602.         my $ssl = Net::SSLeay::new($ctx);
  603.  
  604.         # Bind the SSL descriptor to the socket
  605.         Net::SSLeay::set_fd($ssl, $sock->fileno);
  606.         
  607.         # Negotiate connection
  608.         my $sslConn = Net::SSLeay::connect($ssl);
  609.  
  610.         if ($sslConn <= 0) {
  611.             print STDERR "[*] SSL error:". Net::SSLeay::print_errs()."\n";
  612.             $sock->close;
  613.             return;
  614.         }
  615.         
  616.         Net::SSLeay::ssl_write_all($ssl, $req);
  617.         
  618.         my $cert = Net::SSLeay::get_peer_certificate($ssl);
  619.  
  620.         $data = Net::SSLeay::ssl_read_all($ssl);
  621.         
  622.         Net::SSLeay::free ($ssl);
  623.         Net::SSLeay::CTX_free ($ctx);
  624.         $sock->close;
  625.  
  626.         $data = ProcessHTTP($data);
  627.         return $data;
  628.     }
  629.     
  630.     $sock->send($req);
  631.     $sock->shutdown(1);
  632.     while (<$sock>) { $data .= $_ }
  633.     close ($sock);
  634.     
  635.     $data = ProcessHTTP($data);    
  636.     return $data;
  637. }
  638.  
  639. # Prevent MiTM attacks on the update downloads when run over SSL
  640. sub SSLVerify {
  641.     my ($ok, $x509_store_ctx) = @_;
  642.     my $cert = Net::SSLeay::X509_STORE_CTX_get_current_cert($x509_store_ctx);
  643.     
  644.     if ($cert) {
  645.         my $x509_issuer =  Net::SSLeay::X509_get_issuer_name($cert);
  646.         my $issuer = Net::SSLeay::X509_NAME_oneline($x509_issuer);
  647.         
  648.         # differences between openssl 0.9.6 vs 0.9.7 (thanks par!)
  649.         $issuer =~ s/Email/emailAddress/g;
  650.         
  651.         if ($ok && $issuer eq $SSL_ISSUER) {
  652.             $SSL_VERIFIED++;
  653.             return 1;
  654.         }
  655.     }
  656.    
  657.     return;
  658. }
  659.  
  660. sub ProcessHTTP {
  661.     my $http = shift;
  662.     my $idx = index($http, "\r\n\r\n");
  663.     return if -1 == $idx;
  664.     my $head = substr($http, 0, $idx);
  665.     my $body = substr($http, $idx + 4);
  666.     return if $head !~ /HTTP\/1..\s+2/;
  667.     return $body;  
  668. }
  669.  
  670. sub WriteFile {
  671.     my $file = shift;
  672.     my $data = shift;
  673.  
  674.     my @path = split(/\//, $file);
  675.     pop(@path);
  676.     
  677.     my $cdir = ".";
  678.     foreach (@path) {
  679.         $cdir .= "/".$_;
  680.         if (! -d $cdir) {
  681.             mkdir($cdir, 0755);
  682.         }
  683.     }
  684.     
  685.     open (my $out, ">$file") || return;
  686.     print $out $data;
  687.     close ($out);
  688. }
  689.  
  690. sub ReadFile {
  691.     my $path = shift;
  692.     my $data;
  693.     my $inp;
  694.     
  695.     open($inp, "<$path") || return;
  696.     while (<$inp>) { $data .= $_ }
  697.     close($inp);
  698.     
  699.     return $data;
  700. }
  701.  
  702. sub HashFile {
  703.     my $path = shift;
  704.     my $data = ReadFile($path);
  705.     return md5_hex($data);
  706. }
  707.  
  708. sub Hashit {
  709.     my $data = shift;
  710.     my $hash = {};
  711.     foreach my $line (split(/\n/, $data)) {
  712.         my ($md5, $path) = $line =~ m/^([^\s]+)\s+(.*)/g;
  713.         $hash->{$path} = $md5;
  714.     }
  715.     return $hash;
  716. }
  717.  
  718. sub Diff {
  719.     my $setA = shift;
  720.     my $setB = shift;
  721.     my $res;
  722.     
  723.     foreach (keys(%{$setA})) {
  724.         if (exists($setB->{$_})) {
  725.             if ($setA->{$_} ne $setB->{$_}) {
  726.                 $res->{$_} = 'Mod';
  727.             }
  728.         } 
  729.         else {
  730.             $res->{$_} = 'Del';
  731.         }
  732.     }
  733.     
  734.     foreach (keys(%{$setB})) {
  735.         if (! exists($setA->{$_})) {
  736.             $res->{$_} = 'New';
  737.         }
  738.     }
  739.     
  740.     return $res;
  741. }
  742.  
  743. sub EscapeURI {
  744.     my $path = shift;
  745.     my %escapes = ();
  746.     for (0..255) { $escapes{chr($_)} = sprintf("%%%02X", $_) }
  747.     $path =~ s/([^A-Za-z0-9\-_.!~*'()\/])/$escapes{$1}/eg;
  748.     return $path;
  749. }
  750.  
  751. sub BrokenUTF8 {
  752.     if ( $] >= 5.008 && $] < 5.008002 )
  753.      {
  754.          my $badver;
  755.         
  756.         # Check LANG first
  757.         $badver = ($ENV{'LANG'} =~ /utf/i) ? 1 : 0;
  758.         
  759.         # LC_ALL overrides LANG if its set
  760.         if (defined($ENV{'LC_ALL'})) {
  761.             $badver = ($ENV{'LC_ALL'} =~ /utf/i) ? 1 : 0;
  762.         }
  763.         
  764.         return if ! $badver;
  765.      
  766.         print STDERR qq|
  767. [*] This version of Perl ($]) contains a buggy utf-8 implementation. If you
  768.     would like to use this version with the Metasploit Framework, you must
  769.     set the LC_ALL environment variable to 'C'. For example:
  770.  
  771.     \$ export LC_ALL=C; ./msfconsole
  772.     
  773. |;
  774.     exit(0);
  775.     }
  776. }
  777.