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
|
using System;
using System.Diagnostics;
namespace Org.BouncyCastle.Asn1
{
public class BerBitString
: DLBitString
{
public static BerBitString FromSequence(Asn1Sequence seq)
{
return new BerBitString(seq.MapElements(GetInstance));
}
internal static byte[] FlattenBitStrings(DerBitString[] bitStrings)
{
int count = bitStrings.Length;
switch (count)
{
case 0:
// No bits
return new byte[]{ 0 };
case 1:
return bitStrings[0].contents;
default:
{
int last = count - 1, totalLength = 0;
for (int i = 0; i < last; ++i)
{
byte[] elementContents = bitStrings[i].contents;
if (elementContents[0] != 0)
throw new ArgumentException("only the last nested bitstring can have padding", "bitStrings");
totalLength += elementContents.Length - 1;
}
// Last one can have padding
byte[] lastElementContents = bitStrings[last].contents;
byte padBits = lastElementContents[0];
totalLength += lastElementContents.Length;
byte[] contents = new byte[totalLength];
contents[0] = padBits;
int pos = 1;
for (int i = 0; i < count; ++i)
{
byte[] elementContents = bitStrings[i].contents;
int length = elementContents.Length - 1;
Array.Copy(elementContents, 1, contents, pos, length);
pos += length;
}
Debug.Assert(pos == totalLength);
return contents;
}
}
}
private readonly DerBitString[] elements;
public BerBitString(byte data, int padBits)
: base(data, padBits)
{
this.elements = null;
}
public BerBitString(byte[] data)
: this(data, 0)
{
}
public BerBitString(byte[] data, int padBits)
: base(data, padBits)
{
this.elements = null;
}
[Obsolete("Use version without segmentLimit (which is ignored anyway)")]
public BerBitString(byte[] data, int padBits, int segmentLimit)
: this(data, padBits)
{
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public BerBitString(ReadOnlySpan<byte> data)
: this(data, 0)
{
}
public BerBitString(ReadOnlySpan<byte> data, int padBits)
: base(data, padBits)
{
this.elements = null;
}
#endif
public BerBitString(int namedBits)
: base(namedBits)
{
this.elements = null;
}
public BerBitString(Asn1Encodable obj)
: this(obj.GetDerEncoded(), 0)
{
}
public BerBitString(DerBitString[] elements)
: base(FlattenBitStrings(elements), false)
{
this.elements = elements;
}
[Obsolete("Use version without segmentLimit (which is ignored anyway)")]
public BerBitString(DerBitString[] elements, int segmentLimit)
: this(elements)
{
}
internal BerBitString(byte[] contents, bool check)
: base(contents, check)
{
this.elements = null;
}
internal override IAsn1Encoding GetEncoding(int encoding)
{
if (Asn1OutputStream.EncodingBer != encoding)
return base.GetEncoding(encoding);
if (null == elements)
return new PrimitiveEncoding(Asn1Tags.Universal, Asn1Tags.BitString, contents);
return new ConstructedILEncoding(Asn1Tags.Universal, Asn1Tags.BitString,
Asn1OutputStream.GetContentsEncodings(encoding, elements));
}
internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
{
if (Asn1OutputStream.EncodingBer != encoding)
return base.GetEncodingImplicit(encoding, tagClass, tagNo);
if (null == elements)
return new PrimitiveEncoding(tagClass, tagNo, contents);
return new ConstructedILEncoding(tagClass, tagNo,
Asn1OutputStream.GetContentsEncodings(encoding, elements));
}
}
}
|
