public static int addProvider(Provider provider) 
{
        /*
         * We can't assign a position here because the statically
         * registered providers may not have been installed yet.
         * insertProviderAt() will fix that value after it has
         * loaded the static providers.
         */
        return insertProviderAt(provider, 0);
}

Adds a provider to the next position available.

First, if there is a security manager, its checkSecurityAccess method is called with the string "insertProvider."+provider.getName() to see if it's ok to add a new provider. If the default implementation of checkSecurityAccess is used (i.e., that method is not overriden), then this will result in a call to the security manager's checkPermission method with a SecurityPermission("insertProvider."+provider.getName()) permission.

 public static String getAlgorithmProperty(String algName,
    String propName) 
{
        ProviderProperty entry = getProviderProperty("Alg." + propName
                                                     + "." + algName);
        if (entry != null) {
            return entry.className;
        } else {
            return null;
        }
}

Gets a specified property for an algorithm. The algorithm name should be a standard name. See the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard algorithm names. One possible use is by specialized algorithm parsers, which may map classes to algorithms which they understand (much like Key parsers do).

 public static Set<String> getAlgorithms(String serviceName) 
{
        if ((serviceName == null) || (serviceName.length() == 0) ||
            (serviceName.endsWith("."))) {
            return Collections.EMPTY_SET;
        }
        HashSet< String > result = new HashSet<  >();
        Provider[] providers = Security.getProviders();
        for (int i = 0; i <  providers.length; i++) {
            // Check the keys for each provider.
            for (Enumeration< Object > e = providers[i].keys();
                                                e.hasMoreElements(); ) {
                String currentKey = ((String)e.nextElement()).toUpperCase();
                if (currentKey.startsWith(serviceName.toUpperCase())) {
                    // We should skip the currentKey if it contains a
                    // whitespace. The reason is: such an entry in the
                    // provider property contains attributes for the
                    // implementation of an algorithm. We are only interested
                    // in entries which lead to the implementation
                    // classes.
                    if (currentKey.indexOf(" ") <  0) {
                        result.add(currentKey.substring(serviceName.length() + 1));
                    }
                }
            }
        }
        return Collections.unmodifiableSet(result);
}

Returns a Set of Strings containing the names of all available algorithms or types for the specified Java cryptographic service (e.g., Signature, MessageDigest, Cipher, Mac, KeyStore). Returns an empty Set if there is no provider that supports the specified service or if serviceName is null. For a complete list of Java cryptographic services, please see the Java Cryptography Architecture API Specification & Reference. Note: the returned set is immutable.

 static String[] getFilterComponents(String filterKey,
    String filterValue) 
{
        int algIndex = filterKey.indexOf('.');
        if (algIndex <  0) {
            // There must be a dot in the filter, and the dot
            // shouldn't be at the beginning of this string.
            throw new InvalidParameterException("Invalid filter");
        }
        String serviceName = filterKey.substring(0, algIndex);
        String algName = null;
        String attrName = null;
        if (filterValue.length() == 0) {
            // The filterValue is an empty string. So the filterKey
            // should be in the format of < crypto_service >.< algorithm_or_type >.
            algName = filterKey.substring(algIndex + 1).trim();
            if (algName.length() == 0) {
                // There must be a algorithm or type name.
                throw new InvalidParameterException("Invalid filter");
            }
        } else {
            // The filterValue is a non-empty string. So the filterKey must be
            // in the format of
            // < crypto_service >.< algorithm_or_type > < attribute_name >
            int attrIndex = filterKey.indexOf(' ');
            if (attrIndex == -1) {
                // There is no attribute name in the filter.
                throw new InvalidParameterException("Invalid filter");
            } else {
                attrName = filterKey.substring(attrIndex + 1).trim();
                if (attrName.length() == 0) {
                    // There is no attribute name in the filter.
                    throw new InvalidParameterException("Invalid filter");
                }
            }
            // There must be an algorithm name in the filter.
            if ((attrIndex <  algIndex) ||
                (algIndex == attrIndex - 1)) {
                throw new InvalidParameterException("Invalid filter");
            } else {
                algName = filterKey.substring(algIndex + 1, attrIndex);
            }
        }
        String[] result = new String[3];
        result[0] = serviceName;
        result[1] = algName;
        result[2] = attrName;
        return result;
}

 static Object[] getImpl(String algorithm,
    String type,
    String provider) throws NoSuchAlgorithmException, NoSuchProviderException 
{
        if (provider == null) {
            return GetInstance.getInstance
                (type, getSpiClass(type), algorithm).toArray();
        } else {
            return GetInstance.getInstance
                (type, getSpiClass(type), algorithm, provider).toArray();
        }
}

 static Object[] getImpl(String algorithm,
    String type,
    Provider provider) throws NoSuchAlgorithmException 
{
        return GetInstance.getInstance
            (type, getSpiClass(type), algorithm, provider).toArray();
}

 static Object[] getImpl(String algorithm,
    String type,
    String provider,
    Object params) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException 
{
        if (provider == null) {
            return GetInstance.getInstance
                (type, getSpiClass(type), algorithm, params).toArray();
        } else {
            return GetInstance.getInstance
                (type, getSpiClass(type), algorithm, params, provider).toArray();
        }
}

 static Object[] getImpl(String algorithm,
    String type,
    Provider provider,
    Object params) throws NoSuchAlgorithmException, InvalidAlgorithmParameterException 
{
        return GetInstance.getInstance
            (type, getSpiClass(type), algorithm, params, provider).toArray();
}

 public static String getProperty(String key) 
{
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new SecurityPermission("getProperty."+
                                                      key));
        }
        String name = props.getProperty(key);
        if (name != null)
            name = name.trim(); // could be a class name with trailing ws
        return name;
}

Gets a security property value.

First, if there is a security manager, its checkPermission method is called with a java.security.SecurityPermission("getProperty."+key) permission to see if it's ok to retrieve the specified security property value..

 public static Provider getProvider(String name) 
{
        return Providers.getProviderList().getProvider(name);
}

Returns the provider installed with the specified name, if any. Returns null if no provider with the specified name is installed or if name is null.

 public static Provider[] getProviders() 
{
        return Providers.getFullProviderList().toArray();
}

Returns an array containing all the installed providers. The order of the providers in the array is their preference order.

 public static Provider[] getProviders(String filter) 
{
        String key = null;
        String value = null;
        int index = filter.indexOf(':');
        if (index == -1) {
            key = filter;
            value = "";
        } else {
            key = filter.substring(0, index);
            value = filter.substring(index + 1);
        }
        Hashtable< String, String > hashtableFilter = new Hashtable<  >(1);
        hashtableFilter.put(key, value);
        return (getProviders(hashtableFilter));
}

Returns an array containing all installed providers that satisfy the specified selection criterion, or null if no such providers have been installed. The returned providers are ordered according to their preference order.

A cryptographic service is always associated with a particular algorithm or type. For example, a digital signature service is always associated with a particular algorithm (e.g., DSA), and a CertificateFactory service is always associated with a particular certificate type (e.g., X.509).

The selection criterion must be specified in one of the following two formats:

• <crypto_service>.<algorithm_or_type>

  The cryptographic service name must not contain any dots.

  A provider satisfies the specified selection criterion iff the provider implements the specified algorithm or type for the specified cryptographic service.

  For example, "CertificateFactory.X.509" would be satisfied by any provider that supplied a CertificateFactory implementation for X.509 certificates.

• <crypto_service>.<algorithm_or_type> <attribute_name>:< attribute_value>

  The cryptographic service name must not contain any dots. There must be one or more space charaters between the <algorithm_or_type> and the <attribute_name>.

  A provider satisfies this selection criterion iff the provider implements the specified algorithm or type for the specified cryptographic service and its implementation meets the constraint expressed by the specified attribute name/value pair.

  For example, "Signature.SHA1withDSA KeySize:1024" would be satisfied by any provider that implemented the SHA1withDSA signature algorithm with a keysize of 1024 (or larger).

See the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard cryptographic service names, standard algorithm names and standard attribute names.

 public static Provider[] getProviders(Map<String, String> filter) 
{
        // Get all installed providers first.
        // Then only return those providers who satisfy the selection criteria.
        Provider[] allProviders = Security.getProviders();
        Set< String > keySet = filter.keySet();
        LinkedHashSet< Provider > candidates = new LinkedHashSet<  >(5);
        // Returns all installed providers
        // if the selection criteria is null.
        if ((keySet == null) || (allProviders == null)) {
            return allProviders;
        }
        boolean firstSearch = true;
        // For each selection criterion, remove providers
        // which don't satisfy the criterion from the candidate set.
        for (Iterator< String > ite = keySet.iterator(); ite.hasNext(); ) {
            String key = ite.next();
            String value = filter.get(key);
            LinkedHashSet< Provider > newCandidates = getAllQualifyingCandidates(key, value,
                                                               allProviders);
            if (firstSearch) {
                candidates = newCandidates;
                firstSearch = false;
            }
            if ((newCandidates != null) && !newCandidates.isEmpty()) {
                // For each provider in the candidates set, if it
                // isn't in the newCandidate set, we should remove
                // it from the candidate set.
                for (Iterator< Provider > cansIte = candidates.iterator();
                     cansIte.hasNext(); ) {
                    Provider prov = cansIte.next();
                    if (!newCandidates.contains(prov)) {
                        cansIte.remove();
                    }
                }
            } else {
                candidates = null;
                break;
            }
        }
        if ((candidates == null) || (candidates.isEmpty()))
            return null;
        Object[] candidatesArray = candidates.toArray();
        Provider[] result = new Provider[candidatesArray.length];
        for (int i = 0; i <  result.length; i++) {
            result[i] = (Provider)candidatesArray[i];
        }
        return result;
}

Returns an array containing all installed providers that satisfy the specified* selection criteria, or null if no such providers have been installed. The returned providers are ordered according to their preference order.

The selection criteria are represented by a map. Each map entry represents a selection criterion. A provider is selected iff it satisfies all selection criteria. The key for any entry in such a map must be in one of the following two formats:

• <crypto_service>.<algorithm_or_type>

  The cryptographic service name must not contain any dots.

  The value associated with the key must be an empty string.

  A provider satisfies this selection criterion iff the provider implements the specified algorithm or type for the specified cryptographic service.

• <crypto_service>.<algorithm_or_type> <attribute_name>

  The cryptographic service name must not contain any dots. There must be one or more space charaters between the <algorithm_or_type> and the <attribute_name>.

  The value associated with the key must be a non-empty string. A provider satisfies this selection criterion iff the provider implements the specified algorithm or type for the specified cryptographic service and its implementation meets the constraint expressed by the specified attribute name/value pair.

See the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard cryptographic service names, standard algorithm names and standard attribute names.

 public static synchronized int insertProviderAt(Provider provider,
    int position) 
{
        String providerName = provider.getName();
        check("insertProvider." + providerName);
        ProviderList list = Providers.getFullProviderList();
        ProviderList newList = ProviderList.insertAt(list, provider, position - 1);
        if (list == newList) {
            return -1;
        }
        Providers.setProviderList(newList);
        return newList.getIndex(providerName) + 1;
}

Adds a new provider, at a specified position. The position is the preference order in which providers are searched for requested algorithms. The position is 1-based, that is, 1 is most preferred, followed by 2, and so on.

If the given provider is installed at the requested position, the provider that used to be at that position, and all providers with a position greater than position, are shifted up one position (towards the end of the list of installed providers).

A provider cannot be added if it is already installed.

First, if there is a security manager, its checkSecurityAccess method is called with the string "insertProvider."+provider.getName() to see if it's ok to add a new provider. If the default implementation of checkSecurityAccess is used (i.e., that method is not overriden), then this will result in a call to the security manager's checkPermission method with a SecurityPermission("insertProvider."+provider.getName()) permission.

 public static synchronized  void removeProvider(String name) 
{
        check("removeProvider." + name);
        ProviderList list = Providers.getFullProviderList();
        ProviderList newList = ProviderList.remove(list, name);
        Providers.setProviderList(newList);
}

Removes the provider with the specified name.

When the specified provider is removed, all providers located at a position greater than where the specified provider was are shifted down one position (towards the head of the list of installed providers).

This method returns silently if the provider is not installed or if name is null.

First, if there is a security manager, its checkSecurityAccess method is called with the string "removeProvider."+name to see if it's ok to remove the provider. If the default implementation of checkSecurityAccess is used (i.e., that method is not overriden), then this will result in a call to the security manager's checkPermission method with a SecurityPermission("removeProvider."+name) permission.

 public static  void setProperty(String key,
    String datum) 
{
        check("setProperty."+key);
        props.put(key, datum);
        invalidateSMCache(key);  /* See below. */
}

Sets a security property value.

First, if there is a security manager, its checkPermission method is called with a java.security.SecurityPermission("setProperty."+key) permission to see if it's ok to set the specified security property value.