Wiki

Outils pour utilisateurs

Outils du site

Piste :
all:bibles:linux:applications:java

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
all:bibles:linux:applications:java [2024/12/17 11:32] – [Installation] omeylhocall:bibles:linux:applications:java [2025/08/22 16:22] (Version actuelle) – [Validation] omeylhoc
Ligne 1: Ligne 1:
 +====== Java ======
  
 +----
 +
 +===== Versions =====
 +
 +==== Installation ====
 +
 +Pour installer manuellement une version (si pas disponible dans les dépôts). Après téléchargement de l'archive :
 +
 +=== Mise en place ===
 +
 +<code bash>
 +tar zxvf <version>.tar.gz 
 +sudo mv <version> /usr/lib/jvm
 +</code>
 +
 +=== Prise en compte ===
 +
 +<code bash>
 +sudo update-alternatives --install /usr/bin/java  java  /usr/lib/jvm/<version>/bin/java  1
 +sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/<version>/bin/javac 1
 +</code> 
 +
 +=== Choix de la version ===
 +
 +<code bash>
 +sudo update-alternatives --config java
 +sudo update-alternatives --config javac
 +</code>
 +
 +==== Configuration ====
 +
 +<code bash>
 +sudo update-alternatives --config java
 +sudo update-alternatives --config javac
 +</code>
 +
 +==== Interrogation ====
 +
 +<code bash>
 +update-alternatives --display java
 +update-alternatives --display javac
 +</code>
 +
 +----
 +
 +===== Keystore / Truststore =====
 +
 +  * Les fichiers Keystore et Truststore sont nécessaires dès que l'on veut communiquer de manière sécurisée en SSL/TLS.
 +  * Le format par défaut de ces fichiers est JKS jusqu'à Java 8.
 +  * Depuis Java 9 le format par défaut pour le keystore est PKCS12 qui est un format standardisé alors JKS est spécifique à Java.
 +
 +==== Java Keystore ====
 +
 +=== Contenu ===
 +
 +Un keystore est un magasin qui contient des clés privées et les certificats associés ainsi que des certificats de serveurs.
 +
 +=== Utilisation ===
 +
 +Utilisé pour stocker les informations nécessaires à l'identité d'une entité (par exemple, un serveur ou un client) pour la signature, le déchiffrement, etc.\\
 +En général on utilise un keystore en tant que serveur pour aller chercher une clef privée et présenter une clef publique correspondante et son certificat au client.
 +
 +=== Lister le contenu d'un keystore ===
 +
 +<code bash>
 +keytool -v -list -storetype jks -keystore <keystore.jks>
 +</code>
 +
 +=== Extraire le rootCA d'un keystore ===
 +
 +Après avoir identifié l'alias du rootCA à l'aide de la commande précédente :
 +
 +<code bash>
 +keytool -exportcert -alias <rootca> -file <rootCA.crt> -keystore <keystore.jks>
 +</code>
 +
 +=== Vérifier le contenu du rootCA ===
 +
 +<code bash>
 +openssl x509 -in <rootCA.crt> -text -noout
 +</code>
 +
 +==== Java truststore ====
 +
 +=== Contenu ===
 +
 +Contient uniquement des certificats de CA, pas de clés privées.
 +
 +=== Utilisation ===
 +
 +Utilisé pour vérifier les certificats présentés par d'autres entités, assurant que les communications sont sécurisées et de confiance.\\
 +Typiquement utilisé par le client pour vérifier le certificat présenté par le serveur.
 +
 +=== Lister le contenu d'un trustore ===
 +
 +<code bash>
 +keytool -v -list -storetype jks -keystore <fichier_keystore.jks>
 +</code>
 +
 +==== Validation ====
 +
 +=== Programme ===
 +
 +<code java CertificateValidator.java>
 +import javax.net.ssl.*;
 +import java.io.FileInputStream;
 +import java.io.IOException;
 +import java.net.URL;
 +import java.security.KeyStore;
 +import java.security.cert.Certificate;
 +import java.security.cert.X509Certificate;
 +import java.util.Date;
 +
 +public class CertificateValidator {
 +
 +    public static void validateUrlWithKeystore(String urlStr, String keystorePath, String keystorePassword) {
 +        try {
 +            // 1. Charger le keystore
 +            KeyStore keystore = loadKeystore(keystorePath, keystorePassword);
 +
 +            // 2. Configurer le contexte SSL
 +            SSLContext sslContext = configureSSLContext(keystore);
 +
 +            // 3. Créer et configurer la connexion
 +            HttpsURLConnection connection = createSecureConnection(urlStr, sslContext);
 +
 +            // 4. Effectuer la validation
 +            validateConnection(connection);
 +
 +        } catch (Exception e) {
 +            System.err.println("Erreur lors de la validation: " + e.getMessage());
 +            e.printStackTrace();
 +        }
 +    }
 +
 +    private static KeyStore loadKeystore(String keystorePath, String keystorePassword) throws Exception {
 +        System.out.println("Chargement du keystore: " + keystorePath);
 +        KeyStore keystore = KeyStore.getInstance("JKS");
 +        try (FileInputStream fis = new FileInputStream(keystorePath)) {
 +            keystore.load(fis, keystorePassword.toCharArray());
 +            System.out.println("Keystore chargé avec succès");
 +            return keystore;
 +        }
 +    }
 +
 +    private static SSLContext configureSSLContext(KeyStore keystore) throws Exception {
 +        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
 +        tmf.init(keystore);
 +
 +        SSLContext sslContext = SSLContext.getInstance("TLS");
 +        sslContext.init(null, tmf.getTrustManagers(), null);
 +        return sslContext;
 +    }
 +
 +    private static HttpsURLConnection createSecureConnection(String urlStr, SSLContext sslContext)
 +            throws IOException {
 +        URL url = new URL(urlStr);
 +        HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
 +        connection.setSSLSocketFactory(sslContext.getSocketFactory());
 +
 +        // Configuration du HostnameVerifier personnalisé
 +        connection.setHostnameVerifier((hostname, session) -> {
 +            System.out.println("\nVérification du hostname: " + hostname);
 +            try {
 +                Certificate[] certs = session.getPeerCertificates();
 +                printCertificateInfo(certs);
 +                return true;
 +            } catch (SSLPeerUnverifiedException e) {
 +                System.err.println("Erreur lors de la vérification du hostname: " + e.getMessage());
 +                return false;
 +            }
 +        });
 +
 +        return connection;
 +    }
 +
 +    private static void validateConnection(HttpsURLConnection connection) {
 +        try {
 +            System.out.println("\nTentative de connexion à: " + connection.getURL());
 +
 +            // Effectuer la connexion
 +            connection.connect();
 +
 +            // Récupérer et afficher les informations des certificats
 +            Certificate[] serverCerts = connection.getServerCertificates();
 +
 +            System.out.println("\nConnexion établie avec succès!");
 +            System.out.println("Certificats du serveur:");
 +            printCertificateInfo(serverCerts);
 +
 +            // Vérifier le code de réponse HTTP
 +            int responseCode = connection.getResponseCode();
 +            System.out.println("\nCode de réponse HTTP: " + responseCode);
 +
 +        } catch (SSLHandshakeException e) {
 +            System.err.println("\nErreur SSL lors de la négociation: " + e.getMessage());
 +            System.err.println("Vérifiez que le certificat est présent dans le keystore.");
 +        } catch (Exception e) {
 +            System.err.println("\nErreur lors de la validation: " + e.getMessage());
 +        } finally {
 +            connection.disconnect();
 +        }
 +    }
 +
 +    private static void printCertificateInfo(Certificate[] certs) {
 +        for (int i = 0; i < certs.length; i++) {
 +            if (certs[i] instanceof X509Certificate) {
 +                X509Certificate cert = (X509Certificate) certs[i];
 +                System.out.println("\nCertificat " + (i + 1) + ":");
 +                System.out.println("  Sujet: " + cert.getSubjectX500Principal());
 +                System.out.println("  Émetteur: " + cert.getIssuerX500Principal());
 +                System.out.println("  Numéro de série: " + cert.getSerialNumber());
 +                System.out.println("  Valide à partir de: " + cert.getNotBefore());
 +                System.out.println("  Valide jusqu'au: " + cert.getNotAfter());
 +
 +                // Vérifier si le certificat est expiré
 +                Date now = new Date();
 +                if (now.after(cert.getNotAfter())) {
 +                    System.out.println("  ATTENTION: Ce certificat est expiré!");
 +                } else if (now.before(cert.getNotBefore())) {
 +                    System.out.println("  ATTENTION: Ce certificat n'est pas encore valide!");
 +                } else {
 +                    System.out.println("  État: Certificat valide");
 +                }
 +            }
 +        }
 +    }
 +
 +    public static void main(String[] args) {
 +        // Exemple d'utilisation
 +        if (args.length != 3) {
 +            System.out.println("Usage: java CertificateValidator <url> <keystore_path> <keystore_password>");
 +            System.out.println("Exemple: java CertificateValidator https://example.com /path/to/keystore.jks password");
 +            return;
 +        }
 +
 +        String url = args[0];
 +        String keystorePath = args[1];
 +        String keystorePassword = args[2];
 +
 +        validateUrlWithKeystore(url, keystorePath, keystorePassword);
 +    }
 +}
 +</code>
 +
 +=== Fonctionnement===
 +
 +  * Charge le keystore
 +  * Configure un contexte SSL avec les certificats du keystore
 +  * Établit une connexion HTTPS avec l'URL
 +  * Vérifie la chaîne de certificats
 +  * Affiche les informations détaillées des certificats
 +
 +=== Compilation ===
 +
 +<code bash>
 +sudo dnf install java-xx-openjdk-devel # redhat
 +sudo apt install default-jdk           # ubuntu
 +javac CertificateValidator.java
 +</code>
 +
 +=== Utilisation ===
 +
 +<code bash>
 +java CertificateValidator <url> <keystore> <mot de passe>
 +</code>
 +
 +----
 +[[all:bibles:linux:applications:java|Haut de page]]