1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
using System;
namespace Org.BouncyCastle.Asn1.Cms
{
/**
* a signed data object.
*/
public class SignedData
: Asn1Encodable
{
public static SignedData GetInstance(object obj)
{
if (obj == null)
return null;
if (obj is SignedData signedData)
return signedData;
return new SignedData(Asn1Sequence.GetInstance(obj));
}
public static SignedData GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
{
return new SignedData(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
}
private readonly DerInteger m_version;
private readonly Asn1Set m_digestAlgorithms;
private readonly ContentInfo m_contentInfo;
private readonly Asn1Set m_certificates;
private readonly Asn1Set m_crls;
private readonly Asn1Set m_signerInfos;
private readonly bool m_certsBer;
private readonly bool m_crlsBer;
public SignedData(Asn1Set digestAlgorithms, ContentInfo contentInfo, Asn1Set certificates, Asn1Set crls,
Asn1Set signerInfos)
{
m_digestAlgorithms = digestAlgorithms ?? throw new ArgumentNullException(nameof(digestAlgorithms));
m_contentInfo = contentInfo ?? throw new ArgumentNullException(nameof(contentInfo));
m_certificates = certificates;
m_crls = crls;
m_signerInfos = signerInfos ?? throw new ArgumentNullException(nameof(signerInfos));
m_crlsBer = crls is BerSet;
m_certsBer = certificates is BerSet;
m_version = CalculateVersionField(contentInfo.ContentType, certificates, crls, signerInfos);
}
private SignedData(Asn1Sequence seq)
{
int count = seq.Count, pos = 0;
if (count < 4 || count > 6)
throw new ArgumentException("Bad sequence size: " + count, nameof(seq));
m_version = DerInteger.GetInstance(seq[pos++]);
m_digestAlgorithms = Asn1Set.GetInstance(seq[pos++]);
m_contentInfo = ContentInfo.GetInstance(seq[pos++]);
m_certificates = ReadOptionalTaggedSet(seq, ref pos, 0, out m_certsBer);
m_crls = ReadOptionalTaggedSet(seq, ref pos, 1, out m_crlsBer);
m_signerInfos = Asn1Set.GetInstance(seq[pos++]);
if (pos != count)
throw new ArgumentException("Unexpected elements in sequence", nameof(seq));
}
public DerInteger Version => m_version;
public Asn1Set DigestAlgorithms => m_digestAlgorithms;
public ContentInfo EncapContentInfo => m_contentInfo;
public Asn1Set Certificates => m_certificates;
public Asn1Set CRLs => m_crls;
public Asn1Set SignerInfos => m_signerInfos;
/**
* Produce an object suitable for an Asn1OutputStream.
* <pre>
* SignedData ::= Sequence {
* version CMSVersion,
* digestAlgorithms DigestAlgorithmIdentifiers,
* encapContentInfo EncapsulatedContentInfo,
* certificates [0] IMPLICIT CertificateSet OPTIONAL,
* crls [1] IMPLICIT CertificateRevocationLists OPTIONAL,
* signerInfos SignerInfos
* }
* </pre>
*/
public override Asn1Object ToAsn1Object()
{
Asn1EncodableVector v = new Asn1EncodableVector(6);
v.Add(m_version, m_digestAlgorithms, m_contentInfo);
if (m_certificates != null)
{
if (m_certsBer)
{
v.Add(new BerTaggedObject(false, 0, m_certificates));
}
else
{
v.Add(new DerTaggedObject(false, 0, m_certificates));
}
}
if (m_crls != null)
{
if (m_crlsBer)
{
v.Add(new BerTaggedObject(false, 1, m_crls));
}
else
{
v.Add(new DerTaggedObject(false, 1, m_crls));
}
}
v.Add(m_signerInfos);
return new BerSequence(v);
}
private static DerInteger CalculateVersionField(DerObjectIdentifier contentOid, Asn1Set certs, Asn1Set crls,
Asn1Set signerInfs)
{
/*
* RFC3852, section 5.1:
* IF((certificates is present) AND
* (any certificates with a type of other are present)) OR
* ((crls is present) AND
* (any crls with a type of other are present))
* THEN version MUST be 5
* ELSE
* IF(certificates is present) AND
* (any version 2 attribute certificates are present)
* THEN version MUST be 4
* ELSE
* IF((certificates is present) AND
* (any version 1 attribute certificates are present)) OR
* (any SignerInfo structures are version 3) OR
* (encapContentInfo eContentType is other than id - data)
* THEN version MUST be 3
* ELSE version MUST be 1
*/
if (crls != null)
{
foreach (var element in crls)
{
var tagged = Asn1TaggedObject.GetOptional(element);
if (tagged != null)
{
// RevocationInfoChoice.other
if (tagged.HasContextTag(1))
return DerInteger.Five;
}
}
}
bool anyV1AttrCerts = false;
if (certs != null)
{
bool anyV2AttrCerts = false;
foreach (var element in certs)
{
var tagged = Asn1TaggedObject.GetOptional(element);
if (tagged != null)
{
// CertificateChoices.other
if (tagged.HasContextTag(3))
return DerInteger.Five;
// CertificateChoices.v2AttrCert
anyV2AttrCerts = anyV2AttrCerts || tagged.HasContextTag(2);
// CertificateChoices.v1AttrCert
anyV1AttrCerts = anyV1AttrCerts || tagged.HasContextTag(1);
}
}
if (anyV2AttrCerts)
return DerInteger.Four;
}
if (anyV1AttrCerts || !CmsObjectIdentifiers.Data.Equals(contentOid) || HasV3SignerInfos(signerInfs))
return DerInteger.Three;
return DerInteger.One;
}
// (any SignerInfo structures are version 3)
private static bool HasV3SignerInfos(Asn1Set signerInfs)
{
foreach (object obj in signerInfs)
{
var signerInfo = SignerInfo.GetInstance(obj);
if (signerInfo.Version.HasValue(3))
return true;
}
return false;
}
private static Asn1Set ReadOptionalTaggedSet(Asn1Sequence sequence, ref int sequencePosition, int tagNo,
out bool isBer)
{
if (sequencePosition < sequence.Count &&
sequence[sequencePosition] is Asn1TaggedObject taggedObject &&
taggedObject.HasContextTag(tagNo))
{
var result = Asn1Set.GetInstance(taggedObject, false);
sequencePosition++;
isBer = taggedObject is BerTaggedObject;
return result;
}
isBer = default;
return null;
}
}
}
|
