webshell-analyzer 1.0.0__py3-none-any.whl

webshell_analyzer/extractor/ast_extraction/vendor/nikic/php-parser/lib/PhpParser/Node/IntersectionType.php

@@ -0,0 +1,27 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+class IntersectionType extends ComplexType {
+    /** @var (Identifier|Name)[] Types */
+    public array $types;
+
+    /**
+     * Constructs an intersection type.
+     *
+     * @param (Identifier|Name)[] $types Types
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct(array $types, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->types = $types;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['types'];
+    }
+
+    public function getType(): string {
+        return 'IntersectionType';
+    }
+}

webshell_analyzer/extractor/ast_extraction/vendor/nikic/php-parser/lib/PhpParser/Node/MatchArm.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+
+class MatchArm extends NodeAbstract {
+    /** @var null|list<Node\Expr> */
+    public ?array $conds;
+    public Expr $body;
+
+    /**
+     * @param null|list<Node\Expr> $conds
+     */
+    public function __construct(?array $conds, Node\Expr $body, array $attributes = []) {
+        $this->conds = $conds;
+        $this->body = $body;
+        $this->attributes = $attributes;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['conds', 'body'];
+    }
+
+    public function getType(): string {
+        return 'MatchArm';
+    }
+}

webshell_analyzer/extractor/ast_extraction/vendor/nikic/php-parser/lib/PhpParser/Node/Name/FullyQualified.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Name;
+
+class FullyQualified extends \PhpParser\Node\Name {
+    /**
+     * Checks whether the name is unqualified. (E.g. Name)
+     *
+     * @return bool Whether the name is unqualified
+     */
+    public function isUnqualified(): bool {
+        return false;
+    }
+
+    /**
+     * Checks whether the name is qualified. (E.g. Name\Name)
+     *
+     * @return bool Whether the name is qualified
+     */
+    public function isQualified(): bool {
+        return false;
+    }
+
+    /**
+     * Checks whether the name is fully qualified. (E.g. \Name)
+     *
+     * @return bool Whether the name is fully qualified
+     */
+    public function isFullyQualified(): bool {
+        return true;
+    }
+
+    /**
+     * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
+     *
+     * @return bool Whether the name is relative
+     */
+    public function isRelative(): bool {
+        return false;
+    }
+
+    public function toCodeString(): string {
+        return '\\' . $this->toString();
+    }
+
+    public function getType(): string {
+        return 'Name_FullyQualified';
+    }
+}

webshell_analyzer/extractor/ast_extraction/vendor/nikic/php-parser/lib/PhpParser/Node/Name/Relative.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Name;
+
+class Relative extends \PhpParser\Node\Name {
+    /**
+     * Checks whether the name is unqualified. (E.g. Name)
+     *
+     * @return bool Whether the name is unqualified
+     */
+    public function isUnqualified(): bool {
+        return false;
+    }
+
+    /**
+     * Checks whether the name is qualified. (E.g. Name\Name)
+     *
+     * @return bool Whether the name is qualified
+     */
+    public function isQualified(): bool {
+        return false;
+    }
+
+    /**
+     * Checks whether the name is fully qualified. (E.g. \Name)
+     *
+     * @return bool Whether the name is fully qualified
+     */
+    public function isFullyQualified(): bool {
+        return false;
+    }
+
+    /**
+     * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
+     *
+     * @return bool Whether the name is relative
+     */
+    public function isRelative(): bool {
+        return true;
+    }
+
+    public function toCodeString(): string {
+        return 'namespace\\' . $this->toString();
+    }
+
+    public function getType(): string {
+        return 'Name_Relative';
+    }
+}

webshell_analyzer/extractor/ast_extraction/vendor/nikic/php-parser/lib/PhpParser/Node/Name.php

@@ -0,0 +1,278 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\NodeAbstract;
+
+class Name extends NodeAbstract {
+    /**
+     * @psalm-var non-empty-string
+     * @var string Name as string
+     */
+    public string $name;
+
+    /** @var array<string, bool> */
+    private static array $specialClassNames = [
+        'self'   => true,
+        'parent' => true,
+        'static' => true,
+    ];
+
+    /**
+     * Constructs a name node.
+     *
+     * @param string|string[]|self $name Name as string, part array or Name instance (copy ctor)
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    final public function __construct($name, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->name = self::prepareName($name);
+    }
+
+    public function getSubNodeNames(): array {
+        return ['name'];
+    }
+
+    /**
+     * Get parts of name (split by the namespace separator).
+     *
+     * @psalm-return non-empty-list<string>
+     * @return string[] Parts of name
+     */
+    public function getParts(): array {
+        return \explode('\\', $this->name);
+    }
+
+    /**
+     * Gets the first part of the name, i.e. everything before the first namespace separator.
+     *
+     * @return string First part of the name
+     */
+    public function getFirst(): string {
+        if (false !== $pos = \strpos($this->name, '\\')) {
+            return \substr($this->name, 0, $pos);
+        }
+        return $this->name;
+    }
+
+    /**
+     * Gets the last part of the name, i.e. everything after the last namespace separator.
+     *
+     * @return string Last part of the name
+     */
+    public function getLast(): string {
+        if (false !== $pos = \strrpos($this->name, '\\')) {
+            return \substr($this->name, $pos + 1);
+        }
+        return $this->name;
+    }
+
+    /**
+     * Checks whether the name is unqualified. (E.g. Name)
+     *
+     * @return bool Whether the name is unqualified
+     */
+    public function isUnqualified(): bool {
+        return false === \strpos($this->name, '\\');
+    }
+
+    /**
+     * Checks whether the name is qualified. (E.g. Name\Name)
+     *
+     * @return bool Whether the name is qualified
+     */
+    public function isQualified(): bool {
+        return false !== \strpos($this->name, '\\');
+    }
+
+    /**
+     * Checks whether the name is fully qualified. (E.g. \Name)
+     *
+     * @return bool Whether the name is fully qualified
+     */
+    public function isFullyQualified(): bool {
+        return false;
+    }
+
+    /**
+     * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
+     *
+     * @return bool Whether the name is relative
+     */
+    public function isRelative(): bool {
+        return false;
+    }
+
+    /**
+     * Returns a string representation of the name itself, without taking the name type into
+     * account (e.g., not including a leading backslash for fully qualified names).
+     *
+     * @psalm-return non-empty-string
+     * @return string String representation
+     */
+    public function toString(): string {
+        return $this->name;
+    }
+
+    /**
+     * Returns a string representation of the name as it would occur in code (e.g., including
+     * leading backslash for fully qualified names.
+     *
+     * @psalm-return non-empty-string
+     * @return string String representation
+     */
+    public function toCodeString(): string {
+        return $this->toString();
+    }
+
+    /**
+     * Returns lowercased string representation of the name, without taking the name type into
+     * account (e.g., no leading backslash for fully qualified names).
+     *
+     * @psalm-return non-empty-string&lowercase-string
+     * @return string Lowercased string representation
+     */
+    public function toLowerString(): string {
+        return strtolower($this->name);
+    }
+
+    /**
+     * Checks whether the identifier is a special class name (self, parent or static).
+     *
+     * @return bool Whether identifier is a special class name
+     */
+    public function isSpecialClassName(): bool {
+        return isset(self::$specialClassNames[strtolower($this->name)]);
+    }
+
+    /**
+     * Returns a string representation of the name by imploding the namespace parts with the
+     * namespace separator.
+     *
+     * @psalm-return non-empty-string
+     * @return string String representation
+     */
+    public function __toString(): string {
+        return $this->name;
+    }
+
+    /**
+     * Gets a slice of a name (similar to array_slice).
+     *
+     * This method returns a new instance of the same type as the original and with the same
+     * attributes.
+     *
+     * If the slice is empty, null is returned. The null value will be correctly handled in
+     * concatenations using concat().
+     *
+     * Offset and length have the same meaning as in array_slice().
+     *
+     * @param int $offset Offset to start the slice at (may be negative)
+     * @param int|null $length Length of the slice (may be negative)
+     *
+     * @return static|null Sliced name
+     */
+    public function slice(int $offset, ?int $length = null) {
+        if ($offset === 1 && $length === null) {
+            // Short-circuit the common case.
+            if (false !== $pos = \strpos($this->name, '\\')) {
+                return new static(\substr($this->name, $pos + 1));
+            }
+            return null;
+        }
+
+        $parts = \explode('\\', $this->name);
+        $numParts = \count($parts);
+
+        $realOffset = $offset < 0 ? $offset + $numParts : $offset;
+        if ($realOffset < 0 || $realOffset > $numParts) {
+            throw new \OutOfBoundsException(sprintf('Offset %d is out of bounds', $offset));
+        }
+
+        if (null === $length) {
+            $realLength = $numParts - $realOffset;
+        } else {
+            $realLength = $length < 0 ? $length + $numParts - $realOffset : $length;
+            if ($realLength < 0 || $realLength > $numParts - $realOffset) {
+                throw new \OutOfBoundsException(sprintf('Length %d is out of bounds', $length));
+            }
+        }
+
+        if ($realLength === 0) {
+            // Empty slice is represented as null
+            return null;
+        }
+
+        return new static(array_slice($parts, $realOffset, $realLength), $this->attributes);
+    }
+
+    /**
+     * Concatenate two names, yielding a new Name instance.
+     *
+     * The type of the generated instance depends on which class this method is called on, for
+     * example Name\FullyQualified::concat() will yield a Name\FullyQualified instance.
+     *
+     * If one of the arguments is null, a new instance of the other name will be returned. If both
+     * arguments are null, null will be returned. As such, writing
+     *     Name::concat($namespace, $shortName)
+     * where $namespace is a Name node or null will work as expected.
+     *
+     * @param string|string[]|self|null $name1 The first name
+     * @param string|string[]|self|null $name2 The second name
+     * @param array<string, mixed> $attributes Attributes to assign to concatenated name
+     *
+     * @return static|null Concatenated name
+     */
+    public static function concat($name1, $name2, array $attributes = []) {
+        if (null === $name1 && null === $name2) {
+            return null;
+        }
+        if (null === $name1) {
+            return new static($name2, $attributes);
+        }
+        if (null === $name2) {
+            return new static($name1, $attributes);
+        } else {
+            return new static(
+                self::prepareName($name1) . '\\' . self::prepareName($name2), $attributes
+            );
+        }
+    }
+
+    /**
+     * Prepares a (string, array or Name node) name for use in name changing methods by converting
+     * it to a string.
+     *
+     * @param string|string[]|self $name Name to prepare
+     *
+     * @psalm-return non-empty-string
+     * @return string Prepared name
+     */
+    private static function prepareName($name): string {
+        if (\is_string($name)) {
+            if ('' === $name) {
+                throw new \InvalidArgumentException('Name cannot be empty');
+            }
+
+            return $name;
+        }
+        if (\is_array($name)) {
+            if (empty($name)) {
+                throw new \InvalidArgumentException('Name cannot be empty');
+            }
+
+            return implode('\\', $name);
+        }
+        if ($name instanceof self) {
+            return $name->name;
+        }
+
+        throw new \InvalidArgumentException(
+            'Expected string, array of parts or Name instance'
+        );
+    }
+
+    public function getType(): string {
+        return 'Name';
+    }
+}

webshell_analyzer/extractor/ast_extraction/vendor/nikic/php-parser/lib/PhpParser/Node/NullableType.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Node;
+
+class NullableType extends ComplexType {
+    /** @var Identifier|Name Type */
+    public Node $type;
+
+    /**
+     * Constructs a nullable type (wrapping another type).
+     *
+     * @param Identifier|Name $type Type
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct(Node $type, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->type = $type;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['type'];
+    }
+
+    public function getType(): string {
+        return 'NullableType';
+    }
+}

webshell_analyzer/extractor/ast_extraction/vendor/nikic/php-parser/lib/PhpParser/Node/Param.php

@@ -0,0 +1,123 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Modifiers;
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+
+class Param extends NodeAbstract {
+    /** @var null|Identifier|Name|ComplexType Type declaration */
+    public ?Node $type;
+    /** @var bool Whether parameter is passed by reference */
+    public bool $byRef;
+    /** @var bool Whether this is a variadic argument */
+    public bool $variadic;
+    /** @var Expr\Variable|Expr\Error Parameter variable */
+    public Expr $var;
+    /** @var null|Expr Default value */
+    public ?Expr $default;
+    /** @var int Optional visibility flags */
+    public int $flags;
+    /** @var AttributeGroup[] PHP attribute groups */
+    public array $attrGroups;
+    /** @var PropertyHook[] Property hooks for promoted properties */
+    public array $hooks;
+
+    /**
+     * Constructs a parameter node.
+     *
+     * @param Expr\Variable|Expr\Error $var Parameter variable
+     * @param null|Expr $default Default value
+     * @param null|Identifier|Name|ComplexType $type Type declaration
+     * @param bool $byRef Whether is passed by reference
+     * @param bool $variadic Whether this is a variadic argument
+     * @param array<string, mixed> $attributes Additional attributes
+     * @param int $flags Optional visibility flags
+     * @param list<AttributeGroup> $attrGroups PHP attribute groups
+     * @param PropertyHook[] $hooks Property hooks for promoted properties
+     */
+    public function __construct(
+        Expr $var, ?Expr $default = null, ?Node $type = null,
+        bool $byRef = false, bool $variadic = false,
+        array $attributes = [],
+        int $flags = 0,
+        array $attrGroups = [],
+        array $hooks = []
+    ) {
+        $this->attributes = $attributes;
+        $this->type = $type;
+        $this->byRef = $byRef;
+        $this->variadic = $variadic;
+        $this->var = $var;
+        $this->default = $default;
+        $this->flags = $flags;
+        $this->attrGroups = $attrGroups;
+        $this->hooks = $hooks;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['attrGroups', 'flags', 'type', 'byRef', 'variadic', 'var', 'default', 'hooks'];
+    }
+
+    public function getType(): string {
+        return 'Param';
+    }
+
+    /**
+     * Whether this parameter uses constructor property promotion.
+     */
+    public function isPromoted(): bool {
+        return $this->flags !== 0 || $this->hooks !== [];
+    }
+
+    public function isFinal(): bool {
+        return (bool) ($this->flags & Modifiers::FINAL);
+    }
+
+    public function isPublic(): bool {
+        $public = (bool) ($this->flags & Modifiers::PUBLIC);
+        if ($public) {
+            return true;
+        }
+
+        if (!$this->isPromoted()) {
+            return false;
+        }
+
+        return ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
+    }
+
+    public function isProtected(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED);
+    }
+
+    public function isPrivate(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE);
+    }
+
+    public function isReadonly(): bool {
+        return (bool) ($this->flags & Modifiers::READONLY);
+    }
+
+    /**
+     * Whether the promoted property has explicit public(set) visibility.
+     */
+    public function isPublicSet(): bool {
+        return (bool) ($this->flags & Modifiers::PUBLIC_SET);
+    }
+
+    /**
+     * Whether the promoted property has explicit protected(set) visibility.
+     */
+    public function isProtectedSet(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED_SET);
+    }
+
+    /**
+     * Whether the promoted property has explicit private(set) visibility.
+     */
+    public function isPrivateSet(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE_SET);
+    }
+}

webshell_analyzer/extractor/ast_extraction/vendor/nikic/php-parser/lib/PhpParser/Node/PropertyHook.php

@@ -0,0 +1,105 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Modifiers;
+use PhpParser\Node\Expr\Assign;
+use PhpParser\Node\Expr\PropertyFetch;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Stmt\Expression;
+use PhpParser\Node\Stmt\Return_;
+use PhpParser\NodeAbstract;
+
+class PropertyHook extends NodeAbstract implements FunctionLike {
+    /** @var AttributeGroup[] PHP attribute groups */
+    public array $attrGroups;
+    /** @var int Modifiers */
+    public int $flags;
+    /** @var bool Whether hook returns by reference */
+    public bool $byRef;
+    /** @var Identifier Hook name */
+    public Identifier $name;
+    /** @var Param[] Parameters */
+    public array $params;
+    /** @var null|Expr|Stmt[] Hook body */
+    public $body;
+
+    /**
+     * Constructs a property hook node.
+     *
+     * @param string|Identifier $name Hook name
+     * @param null|Expr|Stmt[] $body Hook body
+     * @param array{
+     *     flags?: int,
+     *     byRef?: bool,
+     *     params?: Param[],
+     *     attrGroups?: AttributeGroup[],
+     * } $subNodes Array of the following optional subnodes:
+     *             'flags       => 0      : Flags
+     *             'byRef'      => false  : Whether hook returns by reference
+     *             'params'     => array(): Parameters
+     *             'attrGroups' => array(): PHP attribute groups
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct($name, $body, array $subNodes = [], array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->name = \is_string($name) ? new Identifier($name) : $name;
+        $this->body = $body;
+        $this->flags = $subNodes['flags'] ?? 0;
+        $this->byRef = $subNodes['byRef'] ?? false;
+        $this->params = $subNodes['params'] ?? [];
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
+    }
+
+    public function returnsByRef(): bool {
+        return $this->byRef;
+    }
+
+    public function getParams(): array {
+        return $this->params;
+    }
+
+    public function getReturnType() {
+        return null;
+    }
+
+    /**
+     * Whether the property hook is final.
+     */
+    public function isFinal(): bool {
+        return (bool) ($this->flags & Modifiers::FINAL);
+    }
+
+    public function getStmts(): ?array {
+        if ($this->body instanceof Expr) {
+            $name = $this->name->toLowerString();
+            if ($name === 'get') {
+                return [new Return_($this->body)];
+            }
+            if ($name === 'set') {
+                if (!$this->hasAttribute('propertyName')) {
+                    throw new \LogicException(
+                        'Can only use getStmts() on a "set" hook if the "propertyName" attribute is set');
+                }
+
+                $propName = $this->getAttribute('propertyName');
+                $prop = new PropertyFetch(new Variable('this'), (string) $propName);
+                return [new Expression(new Assign($prop, $this->body))];
+            }
+            throw new \LogicException('Unknown property hook "' . $name . '"');
+        }
+        return $this->body;
+    }
+
+    public function getAttrGroups(): array {
+        return $this->attrGroups;
+    }
+
+    public function getType(): string {
+        return 'PropertyHook';
+    }
+
+    public function getSubNodeNames(): array {
+        return ['attrGroups', 'flags', 'byRef', 'name', 'params', 'body'];
+    }
+}