blob: 9e09cd72284a709af763eb4d7ecdf67cf94a0a8f (
plain)
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
|
package org.bouncycastle.asn1.x509;
import java.io.IOException;
import java.util.Enumeration;
import org.bouncycastle.asn1.ASN1Encodable;
import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1InputStream;
import org.bouncycastle.asn1.ASN1Object;
import org.bouncycastle.asn1.ASN1Primitive;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.ASN1TaggedObject;
import org.bouncycastle.asn1.DERBitString;
import org.bouncycastle.asn1.DERSequence;
/**
* The object that contains the public key stored in a certficate.
* <p>
* The getEncoded() method in the public keys in the JCE produces a DER
* encoded one of these.
*/
public class SubjectPublicKeyInfo
extends ASN1Object
{
private AlgorithmIdentifier algId;
private DERBitString keyData;
public static SubjectPublicKeyInfo getInstance(
ASN1TaggedObject obj,
boolean explicit)
{
return getInstance(ASN1Sequence.getInstance(obj, explicit));
}
public static SubjectPublicKeyInfo getInstance(
Object obj)
{
if (obj instanceof SubjectPublicKeyInfo)
{
return (SubjectPublicKeyInfo)obj;
}
else if (obj != null)
{
return new SubjectPublicKeyInfo(ASN1Sequence.getInstance(obj));
}
return null;
}
public SubjectPublicKeyInfo(
AlgorithmIdentifier algId,
ASN1Encodable publicKey)
throws IOException
{
this.keyData = new DERBitString(publicKey);
this.algId = algId;
}
public SubjectPublicKeyInfo(
AlgorithmIdentifier algId,
byte[] publicKey)
{
this.keyData = new DERBitString(publicKey);
this.algId = algId;
}
public SubjectPublicKeyInfo(
ASN1Sequence seq)
{
if (seq.size() != 2)
{
throw new IllegalArgumentException("Bad sequence size: "
+ seq.size());
}
Enumeration e = seq.getObjects();
this.algId = AlgorithmIdentifier.getInstance(e.nextElement());
this.keyData = DERBitString.getInstance(e.nextElement());
}
public AlgorithmIdentifier getAlgorithm()
{
return algId;
}
/**
* @deprecated use getAlgorithm()
* @return alg ID.
*/
public AlgorithmIdentifier getAlgorithmId()
{
return algId;
}
/**
* for when the public key is an encoded object - if the bitstring
* can't be decoded this routine throws an IOException.
*
* @exception IOException - if the bit string doesn't represent a DER
* encoded object.
* @return the public key as an ASN.1 primitive.
*/
public ASN1Primitive parsePublicKey()
throws IOException
{
ASN1InputStream aIn = new ASN1InputStream(keyData.getBytes());
return aIn.readObject();
}
/**
* for when the public key is an encoded object - if the bitstring
* can't be decoded this routine throws an IOException.
*
* @exception IOException - if the bit string doesn't represent a DER
* encoded object.
* @deprecated use parsePublicKey
* @return the public key as an ASN.1 primitive.
*/
public ASN1Primitive getPublicKey()
throws IOException
{
ASN1InputStream aIn = new ASN1InputStream(keyData.getBytes());
return aIn.readObject();
}
/**
* for when the public key is raw bits.
*
* @return the public key as the raw bit string...
*/
public DERBitString getPublicKeyData()
{
return keyData;
}
/**
* Produce an object suitable for an ASN1OutputStream.
* <pre>
* SubjectPublicKeyInfo ::= SEQUENCE {
* algorithm AlgorithmIdentifier,
* publicKey BIT STRING }
* </pre>
*/
public ASN1Primitive toASN1Primitive()
{
ASN1EncodableVector v = new ASN1EncodableVector();
v.add(algId);
v.add(keyData);
return new DERSequence(v);
}
}
|
