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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
package org.spongycastle.jce.cert;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidParameterException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.util.Set;
/**
* Parameters used as input for the PKIX <code>CertPathBuilder</code>
* algorithm.<br />
* <br />
* A PKIX <code>CertPathBuilder</code> uses these parameters to {@link
* CertPathBuilder#build build} a <code>CertPath</code> which has been
* validated according to the PKIX certification path validation algorithm.<br />
* <br />
* To instantiate a <code>PKIXBuilderParameters</code> object, an
* application must specify one or more <i>most-trusted CAs</i> as defined by
* the PKIX certification path validation algorithm. The most-trusted CA
* can be specified using one of two constructors. An application
* can call {@link #PKIXBuilderParameters(Set, CertSelector)
* PKIXBuilderParameters(Set, CertSelector)}, specifying a
* <code>Set</code> of <code>TrustAnchor</code> objects, each of which
* identifies a most-trusted CA. Alternatively, an application can call
* {@link #PKIXBuilderParameters(KeyStore, CertSelector)
* PKIXBuilderParameters(KeyStore, CertSelector)}, specifying a
* <code>KeyStore</code> instance containing trusted certificate entries, each
* of which will be considered as a most-trusted CA.<br />
* <br />
* In addition, an application must specify constraints on the target
* certificate that the <code>CertPathBuilder</code> will attempt
* to build a path to. The constraints are specified as a
* <code>CertSelector</code> object. These constraints should provide the
* <code>CertPathBuilder</code> with enough search criteria to find the target
* certificate. Minimal criteria for an <code>X509Certificate</code> usually
* include the subject name and/or one or more subject alternative names.
* If enough criteria is not specified, the <code>CertPathBuilder</code>
* may throw a <code>CertPathBuilderException</code>.<br />
* <br />
* <b>Concurrent Access</b><br />
* <br />
* Unless otherwise specified, the methods defined in this class are not
* thread-safe. Multiple threads that need to access a single
* object concurrently should synchronize amongst themselves and
* provide the necessary locking. Multiple threads each manipulating
* separate objects need not synchronize.
*
* @see CertPathBuilder
**/
public class PKIXBuilderParameters extends PKIXParameters
{
private int maxPathLength = 5;
/**
* Creates an instance of <code>PKIXBuilderParameters</code> with the
* specified <code>Set</code> of most-trusted CAs. Each element of the set
* is a {@link TrustAnchor TrustAnchor}.<br />
* <br />
* Note that the <code>Set</code> is copied to protect against subsequent
* modifications.
*
* @param trustAnchors
* a <code>Set</code> of <code>TrustAnchor</code>s
* @param targetConstraints
* a <code>CertSelector</code> specifying the constraints on
* the target certificate
*
* @exception InvalidAlgorithmParameterException
* if <code>trustAnchors</code> is empty
* <code>(trustAnchors.isEmpty() == true)</code>
* @exception NullPointerException
* if <code>trustAnchors</code> is <code>null</code>
* @exception ClassCastException
* if any of the elements of <code>trustAnchors</code> are
* not of type <code>java.security.cert.TrustAnchor</code>
*/
public PKIXBuilderParameters(
Set trustAnchors,
CertSelector targetConstraints)
throws InvalidAlgorithmParameterException
{
super(trustAnchors);
setTargetCertConstraints(targetConstraints);
}
/**
* Creates an instance of <code>PKIXBuilderParameters</code> that
* populates the set of most-trusted CAs from the trusted certificate
* entries contained in the specified <code>KeyStore</code>. Only
* keystore entries that contain trusted <code>X509Certificate</code>s
* are considered; all other certificate types are ignored.
*
* @param keystore
* a <code>KeyStore</code> from which the set of most-trusted
* CAs will be populated
* @param targetConstraints
* a <code>CertSelector</code> specifying the constraints on
* the target certificate
*
* @exception KeyStoreException
* if <code>keystore</code> has not been initialized
* @exception InvalidAlgorithmParameterException
* if <code>keystore</code> does not contain at least one
* trusted certificate entry
* @exception NullPointerException
* if <code>keystore</code> is <code>null</code>
*/
public PKIXBuilderParameters(
KeyStore keystore,
CertSelector targetConstraints) throws KeyStoreException,
InvalidAlgorithmParameterException
{
super(keystore);
setTargetCertConstraints(targetConstraints);
}
/**
* Sets the value of the maximum number of non-self-issued intermediate
* certificates that may exist in a certification path. A certificate is
* self-issued if the DNs that appear in the subject and issuer fields are
* identical and are not empty. Note that the last certificate in a
* certification path is not an intermediate certificate, and is not
* included in this limit. Usually the last certificate is an end entity
* certificate, but it can be a CA certificate. A PKIX
* <code>CertPathBuilder</code> instance must not build paths longer than
* the length specified.<br />
* <br />
* A value of 0 implies that the path can only contain a single certificate.
* A value of -1 implies that the path length is unconstrained (i.e. there
* is no maximum). The default maximum path length, if not specified, is 5.
* Setting a value less than -1 will cause an exception to be thrown.<br />
* <br />
* If any of the CA certificates contain the
* <code>BasicConstraintsExtension</code>, the value of the
* <code>pathLenConstraint</code> field of the extension overrides the
* maximum path length parameter whenever the result is a certification path
* of smaller length.
*
* @param maxPathLength
* the maximum number of non-self-issued intermediate
* certificates that may exist in a certification path
*
* @exception InvalidParameterException
* if <code>maxPathLength</code> is set to a value less
* than -1
*
* @see #getMaxPathLength
*/
public void setMaxPathLength(int maxPathLength)
{
if (maxPathLength < -1)
{
throw new InvalidParameterException(
"the maximum path length parameter can not be less than -1");
}
this.maxPathLength = maxPathLength;
}
/**
* Returns the value of the maximum number of intermediate non-self-issued
* certificates that may exist in a certification path. See the
* {@link #setMaxPathLength} method for more details.
*
* @return the maximum number of non-self-issued intermediate certificates
* that may exist in a certification path, or -1 if there is no
* limit
*
* @see #setMaxPathLength
*/
public int getMaxPathLength()
{
return maxPathLength;
}
/**
* Returns a formatted string describing the parameters.
*
* @return a formatted string describing the parameters
*/
public String toString()
{
StringBuffer s = new StringBuffer();
s.append("PKIXBuilderParameters [\n");
s.append(super.toString());
s.append(" Maximum Path Length: ");
s.append(getMaxPathLength());
s.append("\n]\n");
return s.toString();
}
}
|
