Java 如何将OID转换为JCE算法名称？

我正在寻找一个库，它可以接受oid，如

1.2.840.10040.4.3

，并将其转换为标准名称（在本例中

SHA1withDSA

）

使用

org.cesecore.certificates.util.AlgorithmTools

，我能够实现一些必需的功能，但它非常有限

这是当前代码：

String signatureAlgorithmName = AlgorithmTools.getAlgorithmNameFromOID(oid);

注意：

---

可以找到标准名称

有一个在线OID数据库，您可以使用

正如您所看到的，OID数据库非常庞大。此外，由于公司在其基本OID下定义了自己的OID，许多OID实际上是未知的

AlgorithmTools

类只是为签名算法定义了一个OID列表，它不尝试通过使用OID作为别名来动态地找出哪些算法可用

请注意，某些OID用于多个类。例如，您可以使用RSA

密码

、

密钥工厂

和

密钥生成器

但是，您可以找出哪些OID可用于当前安装的提供程序：

package nl.owlstead.stackoverflow;

import java.security.Provider;
import java.security.Provider.Service;
import java.security.Security;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class GetOIDToAlgorithmNameMapping {
    private static final Pattern KEY_TYPE_PATTERN = Pattern.compile("^(\\w+)[.].*$");
    private static final Pattern KEY_ALIAS_TYPE_PATTERN = Pattern.compile("^Alg[.]Alias[.](\\w+).*$");
    private static final Pattern KEY_OID_PATTERN = Pattern.compile(".*?(\\d+(?:[.]\\d+){3,})$");

    public static void main(String[] args) throws Exception {
        Provider[] provs = Security.getProviders();

        for (Provider prov : provs) {
            System.out.printf("%n >>> Provider: %s <<< %n%n", prov.getName());

            SortedSet<String> typeAndOID = getTypeAndOIDStrings(prov);

            for (String entry : typeAndOID) {
                String[] typeAndOIDArray = entry.split("-");
                String type = typeAndOIDArray[0];
                String oid = typeAndOIDArray[1];
                Service service = prov.getService(type, oid);
                String algo = service.getAlgorithm();
                System.out.printf("Type: %s, OID: %s, algo: %s%n", type, oid, algo);
            }
        }
    }

    private static SortedSet<String> getTypeAndOIDStrings(Provider prov) {
        SortedSet<String> typeAndOID = new TreeSet<>();

        Set<Object> keys = prov.keySet();
        for (Object key : keys) {
            String keyString = key.toString();
            Matcher oidMatcher = KEY_OID_PATTERN.matcher(keyString);
            if (oidMatcher.matches()) {
                // get OID from matched keyString
                String oid = oidMatcher.group(1);

                // determine type
                String type;
                Matcher aliasTypeMatcher = KEY_ALIAS_TYPE_PATTERN.matcher(keyString);
                if (aliasTypeMatcher.matches()) {
                    type = aliasTypeMatcher.group(1);
                } else {
                    Matcher typeMatcher = KEY_TYPE_PATTERN.matcher(keyString);
                    typeMatcher.matches();
                    type = typeMatcher.group(1);
                }

                // algorithm parameters are not algorithms, so skip them
                if (type.equals("AlgorithmParameters")) {
                    continue;
                }

                // auto-removes dupes
                typeAndOID.add(type + "-" + oid);
            }
        }
        return typeAndOID;
    }
}

包nl.owlstead.stackoverflow；
导入java.security.Provider；
导入java.security.Provider.Service；
导入java.security.security；
导入java.util.Set；
导入java.util.SortedSet；
导入java.util.TreeSet；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类GetOIDToAlgorithmNameMapping{
私有静态最终模式键\u TYPE\u Pattern=Pattern.compile（“^（\\w+[.].*$”）；
私有静态最终模式键\u别名\u类型\u Pattern=Pattern.compile（“^Alg[.]ALIAS[.]（\\w+）.*$”；
私有静态最终模式键\u OID\u Pattern=Pattern.compile（“.*（\\d+（？：[.]\\d+{3，}）$”；
公共静态void main（字符串[]args）引发异常{
Provider[]provs=Security.getProviders（）；
对于（提供商认证：认证）{
System.out.printf（“%n>>>提供程序：%s