// // Decompiled by Procyon v0.6.0 // package org.bouncycastle.pqc.crypto.util; import org.bouncycastle.util.Pack; import org.bouncycastle.pqc.crypto.bike.BIKEParameters; import org.bouncycastle.pqc.crypto.crystals.dilithium.DilithiumParameters; import org.bouncycastle.pqc.crypto.mldsa.MLDSAPublicKeyParameters; import org.bouncycastle.pqc.crypto.mldsa.MLDSAParameters; import org.bouncycastle.pqc.crypto.mlkem.MLKEMPublicKeyParameters; import org.bouncycastle.pqc.crypto.mlkem.MLKEMParameters; import org.bouncycastle.pqc.crypto.slhdsa.SLHDSAParameters; import org.bouncycastle.pqc.asn1.SPHINCSPLUSPublicKey; import org.bouncycastle.asn1.ASN1Encodable; import org.bouncycastle.pqc.crypto.sphincsplus.SPHINCSPlusParameters; import org.bouncycastle.asn1.ASN1ObjectIdentifier; import org.bouncycastle.asn1.x509.AlgorithmIdentifier; import org.bouncycastle.pqc.crypto.snova.SnovaPrivateKeyParameters; import org.bouncycastle.pqc.crypto.mayo.MayoPrivateKeyParameters; import org.bouncycastle.pqc.crypto.xmss.BDSStateMap; import org.bouncycastle.pqc.crypto.xmss.XMSSMTPrivateKeyParameters; import org.bouncycastle.pqc.crypto.xmss.XMSSMTParameters; import org.bouncycastle.pqc.asn1.XMSSMTPrivateKey; import org.bouncycastle.pqc.asn1.XMSSMTKeyParams; import org.bouncycastle.pqc.crypto.xmss.XMSSUtil; import org.bouncycastle.pqc.crypto.xmss.BDS; import org.bouncycastle.pqc.crypto.xmss.XMSSPrivateKeyParameters; import org.bouncycastle.pqc.crypto.xmss.XMSSParameters; import org.bouncycastle.pqc.asn1.XMSSPrivateKey; import org.bouncycastle.pqc.asn1.XMSSKeyParams; import org.bouncycastle.pqc.crypto.rainbow.RainbowPrivateKeyParameters; import org.bouncycastle.pqc.crypto.hqc.HQCPrivateKeyParameters; import org.bouncycastle.pqc.crypto.bike.BIKEPrivateKeyParameters; import org.bouncycastle.pqc.crypto.falcon.FalconPrivateKeyParameters; import org.bouncycastle.pqc.asn1.FalconPrivateKey; import org.bouncycastle.pqc.crypto.crystals.dilithium.DilithiumPublicKeyParameters; import org.bouncycastle.asn1.DEROctetString; import org.bouncycastle.pqc.crypto.crystals.dilithium.DilithiumPrivateKeyParameters; import org.bouncycastle.asn1.ASN1BitString; import org.bouncycastle.asn1.ASN1Integer; import org.bouncycastle.pqc.crypto.mldsa.MLDSAPrivateKeyParameters; import org.bouncycastle.pqc.crypto.ntruprime.SNTRUPrimePrivateKeyParameters; import org.bouncycastle.pqc.crypto.ntruprime.NTRULPRimePrivateKeyParameters; import org.bouncycastle.pqc.crypto.mlkem.MLKEMPrivateKeyParameters; import org.bouncycastle.asn1.nist.NISTObjectIdentifiers; import org.bouncycastle.pqc.crypto.ntru.NTRUPrivateKeyParameters; import org.bouncycastle.pqc.crypto.saber.SABERPrivateKeyParameters; import org.bouncycastle.pqc.crypto.frodo.FrodoPrivateKeyParameters; import org.bouncycastle.pqc.crypto.cmce.CMCEPrivateKeyParameters; import org.bouncycastle.pqc.asn1.CMCEPrivateKey; import org.bouncycastle.pqc.crypto.picnic.PicnicPrivateKeyParameters; import org.bouncycastle.pqc.crypto.slhdsa.SLHDSAPrivateKeyParameters; import org.bouncycastle.pqc.crypto.sphincsplus.SPHINCSPlusPrivateKeyParameters; import org.bouncycastle.pqc.asn1.SPHINCSPLUSPrivateKey; import org.bouncycastle.asn1.ASN1Sequence; import org.bouncycastle.asn1.bc.BCObjectIdentifiers; import org.bouncycastle.pqc.crypto.lms.HSSPrivateKeyParameters; import org.bouncycastle.util.Arrays; import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers; import org.bouncycastle.pqc.crypto.newhope.NHPrivateKeyParameters; import org.bouncycastle.pqc.crypto.sphincs.SPHINCSPrivateKeyParameters; import org.bouncycastle.pqc.asn1.SPHINCS256KeyParams; import org.bouncycastle.asn1.ASN1OctetString; import org.bouncycastle.pqc.asn1.PQCObjectIdentifiers; import org.bouncycastle.asn1.ASN1InputStream; import java.io.InputStream; import java.io.IOException; import org.bouncycastle.asn1.pkcs.PrivateKeyInfo; import org.bouncycastle.asn1.ASN1Primitive; import org.bouncycastle.crypto.params.AsymmetricKeyParameter; public class PrivateKeyFactory { public static AsymmetricKeyParameter createKey(final byte[] array) throws IOException { if (array == null) { throw new IllegalArgumentException("privateKeyInfoData array null"); } if (array.length == 0) { throw new IllegalArgumentException("privateKeyInfoData array empty"); } return createKey(PrivateKeyInfo.getInstance(ASN1Primitive.fromByteArray(array))); } public static AsymmetricKeyParameter createKey(final InputStream inputStream) throws IOException { return createKey(PrivateKeyInfo.getInstance(new ASN1InputStream(inputStream).readObject())); } public static AsymmetricKeyParameter createKey(final PrivateKeyInfo privateKeyInfo) throws IOException { if (privateKeyInfo == null) { throw new IllegalArgumentException("keyInfo array null"); } final AlgorithmIdentifier privateKeyAlgorithm = privateKeyInfo.getPrivateKeyAlgorithm(); final ASN1ObjectIdentifier algorithm = privateKeyAlgorithm.getAlgorithm(); if (algorithm.equals(PQCObjectIdentifiers.sphincs256)) { return new SPHINCSPrivateKeyParameters(ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets(), Utils.sphincs256LookupTreeAlgName(SPHINCS256KeyParams.getInstance(privateKeyAlgorithm.getParameters()))); } if (algorithm.equals(PQCObjectIdentifiers.newHope)) { return new NHPrivateKeyParameters(convert(ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets())); } if (algorithm.equals(PKCSObjectIdentifiers.id_alg_hss_lms_hashsig)) { final byte[] octets = parseOctetString(privateKeyInfo.getPrivateKey(), 64).getOctets(); final ASN1BitString publicKeyData = privateKeyInfo.getPublicKeyData(); if (publicKeyData != null) { return HSSPrivateKeyParameters.getInstance(Arrays.copyOfRange(octets, 4, octets.length), publicKeyData.getOctets()); } return HSSPrivateKeyParameters.getInstance(Arrays.copyOfRange(octets, 4, octets.length)); } else if (algorithm.on(BCObjectIdentifiers.sphincsPlus) || algorithm.on(BCObjectIdentifiers.sphincsPlus_interop)) { final SPHINCSPlusParameters sphincsPlusParamsLookup = Utils.sphincsPlusParamsLookup(algorithm); final ASN1Encodable privateKey = privateKeyInfo.parsePrivateKey(); if (privateKey instanceof ASN1Sequence) { final SPHINCSPLUSPrivateKey instance = SPHINCSPLUSPrivateKey.getInstance(privateKey); final SPHINCSPLUSPublicKey publicKey = instance.getPublicKey(); return new SPHINCSPlusPrivateKeyParameters(sphincsPlusParamsLookup, instance.getSkseed(), instance.getSkprf(), publicKey.getPkseed(), publicKey.getPkroot()); } return new SPHINCSPlusPrivateKeyParameters(sphincsPlusParamsLookup, ASN1OctetString.getInstance(privateKey).getOctets()); } else { if (Utils.slhdsaParams.containsKey(algorithm)) { final SLHDSAParameters slhdsaParamsLookup = Utils.slhdsaParamsLookup(algorithm); return new SLHDSAPrivateKeyParameters(slhdsaParamsLookup, parseOctetString(privateKeyInfo.getPrivateKey(), slhdsaParamsLookup.getN() * 4).getOctets()); } if (algorithm.on(BCObjectIdentifiers.picnic)) { return new PicnicPrivateKeyParameters(Utils.picnicParamsLookup(algorithm), ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets()); } if (algorithm.on(BCObjectIdentifiers.pqc_kem_mceliece)) { final CMCEPrivateKey instance2 = CMCEPrivateKey.getInstance(privateKeyInfo.parsePrivateKey()); return new CMCEPrivateKeyParameters(Utils.mcElieceParamsLookup(algorithm), instance2.getDelta(), instance2.getC(), instance2.getG(), instance2.getAlpha(), instance2.getS()); } if (algorithm.on(BCObjectIdentifiers.pqc_kem_frodo)) { return new FrodoPrivateKeyParameters(Utils.frodoParamsLookup(algorithm), ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets()); } if (algorithm.on(BCObjectIdentifiers.pqc_kem_saber)) { return new SABERPrivateKeyParameters(Utils.saberParamsLookup(algorithm), ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets()); } if (algorithm.on(BCObjectIdentifiers.pqc_kem_ntru)) { return new NTRUPrivateKeyParameters(Utils.ntruParamsLookup(algorithm), ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets()); } if (algorithm.equals(NISTObjectIdentifiers.id_alg_ml_kem_512) || algorithm.equals(NISTObjectIdentifiers.id_alg_ml_kem_768) || algorithm.equals(NISTObjectIdentifiers.id_alg_ml_kem_1024)) { final ASN1Primitive primitiveString = parsePrimitiveString(privateKeyInfo.getPrivateKey(), 64); final MLKEMParameters mlkemParamsLookup = Utils.mlkemParamsLookup(algorithm); MLKEMPublicKeyParameters publicKeyParams = null; if (privateKeyInfo.getPublicKeyData() != null) { publicKeyParams = PublicKeyFactory.MLKEMConverter.getPublicKeyParams(mlkemParamsLookup, privateKeyInfo.getPublicKeyData()); } if (primitiveString instanceof ASN1OctetString) { return new MLKEMPrivateKeyParameters(mlkemParamsLookup, ((ASN1OctetString)primitiveString).getOctets(), publicKeyParams); } if (!(primitiveString instanceof ASN1Sequence)) { throw new IllegalArgumentException("invalid " + mlkemParamsLookup.getName() + " private key"); } final ASN1Sequence asn1Sequence = (ASN1Sequence)primitiveString; final byte[] octets2 = ASN1OctetString.getInstance(asn1Sequence.getObjectAt(0)).getOctets(); final byte[] octets3 = ASN1OctetString.getInstance(asn1Sequence.getObjectAt(1)).getOctets(); final MLKEMPrivateKeyParameters mlkemPrivateKeyParameters = new MLKEMPrivateKeyParameters(mlkemParamsLookup, octets2, publicKeyParams); if (!Arrays.constantTimeAreEqual(mlkemPrivateKeyParameters.getEncoded(), octets3)) { throw new IllegalArgumentException("inconsistent " + mlkemParamsLookup.getName() + " private key"); } return mlkemPrivateKeyParameters; } else { if (algorithm.on(BCObjectIdentifiers.pqc_kem_ntrulprime)) { final ASN1Sequence instance3 = ASN1Sequence.getInstance(privateKeyInfo.parsePrivateKey()); return new NTRULPRimePrivateKeyParameters(Utils.ntrulprimeParamsLookup(algorithm), ASN1OctetString.getInstance(instance3.getObjectAt(0)).getOctets(), ASN1OctetString.getInstance(instance3.getObjectAt(1)).getOctets(), ASN1OctetString.getInstance(instance3.getObjectAt(2)).getOctets(), ASN1OctetString.getInstance(instance3.getObjectAt(3)).getOctets()); } if (algorithm.on(BCObjectIdentifiers.pqc_kem_sntruprime)) { final ASN1Sequence instance4 = ASN1Sequence.getInstance(privateKeyInfo.parsePrivateKey()); return new SNTRUPrimePrivateKeyParameters(Utils.sntruprimeParamsLookup(algorithm), ASN1OctetString.getInstance(instance4.getObjectAt(0)).getOctets(), ASN1OctetString.getInstance(instance4.getObjectAt(1)).getOctets(), ASN1OctetString.getInstance(instance4.getObjectAt(2)).getOctets(), ASN1OctetString.getInstance(instance4.getObjectAt(3)).getOctets(), ASN1OctetString.getInstance(instance4.getObjectAt(4)).getOctets()); } if (Utils.mldsaParams.containsKey(algorithm)) { final ASN1Primitive primitiveString2 = parsePrimitiveString(privateKeyInfo.getPrivateKey(), 32); final MLDSAParameters mldsaParamsLookup = Utils.mldsaParamsLookup(algorithm); MLDSAPublicKeyParameters publicKeyParams2 = null; if (privateKeyInfo.getPublicKeyData() != null) { publicKeyParams2 = PublicKeyFactory.MLDSAConverter.getPublicKeyParams(mldsaParamsLookup, privateKeyInfo.getPublicKeyData()); } if (primitiveString2 instanceof ASN1OctetString) { return new MLDSAPrivateKeyParameters(mldsaParamsLookup, ((ASN1OctetString)primitiveString2).getOctets(), publicKeyParams2); } if (!(primitiveString2 instanceof ASN1Sequence)) { throw new IllegalArgumentException("invalid " + mldsaParamsLookup.getName() + " private key"); } final ASN1Sequence asn1Sequence2 = (ASN1Sequence)primitiveString2; final byte[] octets4 = ASN1OctetString.getInstance(asn1Sequence2.getObjectAt(0)).getOctets(); final byte[] octets5 = ASN1OctetString.getInstance(asn1Sequence2.getObjectAt(1)).getOctets(); final MLDSAPrivateKeyParameters mldsaPrivateKeyParameters = new MLDSAPrivateKeyParameters(mldsaParamsLookup, octets4, publicKeyParams2); if (!Arrays.constantTimeAreEqual(mldsaPrivateKeyParameters.getEncoded(), octets5)) { throw new IllegalArgumentException("inconsistent " + mldsaParamsLookup.getName() + " private key"); } return mldsaPrivateKeyParameters; } else if (algorithm.equals(BCObjectIdentifiers.dilithium2) || algorithm.equals(BCObjectIdentifiers.dilithium3) || algorithm.equals(BCObjectIdentifiers.dilithium5)) { final ASN1Encodable privateKey2 = privateKeyInfo.parsePrivateKey(); final DilithiumParameters dilithiumParamsLookup = Utils.dilithiumParamsLookup(algorithm); if (privateKey2 instanceof ASN1Sequence) { final ASN1Sequence instance5 = ASN1Sequence.getInstance(privateKey2); final int intValueExact = ASN1Integer.getInstance(instance5.getObjectAt(0)).intValueExact(); if (intValueExact != 0) { throw new IOException("unknown private key version: " + intValueExact); } if (privateKeyInfo.getPublicKeyData() != null) { return new DilithiumPrivateKeyParameters(dilithiumParamsLookup, ASN1BitString.getInstance(instance5.getObjectAt(1)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(2)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(3)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(4)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(5)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(6)).getOctets(), PublicKeyFactory.DilithiumConverter.getPublicKeyParams(dilithiumParamsLookup, privateKeyInfo.getPublicKeyData()).getT1()); } return new DilithiumPrivateKeyParameters(dilithiumParamsLookup, ASN1BitString.getInstance(instance5.getObjectAt(1)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(2)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(3)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(4)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(5)).getOctets(), ASN1BitString.getInstance(instance5.getObjectAt(6)).getOctets(), null); } else { if (!(privateKey2 instanceof DEROctetString)) { throw new IOException("not supported"); } final byte[] octets6 = ASN1OctetString.getInstance(privateKey2).getOctets(); if (privateKeyInfo.getPublicKeyData() != null) { return new DilithiumPrivateKeyParameters(dilithiumParamsLookup, octets6, PublicKeyFactory.DilithiumConverter.getPublicKeyParams(dilithiumParamsLookup, privateKeyInfo.getPublicKeyData())); } return new DilithiumPrivateKeyParameters(dilithiumParamsLookup, octets6, null); } } else { if (algorithm.equals(BCObjectIdentifiers.falcon_512) || algorithm.equals(BCObjectIdentifiers.falcon_1024)) { final FalconPrivateKey instance6 = FalconPrivateKey.getInstance(privateKeyInfo.parsePrivateKey()); return new FalconPrivateKeyParameters(Utils.falconParamsLookup(algorithm), instance6.getf(), instance6.getG(), instance6.getF(), instance6.getPublicKey().getH()); } if (algorithm.equals(BCObjectIdentifiers.old_falcon_512) || algorithm.equals(BCObjectIdentifiers.old_falcon_1024)) { final FalconPrivateKey instance7 = FalconPrivateKey.getInstance(privateKeyInfo.parsePrivateKey()); return new FalconPrivateKeyParameters(Utils.falconParamsLookup(algorithm), instance7.getf(), instance7.getG(), instance7.getF(), instance7.getPublicKey().getH()); } if (algorithm.on(BCObjectIdentifiers.pqc_kem_bike)) { final byte[] octets7 = ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets(); final BIKEParameters bikeParamsLookup = Utils.bikeParamsLookup(algorithm); return new BIKEPrivateKeyParameters(bikeParamsLookup, Arrays.copyOfRange(octets7, 0, bikeParamsLookup.getRByte()), Arrays.copyOfRange(octets7, bikeParamsLookup.getRByte(), 2 * bikeParamsLookup.getRByte()), Arrays.copyOfRange(octets7, 2 * bikeParamsLookup.getRByte(), octets7.length)); } if (algorithm.on(BCObjectIdentifiers.pqc_kem_hqc)) { return new HQCPrivateKeyParameters(Utils.hqcParamsLookup(algorithm), ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets()); } if (algorithm.on(BCObjectIdentifiers.rainbow)) { return new RainbowPrivateKeyParameters(Utils.rainbowParamsLookup(algorithm), ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets()); } if (algorithm.equals(PQCObjectIdentifiers.xmss)) { final XMSSKeyParams instance8 = XMSSKeyParams.getInstance(privateKeyAlgorithm.getParameters()); final ASN1ObjectIdentifier algorithm2 = instance8.getTreeDigest().getAlgorithm(); final XMSSPrivateKey instance9 = XMSSPrivateKey.getInstance(privateKeyInfo.parsePrivateKey()); try { final XMSSPrivateKeyParameters.Builder withRoot = new XMSSPrivateKeyParameters.Builder(new XMSSParameters(instance8.getHeight(), Utils.getDigest(algorithm2))).withIndex(instance9.getIndex()).withSecretKeySeed(instance9.getSecretKeySeed()).withSecretKeyPRF(instance9.getSecretKeyPRF()).withPublicSeed(instance9.getPublicSeed()).withRoot(instance9.getRoot()); if (instance9.getVersion() != 0) { withRoot.withMaxIndex(instance9.getMaxIndex()); } if (instance9.getBdsState() != null) { withRoot.withBDSState(((BDS)XMSSUtil.deserialize(instance9.getBdsState(), BDS.class)).withWOTSDigest(algorithm2)); } return withRoot.build(); } catch (final ClassNotFoundException ex) { throw new IOException("ClassNotFoundException processing BDS state: " + ex.getMessage()); } } if (algorithm.equals(PQCObjectIdentifiers.xmss_mt)) { final XMSSMTKeyParams instance10 = XMSSMTKeyParams.getInstance(privateKeyAlgorithm.getParameters()); final ASN1ObjectIdentifier algorithm3 = instance10.getTreeDigest().getAlgorithm(); try { final XMSSMTPrivateKey instance11 = XMSSMTPrivateKey.getInstance(privateKeyInfo.parsePrivateKey()); final XMSSMTPrivateKeyParameters.Builder withRoot2 = new XMSSMTPrivateKeyParameters.Builder(new XMSSMTParameters(instance10.getHeight(), instance10.getLayers(), Utils.getDigest(algorithm3))).withIndex(instance11.getIndex()).withSecretKeySeed(instance11.getSecretKeySeed()).withSecretKeyPRF(instance11.getSecretKeyPRF()).withPublicSeed(instance11.getPublicSeed()).withRoot(instance11.getRoot()); if (instance11.getVersion() != 0) { withRoot2.withMaxIndex(instance11.getMaxIndex()); } if (instance11.getBdsState() != null) { withRoot2.withBDSState(((BDSStateMap)XMSSUtil.deserialize(instance11.getBdsState(), BDSStateMap.class)).withWOTSDigest(algorithm3)); } return withRoot2.build(); } catch (final ClassNotFoundException ex2) { throw new IOException("ClassNotFoundException processing BDS state: " + ex2.getMessage()); } } if (algorithm.on(BCObjectIdentifiers.mayo)) { return new MayoPrivateKeyParameters(Utils.mayoParamsLookup(algorithm), ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets()); } if (algorithm.on(BCObjectIdentifiers.snova)) { return new SnovaPrivateKeyParameters(Utils.snovaParamsLookup(algorithm), ASN1OctetString.getInstance(privateKeyInfo.parsePrivateKey()).getOctets()); } throw new RuntimeException("algorithm identifier in private key not recognised"); } } } } private static ASN1OctetString parseOctetString(final ASN1OctetString asn1OctetString, final int n) throws IOException { final byte[] octets = asn1OctetString.getOctets(); if (octets.length == n) { return asn1OctetString; } final ASN1OctetString octetData = Utils.parseOctetData(octets); if (octetData != null) { return ASN1OctetString.getInstance(octetData); } return asn1OctetString; } private static ASN1Primitive parsePrimitiveString(final ASN1OctetString asn1OctetString, final int n) throws IOException { final byte[] octets = asn1OctetString.getOctets(); if (octets.length == n) { return asn1OctetString; } final ASN1Primitive data = Utils.parseData(octets); if (data instanceof ASN1OctetString) { return ASN1OctetString.getInstance(data); } if (data instanceof ASN1Sequence) { return ASN1Sequence.getInstance(data); } return asn1OctetString; } private static short[] convert(final byte[] array) { final short[] array2 = new short[array.length / 2]; for (int i = 0; i != array2.length; ++i) { array2[i] = Pack.littleEndianToShort(array, i * 2); } return array2; } }