!C99Shell v. 1.0 pre-release build #13!

Software: Apache. PHP/5.5.15 

uname -a: Windows NT SVR-DMZ 6.1 build 7600 (Windows Server 2008 R2 Enterprise Edition) i586 

SYSTEM 

Safe-mode: OFF (not secure)

C:\Intranet\C\xampp\php\PEAR\Net\DNS\   drwxrwxrwx
Free 4.09 GB of 39.52 GB (10.36%)
Detected drives: [ a ] [ c ] [ d ] [ e ] [ f ]
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     Packet.php (21.37 KB)      -rw-rw-rw-
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php
/*
 *  License Information:
 *
 *    Net_DNS:  A resolver library for PHP
 *    Copyright (c) 2002-2003 Eric Kilfoil eric@ypass.net
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 2.1 of the License, or (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/* Net_DNS_Packet object definition {{{ */
/**
 * A object represation of a DNS packet (RFC1035)
 *
 * This object is used to manage a DNS packet.  It contains methods for
 * DNS packet compression as defined in RFC1035, as well as parsing  a DNS
 * packet response from a DNS server, or building a DNS packet from  the
 * instance variables contained in the class.
 *
 * @package Net_DNS
 */
class Net_DNS_Packet
{
    
/* class variable definitions {{{ */
    /**
     * debugging flag
     *
     * If set to true (non-zero), debugging code will be displayed as the
     * packet is parsed.
     *
     * @var boolean $debug
     * @access  public
     */
    
var $debug;
    
/**
     * A packet Header object.
     *
     * An object of type Net_DNS_Header which contains the header
     * information  of the packet.
     *
     * @var object Net_DNS_Header $header
     * @access  public
     */
    
var $header;
    
/**
     * A hash of compressed labels
     *
     * A list of all labels which have been compressed in the DNS packet
     * and  the location offset of the label within the packet.
     *
     * @var array   $compnames
     */
    
var $compnames;
    
/**
     * The origin of the packet, if the packet is a server response.
     *
     * This contains a string containing the IP address of the name server
     * from which the answer was given.
     *
     * @var string  $answerfrom
     * @access  public
     */
    
var $answerfrom;
    
/**
     * The size of the answer packet, if the packet is a server response.
     *
     * This contains a integer containing the size of the DNS packet the
     * server responded with if this packet was received by a DNS server
     * using the query() method.
     *
     * @var string  $answersize
     * @access  public
     */
    
var $answersize;
    
/**
     * An array of Net_DNS_Question objects
     *
     * Contains all of the questions within the packet.  Each question is
     * stored as an object of type Net_DNS_Question.
     *
     * @var array   $question
     * @access  public
     */
    
var $question;
    
/**
     * An array of Net_DNS_RR ANSWER objects
     *
     * Contains all of the answer RRs within the packet.  Each answer is
     * stored as an object of type Net_DNS_RR.
     *
     * @var array   $answer
     * @access  public
     */
    
var $answer;
    
/**
     * An array of Net_DNS_RR AUTHORITY objects
     *
     * Contains all of the authority RRs within the packet.  Each authority is
     * stored as an object of type Net_DNS_RR.
     *
     * @var array   $authority
     * @access  public
     */
    
var $authority;
    
/**
     * An array of Net_DNS_RR ADDITIONAL objects
     *
     * Contains all of the additional RRs within the packet.  Each additional is
     * stored as an object of type Net_DNS_RR.
     *
     * @var array   $additional
     * @access  public
     */
    
var $additional;

    
/* }}} */
    /* class constructor - Net_DNS_Packet($debug = false) {{{ */
    /*
     * unfortunately (or fortunately), we can't follow the same
     * silly method for determining if name is a hostname or a packet
     * stream in PHP, since there is no ref() function.  So we're going
     * to define a new method called parse to deal with this
     * circumstance and another method called buildQuestion to build a question.
     * I like it better that way anyway.
     */
    /**
     * Initalizes a Net_DNS_Packet object
     *
     * @param boolean $debug Turns debugging on or off
     */
    
function Net_DNS_Packet($debug false)
    {
        
$this->debug $debug;
        
$this->compnames = array();
    }

    
/* }}} */
    /* Net_DNS_Packet::buildQuestion($name, $type = "A", $class = "IN") {{{ */
    /**
     * Adds a DNS question to the DNS packet
     *
     * @param   string $name    The name of the record to query
     * @param   string $type    The type of record to query
     * @param   string $class   The class of record to query
     * @see Net_DNS::typesbyname(), Net_DNS::classesbyname()
     */
    
function buildQuestion($name$type 'A'$class 'IN')
    {
        
$this->header = new Net_DNS_Header();
        
$this->header->qdcount 1;
        
$this->question[0] = new Net_DNS_Question($name$type$class);
        
$this->answer null;
        
$this->authority null;
        
$this->additional null;
        
/* Do not print question packet
        if ($this->debug) {
            $this->display();
        }
        */
    
}

    
/* }}} */
    /* Net_DNS_Packet::parse($data) {{{ */
    /**
     * Parses a DNS packet returned by a DNS server
     *
     * Parses a complete DNS packet and builds an object hierarchy
     * containing all of the parts of the packet:
     * <ul>
     *   <li>HEADER
     *   <li>QUESTION
     *   <li>ANSWER || PREREQUISITE
     *   <li>ADDITIONAL || UPDATE
     *   <li>AUTHORITY
     * </ul>
     *
     * @param string $data  A binary string containing a DNS packet
     * @return boolean true on success, null on parser error
     */
    
function parse($data)
    {
        if (
$this->debug) {
            echo 
';; HEADER SECTION' "\n";
        }

        
$this->header = new Net_DNS_Header($data);

        if (
$this->debug) {
            
$this->header->display();
        }

        
/*
         *  Print and parse the QUESTION section of the packet
         */
        
if ($this->debug) {
            echo 
"\n";
            
$section = ($this->header->opcode  == 'UPDATE') ? 'ZONE' 'QUESTION';
            echo 
";; $section SECTION (" $this->header->qdcount ' record' .
                (
$this->header->qdcount == '' 's') . ")\n";
        }

        
$offset 12;

        
$this->question = array();
        for (
$ctr 0$ctr $this->header->qdcount$ctr++) {
            list(
$qobj$offset) = $this->parse_question($data$offset);
            if (
is_null($qobj)) {
                return 
null;
            }

            
$this->question[count($this->question)] = $qobj;
            if (
$this->debug) {
                echo 
";;\n;";
                
$qobj->display();
            }
        }

        
/*
         *  Print and parse the PREREQUISITE or ANSWER  section of the packet
         */
        
if ($this->debug) {
            echo 
"\n";
            
$section = ($this->header->opcode == 'UPDATE') ? 'PREREQUISITE' :'ANSWER';
            echo 
";; $section SECTION (" .
                
$this->header->ancount ' record' .
                ((
$this->header->ancount == 1) ? '' 's') .
                
")\n";
        }

        
$this->answer = array();
        for (
$ctr 0$ctr $this->header->ancount$ctr++) {
            list(
$rrobj$offset) = $this->parse_rr($data$offset);

            if (
is_null($rrobj)) {
                return 
null;
            }
            
array_push($this->answer$rrobj);
            if (
$this->debug) {
                
$rrobj->display();
            }
        }

        
/*
         *  Print and parse the UPDATE or AUTHORITY section of the packet
         */
        
if ($this->debug) {
            echo 
"\n";
            
$section = ($this->header->opcode == 'UPDATE') ? 'UPDATE' 'AUTHORITY';
            echo 
";; $section SECTION (" .
                
$this->header->nscount ' record' .
                ((
$this->header->nscount == 1) ? '' 's') .
                
")\n";
        }

        
$this->authority = array();
        for (
$ctr 0$ctr $this->header->nscount$ctr++) {
            list(
$rrobj$offset) = $this->parse_rr($data$offset);

            if (
is_null($rrobj)) {
                return 
null;
            }
            
array_push($this->authority$rrobj);
            if (
$this->debug) {
                
$rrobj->display();
            }
        }

        
/*
         *  Print and parse the ADDITIONAL section of the packet
         */
        
if ($this->debug) {
            echo 
"\n";
            echo 
';; ADDITIONAL SECTION (' .
                
$this->header->arcount ' record' .
                ((
$this->header->arcount == 1) ? '' 's') .
                
")\n";
        }

        
$this->additional = array();
        for (
$ctr 0$ctr $this->header->arcount$ctr++) {
            list(
$rrobj$offset) = $this->parse_rr($data$offset);

            if (
is_null($rrobj)) {
                return 
null;
            }
            
array_push($this->additional$rrobj);
            if (
$this->debug) {
                
$rrobj->display();
            }
        }

        return 
true;
    }

    
/* }}} */
    /* Net_DNS_Packet::data() {{{*/
    /**
     * Build a packet from a Packet object hierarchy
     *
     * Builds a valid DNS packet suitable for sending to a DNS server or
     * resolver client containing all of the data in the packet hierarchy.
     *
     * @return string A binary string containing a DNS Packet
     */
    
function data()
    {
        
$data $this->header->data();

        for (
$ctr 0$ctr $this->header->qdcount$ctr++) {
            
$data .= $this->question[$ctr]->data($thisstrlen($data));
        }

        for (
$ctr 0$ctr $this->header->ancount$ctr++) {
            
$data .= $this->answer[$ctr]->data($thisstrlen($data));
        }

        for (
$ctr 0$ctr $this->header->nscount$ctr++) {
            
$data .= $this->authority[$ctr]->data($thisstrlen($data));
        }

        for (
$ctr 0$ctr $this->header->arcount$ctr++) {
            
$data .= $this->additional[$ctr]->data($thisstrlen($data));
        }

        return 
$data;
    }

    
/*}}}*/
    /* Net_DNS_Packet::dn_comp($name, $offset) {{{*/
    /**
     * DNS packet compression method
     *
     * Returns a domain name compressed for a particular packet object, to
     * be stored beginning at the given offset within the packet data.  The
     * name will be added to a running list of compressed domain names for
     * future use.
     *
     * @param string    $name       The name of the label to compress
     * @param integer   $offset     The location offset in the packet to where
     *                              the label will be stored.
     * @return string   $compname   A binary string containing the compressed
     *                              label.
     * @see Net_DNS_Packet::dn_expand()
     */
    
function dn_comp($name$offset)
    {
        
$names explode('.'$name);
        
$compname '';
        while (
count($names)) {
            
$dname join('.'$names);
            if (isset(
$this->compnames[$dname])) {
                
$compname .= pack('n'0xc000 $this->compnames[$dname]);
                break;
            }

            
$this->compnames[$dname] = $offset;
            
$first array_shift($names);
            
$length strlen($first);
            
$compname .= pack('Ca*'$length$first);
            
$offset += $length 1;
        }
        if (! 
count($names)) {
            
$compname .= pack('C'0);
        }
        return 
$compname;
    }

    
/*}}}*/
    /* Net_DNS_Packet::dn_expand($packet, $offset) {{{ */
    /**
     * DNS packet decompression method
     *
     * Expands the domain name stored at a particular location in a DNS
     * packet.  The first argument is a variable containing  the packet
     * data.  The second argument is the offset within the  packet where
     * the (possibly) compressed domain name is stored.
     *
     * @param   string  $packet The packet data
     * @param   integer $offset The location offset in the packet of the
     *                          label to decompress.
     * @return  array   Returns a list of type array($name, $offset) where
     *                  $name is the name of the label which was decompressed
     *                  and $offset is the offset of the next field in the
     *                  packet.  Returns array(null, null) on error
     */
    
function dn_expand($packet$offset)
    {
        
$packetlen strlen($packet);
        
$int16sz 2;
        
$name '';
        while (
1) {
            if (
$packetlen < ($offset 1)) {
                return array(
nullnull);
            }

            
$a unpack("@$offset/Cchar"$packet);
            
$len $a['char'];

            if (
$len == 0) {
                
$offset++;
                break;
            } else if ((
$len 0xc0) == 0xc0) {
                if (
$packetlen < ($offset $int16sz)) {
                    return array(
nullnull);
                }
                
$ptr unpack("@$offset/ni"$packet);
                
$ptr $ptr['i'];
                
$ptr $ptr 0x3fff;
                
$name2 Net_DNS_Packet::dn_expand($packet$ptr);

                if (
is_null($name2[0])) {
                    return array(
nullnull);
                }
                
$name .= $name2[0];
                
$offset += $int16sz;
                break;
            } else {
                
$offset++;

                if (
$packetlen < ($offset $len)) {
                    return array(
nullnull);
                }

                
$elem substr($packet$offset$len);
                
$name .= $elem '.';
                
$offset += $len;
            }
        }
        
$name ereg_replace('\.$'''$name);
        return array(
$name$offset);
    }

    
/*}}}*/
    /* Net_DNS_Packet::label_extract($packet, $offset) {{{ */
    /**
     * DNS packet decompression method
     *
     * Extracts the label stored at a particular location in a DNS
     * packet.  The first argument is a variable containing  the packet
     * data.  The second argument is the offset within the  packet where
     * the (possibly) compressed domain name is stored.
     *
     * @param   string  $packet The packet data
     * @param   integer $offset The location offset in the packet of the
     *                          label to extract.
     * @return  array   Returns a list of type array($name, $offset) where
     *                  $name is the name of the label which was decompressed
     *                  and $offset is the offset of the next field in the
     *                  packet.  Returns array(null, null) on error
     */
    
function label_extract($packet$offset)
    {
        
$packetlen strlen($packet);
        
$name '';
        if (
$packetlen < ($offset 1)) {
            return array(
nullnull);
        }

        
$a unpack("@$offset/Cchar"$packet);
        
$len $a['char'];
        
$offset++;

        if (
$len $offset $packetlen) {
            
$name substr($packet$offset);
            
$offset $packetlen;
        } else {
            
$name substr($packet$offset$len);
            
$offset += $len;
        }
        return array(
$name$offset);
    }

    
/*}}}*/
    /* Net_DNS_Packet::parse_question($data, $offset) {{{ */
    /**
     * Parses the question section of a packet
     *
     * Examines a DNS packet at the specified offset and parses the data
     * of the QUESTION section.
     *
     * @param   string  $data   The packet data returned from the server
     * @param   integer $offset The location offset of the start of the
     *                          question section.
     * @return  array   An array of type array($q, $offset) where $q
     *                  is a Net_DNS_Question object and $offset is the
     *                  location of the next section of the packet which
     *                  needs to be parsed.
     */
    
function parse_question($data$offset)
    {
        list(
$qname$offset) = $this->dn_expand($data$offset);
        if (
is_null($qname)) {
            return array(
nullnull);
        }

        if (
strlen($data) < ($offset 2)) {
            return array(
nullnull);
        }

        
$q unpack("@$offset/n2int"$data);
        
$qtype $q['int1'];
        
$qclass $q['int2'];
        
$offset += 2;

        
$qtype Net_DNS::typesbyval($qtype);
        
$qclass Net_DNS::classesbyval($qclass);

        
$q = new Net_DNS_Question($qname$qtype$qclass);
        return array(
$q$offset);
    }

    
/*}}}*/
    /* Net_DNS_Packet::parse_rr($data, $offset) {{{ */
    /**
     * Parses a resource record section of a packet
     *
     * Examines a DNS packet at the specified offset and parses the data
     * of a section which contains RRs (ANSWER, AUTHORITY, ADDITIONAL).
     *
     * @param string    $data   The packet data returned from the server
     * @param integer   $offset The location offset of the start of the resource
     *                          record section.
     * @return  array   An array of type array($rr, $offset) where $rr
     *                  is a Net_DNS_RR object and $offset is the
     *                  location of the next section of the packet which
     *                  needs to be parsed.
     */
    
function parse_rr($data$offset)
    {
        list(
$name$offset) = $this->dn_expand($data$offset);
        if (
$name === null) {
            return array(
nullnull);
        }

        if (
strlen($data) < ($offset 10)) {
            return array(
nullnull);
        }

        
$a unpack("@$offset/n2tc/Nttl/nrdlength"$data);
        
$type $a['tc1'];
        
$class $a['tc2'];
        
$ttl $a['ttl'];
        
$rdlength $a['rdlength'];

        
$type Net_DNS::typesbyval($type);
        
$class Net_DNS::classesbyval($class);

        
$offset += 10;
        if (
strlen($data) < ($offset $rdlength)) {
            return array(
nullnull);
        }

        
$rrobj = &Net_DNS_RR::factory(array($name,
                    
$type,
                    
$class,
                    
$ttl,
                    
$rdlength,
                    
$data,
                    
$offset));

        if (
is_null($rrobj)) {
            return array(
nullnull);
        }

        
$offset += $rdlength;

        return array(
$rrobj$offset);
    }

    
/* }}} */
    /* Net_DNS_Packet::display() {{{ */
    /**
     * Prints out the packet in a human readable formatted string
     */
    
function display()
    {
        echo 
$this->string();
    }

    
/*}}}*/
    /* Net_DNS_Packet::string() {{{ */
    /**
     * Builds a human readable formatted string representing a packet
     */
    
function string()
    {
        
$retval '';
        if (
$this->answerfrom) {
            
$retval .= ';; Answer received from ' $this->answerfrom '(' .
                
$this->answersize " bytes)\n;;\n";
        }

        
$retval .= ";; HEADER SECTION\n";
        
$retval .= $this->header->string();
        
$retval .= "\n";

        
$section = ($this->header->opcode == 'UPDATE') ? 'ZONE' 'QUESTION';
        
$retval .= ";; $section SECTION (" $this->header->qdcount     .
            
' record' . ($this->header->qdcount == '' 's') .
            
")\n";

        foreach (
$this->question as $qr) {
            
$retval .= ';; ' $qr->string() . "\n";
        }

        
$section = ($this->header->opcode == 'UPDATE') ? 'PREREQUISITE' 'ANSWER';
        
$retval .= "\n;; $section SECTION (" $this->header->ancount     .
            
' record' . ($this->header->ancount == '' 's') .
            
")\n";

        if (
is_array($this->answer)) {
            foreach (
$this->answer as $ans) {
                
$retval .= ';; ' $ans->string() . "\n";
            }
        }

        
$section = ($this->header->opcode == 'UPDATE') ? 'UPDATE' 'AUTHORITY';
        
$retval .= "\n;; $section SECTION (" $this->header->nscount     .
            
' record' . ($this->header->nscount == '' 's') .
            
")\n";

        if (
is_array($this->authority)) {
            foreach (
$this->authority as $auth) {
                
$retval .= ';; ' $auth->string() . "\n";
            }
        }

        
$retval .= "\n;; ADDITIONAL SECTION (" $this->header->arcount     .
            
' record' . ($this->header->arcount == '' 's') .
            
")\n";

        if (
is_array($this->additional)) {
            foreach (
$this->additional as $addl) {
                
$retval .= ';; ' $addl->string() . "\n";
            }
        }

        
$retval .= "\n\n";
        return 
$retval;
    }

    
/*}}}*/
}
/* }}} */
/* VIM settings {{{
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * soft-stop-width: 4
 * c indent on
 * End:
 * vim600: sw=4 ts=4 sts=4 cindent fdm=marker et
 * vim<600: sw=4 ts=4
 * }}} */
?>

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ ok ]

:: Make Dir ::
 
[ ok ]
:: Make File ::
 
[ ok ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 1.0 pre-release build #13 powered by Captain Crunch Security Team | http://ccteam.ru | Generation time: 0.0312 ]--