EvidenceRecord
using Org.BouncyCastle.Asn1.X509;
using System;
namespace Org.BouncyCastle.Asn1.Tsp
{
public class EvidenceRecord : Asn1Encodable
{
private static readonly DerObjectIdentifier Oid = new DerObjectIdentifier("1.3.6.1.5.5.11.0.2.1");
private readonly DerInteger m_version;
private readonly Asn1Sequence m_digestAlgorithms;
private readonly CryptoInfos m_cryptoInfos;
private readonly EncryptionInfo m_encryptionInfo;
private readonly ArchiveTimeStampSequence m_archiveTimeStampSequence;
public virtual DerInteger Version => m_version;
public virtual CryptoInfos CryptoInfos => m_cryptoInfos;
public virtual EncryptionInfo EncryptionInfo => m_encryptionInfo;
public virtual ArchiveTimeStampSequence ArchiveTimeStampSequence => m_archiveTimeStampSequence;
public static EvidenceRecord GetInstance(object obj)
{
if (obj == null)
return null;
EvidenceRecord evidenceRecord = obj as EvidenceRecord;
if (evidenceRecord != null)
return evidenceRecord;
return new EvidenceRecord(Asn1Sequence.GetInstance(obj));
}
public static EvidenceRecord GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
{
return new EvidenceRecord(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
}
public static EvidenceRecord GetTagged(Asn1TaggedObject taggedObject, bool declaredExplicit)
{
return new EvidenceRecord(Asn1Sequence.GetTagged(taggedObject, declaredExplicit));
}
private EvidenceRecord(EvidenceRecord evidenceRecord, ArchiveTimeStampSequence replacementSequence, ArchiveTimeStamp newChainTimeStamp)
{
m_version = evidenceRecord.m_version;
if (newChainTimeStamp != null) {
AlgorithmIdentifier digestAlgorithmIdentifier = newChainTimeStamp.GetDigestAlgorithmIdentifier();
Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
bool flag = false;
foreach (Asn1Encodable digestAlgorithm in evidenceRecord.m_digestAlgorithms) {
AlgorithmIdentifier instance = AlgorithmIdentifier.GetInstance(digestAlgorithm);
asn1EncodableVector.Add(instance);
if (instance.Equals(digestAlgorithmIdentifier)) {
flag = true;
break;
}
}
if (!flag) {
asn1EncodableVector.Add(digestAlgorithmIdentifier);
m_digestAlgorithms = new DerSequence(asn1EncodableVector);
} else
m_digestAlgorithms = evidenceRecord.m_digestAlgorithms;
} else
m_digestAlgorithms = evidenceRecord.m_digestAlgorithms;
m_cryptoInfos = evidenceRecord.m_cryptoInfos;
m_encryptionInfo = evidenceRecord.m_encryptionInfo;
m_archiveTimeStampSequence = replacementSequence;
}
public EvidenceRecord(CryptoInfos cryptoInfos, EncryptionInfo encryptionInfo, ArchiveTimeStamp archiveTimeStamp)
{
m_version = DerInteger.One;
m_digestAlgorithms = new DerSequence(archiveTimeStamp.GetDigestAlgorithmIdentifier());
m_cryptoInfos = cryptoInfos;
m_encryptionInfo = encryptionInfo;
m_archiveTimeStampSequence = new ArchiveTimeStampSequence(new ArchiveTimeStampChain(archiveTimeStamp));
}
public EvidenceRecord(AlgorithmIdentifier[] digestAlgorithms, CryptoInfos cryptoInfos, EncryptionInfo encryptionInfo, ArchiveTimeStampSequence archiveTimeStampSequence)
{
m_version = DerInteger.One;
m_digestAlgorithms = new DerSequence(digestAlgorithms);
m_cryptoInfos = cryptoInfos;
m_encryptionInfo = encryptionInfo;
m_archiveTimeStampSequence = archiveTimeStampSequence;
}
private EvidenceRecord(Asn1Sequence seq)
{
int count = seq.Count;
int sequencePosition = 0;
if (count < 3 || count > 5)
throw new ArgumentException("Bad sequence size: " + count.ToString(), "seq");
m_version = DerInteger.GetInstance(seq[sequencePosition++]);
m_digestAlgorithms = Asn1Sequence.GetInstance(seq[sequencePosition++]);
m_cryptoInfos = Asn1Utilities.ReadContextTagged(seq, ref sequencePosition, 0, false, CryptoInfos.GetTagged);
m_encryptionInfo = Asn1Utilities.ReadContextTagged(seq, ref sequencePosition, 1, false, EncryptionInfo.GetTagged);
m_archiveTimeStampSequence = ArchiveTimeStampSequence.GetInstance(seq[sequencePosition++]);
if (sequencePosition != count)
throw new ArgumentException("Unexpected elements in sequence", "seq");
if (!m_version.HasValue(1))
throw new ArgumentException("incompatible version");
}
public virtual AlgorithmIdentifier[] GetDigestAlgorithms()
{
return m_digestAlgorithms.MapElements(AlgorithmIdentifier.GetInstance);
}
public virtual EvidenceRecord AddArchiveTimeStamp(ArchiveTimeStamp ats, bool newChain)
{
if (newChain) {
ArchiveTimeStampChain chain = new ArchiveTimeStampChain(ats);
return new EvidenceRecord(this, m_archiveTimeStampSequence.Append(chain), ats);
}
ArchiveTimeStampChain[] archiveTimeStampChains = m_archiveTimeStampSequence.GetArchiveTimeStampChains();
if (!archiveTimeStampChains[archiveTimeStampChains.Length - 1].GetArchiveTimestamps()[0].GetDigestAlgorithmIdentifier().Equals(ats.GetDigestAlgorithmIdentifier()))
throw new ArgumentException("mismatch of digest algorithm in AddArchiveTimeStamp");
archiveTimeStampChains[archiveTimeStampChains.Length - 1] = archiveTimeStampChains[archiveTimeStampChains.Length - 1].Append(ats);
return new EvidenceRecord(this, new ArchiveTimeStampSequence(archiveTimeStampChains), null);
}
public override Asn1Object ToAsn1Object()
{
Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(5);
asn1EncodableVector.Add(m_version, m_digestAlgorithms);
asn1EncodableVector.AddOptionalTagged(false, 0, m_cryptoInfos);
asn1EncodableVector.AddOptionalTagged(false, 1, m_encryptionInfo);
asn1EncodableVector.Add(m_archiveTimeStampSequence);
return new DerSequence(asn1EncodableVector);
}
}
}