下面列出了java.security.Provider#getServices ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private static MessageDigest findAlternativeMessageDigest() {
if ("MD5".equals(hashAlgorithm)) {
for (Provider provider : Security.getProviders()) {
for (Provider.Service service : provider.getServices()) {
hashAlgorithm = service.getAlgorithm();
try {
MessageDigest messageDigest = MessageDigest.getInstance(hashAlgorithm);
if (messageDigest != null)
return messageDigest;
} catch (NoSuchAlgorithmException ignored) {
}
}
}
}
return null;
}
/**
* 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;
}
@BuildStep
void registerSUNProvider(BuildProducer<ReflectiveClassBuildItem> classes) {
Provider provider = Security.getProvider("SUN");
ArrayList<String> providerClasses = new ArrayList<>();
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));
}
}
for (String className : providerClasses) {
classes.produce(new ReflectiveClassBuildItem(true, true, className));
log.debugf("Register SUN.provider class: %s", className);
}
}
public static void main(String[] args) throws Exception {
Provider provider = Security.getProvider("SUN");
System.out.println(provider.getInfo());
for (Provider.Service service : provider.getServices()) {
System.out.println(service);
}
KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA");
kpg.initialize(2048);
System.out.println("DSA.provider: " + kpg.getProvider());
KeyFactory keyFactory = KeyFactory.getInstance("DSA");
System.out.println("DSA.provider: " + keyFactory.getProvider());
KeyPair pair = kpg.genKeyPair();
DSAPublicKey publicKey = (DSAPublicKey) pair.getPublic();
byte[] encoded = publicKey.getEncoded();
X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encoded);
DSAPublicKey publicKey1 = (DSAPublicKey) keyFactory.generatePublic(publicKeySpec);
System.out.printf("keys are equal: %s%n", publicKey1.equals(publicKey));
String base64 = Base64.getEncoder().encodeToString(encoded);
System.out.println(base64);
}
public static String getAlgorithm() {
List<String> keys = new LinkedList<>();
List<String> trusts = new LinkedList<>();
for (Provider p : Security.getProviders()) {
if (p.getServices() != null) {
for (Service s : p.getServices()) {
if ("KeyManagerFactory".equals(s.getType()) && s.getAlgorithm().endsWith("509")) {
keys.add(s.getAlgorithm());
} else if ("TrustManagerFactory".equals(s.getType()) && s.getAlgorithm().endsWith("509")) {
trusts.add(s.getAlgorithm());
}
}
}
}
keys.retainAll(trusts);
return keys.get(0);
}
static private void testDigest() {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
Provider p = md.getProvider();
Set<Provider.Service> services = p.getServices();
for (Provider.Service service : services) {
System.out.println("Service=" + service);
}
} catch (NoSuchAlgorithmException e) {
e.printStackTrace(); // To change body of catch statement use File | Settings | File Templates.
}
}
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 static void SignatureAlgorithms() {
try {
for (Provider provider : Security.getProviders()) {
for (Provider.Service service : provider.getServices()) {
if (service.getType().equals("Signature")) {
logger.debug(service.getAlgorithm());
}
}
}
} catch (Exception e) {
logger.debug(e.toString());
}
}
private static void listKeyGenerators(Queue<String> arguments) {
for (Provider provider : Security.getProviders()) {
for (Provider.Service service : provider.getServices()) {
if (service.getType().equals("KeyGenerator")) {
System.out.println("Provider: " + provider.getName() + " Algorithm: " + service.getAlgorithm());
}
}
}
}
private static void listCiphers(Queue<String> arguments) {
for (Provider provider : Security.getProviders()) {
for (Provider.Service service : provider.getServices()) {
if (service.getType().equals("Cipher")) {
System.out.println("Provider: " + provider.getName() + " Algorithm: " + service.getAlgorithm());
}
}
}
}
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"));
}
/**
* Returns supported algorithms of specified type.
*/
static List<String> getSupportedAlgorithms(String type, String alg,
Provider p) {
// prepare a list of supported algorithms
List<String> algorithms = new ArrayList<>();
Set<Provider.Service> services = p.getServices();
for (Provider.Service service : services) {
if (service.getType().equals(type)
&& service.getAlgorithm().startsWith(alg)) {
algorithms.add(service.getAlgorithm());
}
}
return algorithms;
}
@Test
public void getRandomInstance_should_return_requested_instance_if_available() {
// given: all available SecureRandom algorithm providers
Provider[] availableProviders = Security.getProviders();
assertThat(availableProviders).isNotNull();
assertThat(availableProviders.length).isGreaterThanOrEqualTo(1);
// Ignore some algorithms because they fail on OSX if you're not an admin.
// We don't care that *all* algorithms are available at all times on all platforms, just that the code does what it's supposed to do.
List<String> excludedAlgorithms = Collections.singletonList("NativePRNGNonBlocking");
Set<String> availableSecureRandomAlgorithms = new HashSet<>();
for (Provider provider : availableProviders) {
Set<Provider.Service> services = provider.getServices();
for (Provider.Service service : services) {
String type = service.getType();
if ("SecureRandom".equals(type) && !excludedAlgorithms.contains(service.getAlgorithm()))
availableSecureRandomAlgorithms.add(service.getAlgorithm());
}
}
assertThat(availableSecureRandomAlgorithms).isNotEmpty();
for (String algorithm : availableSecureRandomAlgorithms) {
// when: we ask getRandomInstance for the algorithm
Random randomGenerator = TraceAndSpanIdGenerator.getRandomInstance(algorithm);
// then: we get back a valid SecureRandom that uses the requested algorithm
assertThat(randomGenerator).isNotNull();
assertThat(randomGenerator).isInstanceOf(SecureRandom.class);
//noinspection ConstantConditions
assertThat(((SecureRandom)randomGenerator).getAlgorithm()).isEqualTo(algorithm);
}
}
/** Returns a list of all implemented services of SecureRandom. */
Collection<Provider.Service> secureRandomServices() {
// TODO(bleichen): Check if all instances of SecureRandom are actually
// listed as services. In particular the default SecureRandom() and
// SecureRandom.getInstanceStrong() may not not be registered.
ArrayList<Provider.Service> result = new ArrayList<Provider.Service>();
for (Provider p : Security.getProviders()) {
for (Provider.Service service : p.getServices()) {
if (service.getType().equals("SecureRandom")) {
result.add(service);
}
}
}
return result;
}
/**
* This method lists all defined security providers.
*/
public static void printSecurityProviders() {
final Provider[] providers = Security.getProviders();
for (final Provider provider : providers) {
LOG.info("PROVIDER: {}", provider.getName());
final Set<Provider.Service> services = provider.getServices();
for (final Provider.Service service : services) {
LOG.info("\tALGORITHM: {} / {} / {}", service.getAlgorithm(), service.getType(),
service.getClassName());
}
}
}
private static void addServices(final ModelNode providerModel, final Provider provider) {
ModelNode servicesModel = providerModel.get(ElytronDescriptionConstants.SERVICES);
for (Service current : provider.getServices()) {
ModelNode serviceModel = new ModelNode();
serviceModel.get(ElytronDescriptionConstants.TYPE).set(current.getType());
serviceModel.get(ElytronDescriptionConstants.ALGORITHM).set(current.getAlgorithm());
serviceModel.get(ElytronDescriptionConstants.CLASS_NAME).set(current.getClassName());
servicesModel.add(serviceModel);
}
}
private void getSignatureInfos() {
for (Provider provider : Security.getProviders())
for (Service service : provider.getServices())
if (service.getType().equals("Signature"))
algos.add(service.getAlgorithm());
}
/**
* 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() );
}
}