Java X509CertificateFactory类代码示例

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Override
protected void configure() {
    bind(EncryptionKeyStore.class).to(HubEncryptionKeyStore.class).asEagerSingleton();
    bind(SigningKeyStore.class).annotatedWith(Names.named("authnRequestKeyStore")).to(AuthnRequestKeyStore.class).asEagerSingleton();
    bind(SigningKeyStore.class).annotatedWith(Names.named("samlResponseFromMatchingServiceKeyStore")).to(SamlResponseFromMatchingServiceKeyStore.class).asEagerSingleton();
    bind(X509CertificateFactory.class).toInstance(new X509CertificateFactory());
    bind(CertificateChainValidator.class);
    bind(PKIXParametersProvider.class).toInstance(new PKIXParametersProvider());
    bind(CertificatesConfigProxy.class);
    bind(TrustStoreForCertificateProvider.class);
    bind(EncryptionCredentialFactory.class);
    bind(KeyStoreCache.class);
    bind(KeyStoreLoader.class).toInstance(new KeyStoreLoader());
    bind(SignatureFactory.class);
    bind(IdaKeyStoreCredentialRetriever.class);
    bind(SamlResponseAssertionEncrypter.class);
    bind(AssertionBlobEncrypter.class);
    bind(EncrypterFactory.class).toInstance(new EncrypterFactory());
    bind(SignatureAlgorithm.class).toInstance(new SignatureRSASHA1());
    bind(DigestAlgorithm.class).toInstance(new DigestSHA256());
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
public static AttributeQueryToElementTransformer getAttributeQueryToElementTransformer(SignatureAlgorithm signatureAlgorithm, DigestAlgorithm digestAlgorithm, String hubEntityId) {
    PublicKeyFactory publicKeyFactory = new PublicKeyFactory(new X509CertificateFactory());
    PrivateKey privateKey = new PrivateKeyFactory().createPrivateKey(Base64.decodeBase64(TestCertificateStrings.PRIVATE_SIGNING_KEYS.get(TestEntityIds.HUB_ENTITY_ID)));
    PublicKey publicKey = publicKeyFactory.createPublicKey(TestCertificateStrings.getPrimaryPublicEncryptionCert(TestEntityIds.HUB_ENTITY_ID));

    PrivateKey privateEncryptionKey = new PrivateKeyFactory().createPrivateKey(Base64.decodeBase64(TestCertificateStrings.HUB_TEST_PRIVATE_ENCRYPTION_KEY));
    PublicKey publicEncryptionKey = publicKeyFactory.createPublicKey(TestCertificateStrings.HUB_TEST_PUBLIC_ENCRYPTION_CERT);

    KeyPair encryptionKeyPair = new KeyPair(publicEncryptionKey, privateEncryptionKey);

    KeyPair signingKeyPair = new KeyPair(publicKey, privateKey);
    IdaKeyStore keyStore = new IdaKeyStore(signingKeyPair, Collections.singletonList(encryptionKeyPair));

    IdaKeyStoreCredentialRetriever privateCredentialFactory = new IdaKeyStoreCredentialRetriever(keyStore);
    return new AttributeQueryToElementTransformer(
            new SigningRequestAbstractTypeSignatureCreator<>(new SignatureFactory(privateCredentialFactory, signatureAlgorithm, digestAlgorithm)),
            new SamlAttributeQueryAssertionSignatureSigner(privateCredentialFactory, new OpenSamlXmlObjectFactory(), hubEntityId),
            new SamlSignatureSigner<>(),
            new XmlObjectToElementTransformer<>(),
            new SamlAttributeQueryAssertionEncrypter(new EncryptionCredentialFactory(new HardCodedKeyStore(hubEntityId)), new EncrypterFactory(), requestId -> TEST_RP_MS)
    );
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Before
public void setup() throws Exception {
    PublicKeyFactory publicKeyFactory = new PublicKeyFactory(new X509CertificateFactory());
    PrivateKey privateKey = new PrivateKeyFactory().createPrivateKey(Base64.decodeBase64(TestCertificateStrings.PRIVATE_SIGNING_KEYS.get(HUB_ENTITY_ID)));
    PublicKey publicKey = publicKeyFactory.createPublicKey(TestCertificateStrings.getPrimaryPublicEncryptionCert(HUB_ENTITY_ID));

    PrivateKey privateEncryptionKey = new PrivateKeyFactory().createPrivateKey(Base64.decodeBase64(TestCertificateStrings.HUB_TEST_PRIVATE_ENCRYPTION_KEY));
    PublicKey publicEncryptionKey = publicKeyFactory.createPublicKey(TestCertificateStrings.HUB_TEST_PUBLIC_ENCRYPTION_CERT);

    KeyPair encryptionKeyPair = new KeyPair(publicEncryptionKey, privateEncryptionKey);

    KeyPair signingKeyPair = new KeyPair(publicKey, privateKey);
    IdaKeyStore keyStore = new IdaKeyStore(signingKeyPair, Collections.singletonList(encryptionKeyPair));

    assertionDecrypter = new AssertionDecrypter(new IdaKeyStoreCredentialRetriever(
            keyStore),
            new EncryptionAlgorithmValidator(),
            new DecrypterFactory());
    setUpMatchingService();
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Test
public void createResponse_shouldReturnValidSamlResponse() throws Exception {
    PublicKeyFactory publicKeyFactory = new PublicKeyFactory(new X509CertificateFactory());
    PrivateKey privateKey = new PrivateKeyFactory().createPrivateKey(Base64.decodeBase64(TestCertificateStrings.PRIVATE_SIGNING_KEYS.get(TestEntityIds.STUB_IDP_ONE)));
    PublicKey publicKey = publicKeyFactory.createPublicKey(TestCertificateStrings.getPrimaryPublicEncryptionCert(TestEntityIds.HUB_ENTITY_ID));

    PrivateKey privateEncryptionKey = new PrivateKeyFactory().createPrivateKey(Base64.decodeBase64(TestCertificateStrings.HUB_TEST_PRIVATE_ENCRYPTION_KEY));
    PublicKey publicEncryptionKey = publicKeyFactory.createPublicKey(TestCertificateStrings.HUB_TEST_PUBLIC_ENCRYPTION_CERT);

    KeyPair encryptionKeyPair = new KeyPair(publicEncryptionKey, privateEncryptionKey);

    KeyPair signingKeyPair = new KeyPair(publicKey, privateKey);
    IdaKeyStore keyStore = new IdaKeyStore(signingKeyPair, Arrays.asList(encryptionKeyPair));
    ExceptionResponseFactory exceptionResponseFactory = new ExceptionResponseFactory(new OpenSamlXmlObjectFactory(), new IdaKeyStoreCredentialRetriever(keyStore), new IdGenerator());

    String errorMessage = "some message";
    String requestId = UUID.randomUUID().toString();
    Element element = exceptionResponseFactory.createResponse(requestId, TEST_ENTITY_ID, errorMessage);

    Response attributeQueryResponse = (Response) XMLObjectProviderRegistrySupport.getUnmarshallerFactory().getUnmarshaller(element).unmarshall(element);

    assertThat(attributeQueryResponse.getStatus().getStatusCode().getValue()).isEqualTo(StatusCode.REQUESTER);
    assertThat(attributeQueryResponse.getStatus().getStatusMessage().getMessage()).isEqualTo(errorMessage);
    assertThat(attributeQueryResponse.getInResponseTo()).isEqualTo(requestId);
    assertThat(attributeQueryResponse.getIssuer().getValue()).isEqualTo(TEST_ENTITY_ID);
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Override
protected void configure() {
    bind(TrustStoreConfiguration.class).to(SamlProxyConfiguration.class);
    bind(RestfulClientConfiguration.class).to(SamlProxyConfiguration.class);
    bind(PublicKeyInputStreamFactory.class).toInstance(new PublicKeyFileInputStreamFactory());
    bind(SigningKeyStore.class).to(AuthnRequestKeyStore.class);
    bind(Client.class).toProvider(DefaultClientProvider.class).in(Scopes.SINGLETON);
    bind(EventSinkProxy.class).to(EventSinkHttpProxy.class);
    bind(KeyStore.class).toProvider(KeyStoreProvider.class).in(Scopes.SINGLETON);
    bind(ConfigServiceKeyStore.class).asEagerSingleton();
    bind(KeyStoreLoader.class).toInstance(new KeyStoreLoader());
    bind(ResponseMaxSizeValidator.class);
    bind(ExpiredCertificateMetadataFilter.class).toInstance(new ExpiredCertificateMetadataFilter());
    bind(X509CertificateFactory.class).toInstance(new X509CertificateFactory());
    bind(CertificateChainValidator.class);
    bind(CertificatesConfigProxy.class);
    bind(TrustStoreForCertificateProvider.class);
    bind(StringSizeValidator.class).toInstance(new StringSizeValidator());
    bind(JsonResponseProcessor.class);
    bind(ObjectMapper.class).toInstance(new ObjectMapper());
    bind(PKIXParametersProvider.class).toInstance(new PKIXParametersProvider());
    bind(RelayStateValidator.class).toInstance(new RelayStateValidator());
    bind(ProtectiveMonitoringLogFormatter.class).toInstance(new ProtectiveMonitoringLogFormatter());
    bind(KeyStoreCache.class);
    bind(EventSinkMessageSender.class);
    bind(ExceptionAuditor.class);
    bind(ProtectiveMonitoringLogger.class);
    bind(SessionProxy.class);
    bind(new TypeLiteral<LevelLoggerFactory<SamlProxySamlTransformationErrorExceptionMapper>>(){}).toInstance(new LevelLoggerFactory<>());
    bind(new TypeLiteral<LevelLoggerFactory<NoKeyConfiguredForEntityExceptionMapper>>(){}).toInstance(new LevelLoggerFactory<>());
    bind(new TypeLiteral<LevelLoggerFactory<SamlProxyApplicationExceptionMapper>>(){}).toInstance(new LevelLoggerFactory<>());
    bind(new TypeLiteral<LevelLoggerFactory<SamlProxyExceptionMapper>>(){}).toInstance(new LevelLoggerFactory<>());
    bind(SamlMessageSenderHandler.class);
    bind(ExternalCommunicationEventLogger.class);
    bind(IpAddressResolver.class).toInstance(new IpAddressResolver());
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Inject
public ConfigServiceKeyStore(
        CertificatesConfigProxy certificatesConfigProxy,
        CertificateChainValidator certificateChainValidator,
        TrustStoreForCertificateProvider trustStoreForCertificateProvider,
        X509CertificateFactory x509CertificateFactory) {

    this.certificatesConfigProxy = certificatesConfigProxy;
    this.certificateChainValidator = certificateChainValidator;
    this.trustStoreForCertificateProvider = trustStoreForCertificateProvider;
    this.x509CertificateFactory = x509CertificateFactory;
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
private static IdaKeyStore getKeyStore() throws Base64DecodingException {
    List<KeyPair> encryptionKeyPairs = new ArrayList<>();
    PublicKeyFactory publicKeyFactory = new PublicKeyFactory(new X509CertificateFactory());
    PrivateKeyFactory privateKeyFactory = new PrivateKeyFactory();
    PublicKey encryptionPublicKey = publicKeyFactory.createPublicKey(HUB_TEST_PUBLIC_ENCRYPTION_CERT);
    PrivateKey encryptionPrivateKey = privateKeyFactory.createPrivateKey(Base64.getDecoder().decode(HUB_TEST_PRIVATE_ENCRYPTION_KEY.getBytes()));
    encryptionKeyPairs.add(new KeyPair(encryptionPublicKey, encryptionPrivateKey));
    PublicKey publicSigningKey = publicKeyFactory.createPublicKey(HUB_TEST_PUBLIC_SIGNING_CERT);
    PrivateKey privateSigningKey = privateKeyFactory.createPrivateKey(Base64.getDecoder().decode(HUB_TEST_PRIVATE_SIGNING_KEY.getBytes()));
    KeyPair signingKeyPair = new KeyPair(publicSigningKey, privateSigningKey);

    return new IdaKeyStore(signingKeyPair, encryptionKeyPairs);
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Provides
@Singleton
private IdaKeyStore getKeyStore(X509CertificateFactory certificateFactory, SamlEngineConfiguration configuration) {
    Map<KeyPosition, PrivateKey> privateKeyStore = privateEncryptionKeys(configuration);

    DeserializablePublicKeyConfiguration publicSigningKeyConfiguration = configuration.getPublicSigningCert();
    String encodedSigningCertificate = publicSigningKeyConfiguration.getCert();
    X509Certificate signingCertificate = encodedSigningCertificate != null ? certificateFactory.createCertificate(encodedSigningCertificate) : null;

    KeyPair primaryEncryptionKeyPair = Crypto.keyPairFromPrivateKey(privateKeyStore.get(KeyPosition.PRIMARY));
    KeyPair secondaryEncryptionKeyPair = Crypto.keyPairFromPrivateKey(privateKeyStore.get(KeyPosition.SECONDARY));
    KeyPair signingKeyPair = Crypto.keyPairFromPrivateKey(privateSigningKey(configuration));

    return new IdaKeyStore(signingCertificate, signingKeyPair, asList(primaryEncryptionKeyPair, secondaryEncryptionKeyPair));
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
private String aValidMatchResponseFromMatchingService(final String requestId, final Status status, DateTime notOnOrAfter) throws MarshallingException, SignatureException {
    Credential signingCredential = new TestCredentialFactory(TEST_RP_MS_PUBLIC_SIGNING_CERT, TEST_RP_MS_PRIVATE_SIGNING_KEY).getSigningCredential();
    return XmlUtils.writeToString(aResponse()
            .withStatus(status)
            .withInResponseTo(requestId)
            .withIssuer(anIssuer().withIssuerId(TEST_RP_MS).build())
            .withSigningCredential(signingCredential)
            .addEncryptedAssertion(
                    anAssertion()
                            .withSubject(
                                    aSubject()
                                            .withSubjectConfirmation(
                                                    aSubjectConfirmation()
                                                            .withSubjectConfirmationData(
                                                                    aSubjectConfirmationData()
                                                                            .withInResponseTo(requestId)
                                                                            .withNotOnOrAfter(
                                                                                    notOnOrAfter
                                                                            )
                                                                            .build()
                                                            )
                                                            .build()
                                            )
                                            .build()
                            )
                            .withIssuer(anIssuer().withIssuerId(TEST_RP_MS).build())
                            .withSignature(aSignature().withSigningCredential(signingCredential).build())
                            .addAuthnStatement(anAuthnStatement().build())
                            .buildWithEncrypterCredential(new EncryptionCredentialFactory(entityId -> {
                                PublicKeyFactory keyFactory = new PublicKeyFactory(new X509CertificateFactory());
                                return keyFactory.createPublicKey(HUB_TEST_PUBLIC_ENCRYPTION_CERT);
                            }).getEncryptingCredential(HUB_ENTITY_ID))
            ).build().getDOM());
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
private String aValidMatchResponseFromMatchingService(final String requestId, final Status status, DateTime notOnOrAfter) throws MarshallingException, SignatureException {
    return XmlUtils.writeToString(aResponse()
            .withStatus(status)
            .withInResponseTo(requestId)
            .withIssuer(anIssuer().withIssuerId(TEST_RP_MS).build())
            .withSigningCredential(msaSigningCredential)
            .addEncryptedAssertion(
                    anAssertion()
                            .withSubject(
                                    aSubject()
                                            .withSubjectConfirmation(
                                                    aSubjectConfirmation()
                                                            .withSubjectConfirmationData(
                                                                    aSubjectConfirmationData()
                                                                            .withInResponseTo(requestId)
                                                                            .withNotOnOrAfter(
                                                                                    notOnOrAfter
                                                                            )
                                                                            .build()
                                                            )
                                                            .build()
                                            )
                                            .build()
                            )
                            .withIssuer(anIssuer().withIssuerId(TEST_RP_MS).build())
                            .withSignature(
                                    aSignature().withSigningCredential(msaSigningCredential).build()
                            )
                            .addAuthnStatement(anAuthnStatement().build())
                            .buildWithEncrypterCredential(new EncryptionCredentialFactory(entityId -> {
                                PublicKeyFactory keyFactory = new PublicKeyFactory(new X509CertificateFactory());
                                return keyFactory.createPublicKey(HUB_TEST_PUBLIC_ENCRYPTION_CERT);
                            }).getEncryptingCredential(HUB_ENTITY_ID))
            ).build().getDOM());
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
private String aValidMatchResponseFromMatchingServiceWithMissingData(final String requestId, final Status status, String msaEntityId) throws MarshallingException, SignatureException {
    return XmlUtils.writeToString(aResponse()
            .withStatus(status)
            .withInResponseTo(requestId)
            .withIssuer(anIssuer().withIssuerId(msaEntityId).build())
            .withSigningCredential(msaSigningCredential)
            .addEncryptedAssertion(
                    anAssertion()
                            .withSubject(
                                    aSubject()
                                            .withSubjectConfirmation(
                                                    aSubjectConfirmation()
                                                            .withSubjectConfirmationData(
                                                                    aSubjectConfirmationData()
                                                                            .withInResponseTo(requestId)
                                                                            .withNotOnOrAfter(
                                                                                    DateTime.now()
                                                                                            .plusDays(5)
                                                                            )
                                                                            .build()
                                                            )
                                                            .build()
                                            )
                                            .build()
                            )
                            .withIssuer(anIssuer().withIssuerId(msaEntityId).build())
                            .withSignature(
                                    aSignature().withSigningCredential(msaSigningCredential).build()
                            )
                            .buildWithEncrypterCredential(new EncryptionCredentialFactory(entityId -> {
                                PublicKeyFactory keyFactory = new PublicKeyFactory(new X509CertificateFactory());
                                return keyFactory.createPublicKey(HUB_TEST_PUBLIC_ENCRYPTION_CERT);
                            }).getEncryptingCredential(HUB_ENTITY_ID))
            ).build().getDOM());
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
private IdaKeyStore getKeyStore() throws Base64DecodingException {
    List<KeyPair> encryptionKeyPairs = new ArrayList<>();
    PublicKeyFactory publicKeyFactory = new PublicKeyFactory(new X509CertificateFactory());
    PrivateKeyFactory privateKeyFactory = new PrivateKeyFactory();
    PublicKey encryptionPublicKey = publicKeyFactory.createPublicKey(HUB_TEST_PUBLIC_ENCRYPTION_CERT);
    PrivateKey encryptionPrivateKey = privateKeyFactory.createPrivateKey(Base64.getDecoder().decode(HUB_TEST_PRIVATE_ENCRYPTION_KEY.getBytes()));
    encryptionKeyPairs.add(new KeyPair(encryptionPublicKey, encryptionPrivateKey));
    PublicKey publicSigningKey = publicKeyFactory.createPublicKey(HUB_TEST_PUBLIC_SIGNING_CERT);
    PrivateKey privateSigningKey = privateKeyFactory.createPrivateKey(Base64.getDecoder().decode(HUB_TEST_PRIVATE_SIGNING_KEY.getBytes()));
    KeyPair signingKeyPair = new KeyPair(publicSigningKey, privateSigningKey);

    return new IdaKeyStore(signingKeyPair, encryptionKeyPairs);
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Test
public void run_shouldThrowCertChainValidationExceptionOnResponse() throws Exception {
    when(attributeQueryRequestClient.sendQuery(any(Element.class), anyString(), any(SessionId.class), any(URI.class))).thenReturn(matchingServiceResponse);
    final BasicX509Credential x509Credential = new BasicX509Credential(
            new X509CertificateFactory().createCertificate(UNCHAINED_PUBLIC_CERT),
            new PrivateKeyFactory().createPrivateKey(Base64.decode(UNCHAINED_PRIVATE_KEY.getBytes())));
    Response response = aResponse().withSigningCredential(x509Credential).withIssuer(anIssuer().withIssuerId("issuer-id").build()).build();
    when(elementToResponseTransformer.apply(matchingServiceResponse)).thenReturn(response);
    executeAttributeQueryRequest.execute(sessionId, attributeQueryContainerDto);

    verify(matchingResponseSignatureValidator).validate(response, AttributeAuthorityDescriptor.DEFAULT_ELEMENT_NAME);
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Override
protected void configure() {
    bind(ConfigHealthCheck.class).asEagerSingleton();
    bind(ConfigDataBootstrap.class).asEagerSingleton();
    bind(TrustStoreConfiguration.class).to(ConfigConfiguration.class);
    bind(new TypeLiteral<ConfigurationFactoryFactory<IdentityProviderConfigEntityData>>() {}).toInstance(new DefaultConfigurationFactoryFactory<IdentityProviderConfigEntityData>());
    bind(new TypeLiteral<ConfigurationFactoryFactory<TransactionConfigEntityData>>(){}).toInstance(new DefaultConfigurationFactoryFactory<TransactionConfigEntityData>());
    bind(new TypeLiteral<ConfigurationFactoryFactory<MatchingServiceConfigEntityData>>(){}).toInstance(new DefaultConfigurationFactoryFactory<MatchingServiceConfigEntityData>());
    bind(new TypeLiteral<ConfigurationFactoryFactory<CountriesConfigEntityData>>(){}).toInstance(new DefaultConfigurationFactoryFactory<CountriesConfigEntityData>());
    bind(new TypeLiteral<ConfigDataSource<TransactionConfigEntityData>>() {}).to(FileBackedTransactionConfigDataSource.class).asEagerSingleton();
    bind(new TypeLiteral<ConfigDataSource<MatchingServiceConfigEntityData>>() {}).to(FileBackedMatchingServiceConfigDataSource.class).asEagerSingleton();
    bind(new TypeLiteral<ConfigDataSource<IdentityProviderConfigEntityData>>() {}).to(FileBackedIdentityProviderConfigDataSource.class).asEagerSingleton();
    bind(new TypeLiteral<ConfigDataSource<CountriesConfigEntityData>>() {}).to(FileBackedCountriesConfigDataSource.class).asEagerSingleton();
    bind(new TypeLiteral<ConfigEntityDataRepository<TransactionConfigEntityData>>(){}).asEagerSingleton();
    bind(new TypeLiteral<ConfigEntityDataRepository<CountriesConfigEntityData>>(){}).asEagerSingleton();
    bind(new TypeLiteral<ConfigEntityDataRepository<MatchingServiceConfigEntityData>>(){}).asEagerSingleton();
    bind(new TypeLiteral<ConfigEntityDataRepository<IdentityProviderConfigEntityData>>(){}).asEagerSingleton();
    bind(ObjectMapper.class).toInstance(new ObjectMapper().registerModule(new GuavaModule()));
    bind(LevelsOfAssuranceConfigValidator.class).toInstance(new LevelsOfAssuranceConfigValidator());
    bind(CertificateChainConfigValidator.class);
    bind(CertificateChainValidator.class);
    bind(TrustStoreForCertificateProvider.class);
    bind(X509CertificateFactory.class).toInstance(new X509CertificateFactory());
    bind(KeyStoreCache.class);
    bind(ExceptionFactory.class);
    bind(OCSPCertificateChainValidityChecker.class);
    bind(EntityConfigDataToCertificateDtoTransformer.class);
    bind(OCSPCertificateChainValidator.class);
    bind(IdpPredicateFactory.class);
    bind(KeyStoreLoader.class).toInstance(new KeyStoreLoader());
    bind(OCSPPKIXParametersProvider.class).toInstance(new OCSPPKIXParametersProvider());
    bind(PKIXParametersProvider.class).toInstance(new PKIXParametersProvider());
}
 

import uk.gov.ida.common.shared.security.X509CertificateFactory; //导入依赖的package包/类
@Override
protected void configure() {

    bind(PKIXParametersProvider.class).toInstance(new PKIXParametersProvider());
    bind(SoapMessageManager.class).toInstance(new SoapMessageManager());
    bind(X509CertificateFactory.class);
    bind(KeyStoreLoader.class);
    bind(IdGenerator.class);
    bind(IdaKeyStoreCredentialRetriever.class);
    bind(ExpiredCertificateMetadataFilter.class);
    bind(ExceptionResponseFactory.class);
    bind(InboundMatchingServiceRequestToMatchingServiceRequestDtoMapper.class);
    bind(MatchingServiceResponseDtoToOutboundResponseFromMatchingServiceMapper.class);
    bind(MatchingServiceAdapterMetadataRepository.class);
    bind(DocumentToInboundMatchingServiceRequestMapper.class);
    bind(IdGenerator.class);
    bind(MatchingServiceAssertionFactory.class);
    bind(UserAccountCreationAttributeExtractor.class);
    bind(UnknownUserAttributeQueryHandler.class);

    bind(SigningKeyStore.class).to(MetadataPublicKeyStore.class).in(Singleton.class);
    bind(EncryptionKeyStore.class).to(MetadataPublicKeyStore.class).in(Singleton.class);
    bind(PublicKeyInputStreamFactory.class).to(PublicKeyFileInputStreamFactory.class).in(Singleton.class);
    bind(AssertionLifetimeConfiguration.class).to(MatchingServiceAdapterConfiguration.class).in(Singleton.class);
    bind(MatchingServiceProxy.class).to(MatchingServiceProxyImpl.class).in(Singleton.class);
    bind(ManifestReader.class).toInstance(new ManifestReader());
    bind(MatchingDatasetToMatchingDatasetDtoMapper.class).toInstance(new MatchingDatasetToMatchingDatasetDtoMapper());
}