blob: 7794c81faca5b570f4b59468be47ade2891d3b07 (
plain) (
blame)
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
|
using System;
using Org.BouncyCastle.Asn1.Oiw;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Asn1.Ess
{
[Obsolete("Use version in Asn1.Esf instead")]
public class OtherCertID
: Asn1Encodable
{
private Asn1Encodable otherCertHash;
private IssuerSerial issuerSerial;
public static OtherCertID GetInstance(
object o)
{
if (o == null || o is OtherCertID)
{
return (OtherCertID) o;
}
if (o is Asn1Sequence)
{
return new OtherCertID((Asn1Sequence) o);
}
throw new ArgumentException(
"unknown object in 'OtherCertID' factory : "
+ Platform.GetTypeName(o) + ".");
}
/**
* constructor
*/
public OtherCertID(
Asn1Sequence seq)
{
if (seq.Count < 1 || seq.Count > 2)
{
throw new ArgumentException("Bad sequence size: " + seq.Count);
}
if (seq[0].ToAsn1Object() is Asn1OctetString)
{
otherCertHash = Asn1OctetString.GetInstance(seq[0]);
}
else
{
otherCertHash = DigestInfo.GetInstance(seq[0]);
}
if (seq.Count > 1)
{
issuerSerial = IssuerSerial.GetInstance(Asn1Sequence.GetInstance(seq[1]));
}
}
public OtherCertID(
AlgorithmIdentifier algId,
byte[] digest)
{
this.otherCertHash = new DigestInfo(algId, digest);
}
public OtherCertID(
AlgorithmIdentifier algId,
byte[] digest,
IssuerSerial issuerSerial)
{
this.otherCertHash = new DigestInfo(algId, digest);
this.issuerSerial = issuerSerial;
}
public AlgorithmIdentifier AlgorithmHash
{
get
{
if (otherCertHash.ToAsn1Object() is Asn1OctetString)
{
// SHA-1
return new AlgorithmIdentifier(OiwObjectIdentifiers.IdSha1);
}
return DigestInfo.GetInstance(otherCertHash).AlgorithmID;
}
}
public byte[] GetCertHash()
{
if (otherCertHash.ToAsn1Object() is Asn1OctetString)
{
// SHA-1
return ((Asn1OctetString) otherCertHash.ToAsn1Object()).GetOctets();
}
return DigestInfo.GetInstance(otherCertHash).GetDigest();
}
public IssuerSerial IssuerSerial
{
get { return issuerSerial; }
}
/**
* <pre>
* OtherCertID ::= SEQUENCE {
* otherCertHash OtherHash,
* issuerSerial IssuerSerial OPTIONAL }
*
* OtherHash ::= CHOICE {
* sha1Hash OCTET STRING,
* otherHash OtherHashAlgAndValue }
*
* OtherHashAlgAndValue ::= SEQUENCE {
* hashAlgorithm AlgorithmIdentifier,
* hashValue OCTET STRING }
*
* </pre>
*/
public override Asn1Object ToAsn1Object()
{
Asn1EncodableVector v = new Asn1EncodableVector(otherCertHash);
if (issuerSerial != null)
{
v.Add(issuerSerial);
}
return new DerSequence(v);
}
}
}
|
