pmescan 0.1.0__tar.gz

pmescan-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+# Environnements Python
+.venv/
+venv/
+__pycache__/
+*.py[cod]
+
+# Build / distribution
+build/
+dist/
+*.egg-info/
+
+# Tests / outils
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Rapports générés
+*.pdf
+consent.log
+
+# Éditeurs / OS
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db

pmescan-0.1.0/01-VISION.md

@@ -0,0 +1,62 @@
+# 01 — Vision : à quoi sert le projet
+
+## Nom
+
+**pmescan** — Scanner de sécurité pour PME francophones.
+
+## Le problème
+
+Les petites et moyennes entreprises (PME), en particulier au Sénégal et en Afrique
+francophone, ont presque toutes une présence en ligne : site vitrine, boutique
+WordPress, adresse e-mail professionnelle. Mais :
+
+- Elles n'ont **pas d'équipe sécurité** ni de budget pour un audit à 2 000 €.
+- Les outils existants (Mozilla Observatory, Nuclei, SSL Labs) sont **en anglais**,
+  **techniques**, et crachent une sortie **illisible pour un gérant**.
+- Résultat : un certificat TLS expiré, un WordPress non à jour, une base de données
+  MySQL exposée sur Internet, ou l'absence de DMARC passent inaperçus — jusqu'à
+  l'incident (site piraté, usurpation d'e-mail, fuite de données clients).
+
+## La solution
+
+Un outil **gratuit et open source** qui scanne un site web et produit un **rapport
+PDF en français clair**, compréhensible par un dirigeant non technique. Chaque faille
+est traduite en **risque métier** et accompagnée d'une **action priorisée**.
+
+Exemple de traduction :
+
+| Au lieu de… | pmescan dit… |
+|---|---|
+| `DMARC record not found` | « N'importe qui peut envoyer des e-mails en se faisant passer pour votre entreprise. » |
+| `TLS 1.0 enabled` | « Votre site utilise un chiffrement obsolète qu'un attaquant peut casser. » |
+| `Port 3306 open` | « Votre base de données est accessible depuis Internet. À fermer en urgence. » |
+
+## Pour qui
+
+1. **Gérants de PME** — veulent savoir en 30 secondes si leur site est à risque.
+2. **Agences web et prestataires** — veulent un rapport en marque blanche pour leurs clients.
+3. **Freelances sécurité / étudiants** — veulent un outil pédagogique et un point de départ.
+
+## Ce que le projet n'est pas
+
+- Ce n'est **pas un outil de piratage**. Le mode par défaut ne fait que lire des
+  informations publiques.
+- Ce n'est **pas un pentest complet**. Il repère les failles courantes, pas les 0-day.
+- Ce n'est **pas** un remplaçant d'un expert pour les gros systèmes critiques.
+
+## Objectif de différenciation
+
+Là où les concurrents s'arrêtent à la donnée technique brute, pmescan ajoute trois
+choses qu'aucun ne réunit :
+
+1. **Langue** : tout en français (et plus tard wolof, anglais).
+2. **Vulgarisation** : risque métier + qui corrige + effort estimé.
+3. **Ancrage local** : références à la loi sénégalaise 2008-12 sur les données
+   personnelles et à la CDP, pour crédibiliser le rapport auprès des dirigeants.
+
+## Mesure du succès (version 1)
+
+- Un gérant comprend son rapport **sans aide**.
+- Un scan passif complet s'exécute en **moins de 60 secondes**.
+- Le README montre la valeur en **30 secondes** (démo + exemple de PDF).
+- Publié sur **PyPI**, installable en une commande.

pmescan-0.1.0/02-UTILISATION.md

@@ -0,0 +1,89 @@
+# 02 — Utilisation : comment le projet s'utilise
+
+## Installation
+
+Depuis les sources (pmescan n'est pas encore publié sur PyPI) :
+
+```bash
+python -m venv .venv
+.venv/bin/pip install .          # Windows : .venv\Scripts\pip install .
+```
+
+Une fois publié : `pip install pmescan`. Pour le rapport PDF, il faut en plus les
+bibliothèques système de WeasyPrint (voir le README).
+
+## Les trois modes
+
+| Mode | Commande | Ce qu'il fait | Autorisation |
+|---|---|---|---|
+| **Passif** | *(défaut)* | Lit seulement ce que le site publie : TLS, en-têtes, DNS/e-mail, page d'accueil pour le CMS. | Non |
+| **Actif** | `--mode actif --jai-l-autorisation` | Ajoute les fichiers exposés, les fichiers de version du CMS et le test des ports. | Oui |
+| **Agressif** | `--mode agressif --jai-l-autorisation` | Réservé à de futures vérifications. Équivaut aujourd'hui au mode actif. | Oui |
+
+> ⚠️ Les modes actif et agressif ne s'utilisent que sur une cible dont vous êtes
+> propriétaire, ou pour laquelle vous avez une autorisation écrite. Voir
+> `README-mode-agressif.md`.
+
+## Commandes de base
+
+```bash
+# Scan passif, résultat dans le terminal
+pmescan scan exemple.sn
+
+# Rapport PDF en français
+pmescan scan exemple.sn --pdf
+
+# Préciser le fichier PDF
+pmescan scan exemple.sn --pdf --sortie rapport-client.pdf
+
+# Sortie JSON (intégration, script)
+pmescan scan exemple.sn --json
+
+# Mode actif (fichiers exposés, ports…) : autorisation obligatoire
+pmescan scan exemple.sn --mode actif --jai-l-autorisation
+
+# Vérifier aussi les failles connues du CMS (contacte osv.dev)
+pmescan scan exemple.sn --verifier-cve
+```
+
+## Ce que voit l'utilisateur
+
+Le terminal affiche une ligne par vérification, `[OK]` ou `[PROBLEME]`, avec
+l'identifiant et la gravité, puis la note globale :
+
+```
+[PROBLEME] dmarc_absent (elevee)
+[OK] cms_detecte (info)
+Note globale : D (47/100)
+```
+
+Les explications en français se trouvent dans le rapport PDF.
+
+## Contenu du rapport PDF
+
+- **Page 1** : note globale (A à F), résumé en 3 phrases, les 3 actions les plus urgentes.
+- **Fiches** : une par problème, avec :
+  - le risque expliqué simplement ;
+  - la gravité (critique, élevée, moyenne ou faible) ;
+  - qui doit corriger (hébergeur, développeur ou gérant) ;
+  - l'effort estimé.
+- **Annexe technique** : identifiants et preuves brutes pour le prestataire.
+- **Rappel légal** : loi sénégalaise 2008-12 et CDP.
+
+## Cas d'usage typiques
+
+1. **Un gérant** lance `pmescan scan monsite.sn --pdf`, lit les 3 actions urgentes et
+   les transmet à son hébergeur.
+2. **Une agence web** scanne chaque mois les sites de ses clients, en mode actif avec
+   leur autorisation écrite, et leur remet le PDF.
+3. **Une intégration continue** lance `pmescan scan monsite.sn --json`. Le pipeline
+   échoue si le code de sortie vaut 1, c'est-à-dire s'il y a un problème critique.
+
+## Codes de sortie (pour les scripts)
+
+| Code | Signification |
+|---|---|
+| `0` | Scan terminé, aucun problème critique. |
+| `1` | Scan terminé, au moins un problème critique. |
+| `2` | Erreur : option ou domaine invalide, PDF impossible à générer, erreur imprévue ou interruption. |
+| `3` | Refus : mode actif ou agressif sans `--jai-l-autorisation`. |

pmescan-0.1.0/03-CONCEPTION.md

@@ -0,0 +1,184 @@
+# 03 — Conception : comment on va le créer
+
+## Principe directeur
+
+- **Code en français** : noms de variables, fonctions, classes, commentaires.
+- **Modulaire** : chaque vérification (« check ») est indépendante et renvoie le même
+  type d'objet `Resultat`.
+- **Textes séparés du code** : les explications vulgarisées vivent dans des fichiers
+  YAML, pas dans le code. Un non-développeur peut les améliorer, et on ajoute une
+  langue sans toucher au code.
+- **Sans dépendance lourde** : pas besoin d'installer `nmap` ; le scan de ports se fait
+  en Python via `asyncio`.
+
+## Langage et bibliothèques
+
+| Besoin | Choix | Pourquoi |
+|---|---|---|
+| Langage | Python 3.11+ | Lisible, riche en libs sécurité, facile à contribuer. |
+| CLI | `typer` | Interface en ligne de commande propre et typée. |
+| TLS | `sslyze` | Analyse fine des certificats et protocoles. |
+| HTTP | `httpx` | Client HTTP moderne, async. |
+| DNS / e-mail | `dnspython` | Requêtes SPF, DMARC, DKIM, MX, DNSSEC. |
+| CVE | API OSV / NVD | Comparer versions CMS aux failles connues. |
+| Ports | `asyncio` (natif) | Connexion TCP sans dépendance externe. |
+| Rapport PDF | `jinja2` + `weasyprint` | HTML → PDF, mise en page soignée. |
+| Tests | `pytest` | Standard Python. |
+| Qualité | `ruff` + `mypy` | Lint et typage. |
+
+## Arborescence du projet
+
+```
+pmescan/
+├── pyproject.toml          # métadonnées + dépendances (packaging PyPI)
+├── README.md
+├── README-mode-agressif.md
+├── LICENSE                 # MIT
+├── CONTRIBUTING.md
+├── pmescan/
+│   ├── __init__.py
+│   ├── cli.py              # point d'entrée Typer
+│   ├── modele.py           # classes Resultat, Gravite, Cible
+│   ├── scanner.py          # orchestre les checks selon le mode
+│   ├── checks/
+│   │   ├── __init__.py
+│   │   ├── base.py         # classe abstraite Verification
+│   │   ├── tls.py
+│   │   ├── entetes.py      # en-têtes HTTP
+│   │   ├── dns_mail.py
+│   │   ├── cms.py
+│   │   ├── ports.py
+│   │   └── exposes.py      # fichiers sensibles exposés
+│   ├── notation.py         # pondération → note A–F
+│   ├── i18n/
+│   │   └── fr.yaml         # textes vulgarisés par problème
+│   └── rapport/
+│       ├── modele.html     # gabarit Jinja2
+│       └── generateur.py   # rendu WeasyPrint → PDF
+└── tests/
+    ├── test_tls.py
+    ├── test_entetes.py
+    ├── test_dns_mail.py
+    ├── test_notation.py
+    └── fixtures/           # réponses enregistrées pour tests hors-ligne
+```
+
+## Modèle de données (cœur du système)
+
+```python
+# pmescan/modele.py
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class Gravite(str, Enum):
+    CRITIQUE = "critique"
+    ELEVEE = "elevee"
+    MOYENNE = "moyenne"
+    FAIBLE = "faible"
+    INFO = "info"
+
+
+@dataclass
+class Resultat:
+    """Un problème (ou une absence de problème) trouvé par une vérification."""
+    identifiant: str          # ex. "tls_expire", "dmarc_absent"
+    gravite: Gravite
+    reussi: bool              # True = aucun problème sur ce point
+    preuve: str = ""          # donnée technique brute (ex. date d'expiration)
+    details: dict = field(default_factory=dict)
+
+
+@dataclass
+class Cible:
+    domaine: str
+    ip: str | None = None
+    mode: str = "passif"      # "passif" | "actif" | "agressif"
+```
+
+## Contrat d'une vérification
+
+Chaque check hérite de `Verification` et implémente `executer()`. Il renvoie une liste
+de `Resultat`. Il ne connaît ni la notation ni le rapport : il fait une seule chose.
+
+```python
+# pmescan/checks/base.py
+from abc import ABC, abstractmethod
+from pmescan.modele import Cible, Resultat
+
+
+class Verification(ABC):
+    """Classe mère de toutes les vérifications."""
+
+    nom: str = "verification"
+    niveau_minimum: str = "passif"   # mode minimal qui active ce check
+
+    @abstractmethod
+    async def executer(self, cible: Cible) -> list[Resultat]:
+        """Analyse la cible et renvoie la liste des problèmes trouvés."""
+        ...
+```
+
+## Séparation texte / code (i18n)
+
+Le code produit un `identifiant` (`dmarc_absent`). Le fichier YAML donne la version
+humaine. Pour ajouter le wolof, on copie `fr.yaml` en `wo.yaml`.
+
+```yaml
+# pmescan/i18n/fr.yaml
+dmarc_absent:
+  titre: "Aucune protection contre l'usurpation d'e-mail"
+  risque: >
+    N'importe qui peut envoyer des e-mails en se faisant passer pour votre
+    entreprise. Vos clients peuvent recevoir de fausses factures à votre nom.
+  qui_corrige: "hebergeur"
+  effort: "1 h"
+  action: "Ajouter un enregistrement DMARC dans votre zone DNS."
+```
+
+## Notation (note A–F)
+
+Chaque `Resultat` non réussi retire des points selon sa gravité. La somme donne un
+score sur 100, converti en lettre.
+
+```python
+# pmescan/notation.py
+PENALITES = {
+    "critique": 40,
+    "elevee": 20,
+    "moyenne": 10,
+    "faible": 3,
+    "info": 0,
+}
+
+def calculer_note(resultats: list[Resultat]) -> tuple[int, str]:
+    score = 100
+    for r in resultats:
+        if not r.reussi:
+            score -= PENALITES[r.gravite.value]
+    score = max(0, score)
+    lettre = (
+        "A" if score >= 90 else
+        "B" if score >= 75 else
+        "C" if score >= 60 else
+        "D" if score >= 40 else
+        "E" if score >= 20 else "F"
+    )
+    return score, lettre
+```
+
+## Sécurité et éthique intégrées dès la conception
+
+- Le mode passif est le mode par défaut. Les modes actif et agressif exigent le flag
+  `--jai-l-autorisation` : sans lui, la CLI refuse avant toute requête, avec le code 3.
+- Chaque scan intrusif autorisé est noté dans un journal local (`~/.pmescan/consent.log`).
+- Défense en profondeur : `scanner()` n'exécute une vérification intrusive que si
+  `Cible.autorisation` vaut True. Les checks intrusifs (`ports`, `exposes`) et les
+  sondes de chemins du check `cms` vérifient aussi ce champ eux-mêmes. Même un appel
+  Python direct ne lance donc aucune requête intrusive sans autorisation explicite.
+- La charge sur la cible est bornée : 20 connexions simultanées au plus, 2 s par
+  tentative, une seule tentative par port.
+- Aucune donnée envoyée à un tiers : tout le scan et le rapport restent locaux. La seule
+  exception est la vérification CVE optionnelle via OSV, désactivée par défaut et activable
+  avec `--verifier-cve`, qui envoie uniquement le nom et la version du CMS détecté à l'API
+  publique osv.dev.

pmescan-0.1.0/04-ETAPES.md

@@ -0,0 +1,75 @@
+# 04 — Étapes à suivre pour créer le projet
+
+Plan de construction en 4 semaines pour une version 1 publiable. Chaque étape se
+termine par quelque chose qui marche et qui est testé.
+
+## Étape 0 — Mise en place (jour 1)
+
+1. Créer le dépôt Git et la structure de dossiers (voir `03-CONCEPTION.md`).
+2. Écrire `pyproject.toml` (dépendances, point d'entrée `pmescan`).
+3. Mettre en place l'environnement : `python -m venv .venv`, `pip install -e .`.
+4. Configurer `ruff`, `mypy`, `pytest`.
+5. Ajouter `LICENSE` (MIT) et un `README.md` minimal.
+
+**Fini quand** : `pmescan --version` s'affiche.
+
+## Étape 1 — Noyau + TLS + en-têtes (semaine 1)
+
+1. Écrire `modele.py` (classes `Resultat`, `Gravite`, `Cible`).
+2. Écrire `checks/base.py` (classe `Verification`).
+3. Écrire `scanner.py` (orchestre les checks selon le mode).
+4. Écrire `checks/tls.py` (expiration, TLS 1.0/1.1, chiffrements faibles, redirection).
+5. Écrire `checks/entetes.py` (HSTS, CSP, X-Frame-Options, cookies, fuite de version).
+6. Écrire `cli.py` avec sortie JSON (`--json`).
+7. Écrire les tests `test_tls.py` et `test_entetes.py` avec des fixtures hors-ligne.
+
+**Fini quand** : `pmescan scan exemple.com --json` renvoie les résultats TLS et en-têtes.
+
+## Étape 2 — DNS/e-mail + fichiers exposés + notation (semaine 2)
+
+1. Écrire `checks/dns_mail.py` (SPF, DMARC, DKIM, MX, DNSSEC).
+2. Écrire `checks/exposes.py` (`/.git/`, `/.env`, `backup.zip`, listing de répertoires).
+3. Écrire `notation.py` (score + note A–F).
+4. Écrire `i18n/fr.yaml` avec les textes des problèmes déjà détectés.
+5. Tests : `test_dns_mail.py`, `test_notation.py`.
+
+**Fini quand** : `pmescan scan exemple.com --json` renvoie une note globale A–F.
+
+## Étape 3 — Rapport PDF en français (semaine 3)
+
+1. Écrire `rapport/modele.html` (gabarit Jinja2 : page de garde, fiches, annexe).
+2. Écrire `rapport/generateur.py` (WeasyPrint → PDF).
+3. Brancher `--pdf` et `--sortie` dans `cli.py`.
+4. Ajouter l'encadré légal (loi 2008-12, CDP).
+5. Soigner la mise en page (couleurs par gravité, note en gros sur la page 1).
+
+**Fini quand** : `pmescan scan exemple.com --pdf` produit un PDF lisible par un non-technicien.
+
+## Étape 4 — CMS + ports + publication (semaine 4)
+
+1. Écrire `checks/cms.py` (WordPress/Joomla/Drupal/PrestaShop + API OSV pour les CVE).
+2. Écrire `checks/ports.py` (~30 ports critiques via `asyncio`, mode actif).
+3. Ajouter la garde `--jai-l-autorisation` (modes actif et agressif) et le journal de
+   consentement, puis aligner `README-mode-agressif.md` sur ce comportement.
+4. Finaliser le `README.md` (exemple de sortie, options, codes de sortie). Un exemple de
+   PDF et un GIF de démo restent à ajouter.
+5. Publier sur **PyPI** (`python -m build`, `twine upload`).
+6. Écrire `CONTRIBUTING.md`.
+
+**Fini quand** : `pip install pmescan` fonctionne pour tout le monde.
+
+## Après la version 1 (idées)
+
+- Interface web (FastAPI) pour scanner sans ligne de commande.
+- Scans planifiés avec alerte e-mail si la note baisse.
+- Mode multi-sites pour les agences.
+- Traduction wolof et anglais (`wo.yaml`, `en.yaml`).
+- Rapport en marque blanche (logo de l'agence).
+
+## Règle de qualité à chaque étape
+
+Rien n'est « fini » tant que :
+- les tests passent (`pytest`) ;
+- `ruff` et `mypy` ne signalent aucune erreur ;
+- la fonctionnalité est documentée dans le README ;
+- le code est en français et lisible.

pmescan-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,108 @@
+# Contribuer à pmescan
+
+Merci de votre intérêt ! Toutes les contributions comptent, même sans écrire de code :
+- une explication plus claire dans `fr.yaml` ;
+- une traduction ;
+- un faux positif signalé ;
+- une version de CMS à mettre à jour.
+
+## Installer l'environnement de développement
+
+```bash
+git clone <url-du-depot> pmescan
+cd pmescan
+python -m venv .venv
+.venv/bin/pip install -e ".[dev]"     # Windows : .venv\Scripts\pip install -e ".[dev]"
+```
+
+## Avant chaque proposition (pull request)
+
+Les trois commandes suivantes doivent passer sans erreur :
+
+```bash
+python -m pytest -q
+python -m ruff check pmescan tests
+python -m mypy pmescan
+```
+
+Sous Windows, remplacez `python` par `.venv\Scripts\python.exe`.
+
+Un test est ignoré si WeasyPrint ou ses bibliothèques système (Pango, GTK) sont absents.
+C'est normal.
+
+## Règles du projet
+
+1. **Tout en français.**
+   - Les noms de variables, de fonctions et de classes, les commentaires et les messages
+     de commit sont en français.
+   - Seuls les noms imposés par une bibliothèque restent en anglais (`status_code`,
+     `wait_closed`, …).
+2. **Aucun texte destiné à l'utilisateur dans le code.**
+   - Un check produit un `Resultat` qui porte un `identifiant` stable, par exemple
+     `dmarc_absent`.
+   - L'explication en français se trouve dans `pmescan/i18n/fr.yaml`. Chaque entrée a
+     cinq clés : `titre`, `risque`, `qui_corrige` (`hebergeur`, `developpeur` ou
+     `gerant`), `effort` et `action`.
+3. **Écrire pour un gérant, pas pour un expert.**
+   - Le champ `risque` explique la conséquence concrète, sans jargon : par exemple
+     « essais de mots de passe en masse » plutôt que « force brute ».
+   - Le texte n'exagère pas : on écrit « peut permettre » plutôt que « permet ».
+4. **Tests 100 % hors ligne.** Aucun test ne doit toucher le réseau :
+   - les appels HTTP passent par `respx` ;
+   - le DNS est simulé (`dns.asyncresolver.resolve`, `VerificationPorts._resoudre`) ;
+   - sslyze est remplacé par les faux objets de `tests/conftest.py` ;
+   - les connexions TCP passent par `faux_open_connection`.
+5. **Aucune exception ne doit faire planter le scan.**
+   - Un check gère lui-même ses erreurs réseau.
+   - L'orchestrateur (`scanner.py`) sert de filet de sécurité : il transforme une
+     exception imprévue en `<check>_erreur_interne`.
+6. **Respecter les modes.**
+   - Toute requête qui va au-delà de la simple lecture de ce que le site publie est
+     réservée au mode `actif` : chemins sensibles, fichiers de version, connexions TCP.
+   - Le mode `passif` ne doit jamais faire ce type de requête.
+   - Une requête intrusive exige **aussi** `cible.autorisation`. `scanner()` ignore les
+     vérifications de niveau actif quand `Cible.autorisation` vaut False. C'est la
+     valeur par défaut, y compris lorsqu'on appelle pmescan depuis Python.
+   - Une nouvelle sonde intrusive placée dans un check passif doit tester
+     `cible.autorisation` elle-même, comme le fait `cms.py`.
+7. **Pas de faux positif.**
+   - Dans le doute, un check ne signale rien, ou signale en `INFO`, ce qui ne retire
+     aucun point.
+   - Un problème signalé à tort coûte la confiance du gérant.
+
+## Ajouter une vérification
+
+1. Créez `pmescan/checks/<nom>.py`, avec une classe qui hérite de `Verification` et
+   déclare `nom`, `niveau_minimum` (`"passif"` ou `"actif"`) et `async def executer(self, cible)`.
+2. Ajoutez-la à `VERIFICATIONS` dans `pmescan/scanner.py`.
+3. Ajoutez une entrée dans `fr.yaml` pour **chaque** identifiant non réussi.
+4. Écrivez `tests/test_<nom>.py`, qui couvre le cas « problème », le cas « tout va
+   bien » et les erreurs réseau.
+5. Ajoutez un scénario « problème » dans `_SCENARIOS_PAR_NOM` de `tests/test_i18n.py`.
+   C'est obligatoire : sans ce scénario, le test échoue. Ce garde-fou assure que tout
+   identifiant émis a bien son texte en français.
+
+## Ajouter une langue
+
+Copiez `pmescan/i18n/fr.yaml` en `<code>.yaml` (par exemple `wo.yaml` pour le wolof) et
+traduisez les valeurs. Les **clés** ne changent pas. Une relecture par une personne de
+langue maternelle est très appréciée.
+
+## Mettre à jour les versions de CMS
+
+La table `BRANCHES_MAINTENUES` de `pmescan/checks/cms.py` est tenue à la main. Pour la
+corriger :
+- indiquez dans la pull request la source officielle (calendrier de support du CMS) ;
+- mettez à jour la date du commentaire.
+
+## Signaler une faille de sécurité dans pmescan
+
+Ne publiez pas les détails dans une issue publique. Utilisez le signalement privé de
+vulnérabilité de la plateforme qui héberge le dépôt, ou ouvrez une issue qui demande
+seulement un canal de contact privé.
+
+## Éthique
+
+pmescan est un outil défensif. Une contribution qui ajoute une capacité offensive
+(exploitation de faille, essais de mots de passe, contournement de protections) ou qui
+affaiblit la garde d'autorisation des modes intrusifs sera refusée.

pmescan-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pmescan et ses contributeurs
+
+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.