Envoyer/Récupérer un certificat

Version imprimable

Bonjour,

Je suis à la recherche de codes ou de tutoriels pour gérer une authentification client et serveur.

Récupérer et Verifier les infos d'un certificat venant de mon serveur (signer par une CA comme Verisign)
Envoyer mon certificat client (auto-signer) au serveur pour l'authentification du client

En faisant des recherches, j'ai trouvé un code ainsi que plusieurs classe en rapport avec les certificats ou des connexions sécurités TLS

# javax.net.ssl
# javax.security.auth
# javax.security.auth.callback
# javax.security.auth.login
# javax.security.auth.x500
# javax.security.cert

Code:

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
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
 
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.X509TrustManager;
 
private void trustEveryone() {
        try {
                HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier(){
                        public boolean verify(String hostname, SSLSession session) {
                                return true;
                        }});
                SSLContext context = SSLContext.getInstance("TLS");
                context.init(null, new X509TrustManager[]{new X509TrustManager(){
                        public void checkClientTrusted(X509Certificate[] chain,
                                        String authType) throws CertificateException {}
                        public void checkServerTrusted(X509Certificate[] chain,
                                        String authType) throws CertificateException {}
                        public X509Certificate[] getAcceptedIssuers() {
                                return new X509Certificate[0];
                        }}}, new SecureRandom());
                HttpsURLConnection.setDefaultSSLSocketFactory(
                                context.getSocketFactory());
        } catch (Exception e) { // should never happen
                e.printStackTrace();
        }
}

J'espère que quelqu'un pourra m'orienter. Je nage un peu dans le domaine et j'ai un peu de peine à voir quel classe peut m'aider dans quel situation.

Bonne journée, Palopalo

29/03/2011, 14h26
Roberto125

Bonjour,

quels types d'informations souhaitez-vous donc vérifier ?
Si vous souhaitez avoir les informations de base, veuillez donc regarder les informations dans l'onglet du certificat au niveau de la barre d'adresse du navigateur.

Les certificats auto-générés sont déconseillés.

En attente de vous lire
30/03/2011, 14h44
rougui
Bonjour,
je suis en stage, je commence avec la programmation android. Là je dois accéder à un serveur qui n'accepte que les connexions TCP sur un port avec protocole SSL.
Donc j'ai cherché du coté de SSLSocket, j'ai vu une doc qui dit qu'il suffit juste chez le client d'ajouter que les deux :
Code:

1 2 SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault(); SSLSocket s = (SSLSocket) sf.createSocket(host , port );
Ils disent que la partie "poignée de main" certificat est directement gérée par java.

Avec ça je connecte bien la socket (car je recupère une session dessus) mais je bloque à la recupération des inputStream/ outputstream,
Donc j'ai trouvé une autre doc qui dit qu'il faut que mon client partage le même certificat que le serveur, généré du côté serveur.
Pourriez -vous m'éclaircir la méthode à adopter et comment utiliser ce certificat sous android.
Merci de me proposer des docs ou d'autres forums.
04/04/2011, 16h42
Roberto125

Bonjour,

adoptez alors un certificat FREE SSL s'il ne s'agit que de faire des tests.
En effet, ce certificat est gratuit et ce avec une validité de 30 jours.
05/04/2011, 22h10
PaloPalo
Bonsoir,

J'ai un peu de peine à cerner tes réponses roberto.

Le but du code java que j'essaie de faire et d'authentifier mon serveur, puis d'authentifier mon client. Donc il y a plusieurs chose à faire.
1. Demander le certificat du CA et le vérifier
2. Envoyer mon propre certificat client auto signer (en dur sur le client et sotcker dans une base de donner du serveur)
Mon problème vient du faite que j'arrive pas à trouver des méthodes ou des techniques qui me permettent de demander des informations du certificat du serveur en SSL.

Je pense avoir trouvé ce qu'il me fallait. Je créé un nouveau Trustmanager, je créé un .BKS avec mes certificats (à l'aide de l'outils "portecle") et je l'ajoute aux ressources android (dossier "raw").

Voilà ce que ça donne pour le moment

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    public void setHTTPS() throws IOException, KeyManagementException, KeyStoreException, NoSuchAlgorithmException, CertificateException{
    String host = URL;
    URL myurl = new URL(host);
 
    String trustStoreFileName = PATHKEYSTORE;
    String trustStorePassword = PASSKEYSTORE;
 
      TrustManager[] trustManagers = createTrustManagers(trustStoreFileName, trustStorePassword);
 
      SSLContext sslContext=SSLContext.getInstance("TLS");
      sslContext.init(null,trustManagers,null);
      HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
 
      //Chargement de la page...
      HttpsURLConnection con = (HttpsURLConnection)myurl.openConnection();
      con.connect();
 
  }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    private TrustManager[] createTrustManagers(String trustStoreFileName, String trustStorePassword) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException {
      //create keystore object, load it with truststorefile data
      KeyStore trustStore = KeyStore.getInstance("BKS");
 
      //create Inputstream to truststore file
      InputStream inputstream = this.getResources().openRawResource(R.raw.mykeystore);
      //InputStream inputStream = new java.io.FileInputStream(trustStoreFileName);
 
 
      // Initialize the keystore with the provided trusted certificates
      // Also provide the password of the keystore
      trustStore.load(inputstream, trustStorePassword.toCharArray());
 
      //create trustmanager factory and load the keystore object in it 
      TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
      trustManagerFactory.init(trustStore);
 
      return trustManagerFactory.getTrustManagers();
    }

Donc ce code représente l'authentification du serveur sans le "accepte all" qu'on retrouve presque partout dans les codes d'exemples