byte[] authorityExtensionValue = cert.getExtensionValue(Extension.authorityInfoAccess.getId()); if (authorityExtensionValue != null) Enumeration<?> objects = asn1Seq.getObjects(); while (objects.hasMoreElements()) ASN1Sequence obj = (ASN1Sequence) objects.nextElement(); ASN1ObjectIdentifier oid = (ASN1ObjectIdentifier) obj.getObjectAt(0); DERTaggedObject location = (DERTaggedObject) obj.getObjectAt(1); if (oid.equals(X509ObjectIdentifiers.id_ad_ocsp) && location.getTagNo() == GeneralName.uniformResourceIdentifier)
KeyFactory fact = KeyFactory.getInstance("RSA"); if (type.equals("RSA PRIVATE KEY")) { ASN1Sequence seq = ASN1Sequence.getInstance(content); if (seq.size() != 9) { throw new IllegalArgumentException("Invalid RSA Private Key ASN1 sequence."); publicKey = fact.generatePublic(keySpec); } else if (type.equals("RSA PUBLIC KEY")) { ASN1Sequence seq = ASN1Sequence.getInstance(content); org.bouncycastle.asn1.pkcs.RSAPublicKey key = org.bouncycastle.asn1.pkcs.RSAPublicKey.getInstance(seq); RSAPublicKeySpec pubSpec = new RSAPublicKeySpec(key.getModulus(), key.getPublicExponent());
private DSAParameter( ASN1Sequence seq) { if (seq.size() != 3) { throw new IllegalArgumentException("Bad sequence size: " + seq.size()); } Enumeration e = seq.getObjects(); p = ASN1Integer.getInstance(e.nextElement()); q = ASN1Integer.getInstance(e.nextElement()); g = ASN1Integer.getInstance(e.nextElement()); }
DERApplicationSpecific app = (DERApplicationSpecific) obj; ASN1Sequence seq = (ASN1Sequence) app.getObject(BERTags.SEQUENCE); Enumeration secEnum = seq.getObjects(); while (secEnum.hasMoreElements()) { ASN1Primitive seqObj = (ASN1Primitive) secEnum.nextElement(); System.out.println(seqObj); }
/** * @deprecated use PrivateKeyInfo.getInstance() * @param seq */ public PrivateKeyInfo( ASN1Sequence seq) { Enumeration e = seq.getObjects(); BigInteger version = ((ASN1Integer)e.nextElement()).getValue(); if (version.intValue() != 0) { throw new IllegalArgumentException("wrong version for private key info"); } algId = AlgorithmIdentifier.getInstance(e.nextElement()); privKey = ASN1OctetString.getInstance(e.nextElement()); if (e.hasMoreElements()) { attributes = ASN1Set.getInstance((ASN1TaggedObject)e.nextElement(), false); } }
/** * Returns current certificate policies or null if no policies was found. * * @return list of policies * @throws IOException when policy parsing fails */ public List<String> getCertificatePolicies() throws IOException { logger.debug(""); byte[] extensionValue = originalCert.getExtensionValue("2.5.29.32"); List<String> policies = new ArrayList<>(); byte[] octets = ((DEROctetString) DEROctetString.fromByteArray(extensionValue)).getOctets(); ASN1Sequence sequence = (ASN1Sequence) ASN1Sequence.fromByteArray(octets); Enumeration sequenceObjects = sequence.getObjects(); while (sequenceObjects.hasMoreElements()) { DLSequence next = (DLSequence) sequenceObjects.nextElement(); Object objectAt = next.getObjectAt(0); if (objectAt != null) { policies.add(objectAt.toString()); } } return policies; }
public GOST3410ParamSetParameters( ASN1Sequence seq) { Enumeration e = seq.getObjects(); keySize = ((ASN1Integer)e.nextElement()).getValue().intValue(); p = (ASN1Integer)e.nextElement(); q = (ASN1Integer)e.nextElement(); a = (ASN1Integer)e.nextElement(); }
private EncryptedPrivateKeyInfo( ASN1Sequence seq) { Enumeration e = seq.getObjects(); algId = AlgorithmIdentifier.getInstance(e.nextElement()); data = ASN1OctetString.getInstance(e.nextElement()); }
private DataGroupHash(ASN1Sequence seq) { Enumeration e = seq.getObjects(); // dataGroupNumber dataGroupNumber = ASN1Integer.getInstance(e.nextElement()); // dataGroupHashValue dataGroupHashValue = ASN1OctetString.getInstance(e.nextElement()); }
private MonetaryValue( ASN1Sequence seq) { Enumeration e = seq.getObjects(); // currency currency = Iso4217CurrencyCode.getInstance(e.nextElement()); // hashAlgorithm amount = ASN1Integer.getInstance(e.nextElement()); // exponent exponent = ASN1Integer.getInstance(e.nextElement()); }
private XMSSMTPublicKey(ASN1Sequence seq) { if (!ASN1Integer.getInstance(seq.getObjectAt(0)).getValue().equals(BigInteger.valueOf(0))) { throw new IllegalArgumentException("unknown version of sequence"); } this.publicSeed = Arrays.clone(DEROctetString.getInstance(seq.getObjectAt(1)).getOctets()); this.root = Arrays.clone(DEROctetString.getInstance(seq.getObjectAt(2)).getOctets()); }
/** * Parses an EC private key as defined in RFC 5915. * <pre> * ECPrivateKey ::= SEQUENCE { * version INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1), * privateKey OCTET STRING, * parameters [0] ECParameters {{ NamedCurve }} OPTIONAL, * publicKey [1] BIT STRING OPTIONAL * } * </pre> * * @param seq ASN1 sequence to parse * * @return EC private key */ private ECPrivateKeyParameters parseECPrivateKey(final ASN1Sequence seq) { final ASN1TaggedObject asn1Params = ASN1TaggedObject.getInstance(seq.getObjectAt(2)); final X9ECParameters params; if (asn1Params.getObject() instanceof ASN1ObjectIdentifier) { params = ECUtil.getNamedCurveByOid(ASN1ObjectIdentifier.getInstance(asn1Params.getObject())); } else { params = X9ECParameters.getInstance(asn1Params.getObject()); } return new ECPrivateKeyParameters( new BigInteger(1, ASN1OctetString.getInstance(seq.getObjectAt(1)).getOctets()), new ECDomainParameters(params.getCurve(), params.getG(), params.getN(), params.getH(), params.getSeed())); } }
private McElieceCCA2PrivateKey(ASN1Sequence seq) { BigInteger bigN = ((ASN1Integer)seq.getObjectAt(0)).getValue(); n = bigN.intValue(); BigInteger bigK = ((ASN1Integer)seq.getObjectAt(1)).getValue(); k = bigK.intValue(); encField = ((ASN1OctetString)seq.getObjectAt(2)).getOctets(); encGp = ((ASN1OctetString)seq.getObjectAt(3)).getOctets(); encP = ((ASN1OctetString)seq.getObjectAt(4)).getOctets(); digest = AlgorithmIdentifier.getInstance(seq.getObjectAt(5)); }
private GCMParameters( ASN1Sequence seq) { this.nonce = ASN1OctetString.getInstance(seq.getObjectAt(0)).getOctets(); if (seq.size() == 2) { this.icvLen = ASN1Integer.getInstance(seq.getObjectAt(1)).getValue().intValue(); } else { this.icvLen = 12; } }
private EncryptedData( ASN1Sequence seq) { int version = ((ASN1Integer)seq.getObjectAt(0)).getValue().intValue(); if (version != 0) { throw new IllegalArgumentException("sequence not version 0"); } this.data = ASN1Sequence.getInstance(seq.getObjectAt(1)); }
private XMSSKeyParams(ASN1Sequence sequence) { this.version = ASN1Integer.getInstance(sequence.getObjectAt(0)); this.height = ASN1Integer.getInstance(sequence.getObjectAt(1)).getValue().intValue(); this.treeDigest = AlgorithmIdentifier.getInstance(sequence.getObjectAt(2)); }
private byte[] DSADERtoPlain(byte[] sig) throws IOException { ASN1Sequence seq = (ASN1Sequence) ASN1Primitive.fromByteArray(sig); if (seq.size() != 2) { throw new IOException(ErrorCode.MalformedSignature); } else if (!Arrays.equals(sig, seq.getEncoded("DER"))) { throw new IOException(ErrorCode.MalformedSignature); } byte[] r = ASN1Integer.getInstance(seq.getObjectAt(0)).getValue().toByteArray(); byte[] s = ASN1Integer.getInstance(seq.getObjectAt(1)).getValue().toByteArray(); int ri = (r[0] == 0) ? 1 : 0; int rl = r.length - ri; int si = (s[0] == 0) ? 1 : 0; int sl = s.length - si; byte[] res; if (rl > sl) { res = new byte[rl * 2]; } else { res = new byte[sl * 2]; } System.arraycopy(r, ri, res, res.length/2 - rl, rl); System.arraycopy(s, si, res, res.length-sl, sl); return res; }
private Gost2814789KeyWrapParameters(ASN1Sequence seq) { if (seq.size() == 2) { this.encryptionParamSet = ASN1ObjectIdentifier.getInstance(seq.getObjectAt(0)); this.ukm = ASN1OctetString.getInstance(seq.getObjectAt(1)).getOctets(); } else if (seq.size() == 1) { this.encryptionParamSet = ASN1ObjectIdentifier.getInstance(seq.getObjectAt(0)); this.ukm = null; } else { throw new IllegalArgumentException("unknown sequence length: " + seq.size()); } }
private byte[] generateEcdsaFixedLengthSignature(final byte[] digest) throws SignatureException { byte[] signature; // Unfortunately, we need deterministic lengths some signatures are non-deterministic in length. // So, retry until we get the right length :-( do { trailingSig_.update(digest); signature = trailingSig_.sign(); if (signature.length != cryptoAlgo_.getTrailingSignatureLength()) { // Most of the time, a signature of the wrong length can be fixed // be negating s in the signature relative to the group order. ASN1Sequence seq = ASN1Sequence.getInstance(signature); ASN1Integer r = (ASN1Integer) seq.getObjectAt(0); ASN1Integer s = (ASN1Integer) seq.getObjectAt(1); ECPrivateKey ecKey = (ECPrivateKey) trailingSignaturePrivateKey_; s = new ASN1Integer(ecKey.getParams().getOrder().subtract(s.getPositiveValue())); seq = new DERSequence(new ASN1Encodable[]{r, s}); try { signature = seq.getEncoded(); } catch (IOException ex) { throw new SignatureException(ex); } } } while (signature.length != cryptoAlgo_.getTrailingSignatureLength()); return signature; }
private Challenge(ASN1Sequence seq) { int index = 0; if (seq.size() == 3) { owf = AlgorithmIdentifier.getInstance(seq.getObjectAt(index++)); } witness = ASN1OctetString.getInstance(seq.getObjectAt(index++)); challenge = ASN1OctetString.getInstance(seq.getObjectAt(index)); }