Valider le certificat X.509 par rapport à CA en Java

Permet de dire que j'ai quelque chose comme ceci (côté client):

TrustManager[] trustAllCerts = new TrustManager[]{
    new X509TrustManager() {

        @Override
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        @Override
        public void checkClientTrusted(
                java.security.cert.X509Certificate[] certs, String authType) {
        }

        @Override
        public void checkServerTrusted(
                java.security.cert.X509Certificate[] certs, String authType) {
        }
    }
};

SSLContext sslc = SSLContext.getInstance("TLS");
sslc.init(null, trustAllCerts, null);

SocketFactory sf = sslc.getSocketFactory();
SSLSocket s = (SSLSocket) sf.createSocket("127.0.0.1", 9124);

Ce code est complète et fonctionnelle, mais je ne peux vraiment pas à comprendre, comment valider le certificat du serveur contre un béton certificat de CA que j'ai de disponible dans le fichier pem.

Tous les certificats sont signés par mon auto-signé CA, et c'est CA j'ai besoin de valider contre (seulement à l'encontre de celui-ci).

Chaque réponse est apprécié.

EDIT:

En réponse à jglouie (je vous remercie beaucoup de cette façon - ne peut pas voter votre réponse).

J'ai fondé la solution:

new X509TrustManager() {

        @Override
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        @Override
        public void checkClientTrusted(
                java.security.cert.X509Certificate[] certs, String authType) {
        }

        @Override
        public void checkServerTrusted(
                java.security.cert.X509Certificate[] certs, String authType)
                throws CertificateException {
            InputStream inStream = null;
            try {
                //Loading the CA cert
                URL u = getClass().getResource("tcp/cacert.pem");
                inStream = new FileInputStream(u.getFile());
                CertificateFactory cf = CertificateFactory.getInstance("X.509");
                X509Certificate ca = (X509Certificate) cf.generateCertificate(inStream);
                inStream.close();

                for (X509Certificate cert : certs) {
                    //Verifing by public key
                    cert.verify(ca.getPublicKey());
                }
            } catch (Exception ex) {
                Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
            } finally {
                try {
                    inStream.close();
                } catch (IOException ex) {
                    Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
                }
            }

        }
    }
};

source d'informationauteur Jakub Truneček

  1. 19

    Je suppose que le certificat auto-signé de votre autorité de certification est déjà chargé comme suit: 

    CertificateFactory cf = CertificateFactory.getInstance("X.509");   
FileInputStream finStream = new FileInputStream("CACertificate.pem"); 
X509Certificate caCertificate = (X509Certificate)cf.generateCertificate(finStream);

    Ensuite dans la méthode de vérification de certificat: 

    @Override        
 public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType)  throws CertificateException {

 if (certs == null || certs.length == 0) {  
      throw new IllegalArgumentException("null or zero-length certificate chain");  
 }  

 if (authType == null || authType.length() == 0) {  
            throw new IllegalArgumentException("null or zero-length authentication type");  
  }  

   //Check if certificate send is your CA's
    if(!certs[0].equals(caCertificate)){
         try
         {   //Not your CA's. Check if it has been signed by your CA
             certs[0].verify(caCertificate.getPublicKey())
         }
         catch(Exception e){   
              throw new CertificateException("Certificate not trusted",e);
         }
    }
    //If we end here certificate is trusted. Check if it has expired.  
     try{
          certs[0].checkValidity();
      }
      catch(Exception e){
            throw new CertificateException("Certificate not trusted. It has expired",e);
      }  
}

    Avertissement: n'Ont même pas atempted pour compiler le code

  2. 2

    Accepté la réponse est extrêmement incorrect. Il n'est pas du point de vue cryptographique de vérifier une connexion entre le serveur de certificat et de l'autorité de certification de confiance. En général, vous devriez presque jamais besoin de mettre en œuvre votre propre TrustManager, cela est extrêmement dangereux.

    Comme EJP indiqué, il n'est pas nécessaire de mettre en place votre propre TrustManager, vous pouvez simplement utiliser celui par défaut, et de s'assurer que le certificat CA de confiance a été ajouté à votre défaut TrustStore. Voir cette question pour plus d'informations.

    Prendre un coup d'oeil à la CertPathValidator classe à partir du JDK, qui vérifie qu'une chaîne continue de la confiance du serveur propre certificat par une autorité de certification de confiance. Voir Oracle docs pour une introduction à la chaîne de certificat de validation.

  3. -5

    Ce code est complètement fonctionnel

    Ce code est complètement dysfonctionnel. Il est complètement d'insécurité, ainsi que même pas conformes à ses propres spécifications. Il est rarement nécessaire de fournir votre propre TrustManager, celui par défaut fonctionne très bien.

    Tout ce que vous devez faire est de vous assurer que le certificat d'autorité de certification que vous avez est présent dans votre truststore, puis définissez le système de la propriété javax.net.ssl.trustStore à point pour elle, si elle n'est pas la valeur par défaut de Java fichier truststore. Vous n'avez pas besoin d'écrire de code à tous, au-delà, éventuellement,System.setProperty()si vous n'avez pas défini via la ligne de commande option-D.

    MODIFIER Votre "solution" ne sera certainement pas de travail en général. Il suppose que chaque certificat de la chaîne est signé par votre certificat. Qui ne peut être vrai que pour des chaînes de longueur 1, ou 2 si le certificat de signature = votre certificat.