wopt 0.1.0__py3-none-any.whl

wopt/__init__.py

@@ -0,0 +1,7 @@
+"""wopt — mini audit de sécurité web en ligne de commande."""
+
+__version__ = "0.1.0"
+
+from wopt.core.scanner import scan
+
+__all__ = ["scan", "__version__"]

wopt/checks/__init__.py

@@ -0,0 +1,36 @@
+"""
+wopt.checks
+
+Registre central des checks disponibles. Pour ajouter un nouveau
+check : créer la classe dans un module de ce package, puis
+l'ajouter à ALL_CHECKS. Le scanner n'a rien d'autre à connaître.
+"""
+
+from wopt.checks.cookies import CookiesCheck
+from wopt.checks.cors import CORSCheck
+from wopt.checks.exposure import ExposurePathsCheck
+from wopt.checks.headers import SecurityHeadersCheck
+from wopt.checks.tls import TLSCheck
+
+# Checks "standards" exécutés directement sur le ScanContext
+ALL_CHECKS = [
+    SecurityHeadersCheck,
+    TLSCheck,
+    CookiesCheck,
+    CORSCheck,
+]
+
+# Checks nécessitant des requêtes HTTP additionnelles (probing actif)
+PROBE_CHECKS = [
+    ExposurePathsCheck,
+]
+
+__all__ = [
+    "ALL_CHECKS",
+    "PROBE_CHECKS",
+    "SecurityHeadersCheck",
+    "TLSCheck",
+    "CookiesCheck",
+    "CORSCheck",
+    "ExposurePathsCheck",
+]

wopt/checks/base.py

@@ -0,0 +1,29 @@
+"""
+wopt.checks.base
+
+Contrat que tout check de sécurité doit respecter.
+Chaque nouveau check hérite de Check et implémente run().
+Le scanner orchestrateur n'a besoin de rien connaître de la
+logique interne de chaque check : il les découvre et les exécute
+tous de la même façon.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from wopt.models import Finding, ScanContext
+
+
+class Check(ABC):
+    """Classe abstraite : tout check de sécurité l'implémente."""
+
+    id: str = "base.check"
+    name: str = "Base Check"
+    category: str = "general"  # headers | tls | cookies | cors | exposure
+
+    @abstractmethod
+    def run(self, ctx: ScanContext) -> list[Finding]:
+        """Exécute la vérification et retourne une liste de Finding.
+        Une liste vide = rien à signaler (tout est conforme)."""
+        raise NotImplementedError

wopt/checks/cookies.py

@@ -0,0 +1,58 @@
+"""
+wopt.checks.cookies
+
+Vérifie que chaque cookie détecté sur la réponse HTTP est
+correctement sécurisé : Secure, HttpOnly, SameSite.
+"""
+
+from __future__ import annotations
+
+from wopt.checks.base import Check
+from wopt.models import Finding, ScanContext, Severity
+
+
+class CookiesCheck(Check):
+    id = "cookies.flags"
+    name = "Cookie Security Flags"
+    category = "cookies"
+
+    def run(self, ctx: ScanContext) -> list[Finding]:
+        findings: list[Finding] = []
+
+        for cookie in ctx.cookies:
+            if not cookie.secure:
+                findings.append(
+                    Finding(
+                        check_id=f"{self.id}.{cookie.name}_not_secure",
+                        title=f"Cookie '{cookie.name}' sans flag Secure",
+                        severity=Severity.MEDIUM,
+                        category=self.category,
+                        description="Ce cookie peut être transmis en clair sur une connexion non chiffrée.",
+                        recommendation=f"Ajouter le flag Secure au cookie '{cookie.name}'.",
+                    )
+                )
+            if not cookie.http_only:
+                findings.append(
+                    Finding(
+                        check_id=f"{self.id}.{cookie.name}_not_httponly",
+                        title=f"Cookie '{cookie.name}' sans flag HttpOnly",
+                        severity=Severity.MEDIUM,
+                        category=self.category,
+                        description="Ce cookie est accessible via JavaScript, ce qui facilite son vol en cas de XSS.",
+                        recommendation=f"Ajouter le flag HttpOnly au cookie '{cookie.name}'.",
+                    )
+                )
+            if not cookie.same_site or cookie.same_site.lower() == "none":
+                findings.append(
+                    Finding(
+                        check_id=f"{self.id}.{cookie.name}_samesite_weak",
+                        title=f"Cookie '{cookie.name}' avec SameSite absent ou 'None'",
+                        severity=Severity.LOW,
+                        category=self.category,
+                        description="Ce cookie peut être envoyé lors de requêtes cross-site, augmentant le risque CSRF.",
+                        recommendation=f"Définir 'SameSite=Lax' ou 'Strict' sur le cookie '{cookie.name}'.",
+                        evidence=cookie.same_site or "absent",
+                    )
+                )
+
+        return findings

wopt/checks/cors.py

@@ -0,0 +1,60 @@
+"""
+wopt.checks.cors
+
+Détecte les configurations CORS dangereuses, en particulier
+la combinaison Access-Control-Allow-Origin: * associée à
+Access-Control-Allow-Credentials: true, qui permet à n'importe
+quel site tiers de lire des réponses authentifiées.
+"""
+
+from __future__ import annotations
+
+from wopt.checks.base import Check
+from wopt.models import Finding, ScanContext, Severity
+
+
+class CORSCheck(Check):
+    id = "cors.configuration"
+    name = "CORS Configuration"
+    category = "cors"
+
+    def run(self, ctx: ScanContext) -> list[Finding]:
+        findings: list[Finding] = []
+        headers_lower = {k.lower(): v for k, v in ctx.response_headers.items()}
+
+        acao = headers_lower.get("access-control-allow-origin")
+        acac = headers_lower.get("access-control-allow-credentials", "").lower() == "true"
+
+        if acao == "*" and acac:
+            findings.append(
+                Finding(
+                    check_id=f"{self.id}.wildcard_with_credentials",
+                    title="CORS critique : origine wildcard combinée aux credentials",
+                    severity=Severity.CRITICAL,
+                    category=self.category,
+                    description=(
+                        "Access-Control-Allow-Origin est réglé sur '*' alors que "
+                        "Access-Control-Allow-Credentials est à 'true'. N'importe quel "
+                        "site tiers peut lire des réponses authentifiées de l'utilisateur."
+                    ),
+                    recommendation=(
+                        "Remplacer '*' par une liste blanche explicite d'origines de confiance, "
+                        "ou désactiver les credentials si le wildcard est nécessaire."
+                    ),
+                    evidence=f"Access-Control-Allow-Origin: {acao}",
+                )
+            )
+        elif acao == "*":
+            findings.append(
+                Finding(
+                    check_id=f"{self.id}.wildcard_origin",
+                    title="CORS permissif : origine wildcard",
+                    severity=Severity.LOW,
+                    category=self.category,
+                    description="Access-Control-Allow-Origin accepte toute origine ('*').",
+                    recommendation="Restreindre aux origines réellement nécessaires si l'API contient des données sensibles.",
+                    evidence=f"Access-Control-Allow-Origin: {acao}",
+                )
+            )
+
+        return findings

wopt/checks/exposure.py

@@ -0,0 +1,60 @@
+"""
+wopt.checks.exposure
+
+Vérifie passivement si des chemins sensibles connus répondent
+avec un statut 200 (fichier accessible). Aucune tentative de
+lecture/exploitation du contenu au-delà de la détection : on
+observe uniquement le code de statut HTTP renvoyé.
+
+Ce check nécessite des requêtes HTTP additionnelles, effectuées
+par le scanner (pas par ScanContext initial) via check.probe_paths().
+"""
+
+from __future__ import annotations
+
+from wopt.checks.base import Check
+from wopt.models import Finding, ScanContext, Severity
+
+SENSITIVE_PATHS = {
+    "/.env": Severity.CRITICAL,
+    "/.git/HEAD": Severity.HIGH,
+    "/.git/config": Severity.HIGH,
+    "/wp-config.php.bak": Severity.CRITICAL,
+    "/config.php.bak": Severity.CRITICAL,
+    "/.DS_Store": Severity.LOW,
+    "/backup.zip": Severity.MEDIUM,
+    "/.aws/credentials": Severity.CRITICAL,
+}
+
+
+class ExposurePathsCheck(Check):
+    """Ce check est particulier : il a besoin de requêtes HTTP
+    supplémentaires (une par chemin testé). Le scanner l'invoque
+    via `probe_paths()` plutôt que `run()` classique -- voir
+    core/scanner.py pour l'intégration."""
+
+    id = "exposure.sensitive_paths"
+    name = "Sensitive Paths Exposure"
+    category = "exposure"
+
+    def paths_to_probe(self) -> dict[str, Severity]:
+        return SENSITIVE_PATHS
+
+    def build_finding(self, path: str, severity: Severity, status_code: int) -> Finding:
+        return Finding(
+            check_id=f"{self.id}.{path.strip('/').replace('/', '_').replace('.', '_')}",
+            title=f"Chemin sensible potentiellement exposé : {path}",
+            severity=severity,
+            category=self.category,
+            description=(
+                f"La requête vers '{path}' a retourné un statut {status_code}, "
+                "suggérant que ce fichier pourrait être accessible publiquement."
+            ),
+            recommendation=f"Vérifier manuellement '{path}' et bloquer son accès public si confirmé.",
+            evidence=f"HTTP {status_code}",
+        )
+
+    def run(self, ctx: ScanContext) -> list[Finding]:
+        # Ce check ne fait rien via run() seul -- voir probe_paths()
+        # dans le scanner qui gère les requêtes réseau réelles.
+        return []

wopt/checks/headers.py

@@ -0,0 +1,118 @@
+"""
+wopt.checks.headers
+
+Vérifie la présence et la qualité des en-têtes de sécurité HTTP.
+C'est la faille la plus documentée dans les études sur le code
+généré par IA : la quasi-totalité des applications vibe-codées
+en sont dépourvues.
+"""
+
+from __future__ import annotations
+
+from wopt.checks.base import Check
+from wopt.models import Finding, ScanContext, Severity
+
+SECURITY_HEADERS = {
+    "strict-transport-security": {
+        "severity": Severity.HIGH,
+        "title": "HSTS absent",
+        "description": "Le header Strict-Transport-Security est absent : le navigateur "
+        "peut être redirigé vers une version HTTP non chiffrée du site.",
+        "recommendation": "Ajouter 'Strict-Transport-Security: max-age=31536000; includeSubDomains'.",
+    },
+    "content-security-policy": {
+        "severity": Severity.HIGH,
+        "title": "CSP absent",
+        "description": "Aucune Content-Security-Policy définie : la page est plus "
+        "vulnérable aux attaques XSS et à l'injection de contenu tiers.",
+        "recommendation": "Définir une Content-Security-Policy restrictive adaptée à l'application.",
+    },
+    "x-frame-options": {
+        "severity": Severity.MEDIUM,
+        "title": "X-Frame-Options absent",
+        "description": "Le site peut être intégré dans une iframe tierce, exposant "
+        "les utilisateurs à des attaques de clickjacking.",
+        "recommendation": "Ajouter 'X-Frame-Options: DENY' ou utiliser 'frame-ancestors' en CSP.",
+    },
+    "x-content-type-options": {
+        "severity": Severity.LOW,
+        "title": "X-Content-Type-Options absent",
+        "description": "Le navigateur peut tenter de deviner le type MIME des ressources, "
+        "ce qui ouvre la porte à des attaques par confusion de type.",
+        "recommendation": "Ajouter 'X-Content-Type-Options: nosniff'.",
+    },
+    "referrer-policy": {
+        "severity": Severity.LOW,
+        "title": "Referrer-Policy absent",
+        "description": "Sans Referrer-Policy, l'URL complète peut fuiter vers des sites tiers "
+        "via l'en-tête Referer.",
+        "recommendation": "Ajouter 'Referrer-Policy: strict-origin-when-cross-origin'.",
+    },
+    "permissions-policy": {
+        "severity": Severity.INFO,
+        "title": "Permissions-Policy absent",
+        "description": "Aucune restriction explicite sur les APIs navigateur sensibles "
+        "(caméra, micro, géolocalisation).",
+        "recommendation": "Ajouter 'Permissions-Policy' pour désactiver les APIs non utilisées.",
+    },
+}
+
+
+class SecurityHeadersCheck(Check):
+    id = "headers.security_headers"
+    name = "Security Headers"
+    category = "headers"
+
+    def run(self, ctx: ScanContext) -> list[Finding]:
+        findings: list[Finding] = []
+        headers_lower = {k.lower(): v for k, v in ctx.response_headers.items()}
+
+        for header_name, rule in SECURITY_HEADERS.items():
+            if header_name not in headers_lower:
+                findings.append(
+                    Finding(
+                        check_id=f"{self.id}.{header_name}_missing",
+                        title=rule["title"],
+                        severity=rule["severity"],
+                        category=self.category,
+                        description=rule["description"],
+                        recommendation=rule["recommendation"],
+                    )
+                )
+
+        # Vérification qualitative de la CSP, pas juste présence/absence
+        csp = headers_lower.get("content-security-policy")
+        if csp:
+            weak_tokens = [t for t in ("'unsafe-inline'", "'unsafe-eval'", "*") if t in csp]
+            if weak_tokens:
+                findings.append(
+                    Finding(
+                        check_id=f"{self.id}.csp_weak",
+                        title="CSP affaiblie détectée",
+                        severity=Severity.MEDIUM,
+                        category=self.category,
+                        description=(
+                            "La Content-Security-Policy contient des directives permissives "
+                            f"({', '.join(weak_tokens)}) qui réduisent sa protection contre le XSS."
+                        ),
+                        recommendation="Retirer 'unsafe-inline'/'unsafe-eval'/'*' et utiliser des nonces ou hashes.",
+                        evidence=csp,
+                    )
+                )
+
+        # Exposition de la stack technique
+        for leaky_header in ("server", "x-powered-by"):
+            if leaky_header in headers_lower and headers_lower[leaky_header]:
+                findings.append(
+                    Finding(
+                        check_id=f"{self.id}.stack_disclosure_{leaky_header}",
+                        title=f"Divulgation de stack via '{leaky_header}'",
+                        severity=Severity.INFO,
+                        category=self.category,
+                        description=f"Le header '{leaky_header}' révèle des informations sur la stack technique.",
+                        recommendation=f"Masquer ou supprimer le header '{leaky_header}' côté serveur.",
+                        evidence=headers_lower[leaky_header],
+                    )
+                )
+
+        return findings

wopt/checks/tls.py

@@ -0,0 +1,100 @@
+"""
+wopt.checks.tls
+
+Vérifie la configuration TLS/SSL : version du protocole négociée
+et date d'expiration du certificat. Les informations TLS sont
+collectées en amont (core/http_client.py) et transmises via
+ScanContext.tls_info pour éviter une connexion TLS redondante.
+
+ScanContext.tls_info attendu (dict) :
+    {
+        "protocol_version": "TLSv1.3",
+        "not_after": "2026-09-01T00:00:00+00:00",  # ISO 8601
+        "days_until_expiry": 60,
+        "cipher": "TLS_AES_256_GCM_SHA384",
+    }
+"""
+
+from __future__ import annotations
+
+from wopt.checks.base import Check
+from wopt.models import Finding, ScanContext, Severity
+
+OUTDATED_PROTOCOLS = {"TLSv1", "TLSv1.0", "TLSv1.1", "SSLv2", "SSLv3"}
+
+
+class TLSCheck(Check):
+    id = "tls.configuration"
+    name = "TLS Configuration"
+    category = "tls"
+
+    def run(self, ctx: ScanContext) -> list[Finding]:
+        findings: list[Finding] = []
+
+        if not ctx.url.startswith("https://"):
+            findings.append(
+                Finding(
+                    check_id=f"{self.id}.no_https",
+                    title="Le site n'est pas servi en HTTPS",
+                    severity=Severity.CRITICAL,
+                    category=self.category,
+                    description="La cible a été scannée en HTTP simple, sans chiffrement TLS.",
+                    recommendation="Migrer le site vers HTTPS avec un certificat valide.",
+                )
+            )
+            return findings
+
+        if ctx.tls_info is None:
+            findings.append(
+                Finding(
+                    check_id=f"{self.id}.info_unavailable",
+                    title="Impossible de récupérer les informations TLS",
+                    severity=Severity.INFO,
+                    category=self.category,
+                    description="La négociation TLS a échoué ou n'a pas pu être analysée.",
+                    recommendation="Vérifier manuellement la configuration TLS du serveur.",
+                )
+            )
+            return findings
+
+        protocol = ctx.tls_info.get("protocol_version")
+        if protocol in OUTDATED_PROTOCOLS:
+            findings.append(
+                Finding(
+                    check_id=f"{self.id}.outdated_protocol",
+                    title=f"Protocole TLS obsolète : {protocol}",
+                    severity=Severity.HIGH,
+                    category=self.category,
+                    description=f"Le serveur accepte encore {protocol}, considéré comme non sûr.",
+                    recommendation="Désactiver TLS < 1.2 et n'accepter que TLS 1.2 / 1.3.",
+                    evidence=protocol,
+                )
+            )
+
+        days_left = ctx.tls_info.get("days_until_expiry")
+        if days_left is not None:
+            if days_left < 0:
+                findings.append(
+                    Finding(
+                        check_id=f"{self.id}.cert_expired",
+                        title="Certificat TLS expiré",
+                        severity=Severity.CRITICAL,
+                        category=self.category,
+                        description="Le certificat présenté par le serveur est expiré.",
+                        recommendation="Renouveler le certificat TLS immédiatement.",
+                    )
+                )
+            elif days_left < 14:
+                findings.append(
+                    Finding(
+                        check_id=f"{self.id}.cert_expiring_soon",
+                        title=f"Certificat TLS expire dans {days_left} jours",
+                        severity=Severity.MEDIUM,
+                        category=self.category,
+                        description="Le certificat arrive bientôt à expiration.",
+                        recommendation="Planifier le renouvellement du certificat.",
+                        evidence=str(days_left),
+                    )
+                )
+
+        return findings

wopt/cli.py

@@ -0,0 +1,141 @@
+"""
+wopt.cli
+
+Point d'entrée en ligne de commande.
+
+Exemples :
+    wopt scan exemple.com
+    wopt scan https://exemple.com --format json
+    wopt scan https://exemple.com --format html -o rapport.html
+    wopt scan https://exemple.com --ai-context
+    wopt scan https://exemple.com --no-probes
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from wopt.core.http_client import FetchError
+from wopt.core.scanner import scan
+from wopt.models import Severity
+from wopt.report.ai_context_output import to_ai_context
+from wopt.report.html_output import to_html
+from wopt.report.json_output import to_json
+
+app = typer.Typer(
+    name="wopt",
+    help="Mini audit de sécurité web en ligne de commande.\n\n"
+    "Développé par Eloundou Nkolo Ryan — https://eloundounkolo.com",
+    add_completion=False,
+)
+console = Console()
+
+SEVERITY_COLORS = {
+    Severity.CRITICAL: "bold red",
+    Severity.HIGH: "red",
+    Severity.MEDIUM: "yellow",
+    Severity.LOW: "blue",
+    Severity.INFO: "dim",
+}
+
+SCORE_COLORS = {"A": "green", "B": "green", "C": "yellow", "D": "yellow", "E": "red", "F": "bold red"}
+
+
+@app.command()
+def scan_command(
+    target: str = typer.Argument(..., help="URL ou domaine à scanner, ex: exemple.com"),
+    format: str = typer.Option("table", "--format", "-f", help="table | json | html"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Fichier de sortie (json/html)"),
+    ai_context: bool = typer.Option(
+        False, "--ai-context", help="Génère un rapport markdown prêt à coller dans un agent IA"
+    ),
+    no_probes: bool = typer.Option(
+        False, "--no-probes", help="Désactive la vérification des chemins sensibles (scan plus léger)"
+    ),
+    timeout: float = typer.Option(10.0, "--timeout", help="Timeout HTTP en secondes"),
+):
+    """Lance un audit de sécurité non-intrusif sur TARGET."""
+    with console.status(f"[bold cyan]Scan de {target}...[/bold cyan]"):
+        try:
+            result = scan(target, timeout=timeout, include_probes=not no_probes)
+        except FetchError as exc:
+            console.print(f"[bold red]Erreur :[/bold red] {exc}")
+            raise typer.Exit(code=1)
+
+    if ai_context:
+        content = to_ai_context(result)
+        if output:
+            output.write_text(content, encoding="utf-8")
+            console.print(f"[green]Rapport IA écrit dans {output}[/green]")
+        else:
+            console.print(content)
+        return
+
+    if format == "json":
+        content = to_json(result)
+        if output:
+            output.write_text(content, encoding="utf-8")
+            console.print(f"[green]Rapport JSON écrit dans {output}[/green]")
+        else:
+            console.print(content)
+        return
+
+    if format == "html":
+        content = to_html(result)
+        out_path = output or Path("wopt-report.html")
+        out_path.write_text(content, encoding="utf-8")
+        console.print(f"[green]Rapport HTML écrit dans {out_path}[/green]")
+        return
+
+    _print_table(result)
+
+
+def _print_table(result) -> None:
+    score_color = SCORE_COLORS.get(result.score, "white")
+    console.print()
+    console.print(f"[bold]Cible :[/bold] {result.target}")
+    console.print(f"[bold]Score :[/bold] [{score_color}]{result.score}[/{score_color}] ({result.score_value}/100)")
+    console.print(f"[dim]Scan effectué en {result.duration_ms:.0f} ms[/dim]")
+    console.print()
+
+    if not result.findings:
+        console.print("[green]✓ Aucun problème détecté.[/green]")
+        return
+
+    table = Table(show_lines=False)
+    table.add_column("Sévérité", no_wrap=True)
+    table.add_column("Catégorie", no_wrap=True)
+    table.add_column("Problème")
+    table.add_column("Recommandation")
+
+    severity_order = [
+        Severity.CRITICAL,
+        Severity.HIGH,
+        Severity.MEDIUM,
+        Severity.LOW,
+        Severity.INFO,
+    ]
+    for severity in severity_order:
+        for finding in result.findings_by_severity(severity):
+            color = SEVERITY_COLORS.get(severity, "white")
+            table.add_row(
+                f"[{color}]{severity.value.upper()}[/{color}]",
+                finding.category,
+                finding.title,
+                finding.recommendation,
+            )
+
+    console.print(table)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

wopt/core/http_client.py

@@ -0,0 +1,139 @@
+"""
+wopt.core.http_client
+
+Encapsule les requêtes HTTP nécessaires au scan : une requête
+principale vers la cible, plus les informations TLS et cookies
+extraites de la même connexion pour limiter le nombre de
+requêtes effectuées.
+"""
+
+from __future__ import annotations
+
+import ssl
+import time
+from datetime import datetime, timezone
+
+import httpx
+
+from wopt.models import Cookie, ScanContext
+
+DEFAULT_TIMEOUT = 10.0
+DEFAULT_HEADERS = {
+    "User-Agent": "wopt/0.1 (+https://github.com/eloundou-nkolo/wopt) security-audit-tool",
+}
+
+
+class FetchError(Exception):
+    """Levée quand la cible ne peut pas être contactée."""
+
+
+def _normalize_url(url: str) -> str:
+    if not url.startswith(("http://", "https://")):
+        url = f"https://{url}"
+    return url
+
+
+def _extract_tls_info(url: str, timeout: float) -> dict | None:
+    """Récupère la version du protocole TLS et la date d'expiration
+    du certificat via une connexion SSL directe (indépendante de httpx,
+    qui n'expose pas facilement ces détails bas niveau)."""
+    if not url.startswith("https://"):
+        return None
+
+    hostname = url.split("://", 1)[1].split("/", 1)[0].split(":")[0]
+
+    try:
+        import socket
+
+        context = ssl.create_default_context()
+        with socket.create_connection((hostname, 443), timeout=timeout) as sock:
+            with context.wrap_socket(sock, server_hostname=hostname) as ssock:
+                cert = ssock.getpeercert()
+                protocol_version = ssock.version()
+                cipher = ssock.cipher()
+
+        not_after_str = cert.get("notAfter") if cert else None
+        days_until_expiry = None
+        if not_after_str:
+            not_after = datetime.strptime(not_after_str, "%b %d %H:%M:%S %Y %Z").replace(
+                tzinfo=timezone.utc
+            )
+            days_until_expiry = (not_after - datetime.now(timezone.utc)).days
+
+        return {
+            "protocol_version": protocol_version,
+            "not_after": not_after_str,
+            "days_until_expiry": days_until_expiry,
+            "cipher": cipher[0] if cipher else None,
+        }
+    except Exception:
+        # On ne bloque jamais le scan pour une erreur d'introspection TLS :
+        # le check TLS gérera lui-même le cas tls_info=None.
+        return None
+
+
+def _parse_cookies(response: httpx.Response) -> list[Cookie]:
+    cookies = []
+    for header_value in response.headers.get_list("set-cookie"):
+        parts = [p.strip() for p in header_value.split(";")]
+        name = parts[0].split("=", 1)[0] if parts else "unknown"
+        lower_parts = [p.lower() for p in parts]
+
+        same_site = None
+        for p in parts:
+            if p.lower().startswith("samesite="):
+                same_site = p.split("=", 1)[1]
+
+        cookies.append(
+            Cookie(
+                name=name,
+                secure="secure" in lower_parts,
+                http_only="httponly" in lower_parts,
+                same_site=same_site,
+            )
+        )
+    return cookies
+
+
+def fetch(url: str, timeout: float = DEFAULT_TIMEOUT) -> ScanContext:
+    """Effectue la requête principale vers la cible et construit
+    le ScanContext utilisé par tous les checks standards."""
+    url = _normalize_url(url)
+    start = time.perf_counter()
+
+    try:
+        with httpx.Client(
+            timeout=timeout,
+            follow_redirects=True,
+            headers=DEFAULT_HEADERS,
+            verify=True,
+        ) as client:
+            response = client.get(url)
+    except httpx.RequestError as exc:
+        raise FetchError(f"Impossible de contacter '{url}' : {exc}") from exc
+
+    elapsed_ms = (time.perf_counter() - start) * 1000
+    tls_info = _extract_tls_info(str(response.url), timeout)
+
+    return ScanContext(
+        url=url,
+        final_url=str(response.url),
+        status_code=response.status_code,
+        response_headers=dict(response.headers),
+        response_body=response.text,
+        cookies=_parse_cookies(response),
+        tls_info=tls_info,
+        elapsed_ms=elapsed_ms,
+    )
+
+
+def probe_path(base_url: str, path: str, timeout: float = DEFAULT_TIMEOUT) -> int | None:
+    """Requête légère pour vérifier si un chemin spécifique répond.
+    Retourne le status_code, ou None si la requête échoue."""
+    target = base_url.rstrip("/") + path
+    try:
+        with httpx.Client(timeout=timeout, follow_redirects=False, headers=DEFAULT_HEADERS) as client:
+            response = client.get(target)
+            return response.status_code
+    except httpx.RequestError:
+        return None

wopt/core/scanner.py

@@ -0,0 +1,49 @@
+"""
+wopt.core.scanner
+
+Orchestrateur principal : récupère les données de la cible,
+exécute tous les checks enregistrés, agrège les résultats en
+un ScanResult prêt à être scoré et formaté.
+"""
+
+from __future__ import annotations
+
+import time
+
+from wopt.checks import ALL_CHECKS, PROBE_CHECKS
+from wopt.core.http_client import FetchError, fetch, probe_path
+from wopt.models import Finding, ScanResult
+from wopt.report.scoring import compute_score
+
+
+def scan(url: str, timeout: float = 10.0, include_probes: bool = True) -> ScanResult:
+    """Lance un scan complet sur `url` et retourne un ScanResult.
+
+    Args:
+        url: URL ou nom de domaine de la cible.
+        timeout: timeout HTTP en secondes.
+        include_probes: si True, teste aussi les chemins sensibles
+            connus (requêtes HTTP additionnelles). Mettre à False
+            pour un scan plus rapide/moins bruyant côté serveur cible.
+    """
+    start = time.perf_counter()
+    findings: list[Finding] = []
+
+    ctx = fetch(url, timeout=timeout)
+
+    for check_cls in ALL_CHECKS:
+        check = check_cls()
+        findings.extend(check.run(ctx))
+
+    if include_probes:
+        for check_cls in PROBE_CHECKS:
+            check = check_cls()
+            for path, severity in check.paths_to_probe().items():
+                status = probe_path(ctx.final_url, path, timeout=timeout)
+                if status is not None and status < 400:
+                    findings.append(check.build_finding(path, severity, status))
+
+    duration_ms = (time.perf_counter() - start) * 1000
+    result = ScanResult.build(target=ctx.final_url, findings=findings, duration_ms=duration_ms)
+    result.score, result.score_value = compute_score(findings)
+    return result

wopt/models.py

@@ -0,0 +1,103 @@
+"""
+wopt.models
+
+Structures de données partagées par tout le projet :
+- Severity : niveau de gravité d'un résultat
+- Finding : un résultat individuel produit par un check
+- ScanContext : les données brutes collectées sur la cible, passées à chaque check
+- ScanResult : le résultat final agrégé d'un scan complet
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+
+
+class Severity(str, Enum):
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+    INFO = "info"
+    PASS = "pass"
+
+    @property
+    def weight(self) -> int:
+        """Poids utilisé pour le calcul du score global."""
+        return {
+            Severity.CRITICAL: 25,
+            Severity.HIGH: 15,
+            Severity.MEDIUM: 8,
+            Severity.LOW: 3,
+            Severity.INFO: 0,
+            Severity.PASS: 0,
+        }[self]
+
+
+@dataclass
+class Finding:
+    """Un résultat individuel produit par un check de sécurité."""
+
+    check_id: str
+    title: str
+    severity: Severity
+    category: str
+    description: str
+    recommendation: str
+    evidence: str | None = None
+
+
+@dataclass
+class Cookie:
+    name: str
+    secure: bool
+    http_only: bool
+    same_site: str | None
+
+
+@dataclass
+class ScanContext:
+    """Toutes les données brutes collectées sur la cible.
+    Centralisé pour qu'un seul jeu de requêtes HTTP suffise
+    à alimenter tous les checks (pas de requêtes redondantes)."""
+
+    url: str
+    final_url: str
+    status_code: int
+    response_headers: dict[str, str]
+    response_body: str
+    cookies: list[Cookie] = field(default_factory=list)
+    tls_info: dict | None = None
+    elapsed_ms: float = 0.0
+
+
+@dataclass
+class ScanResult:
+    """Résultat final agrégé, prêt à être formaté (JSON/HTML/CLI)."""
+
+    target: str
+    scanned_at: datetime
+    findings: list[Finding]
+    score: str = "?"          # lettre A-F
+    score_value: int = 0       # 0-100
+    duration_ms: float = 0.0
+
+    @classmethod
+    def build(cls, target: str, findings: list[Finding], duration_ms: float) -> "ScanResult":
+        return cls(
+            target=target,
+            scanned_at=datetime.now(timezone.utc),
+            findings=findings,
+            duration_ms=duration_ms,
+        )
+
+    def findings_by_severity(self, severity: Severity) -> list[Finding]:
+        return [f for f in self.findings if f.severity == severity]
+
+    def count_by_severity(self) -> dict[str, int]:
+        counts = {s.value: 0 for s in Severity}
+        for f in self.findings:
+            counts[f.severity.value] += 1
+        return counts

wopt/report/ai_context_output.py

@@ -0,0 +1,48 @@
+"""
+wopt.report.ai_context_output
+
+Formate un ScanResult en markdown structuré, optimisé pour être
+collé directement dans un prompt d'agent IA (Claude Code, Cursor...)
+afin qu'il corrige automatiquement les failles trouvées.
+C'est le différenciateur "vibe coding" de wopt (v0.3).
+"""
+
+from __future__ import annotations
+
+from wopt.models import ScanResult, Severity
+
+SEVERITY_ORDER = [
+    Severity.CRITICAL,
+    Severity.HIGH,
+    Severity.MEDIUM,
+    Severity.LOW,
+    Severity.INFO,
+]
+
+
+def to_ai_context(result: ScanResult) -> str:
+    lines = [
+        f"# Audit de sécurité — {result.target}",
+        "",
+        f"Score global : {result.score} ({result.score_value}/100)",
+        "",
+        "Corrige les problèmes suivants, du plus critique au moins critique. "
+        "Pour chaque correctif, applique la recommandation indiquée.",
+        "",
+    ]
+
+    for severity in SEVERITY_ORDER:
+        items = result.findings_by_severity(severity)
+        if not items:
+            continue
+        lines.append(f"## {severity.value.upper()} ({len(items)})")
+        lines.append("")
+        for f in items:
+            lines.append(f"- **{f.title}**")
+            lines.append(f"  - Problème : {f.description}")
+            lines.append(f"  - Correctif : {f.recommendation}")
+            if f.evidence:
+                lines.append(f"  - Preuve observée : `{f.evidence}`")
+        lines.append("")
+
+    return "\n".join(lines)

wopt/report/html_output.py

@@ -0,0 +1,28 @@
+"""
+wopt.report.html_output
+
+Rend le rapport HTML lisible via le template Jinja2.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from wopt.models import ScanResult
+
+TEMPLATES_DIR = Path(__file__).parent / "templates"
+
+
+def to_html(result: ScanResult) -> str:
+    env = Environment(
+        loader=FileSystemLoader(str(TEMPLATES_DIR)),
+        autoescape=select_autoescape(["html"]),
+    )
+    template = env.get_template("report.html.j2")
+    return template.render(
+        result=result,
+        findings=result.findings,
+        summary=result.count_by_severity(),
+    )

wopt/report/json_output.py

@@ -0,0 +1,39 @@
+"""
+wopt.report.json_output
+
+Sérialise un ScanResult en JSON, pensé pour être consommé par
+un pipeline CI/CD ou un autre outil (parsing facile, structure stable).
+"""
+
+from __future__ import annotations
+
+import json
+
+from wopt.models import ScanResult
+
+
+def to_dict(result: ScanResult) -> dict:
+    return {
+        "target": result.target,
+        "scanned_at": result.scanned_at.isoformat(),
+        "duration_ms": round(result.duration_ms, 2),
+        "score": result.score,
+        "score_value": result.score_value,
+        "summary": result.count_by_severity(),
+        "findings": [
+            {
+                "check_id": f.check_id,
+                "title": f.title,
+                "severity": f.severity.value,
+                "category": f.category,
+                "description": f.description,
+                "recommendation": f.recommendation,
+                "evidence": f.evidence,
+            }
+            for f in result.findings
+        ],
+    }
+
+
+def to_json(result: ScanResult, indent: int = 2) -> str:
+    return json.dumps(to_dict(result), indent=indent, ensure_ascii=False)

wopt/report/scoring.py

@@ -0,0 +1,35 @@
+"""
+wopt.report.scoring
+
+Calcule un score de sécurité global (0-100, converti en lettre A-F)
+à partir de la liste de findings, en pondérant par sévérité.
+Inspiré de l'approche Mozilla Observatory : on part de 100 et on
+soustrait des points selon la gravité de chaque finding.
+"""
+
+from __future__ import annotations
+
+from wopt.models import Finding
+
+MAX_SCORE = 100
+
+
+def compute_score(findings: list[Finding]) -> tuple[str, int]:
+    """Retourne (lettre, valeur_numerique)."""
+    penalty = sum(f.severity.weight for f in findings)
+    score_value = max(0, MAX_SCORE - penalty)
+    return _to_letter(score_value), score_value
+
+
+def _to_letter(score_value: int) -> str:
+    if score_value >= 90:
+        return "A"
+    if score_value >= 75:
+        return "B"
+    if score_value >= 60:
+        return "C"
+    if score_value >= 40:
+        return "D"
+    if score_value >= 20:
+        return "E"
+    return "F"

wopt/report/templates/report.html.j2

@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="UTF-8">
+<title>Rapport wopt — {{ result.target }}</title>
+<style>
+  :root {
+    --bg: #0f1115; --card: #171a21; --text: #e8e8ea; --muted: #9aa0aa;
+    --critical: #e5484d; --high: #f76b15; --medium: #f5a623; --low: #4c9be8; --info: #6b7280; --pass: #3ecf8e;
+  }
+  * { box-sizing: border-box; }
+  body { background: var(--bg); color: var(--text); font-family: -apple-system, Segoe UI, Roboto, sans-serif; margin: 0; padding: 40px 20px; }
+  .container { max-width: 860px; margin: 0 auto; }
+  h1 { font-size: 1.4rem; word-break: break-all; }
+  .score-badge { display: inline-flex; align-items: center; justify-content: center; width: 72px; height: 72px; border-radius: 50%; font-size: 2rem; font-weight: 700; background: var(--card); border: 3px solid var(--pass); }
+  .meta { color: var(--muted); font-size: 0.9rem; margin-bottom: 30px; }
+  .summary { display: flex; gap: 10px; flex-wrap: wrap; margin: 20px 0 30px; }
+  .pill { padding: 4px 12px; border-radius: 999px; font-size: 0.8rem; font-weight: 600; }
+  .finding { background: var(--card); border-radius: 10px; padding: 16px 20px; margin-bottom: 12px; border-left: 4px solid var(--muted); }
+  .finding.critical { border-color: var(--critical); }
+  .finding.high { border-color: var(--high); }
+  .finding.medium { border-color: var(--medium); }
+  .finding.low { border-color: var(--low); }
+  .finding.info { border-color: var(--info); }
+  .finding h3 { margin: 0 0 8px; font-size: 1rem; }
+  .finding p { margin: 4px 0; color: var(--muted); font-size: 0.9rem; }
+  .finding .reco { color: var(--text); }
+  .sev-tag { display: inline-block; font-size: 0.7rem; text-transform: uppercase; letter-spacing: 0.05em; padding: 2px 8px; border-radius: 4px; margin-bottom: 8px; }
+  .sev-tag.critical { background: var(--critical); }
+  .sev-tag.high { background: var(--high); }
+  .sev-tag.medium { background: var(--medium); color: #1a1a1a; }
+  .sev-tag.low { background: var(--low); }
+  .sev-tag.info { background: var(--info); }
+  footer { margin-top: 40px; color: var(--muted); font-size: 0.8rem; text-align: center; }
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="score-badge">{{ result.score }}</div>
+  <h1>Rapport de sécurité — {{ result.target }}</h1>
+  <div class="meta">Scanné le {{ result.scanned_at.strftime("%d/%m/%Y à %H:%M UTC") }} · {{ "%.0f"|format(result.duration_ms) }} ms · Score {{ result.score_value }}/100</div>
+
+  <div class="summary">
+    {% for sev, count in summary.items() if count > 0 %}
+      <span class="pill {{ sev }}">{{ sev }} : {{ count }}</span>
+    {% endfor %}
+  </div>
+
+  {% for finding in findings %}
+  <div class="finding {{ finding.severity.value }}">
+    <span class="sev-tag {{ finding.severity.value }}">{{ finding.severity.value }}</span>
+    <h3>{{ finding.title }}</h3>
+    <p>{{ finding.description }}</p>
+    <p class="reco">→ {{ finding.recommendation }}</p>
+    {% if finding.evidence %}<p><code>{{ finding.evidence }}</code></p>{% endif %}
+  </div>
+  {% else %}
+  <p>Aucun problème détecté.</p>
+  {% endfor %}
+
+<footer>Généré par <a href="https://github.com/eloundou-nkolo/wopt">wopt</a> — 
+audit de sécurité web open-source, par 
+<a href="https://eloundounkolo.com">Eloundou Nkolo Ryan</a></footer>
+</div>
+</body>
+</html>

wopt-0.1.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: wopt
+Version: 0.1.0
+Summary: Mini audit de sécurité web en ligne de commande : headers, TLS, cookies, CORS, fichiers exposés.
+Project-URL: Homepage, https://github.com/eloundou-nkolo/wopt
+Project-URL: Repository, https://github.com/eloundou-nkolo/wopt
+Project-URL: Issues, https://github.com/eloundou-nkolo/wopt/issues
+Project-URL: Portfolio, https://eloundounkolo.com
+Author-email: Eloundou Nkolo Ryan <ryan@eloundounkolo.com>
+License: MIT
+License-File: LICENSE
+Keywords: audit,cli,cors,http-headers,security,tls,web
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: cryptography
+Requires-Dist: httpx
+Requires-Dist: jinja2
+Requires-Dist: rich
+Requires-Dist: typer
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-httpx; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# wopt
+
+test audit de sécurité web en ligne de commande — non-intrusif, sans configuration, sans infrastructure.
+
+`wopt` scanne un site web et vérifie les points de sécurité les plus fréquemment négligés : en-têtes HTTP, configuration TLS, cookies, CORS, et exposition de fichiers sensibles. Conçu pour s'intégrer facilement à un pipeline CI/CD.
+## Auteurs
+
+Développé par [Eloundou Nkolo Ryan](https://eloundounkolo.com) — développeur web & intégration de solutions numériques.
+
+## Installation
+
+```bash
+pip install wopt
+```
+
+Ou en local depuis le code source :
+
+```bash
+git clone https://github.com/eloundou-nkolo/wopt.git
+cd wopt
+pip install -r requirements.txt
+pip install -e .
+```
+
+## Utilisation
+
+```bash
+# Scan simple, affichage table dans le terminal
+wopt exemple.com
+
+# Export JSON (pour CI/CD)
+wopt exemple.com --format json --output rapport.json
+
+# Export HTML lisible
+wopt exemple.com --format html --output rapport.html
+
+# Rapport formaté pour être collé dans un agent IA (Claude Code, Cursor...)
+wopt exemple.com --ai-context
+
+# Scan plus léger, sans vérification des chemins sensibles
+wopt exemple.com --no-probes
+```
+
+## Ce que wopt vérifie
+
+| Catégorie | Vérifications |
+|---|---|
+| **Headers** | CSP, HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy, divulgation de stack |
+| **TLS** | Version du protocole, expiration du certificat, redirection HTTPS |
+| **Cookies** | Flags Secure, HttpOnly, SameSite |
+| **CORS** | Combinaison dangereuse wildcard + credentials |
+| **Exposition** | Fichiers sensibles accessibles (`.env`, `.git/HEAD`, backups...) |
+
+## Philosophie
+
+- **100% passif et non-intrusif** : aucun scan de ports, aucune tentative d'exploitation, aucun brute-force. Uniquement des requêtes HTTP GET standards.
+- **Zéro infrastructure** : tourne entièrement en local, aucune donnée envoyée à un serveur tiers.
+- **Pensé pour l'ère du vibe coding** : conçu pour combler les lacunes de sécurité fréquentes dans le code généré par IA (absence de headers de sécurité, CSRF, CORS mal configuré).
+
+## Score
+
+Chaque scan produit un score de A à F, calculé par pondération de sévérité (inspiré de l'approche Mozilla Observatory).
+
+## Développement
+
+```bash
+pip install -r requirements-dev.txt
+pytest
+ruff check .
+```
+
+## Avertissement
+
+`wopt` est un outil d'audit passif destiné à un usage sur des sites que vous possédez ou êtes autorisé à tester. L'auteur décline toute responsabilité en cas d'usage non autorisé.
+
+## Licence
+
+MIT

wopt-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+wopt/__init__.py,sha256=tU-pobM-yWKZhtZ3PqBcDTroR7Js1RvycpGKqKulTag,160
+wopt/cli.py,sha256=SC9qr-QxJdL1mRmZg01QlmuKqnGuhvHYGrHLeV71mjc,4447
+wopt/models.py,sha256=vmtsXjaOqp63A0c062-Brxc_lRrHvdhxk-B_Gx8YkHs,2662
+wopt/checks/__init__.py,sha256=BVaYpaXaw7ihe0Lh89wY-psJD4wFzbWSQyL-MW9TQEI,871
+wopt/checks/base.py,sha256=2oAwoRH4U24dsV7UtOaFaCtSt1JqdeAzVeYCkvtANHQ,878
+wopt/checks/cookies.py,sha256=oueyKso05z7gFtq8_kblWJZDUhkjOTbY6dPpO0qHo_o,2457
+wopt/checks/cors.py,sha256=4cLD2y7paxnd8YbgTaH_QOZ6DvHt2_0ngG-aGD28cYw,2477
+wopt/checks/exposure.py,sha256=-OIDSqA4w4vQYL8thOc8mdyZRpPbwGrdNYOVG8RMsqs,2234
+wopt/checks/headers.py,sha256=1onvnX0zOKYhUR7DVPOVYKJ-EOZnEGt9OijPAFbdQhI,5245
+wopt/checks/tls.py,sha256=MUAim5Xj56hujVIm0snpu-THBlM2v4SROXEzF5INj-I,3904
+wopt/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wopt/core/http_client.py,sha256=xFSXXUeN6Y1U1-H2MFemQf-oUcLmwoEkwi6SZr19KeA,4552
+wopt/core/scanner.py,sha256=AvyPkyKRv_jkukaOwW-K5evgpPij1kwixmIHMYxldM0,1740
+wopt/report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wopt/report/ai_context_output.py,sha256=-JYhMLS8O3Q-XPnGIqlr7M8HfBTIvqX9VJ1CQlWlNVc,1446
+wopt/report/html_output.py,sha256=W3LZVxQ8jWTn_km3LEG9XNVWp2yuH5-eJtkuCJwFcTo,663
+wopt/report/json_output.py,sha256=Rd0tolmmUch8oOi3hEyXklwDZ-kKqdZrYcxCIpoXiGM,1107
+wopt/report/scoring.py,sha256=sXIrwRVYYe_oSzqGXbR9PV9Hi7mh5fybhnY1gDWJlSw,919
+wopt/report/templates/report.html.j2,sha256=MINFwZYM1SlXtJ9hXEAHFFt6JqIw7ZB5IUteoLQf3Ww,3310
+wopt-0.1.0.dist-info/METADATA,sha256=RxC7k-Jh2Vcz6EW2of2tmOdaQxgJxr6m9dMJHfmeV_k,3883
+wopt-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+wopt-0.1.0.dist-info/entry_points.txt,sha256=MM9fObXlgpeDJxQUFD3B0QBj0keTqD9P5tumYsO4Eyc,39
+wopt-0.1.0.dist-info/licenses/LICENSE,sha256=jYiTBzP0DvZuaaeiCduAocg5-hp0lILAcwrTTtb0a4k,1095
+wopt-0.1.0.dist-info/RECORD,,

wopt-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

wopt-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wopt = wopt.cli:main

wopt-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 eloundou nkolo ryan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.