public X509Extension(
bool critical,
ASN1OctetString value)
{
this.critical = critical;
this.value = value;
}
public CAST5CBCParameters(
byte[] iv,
int keyLength)
{
this.iv = new DEROctetString(iv);
this.keyLength = new DERInteger(keyLength);
}
public X509Extension(
DERBoolean critical,
ASN1OctetString value)
{
this.critical = critical.isTrue();
this.value = value;
}
public PBEParameter(
byte[] salt,
int iterationCount)
{
this.octStr = new DEROctetString(salt);
this.iterationCount = new DERInteger(iterationCount);
}
public AuthorityKeyIdentifier(
ASN1Sequence seq)
{
IEnumerator e = seq.getObjects();
while (e.MoveNext())
{
DERTaggedObject o = (DERTaggedObject)e.Current;
switch ((int)o.getTagNo())
{
case 0:
this.keyidentifier = ASN1OctetString.getInstance(o, false);
break;
case 1:
this.certissuer = GeneralNames.getInstance(o, false);
break;
case 2:
this.certserno = DERInteger.getInstance(o, false);
break;
default:
throw new ArgumentException("illegal tag");
}
}
}
public PKCS12PBEParams(
byte[] salt,
int iterations)
{
this.iv = new DEROctetString(salt);
this.iterations = new DERInteger(iterations);
}
public static ResponderID getInstance(
object obj)
{
if (obj == null || obj is ResponderID)
{
return((ResponderID)obj);
}
else if (obj is DEROctetString)
{
return(new ResponderID((DEROctetString)obj));
}
else if (obj is ASN1TaggedObject)
{
ASN1TaggedObject o = (ASN1TaggedObject)obj;
if ((int)o.getTagNo() == 1)
{
return(new ResponderID(X509Name.getInstance(o, true)));
}
else
{
return(new ResponderID(ASN1OctetString.getInstance(o, true)));
}
}
return(new ResponderID(X509Name.getInstance(obj)));
}
public RC2CBCParameter(
int parameterVersion,
byte[] iv)
{
this.version = new DERInteger(parameterVersion);
this.iv = new DEROctetString(iv);
}
public EncryptedPrivateKeyInfo(
AlgorithmIdentifier algId,
byte[] encoding)
{
this.algId = algId;
this.data = new DEROctetString(encoding);
}
public KEKIdentifier(
ASN1Sequence seq)
{
keyIdentifier = (ASN1OctetString)seq.getObjectAt(0);
switch (seq.size())
{
case 1:
break;
case 2:
if (seq.getObjectAt(1) is DERGeneralizedTime)
{
date = (DERGeneralizedTime)seq.getObjectAt(1);
}
else
{
other = OtherKeyAttribute.getInstance(seq.getObjectAt(2));
}
break;
case 3:
date = (DERGeneralizedTime)seq.getObjectAt(1);
other = OtherKeyAttribute.getInstance(seq.getObjectAt(2));
break;
default:
throw new ArgumentException("Invalid KEKIdentifier");
}
}
public ResponseBytes(
DERObjectIdentifier responseType,
ASN1OctetString response)
{
this.responseType = responseType;
this.response = response;
}
public KeySpecificInfo(
DERObjectIdentifier algorithm,
ASN1OctetString counter)
{
this.algorithm = algorithm;
this.counter = counter;
}
public PasswordRecipientInfo(
AlgorithmIdentifier keyEncryptionAlgorithm,
ASN1OctetString encryptedKey)
{
this.version = new DERInteger(0);
this.keyEncryptionAlgorithm = keyEncryptionAlgorithm;
this.encryptedKey = encryptedKey;
}
public KEKRecipientInfo(
ASN1Sequence seq)
{
version = (DERInteger)seq.getObjectAt(0);
kekid = KEKIdentifier.getInstance(seq.getObjectAt(1));
keyEncryptionAlgorithm = AlgorithmIdentifier.getInstance(seq.getObjectAt(2));
encryptedKey = (ASN1OctetString)seq.getObjectAt(3);
}
public BigInteger getKey()
{
ASN1OctetString octs = (ASN1OctetString)seq.getObjectAt(1);
BigInteger k = new BigInteger(1, octs.getOctets());
return(k);
}
public CertID(
ASN1Sequence seq)
{
hashAlgorithm = AlgorithmIdentifier.getInstance(seq.getObjectAt(0));
issuerNameHash = (ASN1OctetString)seq.getObjectAt(1);
issuerKeyHash = (ASN1OctetString)seq.getObjectAt(2);
serialNumber = (DERInteger)seq.getObjectAt(3);
}
public ASN1Encodable getId()
{
if (id is ASN1TaggedObject)
{
return(ASN1OctetString.getInstance((ASN1TaggedObject)id, false));
}
return(id);
}
public ASN1Encodable getId()
{
if (id is ASN1TaggedObject)
{
return(ASN1OctetString.getInstance((ASN1TaggedObject)id, false));
}
return(IssuerAndSerialNumber.getInstance(id));
}
public KEKIdentifier(
byte[] keyIdentifier,
DERGeneralizedTime date,
OtherKeyAttribute other)
{
this.keyIdentifier = new DEROctetString(keyIdentifier);
this.date = date;
this.other = other;
}
public EncryptedContentInfo(
DERObjectIdentifier contentType,
AlgorithmIdentifier contentEncryptionAlgorithm,
ASN1OctetString encryptedContent)
{
this.contentType = contentType;
this.contentEncryptionAlgorithm = contentEncryptionAlgorithm;
this.encryptedContent = encryptedContent;
}
public OtherInfo(
KeySpecificInfo keyInfo,
ASN1OctetString partyAInfo,
ASN1OctetString suppPubInfo)
{
this.keyInfo = keyInfo;
this.partyAInfo = partyAInfo;
this.suppPubInfo = suppPubInfo;
}
public RecipientKeyIdentifier(
ASN1OctetString subjectKeyIdentifier,
DERGeneralizedTime date,
OtherKeyAttribute other)
{
this.subjectKeyIdentifier = subjectKeyIdentifier;
this.date = date;
this.other = other;
}
public PBEParameter(ASN1Sequence seq)
{
IEnumerator e = seq.getObjects();
e.MoveNext();
octStr = (ASN1OctetString)e.Current;
e.MoveNext();
iterationCount = (DERInteger)e.Current;
}
public KEKRecipientInfo(
KEKIdentifier kekid,
AlgorithmIdentifier keyEncryptionAlgorithm,
ASN1OctetString encryptedKey)
{
this.version = new DERInteger(4);
this.kekid = kekid;
this.keyEncryptionAlgorithm = keyEncryptionAlgorithm;
this.encryptedKey = encryptedKey;
}
public KeySpecificInfo(
ASN1Sequence seq)
{
IEnumerator e = seq.getObjects();
e.MoveNext();
algorithm = (DERObjectIdentifier)e.Current;
e.MoveNext();
counter = (ASN1OctetString)e.Current;
}
public EncryptedPrivateKeyInfo(
ASN1Sequence seq)
{
IEnumerator e = seq.getObjects();
e.MoveNext();
algId = new AlgorithmIdentifier((ASN1Sequence)e.Current);
e.MoveNext();
data = (ASN1OctetString)e.Current;
}
public CertID(
AlgorithmIdentifier hashAlgorithm,
ASN1OctetString issuerNameHash,
ASN1OctetString issuerKeyHash,
DERInteger serialNumber)
{
this.hashAlgorithm = hashAlgorithm;
this.issuerNameHash = issuerNameHash;
this.issuerKeyHash = issuerKeyHash;
this.serialNumber = serialNumber;
}
public ASN1OctetString getContent()
{
if (data.size() == 3)
{
DERTaggedObject o = (DERTaggedObject)data.getObjectAt(2);
return(ASN1OctetString.getInstance(o.getObject()));
}
return(null);
}
/**
*
* Calulates the keyidentifier using a SHA1 hash over the BIT STRING
* from SubjectPublicKeyInfo as defined in RFC2459.
*
* Example of making a AuthorityKeyIdentifier:
* <pre>
* SubjectPublicKeyInfo apki = new SubjectPublicKeyInfo((ASN1Sequence)new DERInputStream(
* new ByteArrayInputStream(publicKey.getEncoded())).readObject());
* AuthorityKeyIdentifier aki = new AuthorityKeyIdentifier(apki);
* </pre>
*
**/
public AuthorityKeyIdentifier(
SubjectPublicKeyInfo spki)
{
Digest digest = new SHA1Digest();
byte[] resBuf = new byte[digest.getDigestSize()];
byte[] bytes = spki.getPublicKeyData().getBytes();
digest.update(bytes, 0, bytes.Length);
digest.doFinal(resBuf, 0);
this.keyidentifier = new DEROctetString(resBuf);
}
public KeyAgreeRecipientInfo(
OriginatorIdentifierOrKey originator,
ASN1OctetString ukm,
AlgorithmIdentifier keyEncryptionAlgorithm,
ASN1Sequence recipientEncryptedKeys)
{
this.version = new DERInteger(3);
this.originator = originator;
this.ukm = ukm;
this.keyEncryptionAlgorithm = keyEncryptionAlgorithm;
this.recipientEncryptedKeys = recipientEncryptedKeys;
}
