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
|
using System;
using System.Collections;
using System.IO;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Math;
namespace Org.BouncyCastle.Asn1.Pkcs
{
public class PrivateKeyInfo
: Asn1Encodable
{
private readonly Asn1OctetString privKey;
private readonly AlgorithmIdentifier algID;
private readonly Asn1Set attributes;
public static PrivateKeyInfo GetInstance(Asn1TaggedObject obj, bool explicitly)
{
return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
}
public static PrivateKeyInfo GetInstance(
object obj)
{
if (obj == null)
return null;
if (obj is PrivateKeyInfo)
return (PrivateKeyInfo) obj;
return new PrivateKeyInfo(Asn1Sequence.GetInstance(obj));
}
public PrivateKeyInfo(AlgorithmIdentifier algID, Asn1Object privateKey)
: this(algID, privateKey, null)
{
}
public PrivateKeyInfo(
AlgorithmIdentifier algID,
Asn1Object privateKey,
Asn1Set attributes)
{
this.algID = algID;
this.privKey = new DerOctetString(privateKey.GetEncoded(Asn1Encodable.Der));
this.attributes = attributes;
}
private PrivateKeyInfo(Asn1Sequence seq)
{
IEnumerator e = seq.GetEnumerator();
e.MoveNext();
BigInteger version = ((DerInteger)e.Current).Value;
if (version.IntValue != 0)
{
throw new ArgumentException("wrong version for private key info: " + version.IntValue);
}
e.MoveNext();
algID = AlgorithmIdentifier.GetInstance(e.Current);
e.MoveNext();
privKey = Asn1OctetString.GetInstance(e.Current);
if (e.MoveNext())
{
attributes = Asn1Set.GetInstance((Asn1TaggedObject)e.Current, false);
}
}
public virtual AlgorithmIdentifier PrivateKeyAlgorithm
{
get { return algID; }
}
[Obsolete("Use 'PrivateKeyAlgorithm' property instead")]
public virtual AlgorithmIdentifier AlgorithmID
{
get { return algID; }
}
public virtual Asn1Object ParsePrivateKey()
{
return Asn1Object.FromByteArray(privKey.GetOctets());
}
[Obsolete("Use 'ParsePrivateKey' instead")]
public virtual Asn1Object PrivateKey
{
get
{
try
{
return ParsePrivateKey();
}
catch (IOException e)
{
throw new InvalidOperationException("unable to parse private key");
}
}
}
public virtual Asn1Set Attributes
{
get { return attributes; }
}
/**
* write out an RSA private key with its associated information
* as described in Pkcs8.
* <pre>
* PrivateKeyInfo ::= Sequence {
* version Version,
* privateKeyAlgorithm AlgorithmIdentifier {{PrivateKeyAlgorithms}},
* privateKey PrivateKey,
* attributes [0] IMPLICIT Attributes OPTIONAL
* }
* Version ::= Integer {v1(0)} (v1,...)
*
* PrivateKey ::= OCTET STRING
*
* Attributes ::= Set OF Attr
* </pre>
*/
public override Asn1Object ToAsn1Object()
{
Asn1EncodableVector v = new Asn1EncodableVector(new DerInteger(0), algID, privKey);
if (attributes != null)
{
v.Add(new DerTaggedObject(false, 0, attributes));
}
return new DerSequence(v);
}
}
}
|
