private ByteString pkcs1Bytes() { try { PrivateKeyInfo privateKeyInfo = PrivateKeyInfo.getInstance(keyPair.getPrivate().getEncoded()); return ByteString.of(privateKeyInfo.parsePrivateKey().toASN1Primitive().getEncoded()); } catch (IOException e) { throw new AssertionError(e); } }
private String doCollection(ASN1Encodable[] asn1Encodables) throws IOException { switch (asn1Encodables.length) { case 1: // one row, one column return "<table><tr><td colspan='2'>" + doPrimitive(asn1Encodables[0].toASN1Primitive()) + "</td></tr></table>"; case 2: // one row, two columns return "<table><tr><td>" + doPrimitive(asn1Encodables[0].toASN1Primitive()) + "</td>" + "<td>" + doPrimitive(asn1Encodables[1].toASN1Primitive()) + "</td></tr></table>"; default: // a row per per item final StringBuilder sb = new StringBuilder(); for (ASN1Encodable asn1Encodable : asn1Encodables) { sb.append("<table><tr><td colspan='2'>").append(doPrimitive(asn1Encodable.toASN1Primitive())).append("</td></tr></table>"); } return sb.toString(); } }
ASN1Encodable[] asn1Encodables = asn1Sequence.toArray(); for (ASN1Encodable asn1Encodable : asn1Encodables) { ASN1Primitive asn1Primitive = asn1Encodable.toASN1Primitive(); if (asn1Primitive instanceof ASN1Integer) { ASN1Integer asn1Integer = (ASN1Integer) asn1Primitive;
public ASN1Primitive toASN1Primitive() { return obj.toASN1Primitive(); } }
static ASN1Primitive asPrimitive(ASN1Encodable encodable) { return encodable instanceof ASN1Primitive ? (ASN1Primitive) encodable : encodable.toASN1Primitive(); }
public BERConstructedOctetString( ASN1Encodable obj) { this(obj.toASN1Primitive()); }
/** * Constructor from the encoding of an ASN.1 object. * * @param obj the object to be encoded. */ public DEROctetString( ASN1Encodable obj) throws IOException { super(obj.toASN1Primitive().getEncoded(ASN1Encoding.DER)); }
public byte[] getCertHash() { if (otherCertHash.toASN1Primitive() instanceof ASN1OctetString) { // SHA-1 return ((ASN1OctetString)otherCertHash.toASN1Primitive()).getOctets(); } else { return DigestInfo.getInstance(otherCertHash).getDigest(); } }
int encodedLength() throws IOException { int length = 0; for (Enumeration e = getObjects(); e.hasMoreElements();) { length += ((ASN1Encodable)e.nextElement()).toASN1Primitive().encodedLength(); } return 2 + length + 2; }
private ASN1Primitive getObjFromVector(ASN1EncodableVector v, int index) { if (v.size() <= index) { throw new IllegalArgumentException("too few objects in input vector"); } return v.get(index).toASN1Primitive(); }
private PolicyMapping(ASN1Sequence seq) { // java object in sequence is actually not ASN1ObjectIdentifier but CertPolicyId, // so we do a conversion in order to avoid possible class cast exception here this.issuerDomainPolicy = ASN1ObjectIdentifier.getInstance(seq.getObjectAt(0).toASN1Primitive()); this.subjectDomainPolicy = ASN1ObjectIdentifier.getInstance(seq.getObjectAt(1).toASN1Primitive()); }
public ASN1OctetString getMac() throws IOException { if (nextObject == null) { nextObject = seq.readObject(); } ASN1Encodable o = nextObject; nextObject = null; return ASN1OctetString.getInstance(o.toASN1Primitive()); }
public Evidence getTemporalEvidence() throws IOException { if (temporalEvidence == null) { temporalEvidence = Evidence.getInstance(parser.readObject().toASN1Primitive()); } return temporalEvidence; }
/** * Add an object to the SEQUENCE being generated. * * @param object an ASN.1 encodable object to add. * @throws IOException if the target stream cannot be written to or the object cannot be encoded. */ public void addObject( ASN1Encodable object) throws IOException { object.toASN1Primitive().encode(new BEROutputStream(_out)); }
private ByteString pkcs1Bytes() { try { PrivateKeyInfo privateKeyInfo = PrivateKeyInfo.getInstance(keyPair.getPrivate().getEncoded()); return ByteString.of(privateKeyInfo.parsePrivateKey().toASN1Primitive().getEncoded()); } catch (IOException e) { throw new AssertionError(e); } }
@SneakyThrows public static String convertPrivateKeyFromPkcs8ToPkcs1Pem(final byte[] privateKeyPkcs8) { // Convert private key from PKCS8 to PKCS1: final ASN1Encodable encodable = PrivateKeyInfo.getInstance(privateKeyPkcs8).parsePrivateKey(); return pem(encodable.toASN1Primitive().getEncoded(), RsaKey.KEY_FORMAT_PKCS1, RsaKey.KEY_TYPE_PRIVATE); }
public DLBitString( ASN1Encodable obj) throws IOException { super(obj.toASN1Primitive().getEncoded(ASN1Encoding.DER), 0); }
@Override public void parse(ASN1Primitive derObject) { ASN1Sequence derSequence = ASN1Object.getDERSequence(derObject); this.endCertRevReq = new RevReq(); this.endCertRevReq.parse(derSequence.getObjectAt(0).toASN1Primitive()); this.caCerts = new RevReq(); this.caCerts.parse(derSequence.getObjectAt(1).toASN1Primitive()); }
@Override public void parse(ASN1Primitive derObject) { ASN1Sequence derSequence = ASN1Object.getDERSequence(derObject); this.mandatedUnsignedAttr = new MandatedUnsignedAttr(); this.mandatedUnsignedAttr.parse(derSequence.getObjectAt(0).toASN1Primitive()); if (derSequence.size() == 2) { this.signPolExtensions = new SignPolExtensions(); this.signPolExtensions.parse(derSequence.getObjectAt(1).toASN1Primitive()); } }
public EncryptedContentInfoParser( ASN1SequenceParser seq) throws IOException { _contentType = (ASN1ObjectIdentifier)seq.readObject(); _contentEncryptionAlgorithm = AlgorithmIdentifier.getInstance(seq.readObject().toASN1Primitive()); _encryptedContent = (ASN1TaggedObjectParser)seq.readObject(); }