Chiffrement symétrique (clé secrète)
Algorithme Remarques
DES (Data Encryption Standard) Clé de 56 bits → cassable par force brute.
Plus sûr que DES mais lent et vulnérable (attaque
3DES / TDEA (Triple DES)
Sweet32).
RC2 Obsolète, bloc de 64 bits.
RC4 Biais statistiques importants, interdit dans TLS.
IDEA (International Data Encryption
Sécurité limitée, taille de bloc de 64 bits.
Algorithm)
Taille de bloc 64 bits → vulnérable sur grands
Blowfish
volumes de données.
CAST-128 Taille de bloc 64 bits, usages restreints.
Skipjack Algorithme de la NSA, abandonné.
Chiffrement asymétrique (clé publique)
Algorithme Remarques
Trop petites clés → cassables avec moyens
RSA < 2048 bits
modernes.
DSA < 2048 bits Vulnérable si faible taille de clé.
Diffie-Hellman < 2048 bits Vulnérable à la factorisation de clés faibles.
ECC avec courbes obsolètes (ex. secp112r1,
Trop petites tailles → cassables.
secp160k1)
Fonctions de hachage
Algorithme Remarques
MD2 Très faible sécurité, obsolète.
MD4 Complètement cassé.
MD5 Collisions pratiques, interdit pour signature.
SHA-0 Vulnérable aux collisions.
SHA-1 Collisions démontrées, retiré de TLS/SSL.
RIPEMD-128 Sécurité limitée, remplacé par RIPEMD-160 ou SHA-2/SHA-3.
Protocoles cryptographiques considérés comme hérités
Protocole Remarques
SSLv2 et SSLv3 Complètement cassés.
TLS 1.0 et 1.1 Vulnérabilités connues (BEAST, POODLE).
WEP (Wi-Fi) Cassable en quelques minutes.
IPsec avec DES ou 3DES Non recommandé, utiliser AES.
$$$$$$$$$$$$$$$
1. Java Cryptography Architecture (JCA)
Qu’est-ce que c’est ?
C’est l’infrastructure de Java qui fournit une API unifiée pour utiliser différents
services de cryptographie (chiffrement, signatures, hachage, certificats, etc.).
Fonctionnalités offertes :
o Algorithmes de chiffrement symétrique et asymétrique (AES, RSA…)
o Fonctions de hachage (SHA-256…)
o Signatures numériques
o Gestion de certificats et clés
2. Java Secure Socket Extension (JSSE)
Qu’est-ce que c’est ?
C’est une extension de Java qui permet de gérer les communications sécurisées via
SSL et TLS.
Lien avec JCA : JSSE utilise JCA pour la partie cryptographique (génération de clés,
signatures…).
Fonctionnalités offertes :
o Création de serveurs et clients HTTPS/TLS.
o Gestion de certificats (via KeyStore et TrustStore).
o Authentification mutuelle (client et serveur).
3. Python – module ssl et OpenSSL
Module ssl de Python :
C’est le module standard de Python pour gérer SSL/TLS dans les applications réseau.
Lien avec OpenSSL :
Le module ssl ne réimplémente pas SSL/TLS lui-même → il s’appuie sur la
bibliothèque OpenSSL (écrite en C), qui est une implémentation open-source très
utilisée de TLS/SSL et de nombreux algorithmes cryptographiques.
Fonctionnalités offertes :
o Création de connexions sécurisées (serveur/client).
o Gestion des certificats et vérification.
o Sélection de protocoles (TLS 1.2, TLS 1.3…).
Résumé visuel
Langage Outil Rôle Dépendances
Java JCA API crypto générique Fournisseurs Java (SunJCE, BouncyCastle…)
Java JSSE API SSL/TLS Utilise JCA pour la crypto
Python ssl API SSL/TLS Utilise OpenSSL en interne
$$$$$$$$$$$$$
Python ne réimplémente pas lui-même tous les algorithmes cryptographiques ou le
protocole TLS/SSL → il appelle directement les fonctions d’OpenSSL via ce
wrapper.
Python utilise la version d’OpenSSL installée sur ton système (Linux, macOS,
Windows).
Si ton Linux a OpenSSL 1.0.2, Python ne pourra pas faire de TLS 1.3.
Si tu mets à jour vers OpenSSL 1.1.1 ou 3.0, Python pourra.
$$$$$$$$$$$$$$$
Stack SSL/TLS
Un stack (ou pile logicielle) SSL/TLS:
o Les fonctions de chiffrement/déchiffrement (AES, RSA, etc.)
o Les fonctions de hachage (SHA-256…)
o La gestion des certificats et clés
o Les mécanismes de négociation (handshake TLS)
JSSE – Java Secure Socket Extension
C’est la stack SSL/TLS native de Java.
Implémentée en pur Java (et non pas en C comme OpenSSL).
Utilise JCA (Java Cryptography Architecture) comme base pour la crypto.
Permet de créer des clients et serveurs TLS/SSL sans dépendre de bibliothèques
externes.
Compatible avec les protocoles TLS 1.2, TLS 1.3 (selon version de Java).
JSSE ne dépend pas d’une bibliothèque SSL/TLS du système (contrairement à
Python qui dépend d’OpenSSL).
Toute l’implémentation est incluse dans le JDK/JRE.
Cela veut dire :
o Pas besoin d’installer OpenSSL ou GnuTLS pour que Java fasse du TLS.
o La sécurité et les fonctionnalités TLS dépendent uniquement de la version de
Java que tu utilises.
o Les mises à jour TLS se font en mettant à jour Java, pas le système.
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
OpenSSL 3.0 a introduit un système de security levels plus strict qui classe SHA-1 et MD5
comme algorithmes cryptographiquement faibles :
Security Level 1 (par défaut) : Interdit SHA-1 pour les signatures de certificats
Security Level 0 : Autorise les algorithmes faibles (non recommandé)
Les algorithmes MD5 et SHA-1 sont considérés comme vulnérables aux attaques par
collision
2. Différences d'architecture SSL/TLS entre Java et
Python
Différence entre Java JSSE et Python OpenSSL
Architecture Java JSSE (Java Secure Socket Extension) :
Stack TLS/SSL intégré à la JVM
Gestion des certificats via KeyStore/TrustStore
Contrôle granulaire via TrustManager/KeyManager
Indépendant des bibliothèques système
Architecture Python OpenSSL :
Binding direct vers la bibliothèque OpenSSL système
Configuration dépendante de la version OpenSSL installée
Moins de contrôle sur les détails de validation
Dépendance aux politiques de sécurité du système
Java SSL/TLS stack vs OpenSSL : gestion des certificats faibles
Java JSSE :
Permet la création de TrustManager personnalisé
Possibilité de bypass complet de la validation
Configuration fine des algorithmes acceptés
Contrôle au niveau application
Python OpenSSL :
Validation gérée au niveau bibliothèque système
Options de contournement limitées
Dépendance aux security levels OpenSSL
Moins de flexibilité pour les cas d'usage spéciaux
$$$$$$$$$$$$$$$$$$$$$$$$$$
Architecture Système : La Différence Fondamentale
Stack SSL/TLS Python
Application Python
↓
requests/urllib3
↓
Python ssl module
↓
OpenSSL 3.0.16 (système)
↓
Kernel Linux
Stack SSL/TLS Java
Application Java
↓
HttpURLConnection
↓
Java JSSE (intégré JVM)
↓
JVM Runtime
↓
Kernel Linux
Différence critique : Python dépend d'OpenSSL externe, Java utilise sa propre
implémentation SSL.
$$$$$$$$$$$$$$$$$$$ Security Levels OpenSSL 3.0
Level Description Impact
0 Tout accepté Théoriquement permissif
Level Description Impact
1 Défaut Refuse SHA-1 pour signatures
2 Strict Refuse < 112 bits sécurité
3 Plus strict Refuse < 128 bits
4 Maximum Refuse < 192 bits
Problème : Même au level 0, OpenSSL 3.0 maintient certaines interdictions.
$$$$$$$$$$$$$$$$$$$$$$$$$
de différences dans leurs politiques de sécurité par défaut et leurs mécanismes de gestion
des algorithmes faibles ou obsolètes.
Comportement des applications Python (via OpenSSL) :
o Le module Python ssl, qui utilise la bibliothèque OpenSSL, a une politique de
sécurité par défaut plus stricte concernant les algorithmes cryptographiques.
o Les versions SSL 2 et 3 sont considérées comme non sécurisées et sont
désactivées par défaut.
o 3DES a été retiré de la chaîne de chiffrement par défaut à partir de la
version 3.8 de Python.
o Les validations de certificats sont effectuées automatiquement par OpenSSL, et
la connexion peut échouer si la validation échoue.
o OpenSSL peut bloquer des tentatives de configuration de certificats ou de
paramètres avec une sécurité insuffisante. Par exemple, tenter d'utiliser un
certificat avec une signature digest SHA1 à un certain niveau de sécurité
peut être bloqué, entraînant l'abandon de la négociation. Cela suggère que la
bibliothèque OpenSSL, par défaut ou à des niveaux de sécurité spécifiques,
rejette activement les certificats signés avec des algorithmes faibles comme
SHA-1.
Comportement des applications Java (via JSSE/JCA) :
o La plateforme Java, à travers l'architecture JCA (Java Cryptography
Architecture) et l'extension JSSE (Java Secure Socket Extension), offre une
grande flexibilité et une conception axée sur l'indépendance de
l'implémentation et l'extensibilité des algorithmes.
o Java utilise des propriétés de sécurité comme
[Link] et [Link]
pour désactiver des algorithmes jugés faibles ou obsolètes lors de la
négociation TLS/DTLS et de la validation des chemins de certification.
o Par exemple, [Link] désactive par défaut des
protocoles comme SSLv3, TLSv1, TLSv1.1, et des chiffrements spécifiques
comme RC4 et DES.
o Java reconnaît également des "algorithmes cryptographiques hérités"
([Link]) qui ne sont pas préférables mais peuvent être
pris en charge pour des raisons de compatibilité avec des applications plus
anciennes, et ne sont négociés que s'il n'y a pas d'autres alternatives plus fortes.
En somme, la différence principale réside dans la gestion par défaut des certificats faibles :
Python, s'appuyant sur OpenSSL, semble avoir une position par défaut plus intransigeante en
rejetant activement les certificats utilisant des algorithmes faibles, même s'ils sont considérés
comme fiables dans le cadre d'une application existante.
