Example usage for org.bouncycastle.asn1.pkcs PKCSObjectIdentifiers sha1WithRSAEncryption

List of usage examples for org.bouncycastle.asn1.pkcs PKCSObjectIdentifiers sha1WithRSAEncryption

  1. HOME
  2. Java
  3. org.bouncycastle
  4. org.bouncycastle.asn1.pkcs.*
  5. PKCSObjectIdentifiers
  6. sha1WithRSAEncryption

Introduction

In this page you can find the example usage for org.bouncycastle.asn1.pkcs PKCSObjectIdentifiers sha1WithRSAEncryption.

Prototype

ASN1ObjectIdentifier sha1WithRSAEncryption

To view the source code for org.bouncycastle.asn1.pkcs PKCSObjectIdentifiers sha1WithRSAEncryption.

Click Source Link

Document

PKCS#1: 1.2.840.113549.1.1.5

Usage

From source file:org.xipki.common.util.AlgorithmUtil.java

License:Open Source License

static public AlgorithmIdentifier getRSASignatureAlgoId(final String hashAlgo, final boolean mgf1)
        throws NoSuchAlgorithmException {
    if (mgf1) {//www  .  j  av  a2 s. com
        ASN1ObjectIdentifier hashAlgoOid = AlgorithmUtil.getHashAlg(hashAlgo);
        return AlgorithmUtil.buildRSAPSSAlgorithmIdentifier(hashAlgoOid);
    }

    ASN1ObjectIdentifier sigAlgoOid;
    if ("SHA1".equalsIgnoreCase(hashAlgo)) {
        sigAlgoOid = PKCSObjectIdentifiers.sha1WithRSAEncryption;
    } else if ("SHA224".equalsIgnoreCase(hashAlgo)) {
        sigAlgoOid = PKCSObjectIdentifiers.sha224WithRSAEncryption;
    } else if ("SHA256".equalsIgnoreCase(hashAlgo)) {
        sigAlgoOid = PKCSObjectIdentifiers.sha256WithRSAEncryption;
    } else if ("SHA384".equalsIgnoreCase(hashAlgo)) {
        sigAlgoOid = PKCSObjectIdentifiers.sha384WithRSAEncryption;
    } else if ("SHA512".equalsIgnoreCase(hashAlgo)) {
        sigAlgoOid = PKCSObjectIdentifiers.sha512WithRSAEncryption;
    } else {
        throw new RuntimeException("unsupported hash algorithm " + hashAlgo);
    }

    return new AlgorithmIdentifier(sigAlgoOid, DERNull.INSTANCE);
}

From source file:org.xipki.common.util.AlgorithmUtil.java

License:Open Source License

static public AlgorithmIdentifier extractDigesetAlgorithmIdentifier(final AlgorithmIdentifier sigAlgId)
        throws NoSuchAlgorithmException {
    ASN1ObjectIdentifier algOid = sigAlgId.getAlgorithm();

    ASN1ObjectIdentifier digestAlgOid;/*from  ww w  . ja v a  2  s  . com*/
    if (X9ObjectIdentifiers.ecdsa_with_SHA1.equals(algOid)) {
        digestAlgOid = X509ObjectIdentifiers.id_SHA1;
    } else if (X9ObjectIdentifiers.ecdsa_with_SHA224.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha224;
    } else if (X9ObjectIdentifiers.ecdsa_with_SHA256.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha256;
    } else if (X9ObjectIdentifiers.ecdsa_with_SHA384.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha384;
    } else if (X9ObjectIdentifiers.ecdsa_with_SHA512.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha512;
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA1.equals(algOid)) {
        digestAlgOid = X509ObjectIdentifiers.id_SHA1;
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA224.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha224;
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA256.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha256;
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA384.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha384;
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA512.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha512;
    } else if (X9ObjectIdentifiers.id_dsa_with_sha1.equals(algOid)) {
        digestAlgOid = X509ObjectIdentifiers.id_SHA1;
    } else if (NISTObjectIdentifiers.dsa_with_sha224.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha224;
    } else if (NISTObjectIdentifiers.dsa_with_sha256.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha256;
    } else if (NISTObjectIdentifiers.dsa_with_sha384.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha384;
    } else if (NISTObjectIdentifiers.dsa_with_sha512.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha512;
    } else if (PKCSObjectIdentifiers.sha1WithRSAEncryption.equals(algOid)) {
        digestAlgOid = X509ObjectIdentifiers.id_SHA1;
    } else if (PKCSObjectIdentifiers.sha224WithRSAEncryption.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha224;
    } else if (PKCSObjectIdentifiers.sha256WithRSAEncryption.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha256;
    } else if (PKCSObjectIdentifiers.sha384WithRSAEncryption.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha384;
    } else if (PKCSObjectIdentifiers.sha512WithRSAEncryption.equals(algOid)) {
        digestAlgOid = NISTObjectIdentifiers.id_sha512;
    } else if (PKCSObjectIdentifiers.id_RSASSA_PSS.equals(algOid)) {
        ASN1Encodable asn1Encodable = sigAlgId.getParameters();
        RSASSAPSSparams param = RSASSAPSSparams.getInstance(asn1Encodable);
        digestAlgOid = param.getHashAlgorithm().getAlgorithm();
    } else {
        throw new NoSuchAlgorithmException("unknown signature algorithm" + algOid.getId());
    }

    return new AlgorithmIdentifier(digestAlgOid, DERNull.INSTANCE);
}

From source file:org.xipki.commons.security.pkcs11.P11RSAContentSigner.java

License:Open Source License

P11RSAContentSigner(final P11CryptService cryptService, final P11EntityIdentifier identityId,
        final AlgorithmIdentifier signatureAlgId) throws XiSecurityException, P11TokenException {
    this.cryptService = ParamUtil.requireNonNull("cryptService", cryptService);
    this.identityId = ParamUtil.requireNonNull("identityId", identityId);
    this.algorithmIdentifier = ParamUtil.requireNonNull("signatureAlgId", signatureAlgId);

    ASN1ObjectIdentifier algOid = signatureAlgId.getAlgorithm();
    HashAlgoType hashAlgo;/*from  ww w  . j a v  a2 s.  c om*/
    if (PKCSObjectIdentifiers.sha1WithRSAEncryption.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA1;
    } else if (PKCSObjectIdentifiers.sha224WithRSAEncryption.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA224;
    } else if (PKCSObjectIdentifiers.sha256WithRSAEncryption.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA256;
    } else if (PKCSObjectIdentifiers.sha384WithRSAEncryption.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA384;
    } else if (PKCSObjectIdentifiers.sha512WithRSAEncryption.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA512;
    } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_224.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA3_224;
    } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_256.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA3_256;
    } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_384.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA3_384;
    } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_512.equals(algOid)) {
        hashAlgo = HashAlgoType.SHA3_512;
    } else {
        throw new XiSecurityException("unsupported signature algorithm " + algOid.getId());
    }

    P11SlotIdentifier slotId = identityId.getSlotId();
    P11Slot slot = cryptService.getSlot(slotId);
    if (slot.supportsMechanism(P11Constants.CKM_RSA_PKCS)) {
        this.mechanism = P11Constants.CKM_RSA_PKCS;
    } else if (slot.supportsMechanism(P11Constants.CKM_RSA_X_509)) {
        this.mechanism = P11Constants.CKM_RSA_X_509;
    } else {
        switch (hashAlgo) {
        case SHA1:
            this.mechanism = P11Constants.CKM_SHA1_RSA_PKCS;
            break;
        case SHA224:
            this.mechanism = P11Constants.CKM_SHA224_RSA_PKCS;
            break;
        case SHA256:
            this.mechanism = P11Constants.CKM_SHA256_RSA_PKCS;
            break;
        case SHA384:
            this.mechanism = P11Constants.CKM_SHA384_RSA_PKCS;
            break;
        case SHA512:
            this.mechanism = P11Constants.CKM_SHA512_RSA_PKCS;
            break;
        case SHA3_224:
            this.mechanism = P11Constants.CKM_SHA3_224_RSA_PKCS;
            break;
        case SHA3_256:
            this.mechanism = P11Constants.CKM_SHA3_256_RSA_PKCS;
            break;
        case SHA3_384:
            this.mechanism = P11Constants.CKM_SHA3_384_RSA_PKCS;
            break;
        case SHA3_512:
            this.mechanism = P11Constants.CKM_SHA3_512_RSA_PKCS;
            break;
        default:
            throw new RuntimeException("should not reach here, unknown HashAlgoType " + hashAlgo);
        }

        if (!slot.supportsMechanism(this.mechanism)) {
            throw new XiSecurityException("unsupported signature algorithm " + algOid.getId());
        }
    }

    if (mechanism == P11Constants.CKM_RSA_PKCS || mechanism == P11Constants.CKM_RSA_X_509) {
        this.digestPkcsPrefix = SignerUtil.getDigestPkcsPrefix(hashAlgo);
        Digest digest = SignerUtil.getDigest(hashAlgo);
        this.outputStream = new DigestOutputStream(digest);
    } else {
        this.digestPkcsPrefix = null;
        this.outputStream = new ByteArrayOutputStream();
    }

    RSAPublicKey rsaPubKey = (RSAPublicKey) cryptService.getIdentity(identityId).getPublicKey();
    this.modulusBitLen = rsaPubKey.getModulus().bitLength();
}

From source file:org.xipki.commons.security.pkcs12.P12KeypairGenerator.java

License:Open Source License

private static ContentSigner getContentSigner(final PrivateKey key) throws Exception {
    BcContentSignerBuilder builder;//from  ww w  .jav  a2 s . c  o  m

    if (key instanceof RSAPrivateKey) {
        ASN1ObjectIdentifier hashOid = X509ObjectIdentifiers.id_SHA1;
        ASN1ObjectIdentifier sigOid = PKCSObjectIdentifiers.sha1WithRSAEncryption;

        builder = new BcRSAContentSignerBuilder(buildAlgId(sigOid), buildAlgId(hashOid));
    } else if (key instanceof DSAPrivateKey) {
        ASN1ObjectIdentifier hashOid = X509ObjectIdentifiers.id_SHA1;
        AlgorithmIdentifier sigId = new AlgorithmIdentifier(X9ObjectIdentifiers.id_dsa_with_sha1);

        builder = new BcDSAContentSignerBuilder(sigId, buildAlgId(hashOid));
    } else if (key instanceof ECPrivateKey) {
        HashAlgoType hashAlgo;
        ASN1ObjectIdentifier sigOid;

        int keysize = ((ECPrivateKey) key).getParams().getOrder().bitLength();
        if (keysize > 384) {
            hashAlgo = HashAlgoType.SHA512;
            sigOid = X9ObjectIdentifiers.ecdsa_with_SHA512;
        } else if (keysize > 256) {
            hashAlgo = HashAlgoType.SHA384;
            sigOid = X9ObjectIdentifiers.ecdsa_with_SHA384;
        } else if (keysize > 224) {
            hashAlgo = HashAlgoType.SHA224;
            sigOid = X9ObjectIdentifiers.ecdsa_with_SHA224;
        } else if (keysize > 160) {
            hashAlgo = HashAlgoType.SHA256;
            sigOid = X9ObjectIdentifiers.ecdsa_with_SHA256;
        } else {
            hashAlgo = HashAlgoType.SHA1;
            sigOid = X9ObjectIdentifiers.ecdsa_with_SHA1;
        }

        builder = new BcECContentSignerBuilder(new AlgorithmIdentifier(sigOid), buildAlgId(hashAlgo.getOid()));
    } else {
        throw new IllegalArgumentException("unknown type of key " + key.getClass().getName());
    }

    return builder.build(KeyUtil.generatePrivateKeyParameter(key));
}

From source file:org.xipki.commons.security.util.AlgorithmUtil.java

License:Open Source License

public static String getSignatureAlgoName(final AlgorithmIdentifier sigAlgId) throws NoSuchAlgorithmException {
    ParamUtil.requireNonNull("sigAlgId", sigAlgId);
    ASN1ObjectIdentifier algOid = sigAlgId.getAlgorithm();

    if (X9ObjectIdentifiers.ecdsa_with_SHA1.equals(algOid)) {
        return "SHA1withECDSA";
    } else if (X9ObjectIdentifiers.ecdsa_with_SHA224.equals(algOid)) {
        return "SHA224withECDSA";
    } else if (X9ObjectIdentifiers.ecdsa_with_SHA256.equals(algOid)) {
        return "SHA256withECDSA";
    } else if (X9ObjectIdentifiers.ecdsa_with_SHA384.equals(algOid)) {
        return "SHA384withECDSA";
    } else if (X9ObjectIdentifiers.ecdsa_with_SHA512.equals(algOid)) {
        return "SHA512withECDSA";
    } else if (NISTObjectIdentifiers.id_ecdsa_with_sha3_224.equals(algOid)) {
        return "SHA3-224withECDSA";
    } else if (NISTObjectIdentifiers.id_ecdsa_with_sha3_256.equals(algOid)) {
        return "SHA3-256withECDSA";
    } else if (NISTObjectIdentifiers.id_ecdsa_with_sha3_384.equals(algOid)) {
        return "SHA3-384withECDSA";
    } else if (NISTObjectIdentifiers.id_ecdsa_with_sha3_512.equals(algOid)) {
        return "SHA3-512withECDSA";
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA1.equals(algOid)) {
        return "SHA1withPLAIN-ECDSA";
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA224.equals(algOid)) {
        return "SHA224withPLAIN-ECDSA";
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA256.equals(algOid)) {
        return "SHA256withPLAIN-ECDSA";
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA384.equals(algOid)) {
        return "SHA384withPLAIN-ECDSA";
    } else if (BSIObjectIdentifiers.ecdsa_plain_SHA512.equals(algOid)) {
        return "SHA512withPLAIN-ECDSA";
    } else if (X9ObjectIdentifiers.id_dsa_with_sha1.equals(algOid)) {
        return "SHA1withDSA";
    } else if (X9ObjectIdentifiers.id_dsa_with_sha1.equals(algOid)) {
        return "SHA1withDSA";
    } else if (NISTObjectIdentifiers.dsa_with_sha224.equals(algOid)) {
        return "SHA224withDSA";
    } else if (NISTObjectIdentifiers.dsa_with_sha256.equals(algOid)) {
        return "SHA256withDSA";
    } else if (NISTObjectIdentifiers.dsa_with_sha384.equals(algOid)) {
        return "SHA384withDSA";
    } else if (NISTObjectIdentifiers.dsa_with_sha512.equals(algOid)) {
        return "SHA512withDSA";
    } else if (NISTObjectIdentifiers.id_dsa_with_sha3_224.equals(algOid)) {
        return "SHA3-224withDSA";
    } else if (NISTObjectIdentifiers.id_dsa_with_sha3_256.equals(algOid)) {
        return "SHA3-256withDSA";
    } else if (NISTObjectIdentifiers.id_dsa_with_sha3_384.equals(algOid)) {
        return "SHA3-384withDSA";
    } else if (NISTObjectIdentifiers.id_dsa_with_sha3_512.equals(algOid)) {
        return "SHA3-512withDSA";
    } else if (PKCSObjectIdentifiers.sha1WithRSAEncryption.equals(algOid)) {
        return "SHA1withRSA";
    } else if (PKCSObjectIdentifiers.sha224WithRSAEncryption.equals(algOid)) {
        return "SHA224withRSA";
    } else if (PKCSObjectIdentifiers.sha256WithRSAEncryption.equals(algOid)) {
        return "SHA256withRSA";
    } else if (PKCSObjectIdentifiers.sha384WithRSAEncryption.equals(algOid)) {
        return "SHA384withRSA";
    } else if (PKCSObjectIdentifiers.sha512WithRSAEncryption.equals(algOid)) {
        return "SHA512withRSA";
    } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_224.equals(algOid)) {
        return "SHA3-224withRSA";
    } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_256.equals(algOid)) {
        return "SHA3-256withRSA";
    } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_384.equals(algOid)) {
        return "SHA3-384withRSA";
    } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_512.equals(algOid)) {
        return "SHA3-512withRSA";
    } else if (PKCSObjectIdentifiers.id_RSASSA_PSS.equals(algOid)) {
        RSASSAPSSparams param = RSASSAPSSparams.getInstance(sigAlgId.getParameters());
        ASN1ObjectIdentifier digestAlgOid = param.getHashAlgorithm().getAlgorithm();
        if (X509ObjectIdentifiers.id_SHA1.equals(digestAlgOid)) {
            return "SHA1withRSAandMGF1";
        } else if (NISTObjectIdentifiers.id_sha256.equals(digestAlgOid)) {
            return "SHA256withRSAandMGF1";
        } else if (NISTObjectIdentifiers.id_sha384.equals(digestAlgOid)) {
            return "SHA384withRSAandMGF1";
        } else if (NISTObjectIdentifiers.id_sha512.equals(digestAlgOid)) {
            return "SHA512withRSAandMGF1";
        } else if (NISTObjectIdentifiers.id_sha3_224.equals(digestAlgOid)) {
            return "SHA3-224withRSAandMGF1";
        } else if (NISTObjectIdentifiers.id_sha3_256.equals(digestAlgOid)) {
            return "SHA3-256withRSAandMGF1";
        } else if (NISTObjectIdentifiers.id_sha3_384.equals(digestAlgOid)) {
            return "SHA3-384withRSAandMGF1";
        } else if (NISTObjectIdentifiers.id_sha3_512.equals(digestAlgOid)) {
            return "SHA3-512withRSAandMGF1";
        } else {/*from   w w w  . ja  v  a 2  s .  c  o m*/
            throw new NoSuchAlgorithmException("unsupported digest algorithm " + digestAlgOid.getId());
        }
    } else {
        throw new NoSuchAlgorithmException("unsupported signature algorithm " + algOid.getId());
    }
}

From source file:org.xipki.commons.security.util.AlgorithmUtil.java

License:Open Source License

public static AlgorithmIdentifier getSigAlgId(final String sigAlgName) throws NoSuchAlgorithmException {
    ParamUtil.requireNonNull("sigAlgName", sigAlgName);
    String algoS = sigAlgName.toUpperCase();
    if (algoS.indexOf('-') != -1 && algoS.indexOf("SHA3-") == -1) {
        algoS = algoS.replaceAll("-", "");
    }/*from www  .j  a  va  2s . c  o  m*/

    AlgorithmIdentifier signatureAlgId;
    if ("SHA1withRSAandMGF1".equalsIgnoreCase(algoS) || "SHA224withRSAandMGF1".equalsIgnoreCase(algoS)
            || "SHA256withRSAandMGF1".equalsIgnoreCase(algoS) || "SHA384withRSAandMGF1".equalsIgnoreCase(algoS)
            || "SHA512withRSAandMGF1".equalsIgnoreCase(algoS)
            || "SHA3-224withRSAandMGF1".equalsIgnoreCase(algoS)
            || "SHA3-256withRSAandMGF1".equalsIgnoreCase(algoS)
            || "SHA3-384withRSAandMGF1".equalsIgnoreCase(algoS)
            || "SHA3-512withRSAandMGF1".equalsIgnoreCase(algoS)) {
        HashAlgoType hashAlgo;
        if ("SHA1withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA1;
        } else if ("SHA224withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA224;
        } else if ("SHA256withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA256;
        } else if ("SHA384withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA384;
        } else if ("SHA512withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA512;
        } else if ("SHA3-224withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA3_224;
        } else if ("SHA3-256withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA3_256;
        } else if ("SHA3-384withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA3_384;
        } else if ("SHA3-512withRSAandMGF1".equalsIgnoreCase(algoS)) {
            hashAlgo = HashAlgoType.SHA3_512;
        } else {
            throw new NoSuchAlgorithmException("should not reach here, unknown algorithm " + algoS);
        }

        signatureAlgId = buildRSAPSSAlgId(hashAlgo);
    } else {
        boolean withNullParam = false;
        ASN1ObjectIdentifier algOid;
        if ("SHA1withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA1".equalsIgnoreCase(algoS)
                || PKCSObjectIdentifiers.sha1WithRSAEncryption.getId().equals(algoS)) {
            algOid = PKCSObjectIdentifiers.sha1WithRSAEncryption;
            withNullParam = true;
        } else if ("SHA224withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA224".equalsIgnoreCase(algoS)
                || PKCSObjectIdentifiers.sha224WithRSAEncryption.getId().equals(algoS)) {
            algOid = PKCSObjectIdentifiers.sha224WithRSAEncryption;
            withNullParam = true;
        } else if ("SHA256withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA256".equalsIgnoreCase(algoS)
                || PKCSObjectIdentifiers.sha256WithRSAEncryption.getId().equals(algoS)) {
            algOid = PKCSObjectIdentifiers.sha256WithRSAEncryption;
            withNullParam = true;
        } else if ("SHA384withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA384".equalsIgnoreCase(algoS)
                || PKCSObjectIdentifiers.sha384WithRSAEncryption.getId().equals(algoS)) {
            algOid = PKCSObjectIdentifiers.sha384WithRSAEncryption;
            withNullParam = true;
        } else if ("SHA512withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA512".equalsIgnoreCase(algoS)
                || PKCSObjectIdentifiers.sha512WithRSAEncryption.getId().equals(algoS)) {
            algOid = PKCSObjectIdentifiers.sha512WithRSAEncryption;
            withNullParam = true;
        } else if ("SHA512withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA512".equalsIgnoreCase(algoS)
                || PKCSObjectIdentifiers.sha512WithRSAEncryption.getId().equals(algoS)) {
            algOid = PKCSObjectIdentifiers.sha512WithRSAEncryption;
            withNullParam = true;
        } else if ("SHA3-224withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA3-224".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_224.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_224;
            withNullParam = true;
        } else if ("SHA3-256withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA3-256".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_256.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_256;
            withNullParam = true;
        } else if ("SHA3-384withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA3-384".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_384.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_384;
            withNullParam = true;
        } else if ("SHA3-512withRSA".equalsIgnoreCase(algoS) || "RSAwithSHA3-512".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_512.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_512;
            withNullParam = true;
        } else if ("SHA1withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA1".equalsIgnoreCase(algoS)
                || X9ObjectIdentifiers.ecdsa_with_SHA1.getId().equals(algoS)) {
            algOid = X9ObjectIdentifiers.ecdsa_with_SHA1;
        } else if ("SHA224withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA224".equalsIgnoreCase(algoS)
                || X9ObjectIdentifiers.ecdsa_with_SHA224.getId().equals(algoS)) {
            algOid = X9ObjectIdentifiers.ecdsa_with_SHA224;
        } else if ("SHA256withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA256".equalsIgnoreCase(algoS)
                || X9ObjectIdentifiers.ecdsa_with_SHA256.getId().equals(algoS)) {
            algOid = X9ObjectIdentifiers.ecdsa_with_SHA256;
        } else if ("SHA384withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA384".equalsIgnoreCase(algoS)
                || X9ObjectIdentifiers.ecdsa_with_SHA384.getId().equals(algoS)) {
            algOid = X9ObjectIdentifiers.ecdsa_with_SHA384;
        } else if ("SHA512withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA512".equalsIgnoreCase(algoS)
                || X9ObjectIdentifiers.ecdsa_with_SHA512.getId().equals(algoS)) {
            algOid = X9ObjectIdentifiers.ecdsa_with_SHA512;
        } else if ("SHA3-224withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA3-224".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_ecdsa_with_sha3_224.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_ecdsa_with_sha3_224;
        } else if ("SHA3-256withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA3-256".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_ecdsa_with_sha3_256.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_ecdsa_with_sha3_256;
        } else if ("SHA3-384withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA3-384".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_ecdsa_with_sha3_384.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_ecdsa_with_sha3_384;
        } else if ("SHA3-512withECDSA".equalsIgnoreCase(algoS) || "ECDSAwithSHA3-512".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_ecdsa_with_sha3_512.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_ecdsa_with_sha3_512;
        } else if ("SHA1withPlainECDSA".equalsIgnoreCase(algoS) || "PlainECDSAwithSHA1".equalsIgnoreCase(algoS)
                || BSIObjectIdentifiers.ecdsa_plain_SHA1.getId().equals(algoS)) {
            algOid = BSIObjectIdentifiers.ecdsa_plain_SHA1;
        } else if ("SHA224withPlainECDSA".equalsIgnoreCase(algoS)
                || "PlainECDSAwithSHA224".equalsIgnoreCase(algoS)
                || BSIObjectIdentifiers.ecdsa_plain_SHA224.getId().equals(algoS)) {
            algOid = BSIObjectIdentifiers.ecdsa_plain_SHA224;
        } else if ("SHA256withPlainECDSA".equalsIgnoreCase(algoS)
                || "PlainECDSAwithSHA256".equalsIgnoreCase(algoS)
                || BSIObjectIdentifiers.ecdsa_plain_SHA256.getId().equals(algoS)) {
            algOid = BSIObjectIdentifiers.ecdsa_plain_SHA256;
        } else if ("SHA384withPlainECDSA".equalsIgnoreCase(algoS)
                || "PlainECDSAwithSHA384".equalsIgnoreCase(algoS)
                || BSIObjectIdentifiers.ecdsa_plain_SHA384.getId().equals(algoS)) {
            algOid = BSIObjectIdentifiers.ecdsa_plain_SHA384;
        } else if ("SHA512withPlainECDSA".equalsIgnoreCase(algoS)
                || "PlainECDSAwithSHA512".equalsIgnoreCase(algoS)
                || BSIObjectIdentifiers.ecdsa_plain_SHA512.getId().equals(algoS)) {
            algOid = BSIObjectIdentifiers.ecdsa_plain_SHA512;
        } else if ("SHA1withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA1".equalsIgnoreCase(algoS)
                || X9ObjectIdentifiers.id_dsa_with_sha1.getId().equals(algoS)) {
            algOid = X9ObjectIdentifiers.id_dsa_with_sha1;
        } else if ("SHA224withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA224".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.dsa_with_sha224.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.dsa_with_sha224;
        } else if ("SHA256withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA256".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.dsa_with_sha256.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.dsa_with_sha256;
        } else if ("SHA384withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA384".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.dsa_with_sha384.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.dsa_with_sha384;
        } else if ("SHA512withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA512".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.dsa_with_sha512.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.dsa_with_sha512;
        } else if ("SHA3-224withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA3-224".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_dsa_with_sha3_224.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_dsa_with_sha3_224;
        } else if ("SHA3-256withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA3-256".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_dsa_with_sha3_256.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_dsa_with_sha3_256;
        } else if ("SHA3-384withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA3-384".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_dsa_with_sha3_384.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_dsa_with_sha3_384;
        } else if ("SHA3-512withDSA".equalsIgnoreCase(algoS) || "DSAwithSHA3-512".equalsIgnoreCase(algoS)
                || NISTObjectIdentifiers.id_dsa_with_sha3_512.getId().equals(algoS)) {
            algOid = NISTObjectIdentifiers.id_dsa_with_sha3_512;
        } else {
            throw new NoSuchAlgorithmException("unsupported signature algorithm " + algoS);
        }

        signatureAlgId = withNullParam ? new AlgorithmIdentifier(algOid, DERNull.INSTANCE)
                : new AlgorithmIdentifier(algOid);
    }

    return signatureAlgId;
}

From source file:org.xipki.commons.security.util.AlgorithmUtil.java

License:Open Source License

public static boolean isRSASigAlgId(final AlgorithmIdentifier algId) {
    ParamUtil.requireNonNull("algId", algId);
    ASN1ObjectIdentifier oid = algId.getAlgorithm();
    if (PKCSObjectIdentifiers.sha1WithRSAEncryption.equals(oid)
            || PKCSObjectIdentifiers.sha224WithRSAEncryption.equals(oid)
            || PKCSObjectIdentifiers.sha256WithRSAEncryption.equals(oid)
            || PKCSObjectIdentifiers.sha384WithRSAEncryption.equals(oid)
            || PKCSObjectIdentifiers.sha512WithRSAEncryption.equals(oid)
            || NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_224.equals(oid)
            || NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_256.equals(oid)
            || NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_384.equals(oid)
            || NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_512.equals(oid)
            || PKCSObjectIdentifiers.id_RSASSA_PSS.equals(oid)) {
        return true;
    }// www.  j  a v a 2 s . c  o m

    return false;
}

From source file:org.xipki.commons.security.util.AlgorithmUtil.java

License:Open Source License

public static AlgorithmIdentifier getRSASigAlgId(final HashAlgoType hashAlgo, final boolean mgf1)
        throws NoSuchAlgorithmException {
    ParamUtil.requireNonNull("hashAlgo", hashAlgo);
    if (mgf1) {/*from   ww w.j a va2  s.c om*/
        return buildRSAPSSAlgId(hashAlgo);
    }

    ASN1ObjectIdentifier sigAlgOid;
    switch (hashAlgo) {
    case SHA1:
        sigAlgOid = PKCSObjectIdentifiers.sha1WithRSAEncryption;
        break;
    case SHA224:
        sigAlgOid = PKCSObjectIdentifiers.sha224WithRSAEncryption;
        break;
    case SHA256:
        sigAlgOid = PKCSObjectIdentifiers.sha256WithRSAEncryption;
        break;
    case SHA384:
        sigAlgOid = PKCSObjectIdentifiers.sha384WithRSAEncryption;
        break;
    case SHA512:
        sigAlgOid = PKCSObjectIdentifiers.sha512WithRSAEncryption;
        break;
    case SHA3_224:
        sigAlgOid = NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_224;
        break;
    case SHA3_256:
        sigAlgOid = NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_256;
        break;
    case SHA3_384:
        sigAlgOid = NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_384;
        break;
    case SHA3_512:
        sigAlgOid = NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_512;
        break;
    default:
        throw new RuntimeException("unknown HashAlgoType: " + hashAlgo);
    }

    return new AlgorithmIdentifier(sigAlgOid, DERNull.INSTANCE);
}

From source file:org.xipki.commons.security.util.AlgorithmUtil.java

License:Open Source License

public static AlgorithmIdentifier extractDigesetAlgId(final AlgorithmIdentifier sigAlgId)
        throws NoSuchAlgorithmException {
    ASN1ObjectIdentifier algOid = sigAlgId.getAlgorithm();

    ASN1ObjectIdentifier digestAlgOid;//from  w  w  w . java2  s .c  o m
    if (PKCSObjectIdentifiers.id_RSASSA_PSS.equals(algOid)) {
        ASN1Encodable asn1Encodable = sigAlgId.getParameters();
        RSASSAPSSparams param = RSASSAPSSparams.getInstance(asn1Encodable);
        digestAlgOid = param.getHashAlgorithm().getAlgorithm();
    } else {
        HashAlgoType digestAlg;

        if (X9ObjectIdentifiers.ecdsa_with_SHA1.equals(algOid)) {
            digestAlg = HashAlgoType.SHA1;
        } else if (X9ObjectIdentifiers.ecdsa_with_SHA224.equals(algOid)) {
            digestAlg = HashAlgoType.SHA224;
        } else if (X9ObjectIdentifiers.ecdsa_with_SHA256.equals(algOid)) {
            digestAlg = HashAlgoType.SHA256;
        } else if (X9ObjectIdentifiers.ecdsa_with_SHA384.equals(algOid)) {
            digestAlg = HashAlgoType.SHA384;
        } else if (X9ObjectIdentifiers.ecdsa_with_SHA512.equals(algOid)) {
            digestAlg = HashAlgoType.SHA512;
        } else if (NISTObjectIdentifiers.id_ecdsa_with_sha3_224.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_224;
        } else if (NISTObjectIdentifiers.id_ecdsa_with_sha3_256.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_256;
        } else if (NISTObjectIdentifiers.id_ecdsa_with_sha3_384.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_384;
        } else if (NISTObjectIdentifiers.id_ecdsa_with_sha3_512.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_512;
        } else if (BSIObjectIdentifiers.ecdsa_plain_SHA1.equals(algOid)) {
            digestAlg = HashAlgoType.SHA1;
        } else if (BSIObjectIdentifiers.ecdsa_plain_SHA224.equals(algOid)) {
            digestAlg = HashAlgoType.SHA224;
        } else if (BSIObjectIdentifiers.ecdsa_plain_SHA256.equals(algOid)) {
            digestAlg = HashAlgoType.SHA256;
        } else if (BSIObjectIdentifiers.ecdsa_plain_SHA384.equals(algOid)) {
            digestAlg = HashAlgoType.SHA384;
        } else if (BSIObjectIdentifiers.ecdsa_plain_SHA512.equals(algOid)) {
            digestAlg = HashAlgoType.SHA512;
        } else if (X9ObjectIdentifiers.id_dsa_with_sha1.equals(algOid)) {
            digestAlg = HashAlgoType.SHA1;
        } else if (NISTObjectIdentifiers.dsa_with_sha224.equals(algOid)) {
            digestAlg = HashAlgoType.SHA224;
        } else if (NISTObjectIdentifiers.dsa_with_sha256.equals(algOid)) {
            digestAlg = HashAlgoType.SHA256;
        } else if (NISTObjectIdentifiers.dsa_with_sha384.equals(algOid)) {
            digestAlg = HashAlgoType.SHA384;
        } else if (NISTObjectIdentifiers.dsa_with_sha512.equals(algOid)) {
            digestAlg = HashAlgoType.SHA512;
        } else if (NISTObjectIdentifiers.id_dsa_with_sha3_224.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_224;
        } else if (NISTObjectIdentifiers.id_dsa_with_sha3_256.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_256;
        } else if (NISTObjectIdentifiers.id_dsa_with_sha3_384.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_384;
        } else if (NISTObjectIdentifiers.id_dsa_with_sha3_512.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_512;
        } else if (PKCSObjectIdentifiers.sha1WithRSAEncryption.equals(algOid)) {
            digestAlg = HashAlgoType.SHA1;
        } else if (PKCSObjectIdentifiers.sha224WithRSAEncryption.equals(algOid)) {
            digestAlg = HashAlgoType.SHA224;
        } else if (PKCSObjectIdentifiers.sha256WithRSAEncryption.equals(algOid)) {
            digestAlg = HashAlgoType.SHA256;
        } else if (PKCSObjectIdentifiers.sha384WithRSAEncryption.equals(algOid)) {
            digestAlg = HashAlgoType.SHA384;
        } else if (PKCSObjectIdentifiers.sha512WithRSAEncryption.equals(algOid)) {
            digestAlg = HashAlgoType.SHA512;
        } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_224.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_224;
        } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_256.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_256;
        } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_384.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_384;
        } else if (NISTObjectIdentifiers.id_rsassa_pkcs1_v1_5_with_sha3_512.equals(algOid)) {
            digestAlg = HashAlgoType.SHA3_512;
        } else {
            throw new NoSuchAlgorithmException("unknown signature algorithm" + algOid.getId());
        }

        digestAlgOid = digestAlg.getOid();
    }

    return new AlgorithmIdentifier(digestAlgOid, DERNull.INSTANCE);
}

From source file:org.xipki.ocsp.client.api.RequestOptions.java

License:Open Source License

private static AlgorithmIdentifier createAlgId(final String algoName) {
    ASN1ObjectIdentifier algOid = null;/*from  w  ww.jav a2 s.c  om*/
    if ("SHA1withRSA".equalsIgnoreCase(algoName)) {
        algOid = PKCSObjectIdentifiers.sha1WithRSAEncryption;
    } else if ("SHA256withRSA".equalsIgnoreCase(algoName)) {
        algOid = PKCSObjectIdentifiers.sha256WithRSAEncryption;
    } else if ("SHA384withRSA".equalsIgnoreCase(algoName)) {
        algOid = PKCSObjectIdentifiers.sha384WithRSAEncryption;
    } else if ("SHA512withRSA".equalsIgnoreCase(algoName)) {
        algOid = PKCSObjectIdentifiers.sha512WithRSAEncryption;
    } else if ("SHA1withECDSA".equalsIgnoreCase(algoName)) {
        algOid = X9ObjectIdentifiers.ecdsa_with_SHA1;
    } else if ("SHA256withECDSA".equalsIgnoreCase(algoName)) {
        algOid = X9ObjectIdentifiers.ecdsa_with_SHA256;
    } else if ("SHA384withECDSA".equalsIgnoreCase(algoName)) {
        algOid = X9ObjectIdentifiers.ecdsa_with_SHA384;
    } else if ("SHA512withECDSA".equalsIgnoreCase(algoName)) {
        algOid = X9ObjectIdentifiers.ecdsa_with_SHA512;
    } else if ("SHA1withRSAandMGF1".equalsIgnoreCase(algoName)
            || "SHA256withRSAandMGF1".equalsIgnoreCase(algoName)
            || "SHA384withRSAandMGF1".equalsIgnoreCase(algoName)
            || "SHA512withRSAandMGF1".equalsIgnoreCase(algoName)) {
        algOid = PKCSObjectIdentifiers.id_RSASSA_PSS;
    } else {
        throw new RuntimeException("Unsupported algorithm " + algoName); // should not happen
    }

    ASN1Encodable params;
    if (PKCSObjectIdentifiers.id_RSASSA_PSS.equals(algOid)) {
        ASN1ObjectIdentifier digestAlgOid = null;
        if ("SHA1withRSAandMGF1".equalsIgnoreCase(algoName)) {
            digestAlgOid = X509ObjectIdentifiers.id_SHA1;
        } else if ("SHA256withRSAandMGF1".equalsIgnoreCase(algoName)) {
            digestAlgOid = NISTObjectIdentifiers.id_sha256;
        } else if ("SHA384withRSAandMGF1".equalsIgnoreCase(algoName)) {
            digestAlgOid = NISTObjectIdentifiers.id_sha384;
        } else // if("SHA512withRSAandMGF1".equalsIgnoreCase(algoName))
        {
            digestAlgOid = NISTObjectIdentifiers.id_sha512;
        }
        params = createPSSRSAParams(digestAlgOid);
    } else {
        params = DERNull.INSTANCE;
    }

    return new AlgorithmIdentifier(algOid, params);

}