408 # more than what is defined in krb5.conf, it will be ignored. 409 # 410 # Whenever a KDC is detected as available, it is removed from the blacklist. 411 # The blacklist is reset when krb5.conf is reloaded. You can add 412 # refreshKrb5Config=true to a JAAS configuration file so that krb5.conf is 413 # reloaded whenever a JAAS authentication is attempted. 414 # 415 # Example, 416 # krb5.kdc.bad.policy = tryLast 417 # krb5.kdc.bad.policy = tryLess:2,2000 418 krb5.kdc.bad.policy = tryLast 419 420 # Algorithm restrictions for certification path (CertPath) processing 421 # 422 # In some environments, certain algorithms or key lengths may be undesirable 423 # for certification path building and validation. For example, "MD2" is 424 # generally no longer considered to be a secure hash algorithm. This section 425 # describes the mechanism for disabling algorithms based on algorithm name 426 # and/or key length. This includes algorithms used in certificates, as well 427 # as revocation information such as CRLs and signed OCSP Responses. 428 # 429 # The syntax of the disabled algorithm string is described as this Java 430 # BNF-style: 431 # DisabledAlgorithms: 432 # " DisabledAlgorithm { , DisabledAlgorithm } " 433 # 434 # DisabledAlgorithm: 435 # AlgorithmName [Constraint] { '&' Constraint } 436 # 437 # AlgorithmName: 438 # (see below) 439 # 440 # Constraint: 441 # KeySizeConstraint, CertConstraint 442 # 443 # KeySizeConstraint: 444 # keySize Operator DecimalInteger 445 # 446 # Operator: 447 # <= | < | == | != | >= | > 448 # 449 # DecimalInteger: 450 # DecimalDigits 451 # 452 # DecimalDigits: 453 # DecimalDigit {DecimalDigit} 454 # 455 # DecimalDigit: one of 456 # 1 2 3 4 5 6 7 8 9 0 457 # 458 # CertConstraint 459 # jdkCA 460 # 461 # The "AlgorithmName" is the standard algorithm name of the disabled 462 # algorithm. See "Java Cryptography Architecture Standard Algorithm Name 463 # Documentation" for information about Standard Algorithm Names. Matching 464 # is performed using a case-insensitive sub-element matching rule. (For 465 # example, in "SHA1withECDSA" the sub-elements are "SHA1" for hashing and 466 # "ECDSA" for signatures.) If the assertion "AlgorithmName" is a 467 # sub-element of the certificate algorithm name, the algorithm will be 468 # rejected during certification path building and validation. For example, 469 # the assertion algorithm name "DSA" will disable all certificate algorithms 470 # that rely on DSA, such as NONEwithDSA, SHA1withDSA. However, the assertion 471 # will not disable algorithms related to "ECDSA". 472 # 473 # A "Constraint" provides further guidance for the algorithm being specified. 474 # The "KeySizeConstraint" requires a key of a valid size range if the 475 # "AlgorithmName" is of a key algorithm. The "DecimalInteger" indicates the 476 # key size specified in number of bits. For example, "RSA keySize <= 1024" 477 # indicates that any RSA key with key size less than or equal to 1024 bits 478 # should be disabled, and "RSA keySize < 1024, RSA keySize > 2048" indicates 479 # that any RSA key with key size less than 1024 or greater than 2048 should 480 # be disabled. Note that the "KeySizeConstraint" only makes sense to key 481 # algorithms. 482 # 483 # "CertConstraint" specifies additional constraints for 484 # certificates that contain algorithms that are restricted: 485 # 486 # "jdkCA" prohibits the specified algorithm only if the algorithm is used 487 # in a certificate chain that terminates at a marked trust anchor in the 488 # lib/security/cacerts keystore. All other chains are not affected. 489 # If the jdkCA constraint is not set, then all chains using the 490 # specified algorithm are restricted. jdkCA may only be used once in 491 # a DisabledAlgorithm expression. 492 # Example: To apply this constraint to SHA-1 certificates, include 493 # the following: "SHA1 jdkCA" 494 # 495 # When an algorithm must satisfy more than one constraint, it must be 496 # delimited by an ampersand '&'. For example, to restrict certificates in a 497 # chain that terminate at a distribution provided trust anchor and contain 498 # RSA keys that are less than or equal to 1024 bits, add the following 499 # constraint: "RSA keySize <= 1024 & jdkCA". 500 # 501 # All DisabledAlgorithms expressions are processed in the order defined in the 502 # property. This requires lower keysize constraints to be specified 503 # before larger keysize constraints of the same algorithm. For example: 504 # "RSA keySize < 1024 & jdkCA, RSA keySize < 2048". 505 # 506 # Note: This property is currently used by Oracle's PKIX implementation. It 507 # is not guaranteed to be examined and used by other implementations. 508 # 509 # Example: 510 # jdk.certpath.disabledAlgorithms=MD2, DSA, RSA keySize < 2048 511 # 512 # 513 jdk.certpath.disabledAlgorithms=MD2, MD5, RSA keySize < 1024, \ 514 DSA keySize < 1024, EC keySize < 224 515 516 # Algorithm restrictions for signed JAR files 517 # 518 # In some environments, certain algorithms or key lengths may be undesirable 519 # for signed JAR validation. For example, "MD2" is generally no longer 520 # considered to be a secure hash algorithm. This section describes the 521 # mechanism for disabling algorithms based on algorithm name and/or key length. 522 # JARs signed with any of the disabled algorithms or key sizes will be treated 523 # as unsigned. 524 # 525 # The syntax of the disabled algorithm string is described as follows: 526 # DisabledAlgorithms: 527 # " DisabledAlgorithm { , DisabledAlgorithm } " 528 # 529 # DisabledAlgorithm: 530 # AlgorithmName [Constraint] 531 # 532 # AlgorithmName: 533 # (see below) 534 # 535 # Constraint: 536 # KeySizeConstraint 537 # 538 # KeySizeConstraint: 539 # keySize Operator KeyLength 540 # 541 # Operator: 542 # <= | < | == | != | >= | > 543 # 544 # KeyLength: 545 # Integer value of the algorithm's key length in bits 546 # 547 # Note: This property is currently used by the JDK Reference 548 # implementation. It is not guaranteed to be examined and used by other 549 # implementations. 550 # 551 jdk.jar.disabledAlgorithms=MD2, MD5, RSA keySize < 1024 552 553 # Algorithm restrictions for Secure Socket Layer/Transport Layer Security 554 # (SSL/TLS) processing 555 # 556 # In some environments, certain algorithms or key lengths may be undesirable 557 # when using SSL/TLS. This section describes the mechanism for disabling 558 # algorithms during SSL/TLS security parameters negotiation, including 559 # protocol version negotiation, cipher suites selection, peer authentication 560 # and key exchange mechanisms. 561 # 562 # Disabled algorithms will not be negotiated for SSL/TLS connections, even 563 # if they are enabled explicitly in an application. 564 # 565 # For PKI-based peer authentication and key exchange mechanisms, this list 566 # of disabled algorithms will also be checked during certification path 567 # building and validation, including algorithms used in certificates, as 568 # well as revocation information such as CRLs and signed OCSP Responses. 569 # This is in addition to the jdk.certpath.disabledAlgorithms property above. 570 # 571 # See the specification of "jdk.certpath.disabledAlgorithms" for the 572 # syntax of the disabled algorithm string. 573 # 574 # Note: This property is currently used by the JDK Reference implementation. 575 # It is not guaranteed to be examined and used by other implementations. 576 # 577 # Example: 578 # jdk.tls.disabledAlgorithms=MD5, SSLv3, DSA, RSA keySize < 2048 579 jdk.tls.disabledAlgorithms=SSLv3, RC4, MD5withRSA, DH keySize < 768, \ 580 EC keySize < 224 581 582 # Legacy algorithms for Secure Socket Layer/Transport Layer Security (SSL/TLS) 583 # processing in JSSE implementation. 584 # 585 # In some environments, a certain algorithm may be undesirable but it 586 # cannot be disabled because of its use in legacy applications. Legacy 587 # algorithms may still be supported, but applications should not use them 588 # as the security strength of legacy algorithms are usually not strong enough 589 # in practice. 590 # 591 # During SSL/TLS security parameters negotiation, legacy algorithms will 592 # not be negotiated unless there are no other candidates. | 408 # more than what is defined in krb5.conf, it will be ignored. 409 # 410 # Whenever a KDC is detected as available, it is removed from the blacklist. 411 # The blacklist is reset when krb5.conf is reloaded. You can add 412 # refreshKrb5Config=true to a JAAS configuration file so that krb5.conf is 413 # reloaded whenever a JAAS authentication is attempted. 414 # 415 # Example, 416 # krb5.kdc.bad.policy = tryLast 417 # krb5.kdc.bad.policy = tryLess:2,2000 418 krb5.kdc.bad.policy = tryLast 419 420 # Algorithm restrictions for certification path (CertPath) processing 421 # 422 # In some environments, certain algorithms or key lengths may be undesirable 423 # for certification path building and validation. For example, "MD2" is 424 # generally no longer considered to be a secure hash algorithm. This section 425 # describes the mechanism for disabling algorithms based on algorithm name 426 # and/or key length. This includes algorithms used in certificates, as well 427 # as revocation information such as CRLs and signed OCSP Responses. 428 # The syntax of the disabled algorithm string is described as follows: 429 # DisabledAlgorithms: 430 # " DisabledAlgorithm { , DisabledAlgorithm } " 431 # 432 # DisabledAlgorithm: 433 # AlgorithmName [Constraint] { '&' Constraint } 434 # 435 # AlgorithmName: 436 # (see below) 437 # 438 # Constraint: 439 # KeySizeConstraint | CAConstraint | DenyAfterConstraint | 440 # UsageConstraint 441 # 442 # KeySizeConstraint: 443 # keySize Operator KeyLength 444 # 445 # Operator: 446 # <= | < | == | != | >= | > 447 # 448 # KeyLength: 449 # Integer value of the algorithm's key length in bits 450 # 451 # CAConstraint: 452 # jdkCA 453 # 454 # DenyAfterConstraint: 455 # denyAfter YYYY-MM-DD 456 # 457 # UsageConstraint: 458 # usage [TLSServer] [TLSClient] [SignedJAR] 459 # 460 # The "AlgorithmName" is the standard algorithm name of the disabled 461 # algorithm. See "Java Cryptography Architecture Standard Algorithm Name 462 # Documentation" for information about Standard Algorithm Names. Matching 463 # is performed using a case-insensitive sub-element matching rule. (For 464 # example, in "SHA1withECDSA" the sub-elements are "SHA1" for hashing and 465 # "ECDSA" for signatures.) If the assertion "AlgorithmName" is a 466 # sub-element of the certificate algorithm name, the algorithm will be 467 # rejected during certification path building and validation. For example, 468 # the assertion algorithm name "DSA" will disable all certificate algorithms 469 # that rely on DSA, such as NONEwithDSA, SHA1withDSA. However, the assertion 470 # will not disable algorithms related to "ECDSA". 471 # 472 # A "Constraint" defines restrictions on the keys and/or certificates for 473 # a specified AlgorithmName: 474 # 475 # KeySizeConstraint: 476 # keySize Operator KeyLength 477 # The constraint requires a key of a valid size range if the 478 # "AlgorithmName" is of a key algorithm. The "KeyLength" indicates 479 # the key size specified in number of bits. For example, 480 # "RSA keySize <= 1024" indicates that any RSA key with key size less 481 # than or equal to 1024 bits should be disabled, and 482 # "RSA keySize < 1024, RSA keySize > 2048" indicates that any RSA key 483 # with key size less than 1024 or greater than 2048 should be disabled. 484 # This constraint is only used on algorithms that have a key size. 485 # 486 # CAConstraint: 487 # jdkCA 488 # This constraint prohibits the specified algorithm only if the 489 # algorithm is used in a certificate chain that terminates at a marked 490 # trust anchor in the lib/security/cacerts keystore. If the jdkCA 491 # constraint is not set, then all chains using the specified algorithm 492 # are restricted. jdkCA may only be used once in a DisabledAlgorithm 493 # expression. 494 # Example: To apply this constraint to SHA-1 certificates, include 495 # the following: "SHA1 jdkCA" 496 # 497 # DenyAfterConstraint: 498 # denyAfter YYYY-MM-DD 499 # This constraint prohibits a certificate with the specified algorithm 500 # from being used after the date regardless of the certificate's 501 # validity. JAR files that are signed and timestamped before the 502 # constraint date with certificates containing the disabled algorithm 503 # will not be restricted. The date is processed in the UTC timezone. 504 # This constraint can only be used once in a DisabledAlgorithm 505 # expression. 506 # Example: To deny usage of RSA 2048 bit certificates after Feb 3 2020, 507 # use the following: "RSA keySize == 2048 & denyAfter 2020-02-03" 508 # 509 # UsageConstraint: 510 # usage [TLSServer] [TLSClient] [SignedJAR] 511 # This constraint prohibits the specified algorithm for 512 # a specified usage. This should be used when disabling an algorithm 513 # for all usages is not practical. 'TLSServer' restricts the algorithm 514 # in TLS server certificate chains when server authentication is 515 # performed. 'TLSClient' restricts the algorithm in TLS client 516 # certificate chains when client authentication is performed. 517 # 'SignedJAR' constrains use of certificates in signed jar files. 518 # The usage type follows the keyword and more than one usage type can 519 # be specified with a whitespace delimiter. 520 # Example: "SHA1 usage TLSServer TLSClient" 521 # 522 # When an algorithm must satisfy more than one constraint, it must be 523 # delimited by an ampersand '&'. For example, to restrict certificates in a 524 # chain that terminate at a distribution provided trust anchor and contain 525 # RSA keys that are less than or equal to 1024 bits, add the following 526 # constraint: "RSA keySize <= 1024 & jdkCA". 527 # 528 # All DisabledAlgorithms expressions are processed in the order defined in the 529 # property. This requires lower keysize constraints to be specified 530 # before larger keysize constraints of the same algorithm. For example: 531 # "RSA keySize < 1024 & jdkCA, RSA keySize < 2048". 532 # 533 # Note: The algorithm restrictions do not apply to trust anchors or 534 # self-signed certificates. 535 # 536 # Note: This property is currently used by Oracle's PKIX implementation. It 537 # is not guaranteed to be examined and used by other implementations. 538 # 539 # Example: 540 # jdk.certpath.disabledAlgorithms=MD2, DSA, RSA keySize < 2048 541 # 542 # 543 jdk.certpath.disabledAlgorithms=MD2, MD5, RSA keySize < 1024, \ 544 DSA keySize < 1024, EC keySize < 224 545 546 # 547 # Algorithm restrictions for signed JAR files 548 # 549 # In some environments, certain algorithms or key lengths may be undesirable 550 # for signed JAR validation. For example, "MD2" is generally no longer 551 # considered to be a secure hash algorithm. This section describes the 552 # mechanism for disabling algorithms based on algorithm name and/or key length. 553 # JARs signed with any of the disabled algorithms or key sizes will be treated 554 # as unsigned. 555 # 556 # The syntax of the disabled algorithm string is described as follows: 557 # DisabledAlgorithms: 558 # " DisabledAlgorithm { , DisabledAlgorithm } " 559 # 560 # DisabledAlgorithm: 561 # AlgorithmName [Constraint] { '&' Constraint } 562 # 563 # AlgorithmName: 564 # (see below) 565 # 566 # Constraint: 567 # KeySizeConstraint | DenyAfterConstraint 568 # 569 # KeySizeConstraint: 570 # keySize Operator KeyLength 571 # 572 # DenyAfterConstraint: 573 # denyAfter YYYY-MM-DD 574 # 575 # Operator: 576 # <= | < | == | != | >= | > 577 # 578 # KeyLength: 579 # Integer value of the algorithm's key length in bits 580 # 581 # Note: This property is currently used by the JDK Reference 582 # implementation. It is not guaranteed to be examined and used by other 583 # implementations. 584 # 585 # See "jdk.certpath.disabledAlgorithms" for syntax descriptions. 586 # 587 jdk.jar.disabledAlgorithms=MD2, MD5, RSA keySize < 1024 588 589 # 590 # Algorithm restrictions for Secure Socket Layer/Transport Layer Security 591 # (SSL/TLS) processing 592 # 593 # In some environments, certain algorithms or key lengths may be undesirable 594 # when using SSL/TLS. This section describes the mechanism for disabling 595 # algorithms during SSL/TLS security parameters negotiation, including 596 # protocol version negotiation, cipher suites selection, peer authentication 597 # and key exchange mechanisms. 598 # 599 # Disabled algorithms will not be negotiated for SSL/TLS connections, even 600 # if they are enabled explicitly in an application. 601 # 602 # For PKI-based peer authentication and key exchange mechanisms, this list 603 # of disabled algorithms will also be checked during certification path 604 # building and validation, including algorithms used in certificates, as 605 # well as revocation information such as CRLs and signed OCSP Responses. 606 # This is in addition to the jdk.certpath.disabledAlgorithms property above. 607 # 608 # See the specification of "jdk.certpath.disabledAlgorithms" for the 609 # syntax of the disabled algorithm string. 610 # 611 # Note: The algorithm restrictions do not apply to trust anchors or 612 # self-signed certificates. 613 # 614 # Note: This property is currently used by the JDK Reference implementation. 615 # It is not guaranteed to be examined and used by other implementations. 616 # 617 # Example: 618 # jdk.tls.disabledAlgorithms=MD5, SSLv3, DSA, RSA keySize < 2048 619 jdk.tls.disabledAlgorithms=SSLv3, RC4, MD5withRSA, DH keySize < 768, \ 620 EC keySize < 224 621 622 # Legacy algorithms for Secure Socket Layer/Transport Layer Security (SSL/TLS) 623 # processing in JSSE implementation. 624 # 625 # In some environments, a certain algorithm may be undesirable but it 626 # cannot be disabled because of its use in legacy applications. Legacy 627 # algorithms may still be supported, but applications should not use them 628 # as the security strength of legacy algorithms are usually not strong enough 629 # in practice. 630 # 631 # During SSL/TLS security parameters negotiation, legacy algorithms will 632 # not be negotiated unless there are no other candidates. |