javax.net.ssl.ManagerFactoryParameters Java Examples

@Override
protected void engineInit(ManagerFactoryParameters params) throws
        InvalidAlgorithmParameterException {
    if (params instanceof KeyStoreBuilderParameters == false) {
        throw new InvalidAlgorithmParameterException(
        "Parameters must be instance of KeyStoreBuilderParameters");
    }
    if (OpenJSSE.isFIPS()) {
        throw new InvalidAlgorithmParameterException
            ("FIPS mode: KeyStoreBuilderParameters not supported");
    }
    List<Builder> builders =
        ((KeyStoreBuilderParameters)params).getParameters();
    keyManager = new X509KeyManagerImpl(builders);
    isInitialized = true;
}
 

private Factory(final TrustManagerFactory delegate) {
    super(new TrustManagerFactorySpi() {
        @Override
        protected void engineInit(KeyStore keyStore) {
        }

        @Override
        protected void engineInit(ManagerFactoryParameters managerFactoryParameters) {
        }

        @Override
        protected TrustManager[] engineGetTrustManagers() {
            return new TrustManager[]{new AcceptAnyTrustManager()};
        }
    }, delegate.getProvider(), delegate.getAlgorithm());
}
 

@Override
X509TrustManager getInstance(ManagerFactoryParameters spec)
        throws InvalidAlgorithmParameterException {
    if (spec instanceof CertPathTrustManagerParameters == false) {
        throw new InvalidAlgorithmParameterException
            ("Parameters must be CertPathTrustManagerParameters");
    }
    CertPathParameters params =
        ((CertPathTrustManagerParameters)spec).getParameters();
    if (params instanceof PKIXBuilderParameters == false) {
        throw new InvalidAlgorithmParameterException
            ("Encapsulated parameters must be PKIXBuilderParameters");
    }
    PKIXBuilderParameters pkixParams = (PKIXBuilderParameters)params;
    return new X509TrustManagerImpl(Validator.TYPE_PKIX, pkixParams);
}
 

CustomAliasKeyManagerFactory(KeyManagerFactory delegate, String alias) {
    super(new KeyManagerFactorySpi() {
        @Override
        protected void engineInit(KeyStore ks, char[] password)
                throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException {
            delegate.init(ks, password);
        }

        @Override
        protected void engineInit(ManagerFactoryParameters spec) throws InvalidAlgorithmParameterException {
            delegate.init(spec);
        }

        @Override
        protected KeyManager[] engineGetKeyManagers() {
            final KeyManager[] keyManagers = delegate.getKeyManagers().clone();
            for (int i = 0; i < keyManagers.length; i++) {
                if (keyManagers[i] instanceof X509ExtendedKeyManager) {
                    final X509ExtendedKeyManager keyManager = (X509ExtendedKeyManager) keyManagers[i];
                    keyManagers[i] = new CustomAliasX509ExtendedKeyManager(keyManager, alias);
                }
            }
            return keyManagers;
        }
    }, delegate.getProvider(), delegate.getAlgorithm());
}
 

private DittoTrustManagerFactory(final TrustManagerFactory delegate, final String hostname) {
    super(new TrustManagerFactorySpi() {
        @Override
        protected void engineInit(KeyStore keyStore) throws KeyStoreException {
            delegate.init(keyStore);
        }

        @Override
        protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws
                InvalidAlgorithmParameterException {
            delegate.init(managerFactoryParameters);
        }

        @Override
        protected TrustManager[] engineGetTrustManagers() {
            return DittoTrustManager.wrapTrustManagers(delegate.getTrustManagers(), hostname);
        }
    }, delegate.getProvider(), delegate.getAlgorithm());
}
 

/**
 * Gets an array of TrustManagers for the specified trust store
 * and optional CRL file.
 *
 * @param trustStoreFilename
 * @param trustStorePassword
 * @param trustStoreType
 * @param trustStoreProvider
 * @param trustStoreAlgorithm
 * @param maxCertificatePathLength
 * @param crlFilename
 *
 * @return An array of TrustManagers
 *
 * @throws IOException
 * @throws KeyStoreException
 * @throws NoSuchProviderException
 * @throws NoSuchAlgorithmException
 * @throws CertificateException
 * @throws InvalidAlgorithmParameterException
 * @throws CRLException
 */
protected static TrustManager[] getTrustManagers(String trustStoreFilename,
                                                 String trustStorePassword,
                                                 String trustStoreType,
                                                 String trustStoreProvider,
                                                 String trustStoreAlgorithm,
                                                 Integer maxCertificatePathLength,
                                                 String crlFilename)
    throws IOException, KeyStoreException, NoSuchProviderException, NoSuchAlgorithmException, CertificateException, InvalidAlgorithmParameterException, CRLException
{
    KeyStore trustStore = getStore(trustStoreFilename,
                                   trustStorePassword,
                                   trustStoreType,
                                   trustStoreProvider);

    if(null == trustStoreAlgorithm)
        trustStoreAlgorithm = TrustManagerFactory.getDefaultAlgorithm();

    TrustManagerFactory tmf =
            TrustManagerFactory.getInstance(trustStoreAlgorithm);
    if (null == crlFilename)
    {
        tmf.init(trustStore);
    }
    else
    {
        CertPathParameters params =
            getParameters(trustStoreAlgorithm,
                          crlFilename,
                          maxCertificatePathLength,
                          trustStore);

        ManagerFactoryParameters mfp =
            new CertPathTrustManagerParameters(params);

        tmf.init(mfp);
    }

    return tmf.getTrustManagers();
}
 

@Override
X509TrustManager getInstance(ManagerFactoryParameters spec)
        throws InvalidAlgorithmParameterException {
    throw new InvalidAlgorithmParameterException
        ("SunX509 TrustManagerFactory does not use "
        + "ManagerFactoryParameters");
}
 

@Override
public void engineInit(ManagerFactoryParameters spec)
        throws InvalidAlgorithmParameterException {
    if (!(spec instanceof ApplicationConfigParameters)) {
        throw new InvalidAlgorithmParameterException("Unsupported spec: " +  spec + ". Only "
                + ApplicationConfigParameters.class.getName() + " supported");

    }
    mApplicationConfig = ((ApplicationConfigParameters) spec).config;
}
 

CustomAliasKeyManagerFactory(KeyManagerFactory delegate, String alias) {
    super(new KeyManagerFactorySpi() {
        @Override
        protected void engineInit(KeyStore ks, char[] password)
                throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException {
            delegate.init(ks, password);
        }

        @Override
        protected void engineInit(ManagerFactoryParameters spec) throws
                                                                 InvalidAlgorithmParameterException {
            delegate.init(spec);
        }

        @Override
        protected KeyManager[] engineGetKeyManagers() {
            final KeyManager[] keyManagers = delegate.getKeyManagers().clone();
            for (int i = 0; i < keyManagers.length; i++) {
                if (keyManagers[i] instanceof X509ExtendedKeyManager) {
                    final X509ExtendedKeyManager keyManager = (X509ExtendedKeyManager) keyManagers[i];
                    keyManagers[i] = new CustomAliasX509ExtendedKeyManager(keyManager, alias);
                }
            }
            return keyManagers;
        }
    }, delegate.getProvider(), delegate.getAlgorithm());
}
 

KeySelectingKeyManagerFactory(KeyManagerFactory factory, KeyConfiguration keyConfiguration) {
	super(new KeyManagerFactorySpi() {
		@Override
		protected void engineInit(KeyStore keyStore, char[] chars)
				throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException {
			factory.init(keyStore, chars);
		}

		@Override
		protected void engineInit(ManagerFactoryParameters managerFactoryParameters)
				throws InvalidAlgorithmParameterException {
			factory.init(managerFactoryParameters);
		}

		@Override
		protected KeyManager[] engineGetKeyManagers() {

			KeyManager[] keyManagers = factory.getKeyManagers();

			if (keyManagers.length == 1 && keyManagers[0] instanceof X509ExtendedKeyManager) {

				return new KeyManager[] { new KeySelectingX509KeyManager(
						(X509ExtendedKeyManager) keyManagers[0], keyConfiguration) };
			}

			return keyManagers;
		}
	}, factory.getProvider(), factory.getAlgorithm());
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws InvalidAlgorithmParameterException {
    // noop
}
 

@Override
protected void engineInit(final ManagerFactoryParameters managerFactoryParameters) throws Exception {
    // nothing to do
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws Exception {
  throw new UnsupportedOperationException();
}
 

protected void engineInit(ManagerFactoryParameters mgrparams)
   throws InvalidAlgorithmParameterException
{ 
    throw new InvalidAlgorithmParameterException(
        XTrustProvider.NAME + " does not use ManagerFactoryParameters"); 
 }
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws Exception {}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters)
        throws InvalidAlgorithmParameterException {
    // Unused
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters)
        throws InvalidAlgorithmParameterException {
    // noop
}
 

@Override
protected void engineInit(final ManagerFactoryParameters managerFactoryParameters) { }
 

protected void engineInit(ManagerFactoryParameters mgrparams)
        throws InvalidAlgorithmParameterException
{
    throw new InvalidAlgorithmParameterException(
            XTrustProvider.NAME + " does not use ManagerFactoryParameters");
}
 

@Override
protected void engineInit(@Nullable ManagerFactoryParameters managerFactoryParameters) throws Exception {
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters)
        throws InvalidAlgorithmParameterException {
    // Unused
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) {}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws Exception {
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters)
        throws InvalidAlgorithmParameterException {
    // Unused
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws Exception {
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws Exception { }
 

@Override
protected void engineInit(ManagerFactoryParameters spec) throws InvalidAlgorithmParameterException {
}
 

@Override
protected void engineInit(ManagerFactoryParameters spec) {
    throw new UnsupportedOperationException("engineInit not supported by this KeyManagerFactory");
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) {
}
 

@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters)
        throws InvalidAlgorithmParameterException {
    // noop
}