/// <summary>
/// Constructs a new EF_SOD file.
/// </summary>
/// <param name="data">bytes of the EF_DG1 file</param>
public SODFile(byte[] data)
{
MemoryStream dataStream = new MemoryStream(data);
BERTLVInputStream tlvStream = new BERTLVInputStream(dataStream);
int tag = tlvStream.readTag();
if (tag != IDGFile.EF_SOD_TAG) throw new ArgumentException("Expected EF_SOD_TAG");
int length = tlvStream.readLength();
Asn1InputStream sodAsn1 = new Asn1InputStream(dataStream);
DerSequence seq = (DerSequence)sodAsn1.ReadObject();
DerObjectIdentifier objectIdentifier = (DerObjectIdentifier)seq[0];
//DerTaggedObject o = (DerTaggedObject)seq[1];
DerSequence s2 = (DerSequence)((DerTaggedObject)seq[1]).GetObject();
IEnumerator e = s2.GetEnumerator();
e.MoveNext();
DerInteger version = (DerInteger)e.Current;
e.MoveNext();
Asn1Set digestAlgorithms = (Asn1Set)e.Current;
e.MoveNext();
ContentInfo contentInfo = ContentInfo.GetInstance(e.Current);
Asn1Set signerInfos = null;
bool certsBer = false;
bool crlsBer = false;
Asn1Set certificates = null;
Asn1Set crls = null;
while (e.MoveNext())
{
Object o = e.Current;
if (o is Asn1TaggedObject)
{
Asn1TaggedObject tagged = (Asn1TaggedObject)o;
switch (tagged.TagNo)
{
case 0:
certsBer = tagged is BerTaggedObject;
certificates = Asn1Set.GetInstance(tagged, false);
break;
case 1:
crlsBer = tagged is BerTaggedObject;
crls = Asn1Set.GetInstance(tagged, false);
break;
default:
throw new ArgumentException("unknown tag value " + tagged.TagNo);
}
}
else
{
signerInfos = (Asn1Set)o;
}
}
_signedData = new SignedData(digestAlgorithms, contentInfo, certificates, crls, signerInfos);
byte[] content = ((DerOctetString)contentInfo.Content).GetOctets();
Asn1InputStream inStream = new Asn1InputStream(content);
_lds = new LdsSecurityObject((Asn1Sequence)inStream.ReadObject());
}
public override void PerformTest()
{
AlgorithmIdentifier algoId = new AlgorithmIdentifier(OiwObjectIdentifiers.IdSha1);
DataGroupHash[] datas = new DataGroupHash[2];
datas[0] = new DataGroupHash(1, new DerOctetString(GenerateHash()));
datas[1] = new DataGroupHash(2, new DerOctetString(GenerateHash()));
LdsSecurityObject so = new LdsSecurityObject(algoId, datas);
CheckConstruction(so, algoId, datas);
LdsVersionInfo versionInfo = new LdsVersionInfo("Hello", "world");
so = new LdsSecurityObject(algoId, datas, versionInfo);
CheckConstruction(so, algoId, datas, versionInfo);
try
{
LdsSecurityObject.GetInstance(null);
}
catch (Exception)
{
Fail("GetInstance() failed to handle null.");
}
try
{
LdsSecurityObject.GetInstance(new object());
Fail("GetInstance() failed to detect bad object.");
}
catch (ArgumentException)
{
// expected
}
try
{
LdsSecurityObject.GetInstance(DerSequence.Empty);
Fail("constructor failed to detect empty sequence.");
}
catch (ArgumentException)
{
// expected
}
try
{
new LdsSecurityObject(algoId, new DataGroupHash[1]);
Fail("constructor failed to detect small DataGroupHash array.");
}
catch (ArgumentException)
{
// expected
}
try
{
new LdsSecurityObject(algoId, new DataGroupHash[LdsSecurityObject.UBDataGroups + 1]);
Fail("constructor failed to out of bounds DataGroupHash array.");
}
catch (ArgumentException)
{
// expected
}
}
private void CheckConstruction(
LdsSecurityObject so,
AlgorithmIdentifier digestAlgorithmIdentifier,
DataGroupHash[] datagroupHash,
LdsVersionInfo versionInfo)
{
if (!so.Version.Equals(BigInteger.One))
{
Fail("version number not 1");
}
CheckStatement(so, digestAlgorithmIdentifier, datagroupHash, versionInfo);
so = LdsSecurityObject.GetInstance(so);
CheckStatement(so, digestAlgorithmIdentifier, datagroupHash, versionInfo);
Asn1Sequence seq = (Asn1Sequence) Asn1Object.FromByteArray(
so.ToAsn1Object().GetEncoded());
so = LdsSecurityObject.GetInstance(seq);
CheckStatement(so, digestAlgorithmIdentifier, datagroupHash, versionInfo);
}
private void CheckStatement(
LdsSecurityObject so,
AlgorithmIdentifier digestAlgorithmIdentifier,
DataGroupHash[] datagroupHash,
LdsVersionInfo versionInfo)
{
if (digestAlgorithmIdentifier != null)
{
if (!so.DigestAlgorithmIdentifier.Equals(digestAlgorithmIdentifier))
{
Fail("ids don't match.");
}
}
else if (so.DigestAlgorithmIdentifier != null)
{
Fail("digest algorithm Id found when none expected.");
}
if (datagroupHash != null)
{
DataGroupHash[] datas = so.GetDatagroupHash();
for (int i = 0; i != datas.Length; i++)
{
if (!datagroupHash[i].Equals(datas[i]))
{
Fail("name registration authorities don't match.");
}
}
}
else if (so.GetDatagroupHash() != null)
{
Fail("data hash groups found when none expected.");
}
if (versionInfo != null)
{
if (!versionInfo.Equals(so.VersionInfo))
{
Fail("versionInfo doesn't match");
}
}
else if (so.VersionInfo != null)
{
Fail("version info found when none expected.");
}
}
private void CheckConstruction(
LdsSecurityObject so,
AlgorithmIdentifier digestAlgorithmIdentifier,
DataGroupHash[] datagroupHash)
{
CheckStatement(so, digestAlgorithmIdentifier, datagroupHash, null);
so = LdsSecurityObject.GetInstance(so);
CheckStatement(so, digestAlgorithmIdentifier, datagroupHash, null);
Asn1Sequence seq = (Asn1Sequence) Asn1Object.FromByteArray(
so.ToAsn1Object().GetEncoded());
so = LdsSecurityObject.GetInstance(seq);
CheckStatement(so, digestAlgorithmIdentifier, datagroupHash, null);
}