Java Code Examples for java.security.Provider#Service

static SecureRandom getSecureRandom() throws KeyManagementException {
    if (cryptoProvider == null) {
        return new SecureRandom();
    }
    // Try "PKCS11" first. If that is not supported, iterate through
    // the provider and return the first working implementation.
    try {
        return SecureRandom.getInstance("PKCS11", cryptoProvider);
    } catch (NoSuchAlgorithmException e) {
        // ignore
    }
    for (Provider.Service s : cryptoProvider.getServices()) {
        if (s.getType().equals("SecureRandom")) {
            try {
                return SecureRandom.getInstance(s.getAlgorithm(), cryptoProvider);
            } catch (NoSuchAlgorithmException ee) {
                // ignore
            }
        }
    }
    throw new KeyManagementException("FIPS mode: no SecureRandom "
        + " implementation found in provider " + cryptoProvider.getName());
}
 

static SecureRandom getSecureRandom() throws KeyManagementException {
    if (cryptoProvider == null) {
        return new SecureRandom();
    }
    // Try "PKCS11" first. If that is not supported, iterate through
    // the provider and return the first working implementation.
    try {
        return SecureRandom.getInstance("PKCS11", cryptoProvider);
    } catch (NoSuchAlgorithmException e) {
        // ignore
    }
    for (Provider.Service s : cryptoProvider.getServices()) {
        if (s.getType().equals("SecureRandom")) {
            try {
                return SecureRandom.getInstance(s.getAlgorithm(), cryptoProvider);
            } catch (NoSuchAlgorithmException ee) {
                // ignore
            }
        }
    }
    throw new KeyManagementException("FIPS mode: no SecureRandom "
        + " implementation found in provider " + cryptoProvider.getName());
}
 

static SecureRandom getSecureRandom() throws KeyManagementException {
    if (cryptoProvider == null) {
        return new SecureRandom();
    }
    // Try "PKCS11" first. If that is not supported, iterate through
    // the provider and return the first working implementation.
    try {
        return SecureRandom.getInstance("PKCS11", cryptoProvider);
    } catch (NoSuchAlgorithmException e) {
        // ignore
    }
    for (Provider.Service s : cryptoProvider.getServices()) {
        if (s.getType().equals("SecureRandom")) {
            try {
                return SecureRandom.getInstance(s.getAlgorithm(), cryptoProvider);
            } catch (NoSuchAlgorithmException ee) {
                // ignore
            }
        }
    }
    throw new KeyManagementException("FIPS mode: no SecureRandom "
        + " implementation found in provider " + cryptoProvider.getName());
}
 

public void testNewInstance() throws Exception {
    String type = "SecureRandom";
    String algorithm = "algorithm";
    MyProvider p = new MyProvider();
    Provider.Service s = new Provider.Service(p, type,
            algorithm,
            "org.apache.harmony.security.tests.support.RandomImpl",
            null, null);

    p.putService(s);

    // Check success and correct type.
    Object o = s.newInstance(null);
    assertTrue("new service instance is of incorrect class " + o.getClass().getName(),
            o instanceof RandomImpl);
}
 

static SecureRandom getSecureRandom() throws KeyManagementException {
    if (cryptoProvider == null) {
        return new SecureRandom();
    }
    // Try "PKCS11" first. If that is not supported, iterate through
    // the provider and return the first working implementation.
    try {
        return SecureRandom.getInstance("PKCS11", cryptoProvider);
    } catch (NoSuchAlgorithmException e) {
        // ignore
    }
    for (Provider.Service s : cryptoProvider.getServices()) {
        if (s.getType().equals("SecureRandom")) {
            try {
                return SecureRandom.getInstance(s.getAlgorithm(), cryptoProvider);
            } catch (NoSuchAlgorithmException ee) {
                // ignore
            }
        }
    }
    throw new KeyManagementException("FIPS mode: no SecureRandom "
        + " implementation found in provider " + cryptoProvider.getName());
}
 

/**
 * Determine the classes that make up the provider and its services
 *
 * @param providerName - JCA provider name
 * @return class names that make up the provider and its services
 */
private List<String> registerProvider(String providerName) {
    ArrayList<String> providerClasses = new ArrayList<>();
    Provider provider = Security.getProvider(providerName);
    providerClasses.add(provider.getClass().getName());
    Set<Provider.Service> services = provider.getServices();
    for (Provider.Service service : services) {
        String serviceClass = service.getClassName();
        providerClasses.add(serviceClass);
        // Need to pull in the key classes
        String supportedKeyClasses = service.getAttribute("SupportedKeyClasses");
        if (supportedKeyClasses != null) {
            String[] keyClasses = supportedKeyClasses.split("\\|");
            providerClasses.addAll(Arrays.asList(keyClasses));
        }
    }
    return providerClasses;
}
 

static SecureRandom getSecureRandom() throws KeyManagementException {
    if (cryptoProvider == null) {
        return new SecureRandom();
    }
    // Try "PKCS11" first. If that is not supported, iterate through
    // the provider and return the first working implementation.
    try {
        return SecureRandom.getInstance("PKCS11", cryptoProvider);
    } catch (NoSuchAlgorithmException e) {
        // ignore
    }
    for (Provider.Service s : cryptoProvider.getServices()) {
        if (s.getType().equals("SecureRandom")) {
            try {
                return SecureRandom.getInstance(s.getAlgorithm(), cryptoProvider);
            } catch (NoSuchAlgorithmException ee) {
                // ignore
            }
        }
    }
    throw new KeyManagementException("FIPS mode: no SecureRandom "
        + " implementation found in provider " + cryptoProvider.getName());
}
 

public static void main(String args[])
{
  Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());

  Provider[] p_a = Security.getProviders();
  for(Provider p : p_a)
  {
    System.out.println("Provider: " + p.toString());
    System.out.println("-----------------------------------");
    for(Provider.Service ps : p.getServices())
    {
      System.out.println("  " + ps.toString());
    }
  }
}
 

public void testGetProvider() {
    Provider p = new MyProvider();
    Provider.Service s1 = new Provider.Service(p, "type", "algorithm",
            "className", null, null);
    assertTrue(s1.getProvider() == p);

    Provider.Service s2 = new Provider.Service(p, "SecureRandom",
            "algorithm", "tests.java.security.support.RandomImpl", null,
            null);
    assertTrue(s2.getProvider() == p);
}
 

public void testGetAttribute() {
    Provider p = new MyProvider();
    Provider.Service s = new Provider.Service(p, "type", "algorithm",
            "className", null, null);
    try {
        s.getAttribute(null);
        fail("No expected NullPointerException");
    } catch (NullPointerException e) {
    }

    if (s.getAttribute("aaa") != null) {
        fail("getAttribute(aaa) failed");
    }

    HashMap<String, String> hm = new HashMap<String, String>();
    hm.put("attribute", "value");
    hm.put("KeySize", "1024");
    hm.put("AAA", "BBB");

    s = new Provider.Service(p, "type", "algorithm", "className", null, hm);
    if (s.getAttribute("bbb") != null) {
        fail("getAttribute(bbb) failed");
    }
    if (!s.getAttribute("attribute").equals("value")) {
        fail("getAttribute(attribute) failed");
    }
    if (!s.getAttribute("KeySize").equals("1024")) {
        fail("getAttribute(KeySize) failed");
    }
}
 

public void testGetAlgorithm() {
    Provider p = new MyProvider();
    Provider.Service s1 = new Provider.Service(p, "type", "algorithm",
            "className", null, null);
    assertTrue(s1.getAlgorithm().equals("algorithm"));

    Provider.Service s2 = new Provider.Service(p, "SecureRandom",
            "algorithm", "tests.java.security.support.RandomImpl", null,
            null);
    assertTrue(s2.getAlgorithm().equals("algorithm"));
}
 

/**
 * Calling setSeed after use adds the seed to the current state. It must never replace it.
 */
@Test
public void testSetSeedAfterUse() throws Exception {
  final int samples = 10;  // the number of samples per SecureRandom.
  // The size of the generated pseudorandom bytes. An output size of 8 bytes
  // means that the probability of false positives is about
  //   2^{-65}*(samples * (#secure random instances))^2.
  // Hence a random failure of this function is unlikely.
  final int outputsize = 8;
  Set<String> seen = new TreeSet<String>();
  final byte[] seed = new byte[32];
  for (Provider.Service service : secureRandomServices()) {
    for (int i = 0; i < samples; i++) {
      SecureRandom random = SecureRandom.getInstance(service.getAlgorithm(),
          service.getProvider());
      // Calling nextBytes() self-seeds the instance.
      byte[] dummy = new byte[0];
      random.nextBytes(dummy);
      // Calling setSeed() adds the seed to the instance. It would be wrong to
      // replace the current state of the instance with the new seed.
      random.setSeed(seed);
      byte[] bytes = new byte[outputsize];
      // Hence it would be an error (or an unlikely false positive) if the generated
      // bytes are already known.
      random.nextBytes(bytes);
      String hex = TestUtil.bytesToHex(bytes);
      assertFalse("Repeated output from " + service.getAlgorithm(), seen.contains(hex));
      seen.add(hex);
    }
  }
}
 

public static void main(String[] args) throws Exception {
    for (Provider p : Security.getProviders()) {
        for (Provider.Service s : p.getServices()) {
            if (s.getType().equals("SecureRandom") &&
                    !s.getAlgorithm().contains("Block")) {
                test(SecureRandom.getInstance(s.getAlgorithm(), p));
            }
        }
    }
    Security.setProperty("securerandom.drbg.config", "HMAC_DRBG");
    test(SecureRandom.getInstance("DRBG"));
    Security.setProperty("securerandom.drbg.config", "CTR_DRBG");
    test(SecureRandom.getInstance("DRBG"));
}
 

static ResourceDefinition getProviderHttpServerMechanismFactoryDefinition() {
    AttributeDefinition[] attributes = new AttributeDefinition[] { PROVIDERS };
    AbstractAddStepHandler add = new TrivialAddHandler<HttpServerAuthenticationMechanismFactory>(HttpServerAuthenticationMechanismFactory.class, attributes, HTTP_SERVER_MECHANISM_FACTORY_RUNTIME_CAPABILITY) {

        @Override
        protected ValueSupplier<HttpServerAuthenticationMechanismFactory> getValueSupplier(
                ServiceBuilder<HttpServerAuthenticationMechanismFactory> serviceBuilder, OperationContext context,
                ModelNode model) throws OperationFailedException {

            String providers = PROVIDERS.resolveModelAttribute(context, model).asStringOrNull();
            final Supplier<Provider[]> providerSupplier;
            if (providers != null) {
                final InjectedValue<Provider[]> providersInjector = new InjectedValue<Provider[]>();
                serviceBuilder.addDependency(context.getCapabilityServiceName(
                        buildDynamicCapabilityName(PROVIDERS_CAPABILITY, providers), Provider[].class),
                        Provider[].class, providersInjector);
                providerSupplier = providersInjector::getValue;
            } else {
                providerSupplier = Security::getProviders;
            }

            Predicate<Provider.Service> serviceFilter = (Provider.Service s) -> HttpServerAuthenticationMechanismFactory.class.getSimpleName().equals(s.getType());

            return () -> {
                final Provider[] actualProviders = providerSupplier.get();
                if ( findProviderService(actualProviders, serviceFilter) == null ) {
                    throw ROOT_LOGGER.noSuitableProvider(HttpServerAuthenticationMechanismFactory.class.getSimpleName());
                }
                return new SetMechanismInformationMechanismFactory(new SecurityProviderServerMechanismFactory(actualProviders));
            };
        }

    };

    return wrapFactory(new TrivialResourceDefinition(ElytronDescriptionConstants.PROVIDER_HTTP_SERVER_MECHANISM_FACTORY, add,
            attributes, HTTP_SERVER_MECHANISM_FACTORY_RUNTIME_CAPABILITY));
}
 

/**
 * Calling setSeed directly after the initialization may result in deterministic
 * results.
 *
 * The test expects that a SecureRandom instance is either completely deterministic if
 * seeded or non-deterministic and unpredictable (though the test is much too simple
 * to give any meaningful result).
 * 
 * For example the provider "SUN" has the following behaviour:
 * <pre>
 *   Seeding SHA1PRNG from SUN results in deterministic output.
 *   Seeding NativePRNG from SUN results in non-deterministic output.
 *   Seeding NativePRNGBlocking from SUN results in non-deterministic output.
 *   Seeding NativePRNGNonBlocking from SUN results in non-deterministic output.
 * </pre>
 *
 * jdk9 adds a class java.security.DrbgParameter, which allows to better specify the expected
 * behaviour of SecureRandom instances. Tests with these parameters are not included here.
 */
@Test
public void testSetSeedAfterConstruction() throws Exception {
  final int samples = 10;  // the number of samples per SecureRandom.
  // The size of the generated pseudorandom bytes. An output size of 8 bytes
  // means that the probability of false positives is about
  //   2^{-65}*(samples * (#secure random instances))^2.
  // Hence a random failure of this function is unlikely.
  final int outputsize = 8;
  final byte[] seed = new byte[32];
  for (Provider.Service service : secureRandomServices()) {
    Provider provider = service.getProvider();
    Set<String> seen = new TreeSet<String>();
    for (int i = 0; i < samples; i++) {
      SecureRandom random = SecureRandom.getInstance(service.getAlgorithm(), provider);
      random.setSeed(seed);
      byte[] bytes = new byte[outputsize];
      random.nextBytes(bytes);
      String hex = TestUtil.bytesToHex(bytes);
      seen.add(hex);
    }
    if (seen.size() == 1) {
      System.out.println("Seeding " + service.getAlgorithm() + " from " + provider.getName()
                          + " results in deterministic output.");
    } else {
      System.out.println("Seeding " + service.getAlgorithm() + " from " + provider.getName()
                          + " results in non-deterministic output.");
      // ... and if the implementation is non-determinstic, there should be no repetitions.
      assertEquals(samples, seen.size());
    }
  }
}
 

public TestProvider(String name, double version, String info) {
    super(name, version, info);
    serv = new Provider.Service(this, "CertificateFactory", "X.509",
            TestFactorySpi.class.getName(), new ArrayList<String>(), null);
}
 

/**
 * Test server properties
 * @throws P4JavaException 
 */
@Test
public void testServerProperties() {

	String[] serverUris = {
			"p4java://eng-p4java-vm.das.perforce.com:20121?socketPoolSize=10&testKey1=testVal1",
			"p4javassl://eng-p4java-vm.das.perforce.com:30121?socketPoolSize=10&testKey1=testVal1",
			"p4jrpc://eng-p4java-vm.das.perforce.com:20121?socketPoolSize=10&testKey1=testVal1",
			"p4jrpcssl://eng-p4java-vm.das.perforce.com:30121?socketPoolSize=10&testKey1=testVal1",
			"p4jrpcnts://eng-p4java-vm.das.perforce.com:20121?socketPoolSize=10&testKey1=testVal1",
			"p4jrpcntsssl://eng-p4java-vm.das.perforce.com:30121?socketPoolSize=10&testKey1=testVal1" };

	try {
		// List all the providers and the algorithms supporter
		for (Provider provider : Security.getProviders()) {
		    debugPrint("Provider: " + provider.getName());
			for (Provider.Service service : provider.getServices()) {
			    debugPrint("  Algorithm: " + service.getAlgorithm());
			}
		}

		// List supported protocol versions for this connection
		Socket socket = SSLSocketFactory.getDefault().createSocket();
		String[] supportedProtocols = ((SSLSocket) socket)
				.getSupportedProtocols();
		for (String supportedProtocol : supportedProtocols) {
		    debugPrint("Supported Protocol Version: "
					+ supportedProtocol);
		}
		// List enabled protocol versions for this connection
		String[] enabledProtocols = ((SSLSocket) socket)
				.getEnabledProtocols();
		for (String enabledProtocol : enabledProtocols) {
		    debugPrint("Enabled Protocol Version: "
					+ enabledProtocol);
		}

		Properties props = new Properties();

		// props.put("secureSocketTrustAll", "false");
		// props.put("secureSocketProtocol", "TLS");
		props.put("secureSocketProtocol", "SSL");
		// props.put("secureSocketSetEnabledProptocols", "false");
		// props.put("secureSocketEnabledProtocols", "SSLv3, TLSv1");
		props.put("secureSocketEnabledProtocols", "TLSv1, SSLv3");
		// props.put("secureSocketEnabledProtocols", "TLSv1");

		for (String serverUri : serverUris) {
			server = ServerFactory.getOptionsServer(serverUri, props);
			assertNotNull(server);

			// Register callback
			server.registerCallback(new MockCommandCallback());
			setupServer(p4d.getRSHURL(), userName, password, true, props);
			client = server.getClient("p4TestUserWS20112");
			assertNotNull(client);
			server.setCurrentClient(client);
			IServerInfo serverInfo = server.getServerInfo();
			assertNotNull(serverInfo);
		}

	} catch (Exception e) {
	    StringWriter sw = new StringWriter();
	    e.printStackTrace(new PrintWriter(sw));
		fail("Unexpected exception: " + e.getLocalizedMessage() +
		        "\n" + sw.toString() );
	}
}
 

public void removeService(Provider.Service service) {
    super.removeService(service);
}
 

public Iterator<Provider.Service> iterator() {
    return services.iterator();
}
 

@Override
public int compare(Provider.Service object1, Provider.Service object2) {

    String s1 = object1.getType() + object1.getAlgorithm();

    String s2 = object2.getType() + object2.getAlgorithm();


    return s1.compareTo(s2);

}