nehonix-uri-processor/dist/services/NehonixSecurity.service.d.ts

A powerful URI processor for encoding, decoding, and analyzing URI data securely.

import { MaliciousPatternResult, DetectedPattern, MaliciousPatternType, MaliciousPatternOptions } from "./MaliciousPatterns.service";
/**
 * Enhanced service for detecting various malicious patterns in URLs and general input
 * Nehonix Malicious Parttens Service => NMPS
 * Nehonix Security Service => NSS
 */
export declare class NSS {
    private static SQL_INJECTION_PATTERNS;
    private static XSS_PATTERNS;
    private static COMMAND_INJECTION_PATTERNS;
    private static OPEN_REDIRECT_PATTERNS;
    private static PATH_TRAVERSAL_PATTERNS;
    private static SSRF_PATTERNS;
    private static CRLF_INJECTION_PATTERNS;
    private static TEMPLATE_INJECTION_PATTERNS;
    private static NOSQL_INJECTION_PATTERNS;
    private static GRAPHQL_INJECTION_PATTERNS;
    private static ENCODED_PAYLOAD_PATTERNS;
    private static SUSPICIOUS_TLD_PATTERNS;
    private static HOMOGRAPH_ATTACK_PATTERNS;
    private static MULTI_ENCODING_PATTERNS;
    private static SUSPICIOUS_PARAMETER_NAMES;
    private static RFI_PATTERNS;
    private static resultCache;
    private static isSafeHighEntropy;
    /**
     * Analyzes input for malicious patterns and returns detailed detection results
     *
     * @param input - The string to analyze
     * @param options - Configuration options for detection
     * @returns Detailed analysis result
     */
    static detectMaliciousPatterns(receivedInput: string, options?: MaliciousPatternOptions): MaliciousPatternResult;
    /**
     * Analyzes a URL for malicious patterns with specific sensitivity per URL component
     *
     * @param url - The URL to analyze
     * @param options - Configuration options for detection
     * @returns Detailed analysis result
     */
    static analyzeUrl(url: string, options?: MaliciousPatternOptions): Promise<MaliciousPatternResult>;
    /**
     * Generates a recommendation specifically for URLs based on detected patterns
     */
    private static generateUrlRecommendation;
    /**
     * Finds related patterns across different components that might indicate a sophisticated attack
     */
    private static findRelatedPatternGroups;
    /**
     * Checks a string against a set of regex patterns for a specific attack type
     */
    private static checkPatterns;
    /**
     * Checks for suspicious parameter names in a URL
     */
    private static checkSuspiciousParameters;
    /**
     * Calculates confidence level for a pattern match based on match characteristics
     */
    private static calculateConfidence;
    /**
     * Checks if a match is likely a false positive based on context
     */
    private static isLikelyFalsePositive;
    /**
     * Calculates additional context score for pattern matches
     */
    private static calculateContextScore;
    /**
     * Performs contextual analysis on detected patterns to improve detection accuracy
     */
    private static performContextualAnalysis;
    /**
     * Calculates Shannon entropy of a string to detect random or encoded content
     * Higher entropy often indicates encryption or encoding
     */
    private static calculateEntropy;
    /**
     * Detects number of potential encoding layers in a string
     */
    private static detectEncodingLayers;
    /**
     * Calculates statistical anomaly score based on character distribution
     */
    private static calculateAnomalyScore;
    /**
     * Calculates total risk score based on detected patterns
     */
    private static calculateTotalScore;
    /**
     * Determines overall confidence level based on score and pattern count
     */
    static determineConfidence(score: number, patternCount: number): "low" | "medium" | "high";
    /**
     * Generates appropriate recommendation based on detected patterns
     */
    static generateRecommendation(patterns: DetectedPattern[], score: number): string;
    /**
     * Analyzes input for a specific malicious pattern type
     *
     * @param input - The string to analyze
     * @param patternType - The specific pattern type to check for
     * @param options - Configuration options for detection
     * @returns Boolean indicating if pattern was detected
     */
    static detectSpecificPatternType(input: string, patternType: MaliciousPatternType, options?: MaliciousPatternOptions): boolean;
    /**
     * Sanitizes input by removing potentially malicious patterns
     *
     * @param input - The string to sanitize
     * @param options - Additional sanitization options
     * @returns Sanitized string
     */
    /**
     * Sanitizes input by removing potentially malicious patterns
     *
     * @param input - The string to sanitize
     * @param options - Additional sanitization options
     * @returns Sanitized string
     */
    static sanitizeInput(input: string, options?: {
        allowHtml?: boolean;
        allowMarkdown?: boolean;
        strictMode?: boolean;
        preserveLength?: boolean;
        customPatterns?: Array<{
            pattern: RegExp;
            replacement: string;
        }>;
    }): string;
    /**
     * Lightweight check to determine if string needs deep scanning
     * Use as a pre-filter before doing full pattern detection
     *
     * @param input - String to check
     * @returns Whether input needs further scanning
     */
    static needsDeepScan(input: string): boolean;
    /**
     * Checks if content is likely HTML/JavaScript code fragment
     *
     * @param input - String to check
     * @returns boolean indicating if it looks like code
     */
    static isLikelyCode(input: string): boolean;
    /**
     * Checks if a tag is in the allowed safe tags list
     * @param tag - The tag name to check
     * @returns Whether the tag is considered safe
     */
    private static isSafeTag;
    /**
     * Creates a placeholder of specified length to preserve original string length
     * @param type - Type of content being replaced
     * @param length - Length of the original content
     * @returns Placeholder string of approximately the same length
     */
    private static createPlaceholder;
    /**
     * Checks if input appears to be a URL
     * @param input - String to check
     * @returns Whether the input looks like a URL
     */
    private static isUrlLike;
    /**
     * Specialized sanitization for URLs
     * @param url - URL to sanitize
     * @param opts - Sanitization options
     * @returns Sanitized URL
     */
    private static sanitizeUrl;
    /**
     * Handle potential redirect parameters in URLs
     * @param url - URL to check
     * @param opts - Sanitization options
     * @returns Sanitized URL
     */
    private static handlePotentialRedirect;
}
export default NSS;
//# sourceMappingURL=NehonixSecurity.service.d.ts.map