Comment spécifier sortant alias du certificat HTTPS-appels?

Je vais appeler un service qui nécessite une authentification par certificat client.

Si je spécifier un keystore Java contenant un seul certificat (le certificat du client le service attend), alors tout fonctionne bien. Cependant, si j'utilise un fichier de clés qui contient plusieurs certificats alors je ne peux pas semblent être en mesure de spécifier le certificat doit être récupéré par le client, le client semble prendre le premier certificat disponibles (dans l'ordre alphabétique).

J'ai essayé de la propriété suivante, mais sans résultat attendu:

System.setProperty("com.sun.enterprise.security.httpsOutboundKeyAlias", "my-client-certificate alias");

Comment puis-je spécifier le certificat du client alias qui devraient être utilisés?

Le fichier de clés contiennent également le client de la clé privée, ou vous avez seulement importé une liste de certificats?
Oui, il contient les clients de la clé privée, entre autres clés privées.

OriginalL'auteur aksamit | 2011-03-13

10

Réponse courte: il ne peut être fait avec Java par défaut ssl mise en œuvre.

Réponse longue: j'ai regardé sur la façon de la connexion SSL est mis en œuvre dans le sun.security.ssl.ClientHandshaker. Dans sa méthode serverHelloDone est appelé X509ExtendedKeyManager.chooseClientAlias. Sa mise en oeuvre sont vraiment fait de telle manière qu'ils retournent à la première alias, dont l'entrée correspond à la donnée de l'algorithme à clé et quelques autres choses. Aucune façon comment modifier l'alias de sélection.

Pour ceux qui peuvent changer le code, il semble prometteuse solution de contournement: http://www.44342.com/java-f392-t785-p1.htm

J'ai trouvé le lien pour plus d'sofisticated solution: angelfire.com/or/abhilash/site/articles/jsse-km/...

OriginalL'auteur Jakub
13

Les liens qui Jakub fournit dans sa réponse vous conduire à la réponse, mais je voulais poster une simple réponse ici, car nous avons eu du mal avec ce problème pendant un bon moment avant de finalement arriver quelque chose qui a travaillé.

Nous avons le cas où il existe plusieurs certificats disponibles à utiliser, et nous avons besoin d'utiliser celui qui a un alias spécifique pour effectuer notre connexion. Nous l'avons fait en créant notre propre KeyManager de mise en œuvre qui traverse la plupart de ses fonctionnalités à la valeur par défaut X509KeyManager mais dispose de fonctionnalités pour choisir exactement le bon alias à utiliser lors de la connexion est effectuée.

D'abord le gestionnaire de clés que nous avons créé:
```
public class FilteredKeyManager implements X509KeyManager {

private final X509KeyManager originatingKeyManager;
private final X509Certificate[] x509Certificates;

public FilteredKeyManager(X509KeyManager originatingKeyManager, X509Certificate[] x509Certificates) {
    this.originatingKeyManager = originatingKeyManager;
    this.x509Certificates = x509Certificates;
}

public X509Certificate[] getCertificateChain(String alias) {
    return x509Certificates;
}

public String[] getClientAliases(String keyType, Principal[] issuers) {
    return new String[] {"DesiredClientCertAlias"};
}
```
Toutes les autres méthodes nécessaires pour la mise en œuvre sont passthroughs à originatingKeyManager.

Puis, lorsque nous avons effectivement mis en place le contexte:
```
SSLContext context = SSLContext.getInstance("TLSv1");
context.init(new KeyManager[] { new FilteredKeyManager((X509KeyManager)originalKeyManagers[0], desiredCertsForConnection) },
    trustManagerFactory.getTrustManagers(), new SecureRandom());
```
L'espoir qu'il soit clair, et travaille pour quelqu'un d'autre tente de résoudre ce problème.

Si c'est de l'intérêt, c'est ce que le gestionnaire de clés enveloppe ne ici: code.google.com/p/jsslutils/wiki/SSLContextFactory Il devrait être facile de changer le FixedServerAliasKeyManager pour une utilisation sur le côté client plutôt que du côté serveur.

OriginalL'auteur zarniwoop

Heres un code complet ciselée qui fonctionne.

- Je l'utiliser pour créer une connexion SSL sur Android avec un fichier de clés à partir d'une carte à puce qui contient plusieurs certificats correspondant à la norme de critères de filtrage.

Les crédits vont à zarniwoop.

/**
* filters the SSLCertificate we want to use for SSL
* <code>
* KeyManagerFactory kmf = KeyManagerFactory.getInstance("X509");
* kmf.init(keyStore, null);
* String SSLCertificateKeyStoreAlias = keyStore.getCertificateAlias(sslCertificate);
* KeyManager[] keyManagers = new KeyManager[] { new FilteredKeyManager((X509KeyManager)kmf.getKeyManagers()[0], sslCertificate, SSLCertificateKeyStoreAlias) };
* </code>
*/
private class FilteredKeyManager implements X509KeyManager {
private final X509KeyManager originatingKeyManager;
private final X509Certificate sslCertificate;
private final String SSLCertificateKeyStoreAlias;
/**
* @param originatingKeyManager,       original X509KeyManager
* @param sslCertificate,              X509Certificate to use
* @param SSLCertificateKeyStoreAlias, Alias of the certificate in the provided keystore
*/
public FilteredKeyManager(X509KeyManager originatingKeyManager, X509Certificate sslCertificate, String SSLCertificateKeyStoreAlias) {
this.originatingKeyManager = originatingKeyManager;
this.sslCertificate = sslCertificate;
this.SSLCertificateKeyStoreAlias = SSLCertificateKeyStoreAlias;
}
@Override
public String chooseClientAlias(String[] keyType, Principal[] issuers, Socket socket) {
return SSLCertificateKeyStoreAlias;
}
@Override
public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
return originatingKeyManager.chooseServerAlias(keyType, issuers, socket);
}
@Override
public X509Certificate[] getCertificateChain(String alias) {
return new X509Certificate[]{ sslCertificate };
}
@Override
public String[] getClientAliases(String keyType, Principal[] issuers) {
return originatingKeyManager.getClientAliases(keyType, issuers);
}
@Override
public String[] getServerAliases(String keyType, Principal[] issuers) {
return originatingKeyManager.getServerAliases(keyType, issuers);
}
@Override
public PrivateKey getPrivateKey(String alias) {
return originatingKeyManager.getPrivateKey(alias);
}
}

OriginalL'auteur Frankie

1

Mon impression de la KeyManager est qu'une fois qu'il est initialisé avec le fichier de clés, il utilise l'alias de la clé privée de l'entrée pour trouver le certificat associé et de la chaîne de certification.

Sinon,je pense qu'il choisit une chaîne basée sur les types de clés et les autorités de certification reconnues par l'hôte.

Donc dans votre cas, votre description ne mentionne pas une entrée privée dans le fichier de clés, donc je suppose que le keymanager choisit le plus adapté certificat.

Je ne suis pas au courant du tout de la système de la propriété que vous mentionnez.

-Essayez de modifier le fichier de clés à disposer d'une clé privée et les associés de la chaîne d'

-Ou (je ne sais pas si cela va fonctionner) de modifier l'alias du certificat que vous souhaitez envoyer au serveur pour faire correspondre le nom du sujet du certificat

Il contient la clé privée en collaboration avec la chaîne. En Utilisant Le Système.setProperty("javax.net.debug", "ssl"); je suis en mesure de vérifier que, lorsque le fichier de clés contient uniquement une entrée, puis il est repris et tout fonctionne bien. À l'aide d'un fichier de clés avec plusieurs clés privées de l'application semble choisir le 1er certificat dans l'ordre où ils apparaissent lorsque vous liste les entrées à l'aide de keytool-commande.
les clés privées?Vous avez dans le keystore plusieurs clés privées et leurs chaînes?Parce que de votre question, je pensais que tu n'avais que plusieurs certificats (seuls les certificats approuvés)

OriginalL'auteur Cratylus

Vous devez vous connecter pour publier un commentaire.