static boolean canUseProvider(Provider p) 
{
        return getVerificationResult(p) == null;
}

 static URL getCodeBase(Class clazz) 
{
        URL url = (URL)codeBaseCacheRef.get(clazz);
        if (url == null) {
            url = (URL)AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    ProtectionDomain pd = clazz.getProtectionDomain();
                    if (pd != null) {
                        CodeSource cs = pd.getCodeSource();
                        if (cs != null) {
                            return cs.getLocation();
                        }
                    }
                    return NULL_URL;
                }
            });
            codeBaseCacheRef.put(clazz, url);
        }
        return (url == NULL_URL) ? null : url;
}

 static CryptoPermissions getDefaultPolicy() 
{
        return defaultPolicy;
}

 static CryptoPermissions getExemptPolicy() 
{
        return exemptPolicy;
}

 static Instance getInstance(String type,
    Class clazz,
    String algorithm) throws NoSuchAlgorithmException 
{
        List services = GetInstance.getServices(type, algorithm);
        NoSuchAlgorithmException failure = null;
        for (Iterator t = services.iterator(); t.hasNext(); ) {
            Service s = (Service)t.next();
            if (canUseProvider(s.getProvider()) == false) {
                // allow only signed providers
                continue;
            }
            try {
                Instance instance = GetInstance.getInstance(s, clazz);
                return instance;
            } catch (NoSuchAlgorithmException e) {
                failure = e;
            }
        }
        throw new NoSuchAlgorithmException("Algorithm " + algorithm
                + " not available", failure);
}

 static Instance getInstance(String type,
    Class clazz,
    String algorithm,
    String provider) throws NoSuchAlgorithmException, NoSuchProviderException 
{
        Service s = GetInstance.getService(type, algorithm, provider);
        Exception ve = getVerificationResult(s.getProvider());
        if (ve != null) {
            String msg = "JCE cannot authenticate the provider " + provider;
            throw (NoSuchProviderException)
                                new NoSuchProviderException(msg).initCause(ve);
        }
        return GetInstance.getInstance(s, clazz);
}

 static Instance getInstance(String type,
    Class clazz,
    String algorithm,
    Provider provider) throws NoSuchAlgorithmException 
{
        Service s = GetInstance.getService(type, algorithm, provider);
        Exception ve = JceSecurity.getVerificationResult(provider);
        if (ve != null) {
            String msg = "JCE cannot authenticate the provider "
                + provider.getName();
            throw new SecurityException(msg, ve);
        }
        return GetInstance.getInstance(s, clazz);
}

 static synchronized Exception getVerificationResult(Provider p) 
{
        Object o = verificationResults.get(p);
        if (o == PROVIDER_VERIFIED) {
            return null;
        } else if (o != null) {
            return (Exception)o;
        }
        if (verifyingProviders.get(p) != null) {
            // this method is static synchronized, must be recursion
            // return failure now but do not save the result
            return new NoSuchProviderException("Recursion during verification");
        }
        try {
            verifyingProviders.put(p, Boolean.FALSE);
            URL providerURL = getCodeBase(p.getClass());
            verifyProviderJar(providerURL);
            // Verified ok, cache result
            verificationResults.put(p, PROVIDER_VERIFIED);
            return null;
        } catch (Exception e) {
            verificationResults.put(p, e);
            return e;
        } finally {
            verifyingProviders.remove(p);
        }
}

 static boolean isRestricted() 
{
        return isRestricted;
}

 static CryptoPermissions verifyExemptJar(URL codeBase) throws Exception 
{
        JarVerifier jv = new JarVerifier(codeBase, true);
        jv.verify();
        return jv.getPermissions();
}

Verify if the JAR at URL codeBase is a signed exempt application JAR file and returns the permissions bundled with the JAR.

 static  void verifyProviderJar(URL codeBase) throws Exception 
{
        // Verify the provider JAR file and all
        // supporting JAR files if there are any.
        JarVerifier jv = new JarVerifier(codeBase, false);
        jv.verify();
}

Verify if the JAR at URL codeBase is a signed provider JAR file.