IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Plateformes (Java EE, Jakarta EE, Spring) et Serveurs Discussion :

SSLServerSocket erreur : Cannot recover key


Sujet :

Plateformes (Java EE, Jakarta EE, Spring) et Serveurs

  1. #1
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    29
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 29
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 29
    Points : 43
    Points
    43
    Par défaut SSLServerSocket erreur : Cannot recover key
    Bonjour à tous,

    Comme vous pouvez vous en douter avec le titre du topique, je fais face à un problème que je ne parviens pas à résoudre.

    En suivant un mini-tuto, j'ai voulu adapter un mini-chat pour utiliser des sockets sécurisés.

    Mais lorsque je souhaite lancer le serveur, il me met la trace d'erreur suivante :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
    java.security.UnrecoverableKeyException: Cannot recover key
    	at sun.security.provider.KeyProtector.recover(Unknown Source)
    	at sun.security.provider.JavaKeyStore.engineGetKey(Unknown Source)
    	at sun.security.provider.JavaKeyStore$JKS.engineGetKey(Unknown Source)
    	at sun.security.provider.KeyStoreDelegator.engineGetKey(Unknown Source)
    	at sun.security.provider.JavaKeyStore$DualFormatJKS.engineGetKey(Unknown Source)
    	at java.security.KeyStore.getKey(Unknown Source)
    	at sun.security.ssl.SunX509KeyManagerImpl.<init>(Unknown Source)
    	at sun.security.ssl.KeyManagerFactoryImpl$SunX509.engineInit(Unknown Source)
    	at javax.net.ssl.KeyManagerFactory.init(Unknown Source)
    	at server.ServerUtils.km(ServerUtils.java:48)
    	at server.ServerUtils.getServerSocketWithCert(ServerUtils.java:77)
    	at server.Serveur.<init>(Serveur.java:23)
    	at server.Serveur.main(Serveur.java:38)
    Voici le code de la classe Serveur :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    package server;
    import java.io.*;
    import java.net.*;
    import java.security.KeyManagementException;
    import java.security.KeyStoreException;
    import java.security.NoSuchAlgorithmException;
    import java.security.UnrecoverableKeyException;
    import java.security.cert.CertificateException;
     
    import javax.net.ssl.SSLServerSocket;
     
    public class Serveur {
     //public static ServerSocket ss = null;
     public static SSLServerSocket ss = null;
     public static Thread t;
     public static int port = 2009;
     
     	private Serveur() throws KeyManagementException, UnrecoverableKeyException, NoSuchAlgorithmException, CertificateException, KeyStoreException {
     
     		try {
    			//ss = new ServerSocket(2009);
    			//
    			System.out.println("Le serveur est à l'écoute du port "+ss.getLocalPort());
     
    			t = new Thread(new Accepter_connexion(ss));
    			t.start();
     
    		} catch (IOException e) {
    			e.printStackTrace();
    			System.err.println("Le port "+ss.getLocalPort()+" est déjà utilisé !");
    		}
     	}
     
    	public static void main(String[] args) {
     
    		try {
    			Serveur serveur = new Serveur();
    		} catch (KeyManagementException | UnrecoverableKeyException | NoSuchAlgorithmException | CertificateException
    				| KeyStoreException e) {
    			e.printStackTrace();
    		}
     
    	}	
    }
    Puis le code de la classe ServerUtils :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    package server;
     
    import java.io.IOException;
    import java.io.InputStream;
    import java.security.KeyManagementException;
    import java.security.KeyStore;
    import java.security.KeyStoreException;
    import java.security.NoSuchAlgorithmException;
    import java.security.UnrecoverableKeyException;
    import java.security.cert.CertificateException;
     
    import javax.net.ssl.KeyManager;
    import javax.net.ssl.KeyManagerFactory;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLServerSocket;
    import javax.net.ssl.SSLServerSocketFactory;
    import javax.net.ssl.TrustManager;
    import javax.net.ssl.TrustManagerFactory;
    import javax.net.ssl.X509KeyManager;
    import javax.net.ssl.X509TrustManager;
     
    public class ServerUtils {
    	/**
             * Ca c'est une fonction utilitaire permettant de récupérer le "vérifieur de certificat", on prend uniquement celui correspondant au certificat pour minimiser le temps de chargement à la connexion
             * 
             * Pas très intéressante...
             */
    	private static X509TrustManager tm(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException {
    		TrustManagerFactory trustMgrFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustMgrFactory.init(keystore);
            //on prend tous les managers
            TrustManager trustManagers[] = trustMgrFactory.getTrustManagers();
            for (int i = 0; i < trustManagers.length; i++) {
                if (trustManagers[i] instanceof X509TrustManager) {
                    //on renvoie juste celui que l'on va utiliser
                    return (X509TrustManager) trustManagers[i];
                }
            }
            return null;
        };
        /**
         * Ca c'est une fonction utilitaire permettant de récupérer le "gestionnaire de mot de passes des clés" (en gros)
         * 
         * Pas très intéressante...
         */
        private static X509KeyManager km(KeyStore keystore, String password) throws NoSuchAlgorithmException, KeyStoreException, UnrecoverableKeyException {
    		KeyManagerFactory keyMgrFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyMgrFactory.init(keystore, password.toCharArray());
            //on prend tous les managers
            KeyManager keyManagers[] = keyMgrFactory.getKeyManagers();
            for (int i = 0; i < keyManagers.length; i++) {
                if (keyManagers[i] instanceof X509KeyManager) {
                    //on renvoie juste celui que l'on va utiliser
                    return (X509KeyManager) keyManagers[i];
                }
            }
            return null;
        };
     
     
     
        /**
         * Le vrai morceau, que l'on utilisera
         */
        public static SSLServerSocket getServerSocketWithCert(int port, InputStream pathToCert, String passwordFromCert) throws IOException,
    									KeyManagementException, NoSuchAlgorithmException, CertificateException, KeyStoreException, UnrecoverableKeyException{
    		TrustManager[] tmm = new TrustManager[1];
    		KeyManager[] kmm = new KeyManager[1];
    		//On charge le lecteur de Keystore en fonction du format
    		//ATTENTION
    		//POUR LES SERVEURS android, remplacez le JKS par BKS, si c'est juste le client qui est android, laissez JKS
    		KeyStore ks  = KeyStore.getInstance("JKS");
    		//On charge le Keystore avec sont stream et son mot de passe
    		ks.load(pathToCert, passwordFromCert.toCharArray());
    		//On lance les gestionnaires de clés et de vérification des clients
    		tmm[0]=tm(ks);
    		kmm[0]=km(ks, passwordFromCert);
    		//On démarre le contexte, autrement dit le langage utilisé pour crypter les données
    		//ATTENTION
    		//Ici, on peut remplacer SSL par TLSv1.2 , mais il faudra le faire aussi bien dans le client que le serveur
    		SSLContext ctx = SSLContext.getInstance("TLSv1.2");
    		ctx.init(kmm, tmm, null);
    		//On lance la serversocket sur le port indiqué, avec le contexte fourni
    		SSLServerSocketFactory socketFactory = (SSLServerSocketFactory) ctx.getServerSocketFactory();
    		return (SSLServerSocket) socketFactory.createServerSocket(port);
    	}
    }
    Quelqu'un a-t-il une solution ?

    Merci

  2. #2
    Membre actif
    Homme Profil pro
    Architecte technique
    Inscrit en
    Août 2006
    Messages
    178
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2006
    Messages : 178
    Points : 274
    Points
    274
    Par défaut
    A mon avis tu n'as pas ta clef privée dans le keystore sur lequel tu pointes ou alors tu ne passes pas le bon mot de passe qui peut etre différent entre celui de la clef et celui du keystore.
    Que donne un
    keytool --list -v -rfc -keystore monfichier.keystore

  3. #3
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    29
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 29
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 29
    Points : 43
    Points
    43
    Par défaut
    Déjà ça me met que la commande n'est pas reconnu comme commande interne, pour y remédier, je me suis placé dans le répertoire bin de mon JDK pour executer la commande que tu m'a donné et il me met :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    -v et -rfc ne doivent pas être spécifiés avec la commande 'list'
    keytool -list [OPTION]...
     
    Répertorie les entrées d'un fichier de clés
     
    Options :
     
     -rfc                            sortie au style RFC
     -alias <alias>                  nom d'alias de l'entrée à traiter
     -keystore <keystore>            nom du fichier de clés
     -storepass <arg>                mot de passe du fichier de clés
     -storetype <storetype>          type du fichier de clés
     -providername <providername>    nom du fournisseur
     -providerclass <providerclass>  nom de la classe de fournisseur
     -providerarg <arg>              argument du fournisseur
     -providerpath <pathlist>        variable d'environnement CLASSPATH du fournisseur
     -v                              sortie en mode verbose
     -protected                      mot de passe via mécanisme protégé
     
    Utiliser "keytool -help" pour toutes les commandes disponibles

  4. #4
    Membre actif
    Homme Profil pro
    Architecte technique
    Inscrit en
    Août 2006
    Messages
    178
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2006
    Messages : 178
    Points : 274
    Points
    274
    Par défaut
    rfc tu peux le virer mais regarde le message et tu verras que les options sont valides
    Options :
    -rfc sortie au style RFC
    -keystore <keystore> nom du fichier de clés
    -v sortie en mode verbose

    tu pointes bien vers ton keystore ? c'est peut être un souci sur les -, tape la commande manuellement

  5. #5
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    29
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 29
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 29
    Points : 43
    Points
    43
    Par défaut
    Le retour est le suivant :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    Type de fichier de clés : JKS
    Fournisseur de fichier de clés : SUN
     
    Votre fichier de clés d'accès contient 1 entrée
     
    Nom d'alias : ****
    Date de création : 24 juin 2016
    Type d'entrée*: PrivateKeyEntry
    Longueur de chaîne du certificat : 1
    Certificat[1]:
    Propriétaire : CN=****, C=FR
    Emetteur : CN=****, C=FR
    Numéro de série : 576d2e17
    Valide du : Fri Jun 24 14:56:55 CEST 2016 au : Sat Jun 24 14:56:55 CEST 2017
    Empreintes du certificat :
             MD5:  AA:D4:30:18:43:01:24:D2:60:51:EB:55:4F:40:D0:39
             SHA1 : D1:AE:43:22:BE:FD:3B:AA:83:FF:21:54:FF:53:43:6D:F8:55:12:E3
             SHA256 : 2A:AE:24:04:30:69:4F:6F:11:81:B8:1C:47:5F:42:2C:DE:39:96:50:C0:E4:7F:6E:7A:B8:2F:A4:EC:80:45:2C
             Nom de l'algorithme de signature : SHA256withRSA
             Version : 1
     
     
    *******************************************
    *******************************************

  6. #6
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    29
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 29
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 29
    Points : 43
    Points
    43
    Par défaut
    J'ai trouvé la solution, il faut que le mot de passe lors de la création de la paire de clés soit identique au mot de passe de la clé privé.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 2
    Dernier message: 06/03/2013, 18h20
  2. Réponses: 2
    Dernier message: 11/07/2012, 18h52
  3. Réponses: 3
    Dernier message: 05/12/2005, 11h27
  4. Erreur cannot focus a disabled or invisible window
    Par Andry dans le forum Composants VCL
    Réponses: 3
    Dernier message: 17/12/2003, 08h33
  5. [CR7] Erreur CanNot initalize OLE
    Par elifqaoui dans le forum SAP Crystal Reports
    Réponses: 4
    Dernier message: 17/07/2003, 23h03

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo