Java X509KeyManager.getCertificateChain方法代碼示例

import javax.net.ssl.X509KeyManager; //導入方法依賴的package包/類
private void test_X509KeyManager_alias(X509KeyManager km, String alias, String keyType) {
    if (alias == null) {
        assertNull(km.getCertificateChain(alias));
        assertNull(km.getPrivateKey(alias));
        return;
    }

    X509Certificate[] certificateChain = km.getCertificateChain(alias);
    PrivateKey privateKey = km.getPrivateKey(alias);

    if (keyType == null) {
        keyType = privateKey.getAlgorithm();
    } else {
        assertEquals(keyType, certificateChain[0].getPublicKey().getAlgorithm());
        assertEquals(keyType, privateKey.getAlgorithm());
    }

    PrivateKeyEntry privateKeyEntry
            = TestKeyStore.privateKey(TEST_KEY_STORE.keyStore,
                                      TEST_KEY_STORE.storePassword,
                                      keyType);
    assertEquals(Arrays.asList(privateKeyEntry.getCertificateChain()),
                 Arrays.asList(certificateChain));
    assertEquals(privateKeyEntry.getPrivateKey(), privateKey);
}
 

import javax.net.ssl.X509KeyManager; //導入方法依賴的package包/類
/** 
 * Create a key manager which manages one single key.  
 */ 
private KeyManager createSingleKeyManager(KeyStore keyStore,String alias,Secret privKeyPasswd) throws Exception
{
    KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX509");

    keyManagerFactory.init(keyStore, privKeyPasswd.getChars());
    X509KeyManager managerImpl = (X509KeyManager)keyManagerFactory.getKeyManagers()[0];
    X509Certificate[] chain = managerImpl.getCertificateChain(alias); 

    // === //
    
    PrivateKey privKey ;
    privKey=(PrivateKey)keyStore.getKey(alias,privKeyPasswd.getChars());
    
    PrivateX509KeyManager manager=new PrivateX509KeyManager(chain,privKey); 
   
    for (X509Certificate cert:chain)
    {
        logger.debugPrintf("--- my cert chain ---\n"); 
        logger.debugPrintf(" - subject %s\n",cert.getSubjectDN()); 
    }

    return manager;
}
 

import javax.net.ssl.X509KeyManager; //導入方法依賴的package包/類
@Override
public X509Certificate[] getCertificateChain(final String alias) {
    for (final X509KeyManager keyManager : keyManagers) {
        final X509Certificate[] chain = keyManager.getCertificateChain(alias);
        if (chain != null && chain.length > 0) {
            return chain;
        }
    }
    return null;
}
 

import javax.net.ssl.X509KeyManager; //導入方法依賴的package包/類
void setCertificate(String alias) throws CertificateEncodingException, SSLException {
    if (alias == null) {
        return;
    }
    X509KeyManager keyManager = parameters.getX509KeyManager();
    if (keyManager == null) {
        return;
    }
    PrivateKey privateKey = keyManager.getPrivateKey(alias);
    if (privateKey == null) {
        return;
    }
    localCertificates = keyManager.getCertificateChain(alias);
    if (localCertificates == null) {
        return;
    }
    int numLocalCerts = localCertificates.length;
    PublicKey publicKey = (numLocalCerts > 0) ? localCertificates[0].getPublicKey() : null;

    // Encode the local certificates.
    byte[][] encodedLocalCerts = new byte[numLocalCerts][];
    for (int i = 0; i < numLocalCerts; ++i) {
        encodedLocalCerts[i] = localCertificates[i].getEncoded();
    }

    // Convert the key so we can access a native reference.
    final OpenSSLKey key;
    try {
        key = OpenSSLKey.fromPrivateKeyForTLSStackOnly(privateKey, publicKey);
    } catch (InvalidKeyException e) {
        throw new SSLException(e);
    }

    // Set the local certs and private key.
    NativeCrypto.setLocalCertsAndPrivateKey(ssl, encodedLocalCerts, key.getNativeRef());
}
 

import javax.net.ssl.X509KeyManager; //導入方法依賴的package包/類
private void test_X509KeyManager_alias(X509KeyManager km, String alias, String keyType,
        boolean many, boolean empty) throws Exception {
    if (empty || (!many && (keyType == null || keyType.isEmpty()))) {
        assertNull(keyType, alias);
        assertNull(keyType, km.getCertificateChain(alias));
        assertNull(keyType, km.getPrivateKey(alias));
        return;
    }
    assertNotNull(keyType, alias);

    X509Certificate[] certificateChain = km.getCertificateChain(alias);
    PrivateKey privateKey = km.getPrivateKey(alias);

    String keyAlgName = privateKey.getAlgorithm();

    X509Certificate certificate = certificateChain[0];
    assertEquals(keyType, keyAlgName, certificate.getPublicKey().getAlgorithm());

    String sigAlgName = certificate.getSigAlgName();

    PrivateKeyEntry privateKeyEntry = getTestKeyStore().getPrivateKey(keyAlgName, sigAlgName);

    assertEquals(keyType, Arrays.asList(privateKeyEntry.getCertificateChain()),
            Arrays.<Certificate>asList(certificateChain));
    assertEquals(keyType, privateKeyEntry.getPrivateKey(), privateKey);

    if (keyType != null) {
        assertEquals(TestKeyStore.keyAlgorithm(keyType), keyAlgName);

        // Skip this when we're given only "DH" or "EC" instead of "DH_DSA",
        // "EC_RSA", etc. since we don't know what the expected
        // algorithm was.
        if (!keyType.equals("DH") && !keyType.equals("EC")) {
            assertTrue(sigAlgName.contains(TestKeyStore.signatureAlgorithm(keyType)));
        }
    }
}
 

import javax.net.ssl.X509KeyManager; //導入方法依賴的package包/類
public synchronized X509Certificate[] getCertificateChain(String alias) {
    String[] parts = alias.split(SEP, 2);
    String description = parts[0];
    alias = parts[1];
    X509KeyManager km = (X509KeyManager) _managers.get(description);
    return km.getCertificateChain(alias);
}
 

import javax.net.ssl.X509KeyManager; //導入方法依賴的package包/類
/**
 * Returns the first non-null certificate chain associated with the given alias, or {@code null}
 * if the alias can't be found.
 */
@Override
public @Nullable X509Certificate[] getCertificateChain(String alias){
	for (List<X509KeyManager> keyManagers : keyManagers.values()) {
		for (X509KeyManager x509KeyManager : keyManagers) {
			X509Certificate[] chain = x509KeyManager.getCertificateChain(alias);
			if (chain != null && chain.length > 0) {
				return chain;
			}
		}
	}
	return null;
}