1 #
2 # This is the "master security properties file".
3 #
4 # An alternate java.security properties file may be specified
5 # from the command line via the system property
6 #
7 # -Djava.security.properties=<URL>
8 #
9 # This properties file appends to the master security properties file.
10 # If both properties files specify values for the same key, the value
11 # from the command-line properties file is selected, as it is the last
12 # one loaded.
13 #
14 # Also, if you specify
15 #
16 # -Djava.security.properties==<URL> (2 equals),
17 #
18 # then that properties file completely overrides the master security
19 # properties file.
20 #
21 # To disable the ability to specify an additional properties file from
22 # the command line, set the key security.overridePropertiesFile
23 # to false in the master security properties file. It is set to true
24 # by default.
25
26 # In this file, various security properties are set for use by
27 # java.security classes. This is where users can statically register
28 # Cryptography Package Providers ("providers" for short). The term
29 # "provider" refers to a package or set of packages that supply a
30 # concrete implementation of a subset of the cryptography aspects of
31 # the Java Security API. A provider may, for example, implement one or
32 # more digital signature algorithms or message digest algorithms.
33 #
34 # Each provider must implement a subclass of the Provider class.
35 # To register a provider in this master security properties file,
36 # specify the provider and priority in the format
37 #
38 # security.provider.<n>=<provName | className>
39 #
40 # This declares a provider, and specifies its preference
41 # order n. The preference order is the order in which providers are
42 # searched for requested algorithms (when no specific provider is
43 # requested). The order is 1-based; 1 is the most preferred, followed
44 # by 2, and so on.
45 #
46 # <provName> must specify the name of the Provider as passed to its super
47 # class java.security.Provider constructor. This is for providers loaded
48 # through the ServiceLoader mechanism.
49 #
50 # <className> must specify the subclass of the Provider class whose
51 # constructor sets the values of various properties that are required
52 # for the Java Security API to look up the algorithms or other
53 # facilities implemented by the provider. This is for providers loaded
54 # through classpath.
55 #
56 # Note: Providers can be dynamically registered instead by calls to
57 # either the addProvider or insertProviderAt method in the Security
58 # class.
59
60 #
61 # List of providers and their preference orders (see above):
62 #
63 #ifdef solaris
64 # Note: The OracleUcrypto provider is deprecated and subject to removal in
65 # a future version of the JDK.
66 security.provider.tbd=OracleUcrypto
67 security.provider.tbd=SunPKCS11 ${java.home}/conf/security/sunpkcs11-solaris.cfg
68 #endif
69 security.provider.tbd=SUN
70 security.provider.tbd=SunRsaSign
71 security.provider.tbd=SunEC
72 security.provider.tbd=SunJSSE
73 security.provider.tbd=SunJCE
74 security.provider.tbd=SunJGSS
75 security.provider.tbd=SunSASL
76 security.provider.tbd=XMLDSig
77 security.provider.tbd=SunPCSC
78 security.provider.tbd=JdkLDAP
79 security.provider.tbd=JdkSASL
80 #ifdef windows
81 security.provider.tbd=SunMSCAPI
82 #endif
83 #ifdef macosx
84 security.provider.tbd=Apple
85 #endif
86 #ifndef solaris
87 security.provider.tbd=SunPKCS11
88 #endif
89
90 #
91 # A list of preferred providers for specific algorithms. These providers will
92 # be searched for matching algorithms before the list of registered providers.
93 # Entries containing errors (parsing, etc) will be ignored. Use the
94 # -Djava.security.debug=jca property to debug these errors.
95 #
96 # The property is a comma-separated list of serviceType.algorithm:provider
97 # entries. The serviceType (example: "MessageDigest") is optional, and if
98 # not specified, the algorithm applies to all service types that support it.
99 # The algorithm is the standard algorithm name or transformation.
100 # Transformations can be specified in their full standard name
101 # (ex: AES/CBC/PKCS5Padding), or as partial matches (ex: AES, AES/CBC).
102 # The provider is the name of the provider. Any provider that does not
103 # also appear in the registered list will be ignored.
104 #
105 # There is a special serviceType for this property only to group a set of
106 # algorithms together. The type is "Group" and is followed by an algorithm
107 # keyword. Groups are to simplify and lessen the entries on the property
108 # line. Current groups are:
109 # Group.SHA2 = SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, SHA-512/256
110 # Group.HmacSHA2 = HmacSHA224, HmacSHA256, HmacSHA384, HmacSHA512
111 # Group.SHA2RSA = SHA224withRSA, SHA256withRSA, SHA384withRSA, SHA512withRSA
112 # Group.SHA2DSA = SHA224withDSA, SHA256withDSA, SHA384withDSA, SHA512withDSA
113 # Group.SHA2ECDSA = SHA224withECDSA, SHA256withECDSA, SHA384withECDSA, \
114 # SHA512withECDSA
115 # Group.SHA3 = SHA3-224, SHA3-256, SHA3-384, SHA3-512
116 # Group.HmacSHA3 = HmacSHA3-224, HmacSHA3-256, HmacSHA3-384, HmacSHA3-512
117 #
118 # Example:
119 # jdk.security.provider.preferred=AES/GCM/NoPadding:SunJCE, \
120 # MessageDigest.SHA-256:SUN, Group.HmacSHA2:SunJCE
121 #
122 #ifdef solaris-sparc
123 # Optional Solaris-SPARC configuration for non-FIPS 140 configurations.
124 # jdk.security.provider.preferred=AES:SunJCE, SHA1:SUN, Group.SHA2:SUN, \
125 # HmacSHA1:SunJCE, Group.HmacSHA2:SunJCE
126 #
127 #endif
128 #jdk.security.provider.preferred=
129
130
131 #
132 # Sun Provider SecureRandom seed source.
133 #
134 # Select the primary source of seed data for the "NativePRNG", "SHA1PRNG"
135 # and "DRBG" SecureRandom implementations in the "Sun" provider.
136 # (Other SecureRandom implementations might also use this property.)
137 #
138 # On Unix-like systems (for example, Solaris/Linux/MacOS), the
139 # "NativePRNG", "SHA1PRNG" and "DRBG" implementations obtains seed data from
140 # special device files such as file:/dev/random.
141 #
142 # On Windows systems, specifying the URLs "file:/dev/random" or
143 # "file:/dev/urandom" will enable the native Microsoft CryptoAPI seeding
144 # mechanism for SHA1PRNG and DRBG.
145 #
146 # By default, an attempt is made to use the entropy gathering device
147 # specified by the "securerandom.source" Security property. If an
148 # exception occurs while accessing the specified URL:
149 #
150 # NativePRNG:
151 # a default value of /dev/random will be used. If neither
152 # are available, the implementation will be disabled.
153 # "file" is the only currently supported protocol type.
154 #
155 # SHA1PRNG and DRBG:
156 # the traditional system/thread activity algorithm will be used.
157 #
158 # The entropy gathering device can also be specified with the System
159 # property "java.security.egd". For example:
160 #
161 # % java -Djava.security.egd=file:/dev/random MainClass
162 #
163 # Specifying this System property will override the
164 # "securerandom.source" Security property.
165 #
166 # In addition, if "file:/dev/random" or "file:/dev/urandom" is
167 # specified, the "NativePRNG" implementation will be more preferred than
168 # DRBG and SHA1PRNG in the Sun provider.
169 #
170 securerandom.source=file:/dev/random
171
172 #
173 # A list of known strong SecureRandom implementations.
174 #
175 # To help guide applications in selecting a suitable strong
176 # java.security.SecureRandom implementation, Java distributions should
177 # indicate a list of known strong implementations using the property.
178 #
179 # This is a comma-separated list of algorithm and/or algorithm:provider
180 # entries.
181 #
182 #ifdef windows
183 securerandom.strongAlgorithms=Windows-PRNG:SunMSCAPI,DRBG:SUN
184 #endif
185 #ifndef windows
186 securerandom.strongAlgorithms=NativePRNGBlocking:SUN,DRBG:SUN
187 #endif
188
189 #
190 # Sun provider DRBG configuration and default instantiation request.
191 #
192 # NIST SP 800-90Ar1 lists several DRBG mechanisms. Each can be configured
193 # with a DRBG algorithm name, and can be instantiated with a security strength,
194 # prediction resistance support, etc. This property defines the configuration
195 # and the default instantiation request of "DRBG" SecureRandom implementations
196 # in the SUN provider. (Other DRBG implementations can also use this property.)
197 # Applications can request different instantiation parameters like security
198 # strength, capability, personalization string using one of the
199 # getInstance(...,SecureRandomParameters,...) methods with a
200 # DrbgParameters.Instantiation argument, but other settings such as the
201 # mechanism and DRBG algorithm names are not currently configurable by any API.
202 #
203 # Please note that the SUN implementation of DRBG always supports reseeding.
204 #
205 # The value of this property is a comma-separated list of all configurable
206 # aspects. The aspects can appear in any order but the same aspect can only
207 # appear at most once. Its BNF-style definition is:
208 #
209 # Value:
210 # aspect { "," aspect }
211 #
212 # aspect:
213 # mech_name | algorithm_name | strength | capability | df
214 #
215 # // The DRBG mechanism to use. Default "Hash_DRBG"
216 # mech_name:
217 # "Hash_DRBG" | "HMAC_DRBG" | "CTR_DRBG"
218 #
219 # // The DRBG algorithm name. The "SHA-***" names are for Hash_DRBG and
220 # // HMAC_DRBG, default "SHA-256". The "AES-***" names are for CTR_DRBG,
221 # // default "AES-128" when using the limited cryptographic or "AES-256"
222 # // when using the unlimited.
223 # algorithm_name:
224 # "SHA-224" | "SHA-512/224" | "SHA-256" |
225 # "SHA-512/256" | "SHA-384" | "SHA-512" |
226 # "AES-128" | "AES-192" | "AES-256"
227 #
228 # // Security strength requested. Default "128"
229 # strength:
230 # "112" | "128" | "192" | "256"
231 #
232 # // Prediction resistance and reseeding request. Default "none"
233 # // "pr_and_reseed" - Both prediction resistance and reseeding
234 # // support requested
235 # // "reseed_only" - Only reseeding support requested
236 # // "none" - Neither prediction resistance not reseeding
237 # // support requested
238 # pr:
239 # "pr_and_reseed" | "reseed_only" | "none"
240 #
241 # // Whether a derivation function should be used. only applicable
242 # // to CTR_DRBG. Default "use_df"
243 # df:
244 # "use_df" | "no_df"
245 #
246 # Examples,
247 # securerandom.drbg.config=Hash_DRBG,SHA-224,112,none
248 # securerandom.drbg.config=CTR_DRBG,AES-256,192,pr_and_reseed,use_df
249 #
250 # The default value is an empty string, which is equivalent to
251 # securerandom.drbg.config=Hash_DRBG,SHA-256,128,none
252 #
253 securerandom.drbg.config=
254
255 #
256 # Class to instantiate as the javax.security.auth.login.Configuration
257 # provider.
258 #
259 login.configuration.provider=sun.security.provider.ConfigFile
260
261 #
262 # Default login configuration file
263 #
264 #login.config.url.1=file:${user.home}/.java.login.config
265
266 #
267 # Class to instantiate as the system Policy. This is the name of the class
268 # that will be used as the Policy object. The system class loader is used to
269 # locate this class.
270 #
271 policy.provider=sun.security.provider.PolicyFile
272
273 # The default is to have a single system-wide policy file,
274 # and a policy file in the user's home directory.
275 #
276 policy.url.1=file:${java.home}/conf/security/java.policy
277 policy.url.2=file:${user.home}/.java.policy
278
279 # Controls whether or not properties are expanded in policy and login
280 # configuration files. If set to false, properties (${...}) will not
281 # be expanded in policy and login configuration files. If commented out or
282 # set to an empty string, the default value is "false" for policy files and
283 # "true" for login configuration files.
284 #
285 policy.expandProperties=true
286
287 # Controls whether or not an extra policy or login configuration file is
288 # allowed to be passed on the command line with -Djava.security.policy=somefile
289 # or -Djava.security.auth.login.config=somefile. If commented out or set to
290 # an empty string, the default value is "false".
291 #
292 policy.allowSystemProperty=true
293
294 # whether or not we look into the IdentityScope for trusted Identities
295 # when encountering a 1.1 signed JAR file. If the identity is found
296 # and is trusted, we grant it AllPermission. Note: the default policy
297 # provider (sun.security.provider.PolicyFile) does not support this property.
298 #
299 policy.ignoreIdentityScope=false
300
301 #
302 # Default keystore type.
303 #
304 keystore.type=pkcs12
305
306 #
307 # Controls compatibility mode for JKS and PKCS12 keystore types.
308 #
309 # When set to 'true', both JKS and PKCS12 keystore types support loading
310 # keystore files in either JKS or PKCS12 format. When set to 'false' the
311 # JKS keystore type supports loading only JKS keystore files and the PKCS12
312 # keystore type supports loading only PKCS12 keystore files.
313 #
314 keystore.type.compat=true
315
316 #
317 # List of comma-separated packages that start with or equal this string
318 # will cause a security exception to be thrown when passed to the
319 # SecurityManager::checkPackageAccess method unless the corresponding
320 # RuntimePermission("accessClassInPackage."+package) has been granted.
321 #
322 package.access=sun.misc.,\
323 sun.reflect.,\
324
325 #
326 # List of comma-separated packages that start with or equal this string
327 # will cause a security exception to be thrown when passed to the
328 # SecurityManager::checkPackageDefinition method unless the corresponding
329 # RuntimePermission("defineClassInPackage."+package) has been granted.
330 #
331 # By default, none of the class loaders supplied with the JDK call
332 # checkPackageDefinition.
333 #
334 package.definition=sun.misc.,\
335 sun.reflect.,\
336
337 #
338 # Determines whether this properties file can be appended to
339 # or overridden on the command line via -Djava.security.properties
340 #
341 security.overridePropertiesFile=true
342
343 #
344 # Determines the default key and trust manager factory algorithms for
345 # the javax.net.ssl package.
346 #
347 ssl.KeyManagerFactory.algorithm=SunX509
348 ssl.TrustManagerFactory.algorithm=PKIX
349
350 #
351 # The Java-level namelookup cache policy for successful lookups:
352 #
353 # any negative value: caching forever
354 # any positive value: the number of seconds to cache an address for
355 # zero: do not cache
356 #
357 # default value is forever (FOREVER). For security reasons, this
358 # caching is made forever when a security manager is set. When a security
359 # manager is not set, the default behavior in this implementation
360 # is to cache for 30 seconds.
361 #
362 # NOTE: setting this to anything other than the default value can have
363 # serious security implications. Do not set it unless
364 # you are sure you are not exposed to DNS spoofing attack.
365 #
366 #networkaddress.cache.ttl=-1
367
368 # The Java-level namelookup cache policy for failed lookups:
369 #
370 # any negative value: cache forever
371 # any positive value: the number of seconds to cache negative lookup results
372 # zero: do not cache
373 #
374 # In some Microsoft Windows networking environments that employ
375 # the WINS name service in addition to DNS, name service lookups
376 # that fail may take a noticeably long time to return (approx. 5 seconds).
377 # For this reason the default caching policy is to maintain these
378 # results for 10 seconds.
379 #
380 networkaddress.cache.negative.ttl=10
381
382 #
383 # Properties to configure OCSP for certificate revocation checking
384 #
385
386 # Enable OCSP
387 #
388 # By default, OCSP is not used for certificate revocation checking.
389 # This property enables the use of OCSP when set to the value "true".
390 #
391 # NOTE: SocketPermission is required to connect to an OCSP responder.
392 #
393 # Example,
394 # ocsp.enable=true
395
396 #
397 # Location of the OCSP responder
398 #
399 # By default, the location of the OCSP responder is determined implicitly
400 # from the certificate being validated. This property explicitly specifies
401 # the location of the OCSP responder. The property is used when the
402 # Authority Information Access extension (defined in RFC 5280) is absent
403 # from the certificate or when it requires overriding.
404 #
405 # Example,
406 # ocsp.responderURL=http://ocsp.example.net:80
407
408 #
409 # Subject name of the OCSP responder's certificate
410 #
411 # By default, the certificate of the OCSP responder is that of the issuer
412 # of the certificate being validated. This property identifies the certificate
413 # of the OCSP responder when the default does not apply. Its value is a string
414 # distinguished name (defined in RFC 2253) which identifies a certificate in
415 # the set of certificates supplied during cert path validation. In cases where
416 # the subject name alone is not sufficient to uniquely identify the certificate
417 # then both the "ocsp.responderCertIssuerName" and
418 # "ocsp.responderCertSerialNumber" properties must be used instead. When this
419 # property is set then those two properties are ignored.
420 #
421 # Example,
422 # ocsp.responderCertSubjectName=CN=OCSP Responder, O=XYZ Corp
423
424 #
425 # Issuer name of the OCSP responder's certificate
426 #
427 # By default, the certificate of the OCSP responder is that of the issuer
428 # of the certificate being validated. This property identifies the certificate
429 # of the OCSP responder when the default does not apply. Its value is a string
430 # distinguished name (defined in RFC 2253) which identifies a certificate in
431 # the set of certificates supplied during cert path validation. When this
432 # property is set then the "ocsp.responderCertSerialNumber" property must also
433 # be set. When the "ocsp.responderCertSubjectName" property is set then this
434 # property is ignored.
435 #
436 # Example,
437 # ocsp.responderCertIssuerName=CN=Enterprise CA, O=XYZ Corp
438
439 #
440 # Serial number of the OCSP responder's certificate
441 #
442 # By default, the certificate of the OCSP responder is that of the issuer
443 # of the certificate being validated. This property identifies the certificate
444 # of the OCSP responder when the default does not apply. Its value is a string
445 # of hexadecimal digits (colon or space separators may be present) which
446 # identifies a certificate in the set of certificates supplied during cert path
447 # validation. When this property is set then the "ocsp.responderCertIssuerName"
448 # property must also be set. When the "ocsp.responderCertSubjectName" property
449 # is set then this property is ignored.
450 #
451 # Example,
452 # ocsp.responderCertSerialNumber=2A:FF:00
453
454 #
455 # Policy for failed Kerberos KDC lookups:
456 #
457 # When a KDC is unavailable (network error, service failure, etc), it is
458 # put inside a blacklist and accessed less often for future requests. The
459 # value (case-insensitive) for this policy can be:
460 #
461 # tryLast
462 # KDCs in the blacklist are always tried after those not on the list.
463 #
464 # tryLess[:max_retries,timeout]
465 # KDCs in the blacklist are still tried by their order in the configuration,
466 # but with smaller max_retries and timeout values. max_retries and timeout
467 # are optional numerical parameters (default 1 and 5000, which means once
468 # and 5 seconds). Please notes that if any of the values defined here is
469 # more than what is defined in krb5.conf, it will be ignored.
470 #
471 # Whenever a KDC is detected as available, it is removed from the blacklist.
472 # The blacklist is reset when krb5.conf is reloaded. You can add
473 # refreshKrb5Config=true to a JAAS configuration file so that krb5.conf is
474 # reloaded whenever a JAAS authentication is attempted.
475 #
476 # Example,
477 # krb5.kdc.bad.policy = tryLast
478 # krb5.kdc.bad.policy = tryLess:2,2000
479 #
480 krb5.kdc.bad.policy = tryLast
481
482 #
483 # Kerberos cross-realm referrals (RFC 6806)
484 #
485 # OpenJDK's Kerberos client supports cross-realm referrals as defined in
486 # RFC 6806. This allows to setup more dynamic environments in which clients
487 # do not need to know in advance how to reach the realm of a target principal
488 # (either a user or service).
489 #
490 # When a client issues an AS or a TGS request, the "canonicalize" option
491 # is set to announce support of this feature. A KDC server may fulfill the
492 # request or reply referring the client to a different one. If referred,
493 # the client will issue a new request and the cycle repeats.
494 #
495 # In addition to referrals, the "canonicalize" option allows the KDC server
496 # to change the client name in response to an AS request. For security reasons,
497 # RFC 6806 (section 11) FAST scheme is enforced.
498 #
499 # Disable Kerberos cross-realm referrals. Value may be overwritten with a
500 # System property (-Dsun.security.krb5.disableReferrals).
501 sun.security.krb5.disableReferrals=false
502
503 # Maximum number of AS or TGS referrals to avoid infinite loops. Value may
504 # be overwritten with a System property (-Dsun.security.krb5.maxReferrals).
505 sun.security.krb5.maxReferrals=5
506
507 #
508 # This property contains a list of disabled EC Named Curves that can be included
509 # in the jdk.[tls|certpath|jar].disabledAlgorithms properties. To include this
510 # list in any of the disabledAlgorithms properties, add the property name as
511 # an entry.
512 jdk.disabled.namedCurves = secp112r1, secp112r2, secp128r1, secp128r2, \
513 secp160k1, secp160r1, secp160r2, secp192k1, secp192r1, secp224k1, \
514 secp224r1, secp256k1, sect113r1, sect113r2, sect131r1, sect131r2, \
515 sect163k1, sect163r1, sect163r2, sect193r1, sect193r2, sect233k1, \
516 sect233r1, sect239k1, sect283k1, sect283r1, sect409k1, sect409r1, \
517 sect571k1, sect571r1, X9.62 c2tnb191v1, X9.62 c2tnb191v2, \
518 X9.62 c2tnb191v3, X9.62 c2tnb239v1, X9.62 c2tnb239v2, X9.62 c2tnb239v3, \
519 X9.62 c2tnb359v1, X9.62 c2tnb431r1, X9.62 prime192v2, X9.62 prime192v3, \
520 X9.62 prime239v1, X9.62 prime239v2, X9.62 prime239v3, brainpoolP256r1, \
521 brainpoolP320r1, brainpoolP384r1, brainpoolP512r1
522
523 #
524 # Algorithm restrictions for certification path (CertPath) processing
525 #
526 # In some environments, certain algorithms or key lengths may be undesirable
527 # for certification path building and validation. For example, "MD2" is
528 # generally no longer considered to be a secure hash algorithm. This section
529 # describes the mechanism for disabling algorithms based on algorithm name
530 # and/or key length. This includes algorithms used in certificates, as well
531 # as revocation information such as CRLs and signed OCSP Responses.
532 # The syntax of the disabled algorithm string is described as follows:
533 # DisabledAlgorithms:
534 # " DisabledAlgorithm { , DisabledAlgorithm } "
535 #
536 # DisabledAlgorithm:
537 # AlgorithmName [Constraint] { '&' Constraint } | IncludeProperty
538 #
539 # AlgorithmName:
540 # (see below)
541 #
542 # Constraint:
543 # KeySizeConstraint | CAConstraint | DenyAfterConstraint |
544 # UsageConstraint
545 #
546 # KeySizeConstraint:
547 # keySize Operator KeyLength
548 #
549 # Operator:
550 # <= | < | == | != | >= | >
551 #
552 # KeyLength:
553 # Integer value of the algorithm's key length in bits
554 #
555 # CAConstraint:
556 # jdkCA
557 #
558 # DenyAfterConstraint:
559 # denyAfter YYYY-MM-DD
560 #
561 # UsageConstraint:
562 # usage [TLSServer] [TLSClient] [SignedJAR]
563 #
564 # IncludeProperty:
565 # include <security property>
566 #
567 # The "AlgorithmName" is the standard algorithm name of the disabled
568 # algorithm. See the Java Security Standard Algorithm Names Specification
569 # for information about Standard Algorithm Names. Matching is
570 # performed using a case-insensitive sub-element matching rule. (For
571 # example, in "SHA1withECDSA" the sub-elements are "SHA1" for hashing and
572 # "ECDSA" for signatures.) If the assertion "AlgorithmName" is a
573 # sub-element of the certificate algorithm name, the algorithm will be
574 # rejected during certification path building and validation. For example,
575 # the assertion algorithm name "DSA" will disable all certificate algorithms
576 # that rely on DSA, such as NONEwithDSA, SHA1withDSA. However, the assertion
577 # will not disable algorithms related to "ECDSA".
578 #
579 # The "IncludeProperty" allows a implementation-defined security property that
580 # can be included in the disabledAlgorithms properties. These properties are
581 # to help manage common actions easier across multiple disabledAlgorithm
582 # properties.
583 # There is one defined security property: jdk.disabled.NamedCurves
584 # See the property for more specific details.
585 #
586 #
587 # A "Constraint" defines restrictions on the keys and/or certificates for
588 # a specified AlgorithmName:
589 #
590 # KeySizeConstraint:
591 # keySize Operator KeyLength
592 # The constraint requires a key of a valid size range if the
593 # "AlgorithmName" is of a key algorithm. The "KeyLength" indicates
594 # the key size specified in number of bits. For example,
595 # "RSA keySize <= 1024" indicates that any RSA key with key size less
596 # than or equal to 1024 bits should be disabled, and
597 # "RSA keySize < 1024, RSA keySize > 2048" indicates that any RSA key
598 # with key size less than 1024 or greater than 2048 should be disabled.
599 # This constraint is only used on algorithms that have a key size.
600 #
601 # CAConstraint:
602 # jdkCA
603 # This constraint prohibits the specified algorithm only if the
604 # algorithm is used in a certificate chain that terminates at a marked
605 # trust anchor in the lib/security/cacerts keystore. If the jdkCA
606 # constraint is not set, then all chains using the specified algorithm
607 # are restricted. jdkCA may only be used once in a DisabledAlgorithm
608 # expression.
609 # Example: To apply this constraint to SHA-1 certificates, include
610 # the following: "SHA1 jdkCA"
611 #
612 # DenyAfterConstraint:
613 # denyAfter YYYY-MM-DD
614 # This constraint prohibits a certificate with the specified algorithm
615 # from being used after the date regardless of the certificate's
616 # validity. JAR files that are signed and timestamped before the
617 # constraint date with certificates containing the disabled algorithm
618 # will not be restricted. The date is processed in the UTC timezone.
619 # This constraint can only be used once in a DisabledAlgorithm
620 # expression.
621 # Example: To deny usage of RSA 2048 bit certificates after Feb 3 2020,
622 # use the following: "RSA keySize == 2048 & denyAfter 2020-02-03"
623 #
624 # UsageConstraint:
625 # usage [TLSServer] [TLSClient] [SignedJAR]
626 # This constraint prohibits the specified algorithm for
627 # a specified usage. This should be used when disabling an algorithm
628 # for all usages is not practical. 'TLSServer' restricts the algorithm
629 # in TLS server certificate chains when server authentication is
630 # performed. 'TLSClient' restricts the algorithm in TLS client
631 # certificate chains when client authentication is performed.
632 # 'SignedJAR' constrains use of certificates in signed jar files.
633 # The usage type follows the keyword and more than one usage type can
634 # be specified with a whitespace delimiter.
635 # Example: "SHA1 usage TLSServer TLSClient"
636 #
637 # When an algorithm must satisfy more than one constraint, it must be
638 # delimited by an ampersand '&'. For example, to restrict certificates in a
639 # chain that terminate at a distribution provided trust anchor and contain
640 # RSA keys that are less than or equal to 1024 bits, add the following
641 # constraint: "RSA keySize <= 1024 & jdkCA".
642 #
643 # All DisabledAlgorithms expressions are processed in the order defined in the
644 # property. This requires lower keysize constraints to be specified
645 # before larger keysize constraints of the same algorithm. For example:
646 # "RSA keySize < 1024 & jdkCA, RSA keySize < 2048".
647 #
648 # Note: The algorithm restrictions do not apply to trust anchors or
649 # self-signed certificates.
650 #
651 # Note: This property is currently used by Oracle's PKIX implementation. It
652 # is not guaranteed to be examined and used by other implementations.
653 #
654 # Example:
655 # jdk.certpath.disabledAlgorithms=MD2, DSA, RSA keySize < 2048
656 #
657 #
658 jdk.certpath.disabledAlgorithms=MD2, MD5, SHA1 jdkCA & usage TLSServer, \
659 RSA keySize < 1024, DSA keySize < 1024, EC keySize < 224, \
660 include jdk.disabled.namedCurves
661
662 #
663 # Legacy algorithms for certification path (CertPath) processing and
664 # signed JAR files.
665 #
666 # In some environments, a certain algorithm or key length may be undesirable
667 # but is not yet disabled.
668 #
669 # Tools such as keytool and jarsigner may emit warnings when these legacy
670 # algorithms are used. See the man pages for those tools for more information.
671 #
672 # The syntax is the same as the "jdk.certpath.disabledAlgorithms" and
673 # "jdk.jar.disabledAlgorithms" security properties.
674 #
675 # Note: This property is currently used by the JDK Reference
676 # implementation. It is not guaranteed to be examined and used by other
677 # implementations.
678
679 jdk.security.legacyAlgorithms=SHA1, \
680 RSA keySize < 2048, DSA keySize < 2048
681
682 #
683 # Algorithm restrictions for signed JAR files
684 #
685 # In some environments, certain algorithms or key lengths may be undesirable
686 # for signed JAR validation. For example, "MD2" is generally no longer
687 # considered to be a secure hash algorithm. This section describes the
688 # mechanism for disabling algorithms based on algorithm name and/or key length.
689 # JARs signed with any of the disabled algorithms or key sizes will be treated
690 # as unsigned.
691 #
692 # The syntax of the disabled algorithm string is described as follows:
693 # DisabledAlgorithms:
694 # " DisabledAlgorithm { , DisabledAlgorithm } "
695 #
696 # DisabledAlgorithm:
697 # AlgorithmName [Constraint] { '&' Constraint }
698 #
699 # AlgorithmName:
700 # (see below)
701 #
702 # Constraint:
703 # KeySizeConstraint | DenyAfterConstraint
704 #
705 # KeySizeConstraint:
706 # keySize Operator KeyLength
707 #
708 # DenyAfterConstraint:
709 # denyAfter YYYY-MM-DD
710 #
711 # Operator:
712 # <= | < | == | != | >= | >
713 #
714 # KeyLength:
715 # Integer value of the algorithm's key length in bits
716 #
717 # Note: This property is currently used by the JDK Reference
718 # implementation. It is not guaranteed to be examined and used by other
719 # implementations.
720 #
721 # See "jdk.certpath.disabledAlgorithms" for syntax descriptions.
722 #
723 jdk.jar.disabledAlgorithms=MD2, MD5, RSA keySize < 1024, \
724 DSA keySize < 1024, include jdk.disabled.namedCurves
725
726 #
727 # Algorithm restrictions for Secure Socket Layer/Transport Layer Security
728 # (SSL/TLS/DTLS) processing
729 #
730 # In some environments, certain algorithms or key lengths may be undesirable
731 # when using SSL/TLS/DTLS. This section describes the mechanism for disabling
732 # algorithms during SSL/TLS/DTLS security parameters negotiation, including
733 # protocol version negotiation, cipher suites selection, named groups
734 # selection, signature schemes selection, peer authentication and key
735 # exchange mechanisms.
736 #
737 # Disabled algorithms will not be negotiated for SSL/TLS connections, even
738 # if they are enabled explicitly in an application.
739 #
740 # For PKI-based peer authentication and key exchange mechanisms, this list
741 # of disabled algorithms will also be checked during certification path
742 # building and validation, including algorithms used in certificates, as
743 # well as revocation information such as CRLs and signed OCSP Responses.
744 # This is in addition to the jdk.certpath.disabledAlgorithms property above.
745 #
746 # See the specification of "jdk.certpath.disabledAlgorithms" for the
747 # syntax of the disabled algorithm string.
748 #
749 # Note: The algorithm restrictions do not apply to trust anchors or
750 # self-signed certificates.
751 #
752 # Note: This property is currently used by the JDK Reference implementation.
753 # It is not guaranteed to be examined and used by other implementations.
754 #
755 # Example:
756 # jdk.tls.disabledAlgorithms=MD5, SSLv3, DSA, RSA keySize < 2048, \
757 # rsa_pkcs1_sha1, secp224r1
758 jdk.tls.disabledAlgorithms=SSLv3, RC4, DES, MD5withRSA, DH keySize < 1024, \
759 EC keySize < 224, 3DES_EDE_CBC, anon, NULL, \
760 include jdk.disabled.namedCurves
761
762 #
763 # Legacy algorithms for Secure Socket Layer/Transport Layer Security (SSL/TLS)
764 # processing in JSSE implementation.
765 #
766 # In some environments, a certain algorithm may be undesirable but it
767 # cannot be disabled because of its use in legacy applications. Legacy
768 # algorithms may still be supported, but applications should not use them
769 # as the security strength of legacy algorithms are usually not strong enough
770 # in practice.
771 #
772 # During SSL/TLS security parameters negotiation, legacy algorithms will
773 # not be negotiated unless there are no other candidates.
774 #
775 # The syntax of the legacy algorithms string is described as this Java
776 # BNF-style:
777 # LegacyAlgorithms:
778 # " LegacyAlgorithm { , LegacyAlgorithm } "
779 #
780 # LegacyAlgorithm:
781 # AlgorithmName (standard JSSE algorithm name)
782 #
783 # See the specification of security property "jdk.certpath.disabledAlgorithms"
784 # for the syntax and description of the "AlgorithmName" notation.
785 #
786 # Per SSL/TLS specifications, cipher suites have the form:
787 # SSL_KeyExchangeAlg_WITH_CipherAlg_MacAlg
788 # or
789 # TLS_KeyExchangeAlg_WITH_CipherAlg_MacAlg
790 #
791 # For example, the cipher suite TLS_RSA_WITH_AES_128_CBC_SHA uses RSA as the
792 # key exchange algorithm, AES_128_CBC (128 bits AES cipher algorithm in CBC
793 # mode) as the cipher (encryption) algorithm, and SHA-1 as the message digest
794 # algorithm for HMAC.
795 #
796 # The LegacyAlgorithm can be one of the following standard algorithm names:
797 # 1. JSSE cipher suite name, e.g., TLS_RSA_WITH_AES_128_CBC_SHA
798 # 2. JSSE key exchange algorithm name, e.g., RSA
799 # 3. JSSE cipher (encryption) algorithm name, e.g., AES_128_CBC
800 # 4. JSSE message digest algorithm name, e.g., SHA
801 #
802 # See SSL/TLS specifications and the Java Security Standard Algorithm Names
803 # Specification for information about the algorithm names.
804 #
805 # Note: If a legacy algorithm is also restricted through the
806 # jdk.tls.disabledAlgorithms property or the
807 # java.security.AlgorithmConstraints API (See
808 # javax.net.ssl.SSLParameters.setAlgorithmConstraints()),
809 # then the algorithm is completely disabled and will not be negotiated.
810 #
811 # Note: This property is currently used by the JDK Reference implementation.
812 # It is not guaranteed to be examined and used by other implementations.
813 # There is no guarantee the property will continue to exist or be of the
814 # same syntax in future releases.
815 #
816 # Example:
817 # jdk.tls.legacyAlgorithms=DH_anon, DES_CBC, SSL_RSA_WITH_RC4_128_MD5
818 #
819 jdk.tls.legacyAlgorithms=NULL, anon, RC4, DES, 3DES_EDE_CBC
820
821 #
822 # The pre-defined default finite field Diffie-Hellman ephemeral (DHE)
823 # parameters for Transport Layer Security (SSL/TLS/DTLS) processing.
824 #
825 # In traditional SSL/TLS/DTLS connections where finite field DHE parameters
826 # negotiation mechanism is not used, the server offers the client group
827 # parameters, base generator g and prime modulus p, for DHE key exchange.
828 # It is recommended to use dynamic group parameters. This property defines
829 # a mechanism that allows you to specify custom group parameters.
830 #
831 # The syntax of this property string is described as this Java BNF-style:
832 # DefaultDHEParameters:
833 # DefinedDHEParameters { , DefinedDHEParameters }
834 #
835 # DefinedDHEParameters:
836 # "{" DHEPrimeModulus , DHEBaseGenerator "}"
837 #
838 # DHEPrimeModulus:
839 # HexadecimalDigits
840 #
841 # DHEBaseGenerator:
842 # HexadecimalDigits
843 #
844 # HexadecimalDigits:
845 # HexadecimalDigit { HexadecimalDigit }
846 #
847 # HexadecimalDigit: one of
848 # 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f
849 #
850 # Whitespace characters are ignored.
851 #
852 # The "DefinedDHEParameters" defines the custom group parameters, prime
853 # modulus p and base generator g, for a particular size of prime modulus p.
854 # The "DHEPrimeModulus" defines the hexadecimal prime modulus p, and the
855 # "DHEBaseGenerator" defines the hexadecimal base generator g of a group
856 # parameter. It is recommended to use safe primes for the custom group
857 # parameters.
858 #
859 # If this property is not defined or the value is empty, the underlying JSSE
860 # provider's default group parameter is used for each connection.
861 #
862 # If the property value does not follow the grammar, or a particular group
863 # parameter is not valid, the connection will fall back and use the
864 # underlying JSSE provider's default group parameter.
865 #
866 # Note: This property is currently used by OpenJDK's JSSE implementation. It
867 # is not guaranteed to be examined and used by other implementations.
868 #
869 # Example:
870 # jdk.tls.server.defaultDHEParameters=
871 # { \
872 # FFFFFFFF FFFFFFFF C90FDAA2 2168C234 C4C6628B 80DC1CD1 \
873 # 29024E08 8A67CC74 020BBEA6 3B139B22 514A0879 8E3404DD \
874 # EF9519B3 CD3A431B 302B0A6D F25F1437 4FE1356D 6D51C245 \
875 # E485B576 625E7EC6 F44C42E9 A637ED6B 0BFF5CB6 F406B7ED \
876 # EE386BFB 5A899FA5 AE9F2411 7C4B1FE6 49286651 ECE65381 \
877 # FFFFFFFF FFFFFFFF, 2}
878
879 #
880 # TLS key limits on symmetric cryptographic algorithms
881 #
882 # This security property sets limits on algorithms key usage in TLS 1.3.
883 # When the amount of data encrypted exceeds the algorithm value listed below,
884 # a KeyUpdate message will trigger a key change. This is for symmetric ciphers
885 # with TLS 1.3 only.
886 #
887 # The syntax for the property is described below:
888 # KeyLimits:
889 # " KeyLimit { , KeyLimit } "
890 #
891 # WeakKeyLimit:
892 # AlgorithmName Action Length
893 #
894 # AlgorithmName:
895 # A full algorithm transformation.
896 #
897 # Action:
898 # KeyUpdate
899 #
900 # Length:
901 # The amount of encrypted data in a session before the Action occurs
902 # This value may be an integer value in bytes, or as a power of two, 2^29.
903 #
904 # KeyUpdate:
905 # The TLS 1.3 KeyUpdate handshake process begins when the Length amount
906 # is fulfilled.
907 #
908 # Note: This property is currently used by OpenJDK's JSSE implementation. It
909 # is not guaranteed to be examined and used by other implementations.
910 #
911 jdk.tls.keyLimits=AES/GCM/NoPadding KeyUpdate 2^37
912
913 #
914 # Cryptographic Jurisdiction Policy defaults
915 #
916 # Import and export control rules on cryptographic software vary from
917 # country to country. By default, Java provides two different sets of
918 # cryptographic policy files[1]:
919 #
920 # unlimited: These policy files contain no restrictions on cryptographic
921 # strengths or algorithms
922 #
923 # limited: These policy files contain more restricted cryptographic
924 # strengths
925 #
926 # The default setting is determined by the value of the "crypto.policy"
927 # Security property below. If your country or usage requires the
928 # traditional restrictive policy, the "limited" Java cryptographic
929 # policy is still available and may be appropriate for your environment.
930 #
931 # If you have restrictions that do not fit either use case mentioned
932 # above, Java provides the capability to customize these policy files.
933 # The "crypto.policy" security property points to a subdirectory
934 # within <java-home>/conf/security/policy/ which can be customized.
935 # Please see the <java-home>/conf/security/policy/README.txt file or consult
936 # the Java Security Guide/JCA documentation for more information.
937 #
938 # YOU ARE ADVISED TO CONSULT YOUR EXPORT/IMPORT CONTROL COUNSEL OR ATTORNEY
939 # TO DETERMINE THE EXACT REQUIREMENTS.
940 #
941 # [1] Please note that the JCE for Java SE, including the JCE framework,
942 # cryptographic policy files, and standard JCE providers provided with
943 # the Java SE, have been reviewed and approved for export as mass market
944 # encryption item by the US Bureau of Industry and Security.
945 #
946 # Note: This property is currently used by the JDK Reference implementation.
947 # It is not guaranteed to be examined and used by other implementations.
948 #
949 crypto.policy=crypto.policydir-tbd
950
951 #
952 # The policy for the XML Signature secure validation mode. The mode is
953 # enabled by setting the property "org.jcp.xml.dsig.secureValidation" to
954 # true with the javax.xml.crypto.XMLCryptoContext.setProperty() method,
955 # or by running the code with a SecurityManager.
956 #
957 # Policy:
958 # Constraint {"," Constraint }
959 # Constraint:
960 # AlgConstraint | MaxTransformsConstraint | MaxReferencesConstraint |
961 # ReferenceUriSchemeConstraint | KeySizeConstraint | OtherConstraint
962 # AlgConstraint
963 # "disallowAlg" Uri
964 # MaxTransformsConstraint:
965 # "maxTransforms" Integer
966 # MaxReferencesConstraint:
967 # "maxReferences" Integer
968 # ReferenceUriSchemeConstraint:
969 # "disallowReferenceUriSchemes" String { String }
970 # KeySizeConstraint:
971 # "minKeySize" KeyAlg Integer
972 # OtherConstraint:
973 # "noDuplicateIds" | "noRetrievalMethodLoops"
974 #
975 # For AlgConstraint, Uri is the algorithm URI String that is not allowed.
976 # See the XML Signature Recommendation for more information on algorithm
977 # URI Identifiers. For KeySizeConstraint, KeyAlg is the standard algorithm
978 # name of the key type (ex: "RSA"). If the MaxTransformsConstraint,
979 # MaxReferencesConstraint or KeySizeConstraint (for the same key type) is
980 # specified more than once, only the last entry is enforced.
981 #
982 # Note: This property is currently used by the JDK Reference implementation. It
983 # is not guaranteed to be examined and used by other implementations.
984 #
985 jdk.xml.dsig.secureValidationPolicy=\
986 disallowAlg http://www.w3.org/TR/1999/REC-xslt-19991116,\
987 disallowAlg http://www.w3.org/2001/04/xmldsig-more#rsa-md5,\
988 disallowAlg http://www.w3.org/2001/04/xmldsig-more#hmac-md5,\
989 disallowAlg http://www.w3.org/2001/04/xmldsig-more#md5,\
990 maxTransforms 5,\
991 maxReferences 30,\
992 disallowReferenceUriSchemes file http https,\
993 minKeySize RSA 1024,\
994 minKeySize DSA 1024,\
995 minKeySize EC 224,\
996 noDuplicateIds,\
997 noRetrievalMethodLoops
998
999 #
1000 # Serialization system-wide filter
1001 #
1002 # A filter, if configured, is used by java.io.ObjectInputStream during
1003 # deserialization to check the contents of the stream.
1004 # A filter is configured as a sequence of patterns, each pattern is either
1005 # matched against the name of a class in the stream or defines a limit.
1006 # Patterns are separated by ";" (semicolon).
1007 # Whitespace is significant and is considered part of the pattern.
1008 #
1009 # If the system property jdk.serialFilter is also specified, it supersedes
1010 # the security property value defined here.
1011 #
1012 # If a pattern includes a "=", it sets a limit.
1013 # If a limit appears more than once the last value is used.
1014 # Limits are checked before classes regardless of the order in the
1015 # sequence of patterns.
1016 # If any of the limits are exceeded, the filter status is REJECTED.
1017 #
1018 # maxdepth=value - the maximum depth of a graph
1019 # maxrefs=value - the maximum number of internal references
1020 # maxbytes=value - the maximum number of bytes in the input stream
1021 # maxarray=value - the maximum array length allowed
1022 #
1023 # Other patterns, from left to right, match the class or package name as
1024 # returned from Class.getName.
1025 # If the class is an array type, the class or package to be matched is the
1026 # element type.
1027 # Arrays of any number of dimensions are treated the same as the element type.
1028 # For example, a pattern of "!example.Foo", rejects creation of any instance or
1029 # array of example.Foo.
1030 #
1031 # If the pattern starts with "!", the status is REJECTED if the remaining
1032 # pattern is matched; otherwise the status is ALLOWED if the pattern matches.
1033 # If the pattern contains "/", the non-empty prefix up to the "/" is the
1034 # module name;
1035 # if the module name matches the module name of the class then
1036 # the remaining pattern is matched with the class name.
1037 # If there is no "/", the module name is not compared.
1038 # If the pattern ends with ".**" it matches any class in the package and all
1039 # subpackages.
1040 # If the pattern ends with ".*" it matches any class in the package.
1041 # If the pattern ends with "*", it matches any class with the pattern as a
1042 # prefix.
1043 # If the pattern is equal to the class name, it matches.
1044 # Otherwise, the status is UNDECIDED.
1045 #
1046 #jdk.serialFilter=pattern;pattern
1047
1048 #
1049 # RMI Registry Serial Filter
1050 #
1051 # The filter pattern uses the same format as jdk.serialFilter.
1052 # This filter can override the builtin filter if additional types need to be
1053 # allowed or rejected from the RMI Registry or to decrease limits but not
1054 # to increase limits.
1055 # If the limits (maxdepth, maxrefs, or maxbytes) are exceeded, the object is rejected.
1056 #
1057 # Each non-array type is allowed or rejected if it matches one of the patterns,
1058 # evaluated from left to right, and is otherwise allowed. Arrays of any
1059 # component type, including subarrays and arrays of primitives, are allowed.
1060 #
1061 # Array construction of any component type, including subarrays and arrays of
1062 # primitives, are allowed unless the length is greater than the maxarray limit.
1063 # The filter is applied to each array element.
1064 #
1065 # Note: This property is currently used by the JDK Reference implementation.
1066 # It is not guaranteed to be examined and used by other implementations.
1067 #
1068 # The built-in filter allows subclasses of allowed classes and
1069 # can approximately be represented as the pattern:
1070 #
1071 #sun.rmi.registry.registryFilter=\
1072 # maxarray=1000000;\
1073 # maxdepth=20;\
1074 # java.lang.String;\
1075 # java.lang.Number;\
1076 # java.lang.reflect.Proxy;\
1077 # java.rmi.Remote;\
1078 # sun.rmi.server.UnicastRef;\
1079 # sun.rmi.server.RMIClientSocketFactory;\
1080 # sun.rmi.server.RMIServerSocketFactory;\
1081 # java.rmi.activation.ActivationID;\
1082 # java.rmi.server.UID
1083 #
1084 # RMI Distributed Garbage Collector (DGC) Serial Filter
1085 #
1086 # The filter pattern uses the same format as jdk.serialFilter.
1087 # This filter can override the builtin filter if additional types need to be
1088 # allowed or rejected from the RMI DGC.
1089 #
1090 # Note: This property is currently used by the JDK Reference implementation.
1091 # It is not guaranteed to be examined and used by other implementations.
1092 #
1093 # The builtin DGC filter can approximately be represented as the filter pattern:
1094 #
1095 #sun.rmi.transport.dgcFilter=\
1096 # java.rmi.server.ObjID;\
1097 # java.rmi.server.UID;\
1098 # java.rmi.dgc.VMID;\
1099 # java.rmi.dgc.Lease;\
1100 # maxdepth=5;maxarray=10000
1101
1102 #
1103 # JCEKS Encrypted Key Serial Filter
1104 #
1105 # This filter, if configured, is used by the JCEKS KeyStore during the
1106 # deserialization of the encrypted Key object stored inside a key entry.
1107 # If not configured or the filter result is UNDECIDED (i.e. none of the patterns
1108 # matches), the filter configured by jdk.serialFilter will be consulted.
1109 #
1110 # If the system property jceks.key.serialFilter is also specified, it supersedes
1111 # the security property value defined here.
1112 #
1113 # The filter pattern uses the same format as jdk.serialFilter. The default
1114 # pattern allows java.lang.Enum, java.security.KeyRep, java.security.KeyRep$Type,
1115 # and javax.crypto.spec.SecretKeySpec and rejects all the others.
1116 jceks.key.serialFilter = java.base/java.lang.Enum;java.base/java.security.KeyRep;\
1117 java.base/java.security.KeyRep$Type;java.base/javax.crypto.spec.SecretKeySpec;!*
1118
1119 # The iteration count used for password-based encryption (PBE) in JCEKS
1120 # keystores. Values in the range 10000 to 5000000 are considered valid.
1121 # If the value is out of this range, or is not a number, or is unspecified;
1122 # a default of 200000 is used.
1123 #
1124 # If the system property jdk.jceks.iterationCount is also specified, it
1125 # supersedes the security property value defined here.
1126 #
1127 #jdk.jceks.iterationCount = 200000
1128
1129 #
1130 # PKCS12 KeyStore properties
1131 #
1132 # The following properties, if configured, are used by the PKCS12 KeyStore
1133 # implementation during the creation of a new keystore. Several of the
1134 # properties may also be used when modifying an existing keystore. The
1135 # properties can be overridden by a KeyStore API that specifies its own
1136 # algorithms and parameters.
1137 #
1138 # If an existing PKCS12 keystore is loaded and then stored, the algorithm and
1139 # parameter used to generate the existing Mac will be reused. If the existing
1140 # keystore does not have a Mac, no Mac will be created while storing. If there
1141 # is at least one certificate in the existing keystore, the algorithm and
1142 # parameters used to encrypt the last certificate in the existing keystore will
1143 # be reused to encrypt all certificates while storing. If the last certificate
1144 # in the existing keystore is not encrypted, all certificates will be stored
1145 # unencrypted. If there is no certificate in the existing keystore, any newly
1146 # added certificate will be encrypted (or stored unencrypted if algorithm
1147 # value is "NONE") using the "keystore.pkcs12.certProtectionAlgorithm" and
1148 # "keystore.pkcs12.certPbeIterationCount" values defined here. Existing private
1149 # and secret key(s) are not changed. Newly set private and secret key(s) will
1150 # be encrypted using the "keystore.pkcs12.keyProtectionAlgorithm" and
1151 # "keystore.pkcs12.keyPbeIterationCount" values defined here.
1152 #
1153 # In order to apply new algorithms and parameters to all entries in an
1154 # existing keystore, one can create a new keystore and add entries in the
1155 # existing keystore into the new keystore. This can be achieved by calling the
1156 # "keytool -importkeystore" command.
1157 #
1158 # If a system property of the same name is also specified, it supersedes the
1159 # security property value defined here.
1160 #
1161 # If the property is set to an illegal value,
1162 # an iteration count that is not a positive integer, or an unknown algorithm
1163 # name, an exception will be thrown when the property is used.
1164 # If the property is not set or empty, a default value will be used.
1165 #
1166 # Note: These properties are currently used by the JDK Reference implementation.
1167 # They are not guaranteed to be examined and used by other implementations.
1168
1169 # The algorithm used to encrypt a certificate. This can be any non-Hmac PBE
1170 # algorithm defined in the Cipher section of the Java Security Standard
1171 # Algorithm Names Specification. When set to "NONE", the certificate
1172 # is not encrypted. The default value is "PBEWithSHA1AndRC2_40".
1173 #keystore.pkcs12.certProtectionAlgorithm = PBEWithSHA1AndRC2_40
1174
1175 # The iteration count used by the PBE algorithm when encrypting a certificate.
1176 # This value must be a positive integer. The default value is 50000.
1177 #keystore.pkcs12.certPbeIterationCount = 50000
1178
1179 # The algorithm used to encrypt a private key or secret key. This can be
1180 # any non-Hmac PBE algorithm defined in the Cipher section of the Java
1181 # Security Standard Algorithm Names Specification. The value must not be "NONE".
1182 # The default value is "PBEWithSHA1AndDESede".
1183 #keystore.pkcs12.keyProtectionAlgorithm = PBEWithSHA1AndDESede
1184
1185 # The iteration count used by the PBE algorithm when encrypting a private key
1186 # or a secret key. This value must be a positive integer. The default value
1187 # is 50000.
1188 #keystore.pkcs12.keyPbeIterationCount = 50000
1189
1190 # The algorithm used to calculate the optional MacData at the end of a PKCS12
1191 # file. This can be any HmacPBE algorithm defined in the Mac section of the
1192 # Java Security Standard Algorithm Names Specification. When set to "NONE",
1193 # no Mac is generated. The default value is "HmacPBESHA1".
1194 #keystore.pkcs12.macAlgorithm = HmacPBESHA1
1195
1196 # The iteration count used by the MacData algorithm. This value must be a
1197 # positive integer. The default value is 100000.
1198 #keystore.pkcs12.macIterationCount = 100000
1199
1200 #
1201 # Enhanced exception message information
1202 #
1203 # By default, exception messages should not include potentially sensitive
1204 # information such as file names, host names, or port numbers. This property
1205 # accepts one or more comma separated values, each of which represents a
1206 # category of enhanced exception message information to enable. Values are
1207 # case-insensitive. Leading and trailing whitespaces, surrounding each value,
1208 # are ignored. Unknown values are ignored.
1209 #
1210 # NOTE: Use caution before setting this property. Setting this property
1211 # exposes sensitive information in Exceptions, which could, for example,
1212 # propagate to untrusted code or be emitted in stack traces that are
1213 # inadvertently disclosed and made accessible over a public network.
1214 #
1215 # The categories are:
1216 #
1217 # hostInfo - IOExceptions thrown by java.net.Socket and the socket types in the
1218 # java.nio.channels package will contain enhanced exception
1219 # message information
1220 #
1221 # jar - enables more detailed information in the IOExceptions thrown
1222 # by classes in the java.util.jar package
1223 #
1224 # The property setting in this file can be overridden by a system property of
1225 # the same name, with the same syntax and possible values.
1226 #
1227 #jdk.includeInExceptions=hostInfo,jar
1228
1229 #
1230 # Disabled mechanisms for the Simple Authentication and Security Layer (SASL)
1231 #
1232 # Disabled mechanisms will not be negotiated by both SASL clients and servers.
1233 # These mechanisms will be ignored if they are specified in the "mechanisms"
1234 # argument of "Sasl.createSaslClient" or the "mechanism" argument of
1235 # "Sasl.createSaslServer".
1236 #
1237 # The value of this property is a comma-separated list of SASL mechanisms.
1238 # The mechanisms are case-sensitive. Whitespaces around the commas are ignored.
1239 #
1240 # Note: This property is currently used by the JDK Reference implementation.
1241 # It is not guaranteed to be examined and used by other implementations.
1242 #
1243 # Example:
1244 # jdk.sasl.disabledMechanisms=PLAIN, CRAM-MD5, DIGEST-MD5
1245 jdk.sasl.disabledMechanisms=
1246
1247 #
1248 # Policies for distrusting Certificate Authorities (CAs).
1249 #
1250 # This is a comma separated value of one or more case-sensitive strings, each
1251 # of which represents a policy for determining if a CA should be distrusted.
1252 # The supported values are:
1253 #
1254 # SYMANTEC_TLS : Distrust TLS Server certificates anchored by a Symantec
1255 # root CA and issued after April 16, 2019 unless issued by one of the
1256 # following subordinate CAs which have a later distrust date:
1257 # 1. Apple IST CA 2 - G1, SHA-256 fingerprint:
1258 # AC2B922ECFD5E01711772FEA8ED372DE9D1E2245FCE3F57A9CDBEC77296A424B
1259 # Distrust after December 31, 2019.
1260 # 2. Apple IST CA 8 - G1, SHA-256 fingerprint:
1261 # A4FE7C7F15155F3F0AEF7AAA83CF6E06DEB97CA3F909DF920AC1490882D488ED
1262 # Distrust after December 31, 2019.
1263 #
1264 # Leading and trailing whitespace surrounding each value are ignored.
1265 # Unknown values are ignored. If the property is commented out or set to the
1266 # empty String, no policies are enforced.
1267 #
1268 # Note: This property is currently used by the JDK Reference implementation.
1269 # It is not guaranteed to be supported by other SE implementations. Also, this
1270 # property does not override other security properties which can restrict
1271 # certificates such as jdk.tls.disabledAlgorithms or
1272 # jdk.certpath.disabledAlgorithms; those restrictions are still enforced even
1273 # if this property is not enabled.
1274 #
1275 jdk.security.caDistrustPolicies=SYMANTEC_TLS
1276
1277 #
1278 # FilePermission path canonicalization
1279 #
1280 # This security property dictates how the path argument is processed and stored
1281 # while constructing a FilePermission object. If the value is set to true, the
1282 # path argument is canonicalized and FilePermission methods (such as implies,
1283 # equals, and hashCode) are implemented based on this canonicalized result.
1284 # Otherwise, the path argument is not canonicalized and FilePermission methods are
1285 # implemented based on the original input. See the implementation note of the
1286 # FilePermission class for more details.
1287 #
1288 # If a system property of the same name is also specified, it supersedes the
1289 # security property value defined here.
1290 #
1291 # The default value for this property is false.
1292 #
1293 jdk.io.permissionsUseCanonicalPath=false
1294
1295
1296 #
1297 # Policies for the proxy_impersonator Kerberos ccache configuration entry
1298 #
1299 # The proxy_impersonator ccache configuration entry indicates that the ccache
1300 # is a synthetic delegated credential for use with S4U2Proxy by an intermediate
1301 # server. The ccache file should also contain the TGT of this server and
1302 # an evidence ticket from the default principal of the ccache to this server.
1303 #
1304 # This security property determines how Java uses this configuration entry.
1305 # There are 3 possible values:
1306 #
1307 # no-impersonate - Ignore this configuration entry, and always act as
1308 # the owner of the TGT (if it exists).
1309 #
1310 # try-impersonate - Try impersonation when this configuration entry exists.
1311 # If no matching TGT or evidence ticket is found,
1312 # fallback to no-impersonate.
1313 #
1314 # always-impersonate - Always impersonate when this configuration entry exists.
1315 # If no matching TGT or evidence ticket is found,
1316 # no initial credential is read from the ccache.
1317 #
1318 # The default value is "always-impersonate".
1319 #
1320 # If a system property of the same name is also specified, it supersedes the
1321 # security property value defined here.
1322 #
1323 #jdk.security.krb5.default.initiate.credential=always-impersonate
1324
1325 #
1326 # Trust Anchor Certificates - CA Basic Constraint check
1327 #
1328 # X.509 v3 certificates used as Trust Anchors (to validate signed code or TLS
1329 # connections) must have the cA Basic Constraint field set to 'true'. Also, if
1330 # they include a Key Usage extension, the keyCertSign bit must be set. These
1331 # checks, enabled by default, can be disabled for backward-compatibility
1332 # purposes with the jdk.security.allowNonCaAnchor System and Security
1333 # properties. In the case that both properties are simultaneously set, the
1334 # System value prevails. The default value of the property is "false".
1335 #
1336 #jdk.security.allowNonCaAnchor=true