void m_initialize(Byte[] rawData)
{
Asn1Reader asn = new Asn1Reader(rawData);
if (asn.Tag != 48)
{
throw new Asn1InvalidTagException(asn.Offset);
}
asn.MoveNext();
SerialNumber = Asn1Utils.DecodeInteger(asn.GetTagRawData(), true);
asn.MoveNext();
if (asn.Tag != (Byte)Asn1Type.UTCTime && asn.Tag != (Byte)Asn1Type.GeneralizedTime)
{
throw new Asn1InvalidTagException(asn.Offset);
}
if (asn.Tag == (Byte)Asn1Type.UTCTime)
{
RevocationDate = new Asn1UtcTime(asn.GetTagRawData()).Value;
}
if (asn.Tag == (Byte)Asn1Type.GeneralizedTime)
{
RevocationDate = Asn1Utils.DecodeGeneralizedTime(asn.GetTagRawData());
}
if (asn.MoveNext())
{
var extensions = new X509ExtensionCollection();
extensions.Decode(asn.GetTagRawData());
X509Extension crlReason = extensions[X509CertExtensions.X509CRLReasonCode];
if (crlReason != null)
{
ReasonCode = crlReason.RawData[2];
}
}
RawData = rawData;
}
void decode(Asn1Reader asn)
{
if (asn.Tag != 48)
{
throw new Asn1InvalidTagException(asn.Offset);
}
RawData = asn.GetTagRawData();
Int32 offset = asn.Offset;
asn.MoveNext();
SerialNumber = Asn1Utils.DecodeInteger(asn.GetTagRawData(), true);
asn.MoveNextAndExpectTags(Asn1Type.UTCTime, Asn1Type.GeneralizedTime);
switch (asn.Tag)
{
case (Byte)Asn1Type.UTCTime:
RevocationDate = new Asn1UtcTime(asn.GetTagRawData()).Value;
break;
case (Byte)Asn1Type.GeneralizedTime:
RevocationDate = Asn1Utils.DecodeGeneralizedTime(asn.GetTagRawData());
break;
}
if (asn.MoveNextSibling())
{
// use high-performant extension decoder instead of generic one.
// Since CRLs may store a hundreds of thousands entries, this is
// pretty reasonable to save loops whenever possible.
readCrlReasonCode(asn);
}
asn.Seek(offset);
}
void m_initialize(Asn1Reader response)
{
response.MoveNext();
CertId = new CertID(Asn1Utils.Encode(response.GetPayload(), 48));
response.MoveNextCurrentLevel();
switch (response.Tag)
{
case 128:
CertStatus = CertificateStatus.Good;
response.MoveNextCurrentLevel();
break;
case 161:
CertStatus = CertificateStatus.Revoked;
response.MoveNext();
DateTime revokedWhen = Asn1Utils.DecodeGeneralizedTime(response.GetTagRawData());
response.MoveNext();
Int16 reason = 0;
if (response.Tag == 160)
{
response.MoveNext();
reason = response.GetPayload()[0];
response.MoveNext();
}
RevocationInfo = new X509CRLEntry(CertId.SerialNumber, revokedWhen, reason);
break;
case 130:
CertStatus = CertificateStatus.Unknown;
response.MoveNextCurrentLevel();
break;
}
//response.MoveNextCurrentLevel();
ThisUpdate = Asn1Utils.DecodeGeneralizedTime(response.GetTagRawData());
while (response.MoveNextCurrentLevel())
{
switch (response.Tag)
{
case 160:
Asn1Reader asn = new Asn1Reader(response.GetPayload());
NextUpdate = Asn1Utils.DecodeGeneralizedTime(asn.GetTagRawData());
break;
case 161:
Extensions.Decode(response.GetPayload());
break;
}
}
}
void m_decode(Byte[] rawData)
{
try {
Asn1Reader asn = new Asn1Reader(rawData);
if (asn.Tag == 48)
{
asn.MoveNext();
do
{
StringBuilder SB;
switch (asn.Tag)
{
case 160:
SB = new StringBuilder();
foreach (Byte item in asn.GetPayload())
{
SB.Append(Convert.ToChar(item));
}
URL = new Uri(SB.ToString());
break;
case 161:
SB = new StringBuilder();
foreach (Byte item in asn.GetPayload())
{
SB.Append(Convert.ToChar(item) + " ");
}
CRLNumber = SB.ToString();
break;
case 162:
ThisUpdate = Asn1Utils.DecodeGeneralizedTime(asn.RawData);
break;
}
} while (asn.MoveNext());
}
} catch { throw new ArgumentException("The data is invalid."); }
}
void m_initialize(Byte[] rawData)
{
Asn1Reader asn = new Asn1Reader(rawData);
if (asn.Tag != 48)
{
throw new InvalidDataException();
}
asn.MoveNext();
if (asn.Tag != (Byte)Asn1Type.INTEGER)
{
throw new InvalidDataException();
}
SerialNumber = Asn1Utils.DecodeInteger(asn.GetTagRawData(), true);
asn.MoveNext();
if (asn.Tag != (Byte)Asn1Type.UTCTime && asn.Tag != (Byte)Asn1Type.Generalizedtime)
{
throw new InvalidDataException();
}
if (asn.Tag == (Byte)Asn1Type.UTCTime)
{
RevocationDate = Asn1Utils.DecodeUTCTime(asn.GetTagRawData());
}
if (asn.Tag == (Byte)Asn1Type.Generalizedtime)
{
RevocationDate = Asn1Utils.DecodeGeneralizedTime(asn.GetTagRawData());
}
if (asn.MoveNext())
{
foreach (X509Extension item in Crypt32Managed.DecodeX509Extensions(asn.GetTagRawData()).Cast <X509Extension>().Where(item => item.Oid.Value == "2.5.29.21"))
{
ReasonCode = item.RawData[2];
}
}
RawData = rawData;
}
void m_decode(Byte[] rawData)
{
try {
Type = X509CrlType.BaseCrl;
var signedInfo = new SignedContentBlob(rawData, ContentBlobType.SignedBlob);
// signature and alg
signature = signedInfo.Signature.Value;
sigUnused = signedInfo.Signature.UnusedBits;
SignatureAlgorithm = signedInfo.SignatureAlgorithm.AlgorithmId;
// tbs
Asn1Reader asn = new Asn1Reader(signedInfo.ToBeSignedData);
if (!asn.MoveNext())
{
throw new Asn1InvalidTagException();
}
// version
if (asn.Tag == (Byte)Asn1Type.INTEGER)
{
Version = (Int32)Asn1Utils.DecodeInteger(asn.GetTagRawData()) + 1;
asn.MoveNextCurrentLevel();
}
else
{
Version = 1;
}
// hash algorithm
var h = new AlgorithmIdentifier(asn.GetTagRawData());
if (h.AlgorithmId.Value != SignatureAlgorithm.Value)
{
throw new CryptographicException("Algorithm mismatch.");
}
if (!asn.MoveNextCurrentLevel())
{
throw new Asn1InvalidTagException();
}
// issuer
IssuerName = new X500DistinguishedName(asn.GetTagRawData());
// NextUpdate, RevokedCerts and Extensions are optional. Ref: RFC5280, p.118
if (!asn.MoveNextCurrentLevel())
{
throw new Asn1InvalidTagException();
}
switch (asn.Tag)
{
case (Byte)Asn1Type.UTCTime:
ThisUpdate = Asn1Utils.DecodeUTCTime(asn.GetTagRawData());
break;
case (Byte)Asn1Type.Generalizedtime:
ThisUpdate = Asn1Utils.DecodeGeneralizedTime(asn.GetTagRawData());
break;
default:
throw new Asn1InvalidTagException();
}
if (!asn.MoveNextCurrentLevel())
{
return;
}
switch (asn.Tag)
{
case (Byte)Asn1Type.UTCTime:
case (Byte)Asn1Type.Generalizedtime:
switch (asn.Tag)
{
case (Byte)Asn1Type.UTCTime:
NextUpdate = Asn1Utils.DecodeUTCTime(asn.GetTagRawData());
break;
case (Byte)Asn1Type.Generalizedtime:
NextUpdate = Asn1Utils.DecodeGeneralizedTime(asn.GetTagRawData());
break;
default:
throw new Asn1InvalidTagException();
}
if (!asn.MoveNextCurrentLevel())
{
return;
}
if (asn.Tag == 48)
{
getRevCerts(asn);
if (!asn.MoveNextCurrentLevel())
{
return;
}
getExts(asn);
}
else
{
getExts(asn);
}
break;
case 48:
if (asn.Tag == 48)
{
getRevCerts(asn);
if (!asn.MoveNextCurrentLevel())
{
return;
}
getExts(asn);
}
else
{
getExts(asn);
}
break;
default:
getExts(asn);
break;
}
} catch (Exception e) {
throw new CryptographicException("Cannot find the requested object.", e);
}
}
void m_decode(Byte[] rawData)
{
CutoffDate = Asn1Utils.DecodeGeneralizedTime(rawData);
}
void decodeTbsResponse(Asn1Reader tbsResponseData)
{
tbsResponseData.MoveNext();
if (tbsResponseData.Tag == 160)
{
//Asn1Reader aversion = new Asn1Reader(tbsResponseData.RawData, tbsResponseData.PayloadStartOffset);
Asn1Reader aversion = new Asn1Reader(tbsResponseData);
aversion.MoveNext();
Version = aversion.GetPayload()[0] + 1;
tbsResponseData.MoveNextCurrentLevel();
}
else
{
Version = 1;
}
//responderID
switch (tbsResponseData.Tag)
{
case 161:
ResponderNameId = new X500DistinguishedName(tbsResponseData.GetPayload());
tbsResponseData.MoveNextCurrentLevel();
break;
case 162:
tbsResponseData.MoveNext();
StringBuilder SB = new StringBuilder();
foreach (Byte element in tbsResponseData.GetPayload())
{
SB.Append(element.ToString("X2"));
}
ResponderKeyId = SB.ToString();
tbsResponseData.MoveNext();
break;
default:
throw new Exception("Invalid tag at responderID. Expected 161 (byName) or 162 (byKey).");
}
//tbsResponseData.MoveNextCurrentLevel();
ProducedAt = Asn1Utils.DecodeGeneralizedTime(tbsResponseData.GetTagRawData());
if (DateTime.Now < ProducedAt.AddMinutes(-10))
{
ResponseErrorInformation += (Int32)OCSPResponseComplianceError.ResponseNotTimeValid;
}
//responses
tbsResponseData.MoveNext();
//single response
Asn1Reader responses = new Asn1Reader(tbsResponseData.GetTagRawData());
responses.MoveNext();
Int32 Offset;
Responses = new OCSPSingleResponseCollection();
do
{
Asn1Reader response = new Asn1Reader(responses);
Offset = response.NextCurrentLevelOffset;
Responses.Add(new OCSPSingleResponse(response));
if (Request != null)
{
foreach (OCSPSingleResponse item in Responses)
{
Boolean certidmatch = Request.RequestList.Any(x => x.CertId.Equals(item.CertId));
if (!certidmatch)
{
ResponseErrorInformation += (Int32)OCSPResponseComplianceError.CertIdMismatch;
}
}
}
} while (Offset != 0);
if (tbsResponseData.NextCurrentLevelOffset != 0)
{
tbsResponseData.MoveNextCurrentLevel();
if (tbsResponseData.Tag == 161)
{
X509ExtensionCollection exts = new X509ExtensionCollection();
exts.Decode(tbsResponseData.GetPayload());
foreach (X509Extension item in exts)
{
_listExtensions.Add(CryptographyUtils.ConvertExtension(item));
if (_listExtensions[_listExtensions.Count - 1].Oid.Value == X509CertExtensions.X509OcspNonce)
{
NonceReceived = true;
NonceValue = _listExtensions[_listExtensions.Count - 1].Format(false);
}
}
}
else
{
throw new Exception("Unexpected tag at responseExtensions. Expected 161.");
}
}
}
