public SafeBag(
DerObjectIdentifier oid,
Asn1Object obj)
{
this.bagID = oid;
this.bagValue = obj;
this.bagAttributes = null;
}
public SafeBag(
DerObjectIdentifier oid,
Asn1Object obj,
Asn1Set bagAttributes)
{
this.bagID = oid;
this.bagValue = obj;
this.bagAttributes = bagAttributes;
}
protected override bool Asn1Equals(
Asn1Object asn1Object)
{
DerEnumerated other = asn1Object as DerEnumerated;
if (other == null)
return false;
return Arrays.AreEqual(this.bytes, other.bytes);
}
public SmimeCapability(
Asn1Sequence seq)
{
capabilityID = (DerObjectIdentifier) seq[0].ToAsn1Object();
if (seq.Count > 1)
{
parameters = seq[1].ToAsn1Object();
}
}
public SafeBag(
Asn1Sequence seq)
{
this.bagID = (DerObjectIdentifier) seq[0];
this.bagValue = ((DerTaggedObject) seq[1]).GetObject();
if (seq.Count == 3)
{
this.bagAttributes = (Asn1Set) seq[2];
}
}
public ServiceLocator(
X509Name issuer,
Asn1Object locator)
{
if (issuer == null)
throw new ArgumentNullException("issuer");
this.issuer = issuer;
this.locator = locator;
}
protected override bool Asn1Equals(
Asn1Object asn1Object)
{
DerGeneralString other = asn1Object as DerGeneralString;
if (other == null)
return false;
return this.str.Equals(other.str);
}
private ServiceLocator(
Asn1Sequence seq)
{
this.issuer = X509Name.GetInstance(seq[0]);
if (seq.Count > 1)
{
this.locator = seq[1].ToAsn1Object();
}
}
public Time(
Asn1Object time)
{
if (!(time is DerUtcTime)
&& !(time is DerGeneralizedTime))
{
throw new ArgumentException("unknown object passed to Time");
}
this.time = time;
}
protected override bool Asn1Equals(
Asn1Object asn1Object)
{
DerUnknownTag other = asn1Object as DerUnknownTag;
if (other == null)
return false;
return this.isConstructed == other.isConstructed
&& this.tag == other.tag
&& Arrays.AreEqual(this.data, other.data);
}
protected override bool Asn1Equals(
Asn1Object asn1Object)
{
Asn1TaggedObject other = asn1Object as Asn1TaggedObject;
if (other == null)
return false;
return this.tagNo == other.tagNo
// && this.empty == other.empty
&& this.explicitly == other.explicitly // TODO Should this be part of equality?
&& Platform.Equals(GetObject(), other.GetObject());
}
public SmimeCapability(
DerObjectIdentifier capabilityID,
Asn1Encodable parameters)
{
if (capabilityID == null)
throw new ArgumentNullException("capabilityID");
this.capabilityID = capabilityID;
if (parameters != null)
{
this.parameters = parameters.ToAsn1Object();
}
}
/**
* Creates a new <code>CommitmentTypeQualifier</code> instance.
*
* @param commitmentTypeIdentifier a <code>CommitmentTypeIdentifier</code> value
* @param qualifier the qualifier, defined by the above field.
*/
public CommitmentTypeQualifier(
DerObjectIdentifier commitmentTypeIdentifier,
Asn1Encodable qualifier)
{
if (commitmentTypeIdentifier == null)
throw new ArgumentNullException("commitmentTypeIdentifier");
this.commitmentTypeIdentifier = commitmentTypeIdentifier;
if (qualifier != null)
{
this.qualifier = qualifier.ToAsn1Object();
}
}
/**
* Creates a new <code>CommitmentTypeQualifier</code> instance.
*
* @param as <code>CommitmentTypeQualifier</code> structure
* encoded as an Asn1Sequence.
*/
public CommitmentTypeQualifier(
Asn1Sequence seq)
{
if (seq == null)
throw new ArgumentNullException("seq");
if (seq.Count < 1 || seq.Count > 2)
throw new ArgumentException("Bad sequence size: " + seq.Count, "seq");
commitmentTypeIdentifier = (DerObjectIdentifier) seq[0].ToAsn1Object();
if (seq.Count > 1)
{
qualifier = seq[1].ToAsn1Object();
}
}
/**
* creates a time object from a given date - if the date is between 1950
* and 2049 a UTCTime object is Generated, otherwise a GeneralizedTime
* is used.
*/
public Time(
DateTime date)
{
string d = date.ToString("yyyyMMddHHmmss") + "Z";
int year = int.Parse(d.Substring(0, 4));
if (year < 1950 || year > 2049)
{
time = new DerGeneralizedTime(d);
}
else
{
time = new DerUtcTime(d.Substring(2));
}
}
public DerExternal(
Asn1EncodableVector vector)
{
int offset = 0;
Asn1Object enc = GetObjFromVector(vector, offset);
if (enc is DerObjectIdentifier)
{
directReference = (DerObjectIdentifier)enc;
offset++;
enc = GetObjFromVector(vector, offset);
}
if (enc is DerInteger)
{
indirectReference = (DerInteger) enc;
offset++;
enc = GetObjFromVector(vector, offset);
}
if (!(enc is DerTaggedObject))
{
dataValueDescriptor = (Asn1Object) enc;
offset++;
enc = GetObjFromVector(vector, offset);
}
if (!(enc is DerTaggedObject))
{
throw new InvalidOperationException(
"No tagged object found in vector. Structure doesn't seem to be of type External");
}
if (vector.Count != offset + 1)
throw new ArgumentException("input vector too large", "vector");
if (!(enc is DerTaggedObject))
throw new ArgumentException("No tagged object found in vector. Structure doesn't seem to be of type External", "vector");
DerTaggedObject obj = (DerTaggedObject)enc;
// Use property accessor to include check on value
Encoding = obj.TagNo;
if (encoding < 0 || encoding > 2)
throw new InvalidOperationException("invalid encoding value");
externalContent = obj.GetObject();
}
public X962Parameters(
DerObjectIdentifier namedCurve)
{
this._params = namedCurve;
}
protected override bool Asn1Equals(
Asn1Object asn1Object)
{
Asn1Set other = asn1Object as Asn1Set;
if (other == null)
return false;
if (Count != other.Count)
{
return false;
}
IEnumerator s1 = GetEnumerator();
IEnumerator s2 = other.GetEnumerator();
while (s1.MoveNext() && s2.MoveNext())
{
Asn1Object o1 = GetCurrent(s1).ToAsn1Object();
Asn1Object o2 = GetCurrent(s2).ToAsn1Object();
if (!o1.Equals(o2))
return false;
}
return true;
}
public SignerIdentifier(
Asn1Object id)
{
this.id = id;
}
public OriginatorIdentifierOrKey(
Asn1Object id)
{
this.id = id;
}
protected override bool Asn1Equals(
Asn1Object asn1Object)
{
DerBitString other = asn1Object as DerBitString;
if (other == null)
return false;
return this.padBits == other.padBits
&& Arrays.AreEqual(this.data, other.data);
}
/// <summary>
/// Don't use this one if you are trying to be RFC 3281 compliant.
/// Use it for v1 attribute certificates only.
/// </summary>
/// <param name="names">Our GeneralNames structure</param>
public AttCertIssuer(
GeneralNames names)
{
obj = names;
choiceObj = obj.ToAsn1Object();
}
protected override bool Asn1Equals(Asn1Object asn1Object)
{
var other = asn1Object as DerObjectIdentifier;
if (other == null)
{
return false;
}
return _identifier.Equals(other._identifier);
}
protected abstract bool Asn1Equals(Asn1Object asn1Object);
public AttCertIssuer(
V2Form v2Form)
{
obj = v2Form;
choiceObj = new DerTaggedObject(false, 0, obj);
}
public RecipientIdentifier(
Asn1Object id)
{
this.id = id;
}
protected override bool Asn1Equals(
Asn1Object asn1Object)
{
DerUtcTime other = asn1Object as DerUtcTime;
if (other == null)
return false;
return this.time.Equals(other.time);
}
public X962Parameters(
Asn1Object obj)
{
this._params = obj;
}
internal bool CallAsn1Equals(Asn1Object obj)
{
return Asn1Equals(obj);
}
public X962Parameters(
X9ECParameters ecParameters)
{
this._params = ecParameters.ToAsn1Object();
}
