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
|
using System;
using System.Diagnostics;
namespace Org.BouncyCastle.Asn1
{
public class BerOctetString
: DerOctetString
{
private const int DefaultSegmentLimit = 1000;
public static BerOctetString FromSequence(Asn1Sequence seq)
{
int count = seq.Count;
Asn1OctetString[] v = new Asn1OctetString[count];
for (int i = 0; i < count; ++i)
{
v[i] = GetInstance(seq[i]);
}
return new BerOctetString(v);
}
internal static byte[] FlattenOctetStrings(Asn1OctetString[] octetStrings)
{
int count = octetStrings.Length;
switch (count)
{
case 0:
return EmptyOctets;
case 1:
return octetStrings[0].contents;
default:
{
int totalOctets = 0;
for (int i = 0; i < count; ++i)
{
totalOctets += octetStrings[i].contents.Length;
}
byte[] str = new byte[totalOctets];
int pos = 0;
for (int i = 0; i < count; ++i)
{
byte[] octets = octetStrings[i].contents;
Array.Copy(octets, 0, str, pos, octets.Length);
pos += octets.Length;
}
Debug.Assert(pos == totalOctets);
return str;
}
}
}
private readonly int segmentLimit;
private readonly Asn1OctetString[] elements;
public BerOctetString(byte[] contents)
: this(contents, DefaultSegmentLimit)
{
}
public BerOctetString(Asn1OctetString[] elements)
: this(elements, DefaultSegmentLimit)
{
}
public BerOctetString(byte[] contents, int segmentLimit)
: this(contents, null, segmentLimit)
{
}
public BerOctetString(Asn1OctetString[] elements, int segmentLimit)
: this(FlattenOctetStrings(elements), elements, segmentLimit)
{
}
private BerOctetString(byte[] contents, Asn1OctetString[] elements, int segmentLimit)
: base(contents)
{
this.elements = elements;
this.segmentLimit = segmentLimit;
}
internal override IAsn1Encoding GetEncoding(int encoding)
{
if (Asn1OutputStream.EncodingBer != encoding)
return base.GetEncoding(encoding);
if (null == elements)
return new PrimitiveEncoding(Asn1Tags.Universal, Asn1Tags.OctetString, contents);
return new ConstructedILEncoding(Asn1Tags.Universal, Asn1Tags.OctetString,
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));
}
}
}
|
