Security Skills SDK — Developer Guide — HunterX v6.0.0

@property
def metadata(self) -> SkillMetadata:
    ...

@property
def capabilities(self) -> list[SkillCapability]:
    ...

async def execute(self, context: SkillContext, params: Optional[dict] = None) -> SkillResult:
    ...

from core.skills.base import SecuritySkill
from core.skills.metadata import SkillMetadata, RiskLevel, NoiseLevel
from core.skills.capability import SkillCapability
from core.skills.context import SkillContext
from core.skills.result import SkillResult
from typing import Optional


class CustomAnalyzer(SecuritySkill):
    @property
    def metadata(self) -> SkillMetadata:
        return SkillMetadata(
            skill_id="custom_analyzer",
            name="Custom Technology Analyzer",
            description="Analyzes custom technology patterns in HTTP responses",
            version="1.0.0",
            author="Your Name",
            license="MIT",
            tags=["custom", "analysis", "fingerprint"],
            categories=["RECON"],
            supported_protocols=["http", "https"],
            supported_technologies=["custom-fw", "custom-auth"],
            supported_languages=["python", "javascript"],
            risk_level=RiskLevel.LOW,
            noise_level=NoiseLevel.SILENT,
            safety_policy={"passive_only": True},
            dependencies=[],
            mitre_techniques=["T1592", "T1592.001"],
            owasp_categories=["API1"],
            cwe_ids=["CWE-200"],
            capec_ids=["CAPEC-170"],
            cvss_reference="CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N",
            required_permissions=["network:http"],
            expected_artifacts=["technology_fingerprints"],
            timeout_seconds=30,
            retry_allowed=True,
            max_retries=2,
        )

    @property
    def capabilities(self) -> list[SkillCapability]:
        return [SkillCapability.TECHNOLOGY_DETECTION, SkillCapability.HTTP_ANALYSIS]

    async def initialize(self) -> None:
        # Setup: load patterns, initialise clients, etc.
        self._patterns = {"X-Custom": r"v(\d+\.\d+\.\d+)"}

    async def validate(self, context: SkillContext) -> bool:
        # Skip if target is not reachable
        return context.target_url is not None

    async def execute(self, context: SkillContext, params: Optional[dict] = None) -> SkillResult:
        target = context.target_url
        findings = []
        evidence = []

        # Simulated detection logic
        for header, pattern in self._patterns.items():
            # ... perform HTTP analysis using context.session ...
            findings.append({"header": header, "matched": True})
            evidence.append(f"header: {header}: v1.0.0")

        confidence = 0.85 if findings else 0.0
        status = "PASS" if findings else "FAIL"

        return SkillResult(
            skill_id=self.metadata.skill_id,
            status=status,
            confidence=confidence,
            summary="Detected custom technology fingerprints" if findings else "No custom technology detected",
            details={"target": target, "findings": findings},
            evidence=evidence,
            artifacts=[{"type": "technology_fingerprints", "data": findings}],
            mitre_mappings=["T1592.001"],
            cwe_mappings=["CWE-200"],
            risk_score=1.5 if findings else 0.0,
            severity="low" if findings else "info",
        )

    async def verify(self, result: SkillResult) -> bool:
        # Verify evidence is well-formed
        return len(result.evidence) > 0 if result.status == "PASS" else True

    async def cleanup(self) -> None:
        self._patterns = None

    def explain(self, result: SkillResult) -> str:
        if result.status == "PASS":
            return f"Found {len(result.evidence)} technology fingerprint(s) on target."
        return "No technology fingerprints detected."

    async def estimate_cost(self, context: SkillContext) -> float:
        return 0.5  # credits

    async def estimate_duration(self, context: SkillContext) -> float:
        return 5.0  # seconds

    def risk_level(self) -> RiskLevel:
        return RiskLevel.LOW