java.security.spec.PSSParameterSpec Java Examples

/**
 * Return the PKCS#1 ASN.1 structure RSASSA-PSS-params.
 */
protected byte[] engineGetEncoded() 
    throws IOException
{
    PSSParameterSpec pssSpec = currentSpec;
    AlgorithmIdentifier hashAlgorithm = new AlgorithmIdentifier(
                                        DigestFactory.getOID(pssSpec.getDigestAlgorithm()),
                                        DERNull.INSTANCE);
    MGF1ParameterSpec mgfSpec = (MGF1ParameterSpec)pssSpec.getMGFParameters();
    AlgorithmIdentifier maskGenAlgorithm = new AlgorithmIdentifier(
                                        PKCSObjectIdentifiers.id_mgf1,
                                        new AlgorithmIdentifier(DigestFactory.getOID(mgfSpec.getDigestAlgorithm()), DERNull.INSTANCE));
    RSASSAPSSparams pssP = new RSASSAPSSparams(hashAlgorithm, maskGenAlgorithm, new ASN1Integer(pssSpec.getSaltLength()), new ASN1Integer(pssSpec.getTrailerField()));
    
    return pssP.getEncoded("DER");
}
 

public static PSSParameterSpec getDefaultAlgorithmParameterSpec(
        String sigAlg, PrivateKey k) {
    if (sigAlg.equalsIgnoreCase("RSASSA-PSS")) {
        switch (ifcFfcStrength(KeyUtil.getKeySize(k))) {
            case "SHA256":
                return PSSParamsHolder.PSS_256_SPEC;
            case "SHA384":
                return PSSParamsHolder.PSS_384_SPEC;
            case "SHA512":
                return PSSParamsHolder.PSS_512_SPEC;
            default:
                throw new AssertionError("Should not happen");
        }
    } else {
        return null;
    }
}
 

@Override
protected void engineInit(AlgorithmParameterSpec paramSpec)
        throws InvalidParameterSpecException {
    if (!(paramSpec instanceof PSSParameterSpec)) {
        throw new InvalidParameterSpecException
            ("Inappropriate parameter specification");
    }
    PSSParameterSpec spec = (PSSParameterSpec) paramSpec;

    String mgfName = spec.getMGFAlgorithm();
    if (!spec.getMGFAlgorithm().equalsIgnoreCase("MGF1")) {
        throw new InvalidParameterSpecException("Unsupported mgf " +
            mgfName + "; MGF1 only");
    }
    AlgorithmParameterSpec mgfSpec = spec.getMGFParameters();
    if (!(mgfSpec instanceof MGF1ParameterSpec)) {
        throw new InvalidParameterSpecException("Inappropriate mgf " +
            "parameters; non-null MGF1ParameterSpec only");
    }
    this.spec = spec;
}
 

@Override
protected void engineInit(AlgorithmParameterSpec paramSpec)
        throws InvalidParameterSpecException {
    if (!(paramSpec instanceof PSSParameterSpec)) {
        throw new InvalidParameterSpecException
            ("Inappropriate parameter specification");
    }
    PSSParameterSpec spec = (PSSParameterSpec) paramSpec;

    String mgfName = spec.getMGFAlgorithm();
    if (!spec.getMGFAlgorithm().equalsIgnoreCase("MGF1")) {
        throw new InvalidParameterSpecException("Unsupported mgf " +
            mgfName + "; MGF1 only");
    }
    AlgorithmParameterSpec mgfSpec = spec.getMGFParameters();
    if (!(mgfSpec instanceof MGF1ParameterSpec)) {
        throw new InvalidParameterSpecException("Inappropriate mgf " +
            "parameters; non-null MGF1ParameterSpec only");
    }
    this.spec = spec;
}
 

@Override
protected void engineInit(AlgorithmParameterSpec paramSpec)
        throws InvalidParameterSpecException {
    if (!(paramSpec instanceof PSSParameterSpec)) {
        throw new InvalidParameterSpecException
            ("Inappropriate parameter specification");
    }
    PSSParameterSpec spec = (PSSParameterSpec) paramSpec;

    String mgfName = spec.getMGFAlgorithm();
    if (!spec.getMGFAlgorithm().equalsIgnoreCase("MGF1")) {
        throw new InvalidParameterSpecException("Unsupported mgf " +
            mgfName + "; MGF1 only");
    }
    AlgorithmParameterSpec mgfSpec = spec.getMGFParameters();
    if (!(mgfSpec instanceof MGF1ParameterSpec)) {
        throw new InvalidParameterSpecException("Inappropriate mgf " +
            "parameters; non-null MGF1ParameterSpec only");
    }
    this.spec = spec;
}
 

/**
 * Return the PKCS#1 ASN.1 structure RSASSA-PSS-params.
 */
protected byte[] engineGetEncoded() 
    throws IOException
{
    PSSParameterSpec pssSpec = currentSpec;
    AlgorithmIdentifier hashAlgorithm = new AlgorithmIdentifier(
                                        DigestFactory.getOID(pssSpec.getDigestAlgorithm()),
                                        DERNull.INSTANCE);
    MGF1ParameterSpec mgfSpec = (MGF1ParameterSpec)pssSpec.getMGFParameters();
    AlgorithmIdentifier maskGenAlgorithm = new AlgorithmIdentifier(
                                        PKCSObjectIdentifiers.id_mgf1,
                                        new AlgorithmIdentifier(DigestFactory.getOID(mgfSpec.getDigestAlgorithm()), DERNull.INSTANCE));
    RSASSAPSSparams pssP = new RSASSAPSSparams(hashAlgorithm, maskGenAlgorithm, new ASN1Integer(pssSpec.getSaltLength()), new ASN1Integer(pssSpec.getTrailerField()));
    
    return pssP.getEncoded("DER");
}
 

/**
 * Returns an AlgorithmParameterSpec for generating a RSASSA-PSS key,
 * which include the PSSParameters.
 * Requires jdk11.
 * 
 * @param keySizeInBits the size of the modulus in bits.
 * @param sha the name of the hash function for hashing the input (e.g. "SHA-256")
 * @param mgf the name of the mask generating function (typically "MGF1")
 * @param mgfSha the name of the hash function for the mask generating function
 *        (typically the same as sha).
 * @param saltLength the length of the salt in bytes (typically the digest size of sha,
 *        i.e. 32 for "SHA-256")
 * @throws NoSuchMethodException if the AlgorithmParameterSpec is not
 *   supported (i.e. this happens before jdk11).
 */
public RSAKeyGenParameterSpec getPssAlgorithmParameters(
    int keySizeInBits,
    String sha,
    String mgf,
    String mgfSha,
    int saltLength) throws Exception {
  BigInteger publicExponent = new BigInteger("65537");
  PSSParameterSpec params = 
      new PSSParameterSpec(sha, mgf, new MGF1ParameterSpec(mgfSha), saltLength, 1);
  // Uses reflection to call 
  // public RSAKeyGenParameterSpec(int keysize, BigInteger publicExponent,
  //        AlgorithmParameterSpec keyParams)
  // because this method is only supported in jdk11. This throws a NoSuchMethodException
  // for older jdks.
  Constructor<RSAKeyGenParameterSpec> c =
      RSAKeyGenParameterSpec.class.getConstructor(
          int.class, BigInteger.class, AlgorithmParameterSpec.class);
  return c.newInstance(keySizeInBits, publicExponent, params);
}
 

protected void engineInit(
    AlgorithmParameterSpec paramSpec)
    throws InvalidParameterSpecException
{
    if (!(paramSpec instanceof PSSParameterSpec))
    {
        throw new InvalidParameterSpecException("PSSParameterSpec required to initialise an PSS algorithm parameters object");
    }
    
    this.currentSpec = (PSSParameterSpec)paramSpec;
}
 

protected Signature createSignatureInstance() {

        Signature sig = super.createSignatureInstance();

        PSSParameterSpec spec = PSS_PARAMETER_SPECS.get(alg);
        if (spec != null) {
            setParameter(sig, spec);
        }
        return sig;
    }
 

@Override
protected <T extends AlgorithmParameterSpec>
        T engineGetParameterSpec(Class<T> paramSpec)
        throws InvalidParameterSpecException {
    if (PSSParameterSpec.class.isAssignableFrom(paramSpec)) {
        return paramSpec.cast(spec);
    } else {
        throw new InvalidParameterSpecException
            ("Inappropriate parameter specification");
    }
}
 

protected void setParameter(Signature sig, PSSParameterSpec spec) {
    try {
        doSetParameter(sig, spec);
    } catch (InvalidAlgorithmParameterException e) {
        String msg = "Unsupported RSASSA-PSS parameter '" + spec + "': " + e.getMessage();
        throw new SignatureException(msg, e);
    }
}
 

protected Signature createSignatureInstance() {

        Signature sig = super.createSignatureInstance();

        PSSParameterSpec spec = PSS_PARAMETER_SPECS.get(alg);
        if (spec != null) {
            setParameter(sig, spec);
        }
        return sig;
    }
 

static boolean test(String pg, String ps, String pv, PSSParameterSpec pss)
        throws Exception {

    KeyPairGenerator kpg = pg.length() == 1
            ? KeyPairGenerator.getInstance("RSA")
            :KeyPairGenerator.getInstance("RSA", pg);
    kpg.initialize(
            pss.getDigestAlgorithm().equals("SHA-512") ? 2048: 1024,
            NOT_SECURE_RANDOM);
    KeyPair kp = kpg.generateKeyPair();
    PrivateKey pr = kp.getPrivate();
    PublicKey pu = kp.getPublic();

    Signature s = ps.length() == 1
            ? Signature.getInstance("RSASSA-PSS")
            : Signature.getInstance("RSASSA-PSS", ps);
    s.initSign(pr);
    s.setParameter(pss);
    s.update(msg);
    byte[] sig = s.sign();

    Signature s2 = pv.length() == 1
            ? Signature.getInstance("RSASSA-PSS")
            : Signature.getInstance("RSASSA-PSS", pv);
    s2.initVerify(pu);
    s2.setParameter(pss);
    s2.update(msg);

    return s2.verify(sig);
}
 

protected void engineInit(
    AlgorithmParameterSpec paramSpec)
    throws InvalidParameterSpecException
{
    if (!(paramSpec instanceof PSSParameterSpec))
    {
        throw new InvalidParameterSpecException("PSSParameterSpec required to initialise an PSS algorithm parameters object");
    }
    
    this.currentSpec = (PSSParameterSpec)paramSpec;
}
 

@Override
protected <T extends AlgorithmParameterSpec>
        T engineGetParameterSpec(Class<T> paramSpec)
        throws InvalidParameterSpecException {
    if (PSSParameterSpec.class.isAssignableFrom(paramSpec)) {
        return paramSpec.cast(spec);
    } else {
        throw new InvalidParameterSpecException
            ("Inappropriate parameter specification");
    }
}
 

protected AlgorithmParameterSpec localEngineGetParameterSpec(
    Class paramSpec)
    throws InvalidParameterSpecException
{
    if (paramSpec == PSSParameterSpec.class && currentSpec != null)
    {
        return currentSpec;
    }
    
    throw new InvalidParameterSpecException("unknown parameter spec passed to PSS parameters object.");
}
 

protected AlgorithmParameterSpec localEngineGetParameterSpec(
    Class paramSpec)
    throws InvalidParameterSpecException
{
    if (paramSpec == PSSParameterSpec.class && currentSpec != null)
    {
        return currentSpec;
    }
    
    throw new InvalidParameterSpecException("unknown parameter spec passed to PSS parameters object.");
}
 

@Override
protected <T extends AlgorithmParameterSpec>
        T engineGetParameterSpec(Class<T> paramSpec)
        throws InvalidParameterSpecException {
    if (PSSParameterSpec.class.isAssignableFrom(paramSpec)) {
        return paramSpec.cast(spec);
    } else {
        throw new InvalidParameterSpecException
            ("Inappropriate parameter specification");
    }
}
 

static boolean test(String pg, String ps, String pv, PSSParameterSpec pss)
        throws Exception {

    KeyPairGenerator kpg = pg.length() == 1
            ? KeyPairGenerator.getInstance("RSA")
            :KeyPairGenerator.getInstance("RSA", pg);
    kpg.initialize(
            pss.getDigestAlgorithm().equals("SHA-512") ? 2048: 1024,
            NOT_SECURE_RANDOM);
    KeyPair kp = kpg.generateKeyPair();
    PrivateKey pr = kp.getPrivate();
    PublicKey pu = kp.getPublic();

    Signature s = ps.length() == 1
            ? Signature.getInstance("RSASSA-PSS")
            : Signature.getInstance("RSASSA-PSS", ps);
    s.initSign(pr);
    s.setParameter(pss);
    s.update(msg);
    byte[] sig = s.sign();

    Signature s2 = pv.length() == 1
            ? Signature.getInstance("RSASSA-PSS")
            : Signature.getInstance("RSASSA-PSS", pv);
    s2.initVerify(pu);
    s2.setParameter(pss);
    s2.update(msg);

    return s2.verify(sig);
}
 

public RsaPssSha256()
{
    super(AlgorithmIdentifiers.RSA_PSS_USING_SHA256, "SHA256withRSAandMGF1");
    MGF1ParameterSpec mgf1pec = MGF1ParameterSpec.SHA256;
    PSSParameterSpec pssSpec = new PSSParameterSpec(mgf1pec.getDigestAlgorithm(), MGF1, mgf1pec, 32, TRAILER);
    setAlgorithmParameterSpec(pssSpec);
}
 

public RsaPssSha384()
{
    super(AlgorithmIdentifiers.RSA_PSS_USING_SHA384, "SHA384withRSAandMGF1");
    MGF1ParameterSpec mgf1pec = MGF1ParameterSpec.SHA384;
    PSSParameterSpec pssSpec = new PSSParameterSpec(mgf1pec.getDigestAlgorithm(), MGF1, mgf1pec, 48, TRAILER);
    setAlgorithmParameterSpec(pssSpec);
}
 

protected P11RSAPSSSignatureSpi(PSSParameterSpec baseParamSpec, boolean isRaw) {
  this.originalSpec = baseParamSpec;
  this.paramSpec = (baseParamSpec == null) ? PSSParameterSpec.DEFAULT : baseParamSpec;
  this.mgfDigest = DigestFactory.getDigest(paramSpec.getDigestAlgorithm());
  this.saltLength = paramSpec.getSaltLength();
  this.trailer = getTrailer(paramSpec.getTrailerField());
  this.isRaw = isRaw;

  setupContentDigest();
}
 

/**
 * Test #2 for <code>PSSParameterSpec(int)</code> ctor<br>
 * Assertion:
 * throws <code>IllegalArgumentException</code>
 * if <code>saltLen</code> less than 0
 */
public final void testPSSParameterSpec0102() {
    try {
        new PSSParameterSpec(-1);
        fail("Expected IAE not thrown");
    } catch (IllegalArgumentException e) {
    }
}
 

public SHA224withRSA() {
  super(new PSSParameterSpec("SHA-224", "MGF1", new MGF1ParameterSpec("SHA-224"), 28, 1));
}
 

public SHA256withRSA() {
  super(new PSSParameterSpec("SHA-256", "MGF1", new MGF1ParameterSpec("SHA-256"), 32, 1));
}
 

/**
 * Test for <code>getMGFAlgorithm()</code> method
 * Assertion: returns mask generation function algorithm name
 */
public final void testGetMGFAlgorithm() {
    PSSParameterSpec pssps = new PSSParameterSpec("SHA-1", "MGF1",
            MGF1ParameterSpec.SHA1, 20, 1);
    assertEquals("MGF1", pssps.getMGFAlgorithm());
}
 

/**
 * Test for <code>getDigestAlgorithm()</code> method
 * Assertion: returns message digest algorithm name
 */
public final void testGetDigestAlgorithm() {
    PSSParameterSpec pssps = new PSSParameterSpec("SHA-1", "MGF1",
            MGF1ParameterSpec.SHA1, 20, 1);
    assertEquals("SHA-1", pssps.getDigestAlgorithm());
}
 

public SHA3_256withRSA() {
  super(new PSSParameterSpec("SHA3-256", "MGF1", new MGF1ParameterSpec("SHA3-256"), 32, 1));
}
 

public SHA256withRSA()
{
    super(new RSABlindedEngine(), new PSSParameterSpec("SHA-256", "MGF1", new MGF1ParameterSpec("SHA-256"), 32, 1));
}
 

public SHA3_384withRSA() {
  super(new PSSParameterSpec("SHA3-384", "MGF1", new MGF1ParameterSpec("SHA3-384"), 48, 1));
}