java jce配置_java JCE 不限密钥长度解决办法

大家好，又见面了，我是你们的朋友全栈君。

()转自http://opensourceforgeeks.blogspot.com/2014/09/how-to-install-java-cryptography.html

另外，在StackOverflow上也有相关讨论，并提供了反射实现代码

https://stackoverflow.com/questions/25959948/local-policy-jar-and-us-export-policy-jar-different-with-unlimited-strength-vs-d

https://stackoverflow.com/questions/1179672/how-to-avoid-installing-unlimited-strength-jce-policy-files-when-deploying-an

前言

因为是需要，把英文原文复制了过来。

总结一下下面的内容：

1.java 8 161以上已经不再限制密钥长度

2.java 8 151以上，需要修改security文件，修改配置，重启jvm

3.java 8 151之前的，需要替换jar，重启jvm

4.不想替换jar，需要使用反射，来实现动态(作者不推荐)

How to install Java Cryptography Extension (JCE) unlimited strength jurisdiction policy files

Problem

JCE has been integrated into the Java 2 SDK since the 1.4 release.

Below diagram shows a general overview of Java cryptographic architecture. What we are discussing in this post is related to JCE implementation provided by Sun/Oracle.

As per the Oracle documentation –

Due to import control restrictions by the governments of a few countries, the jurisdiction policy files shipped with the JDK 5.0 from Sun Microsystems specify that “strong” but limited cryptography may be used.

That mean JDK has a deliberate key size restriction by default. So you cannot perform an encryption with key more than 128 bits (16 bytes). If you do you will get an error something like –

Caused by: java.security.InvalidKeyException: Illegal key size or default parameters

If you get this Exception there is nothing wrong that you are doing. It’s just the restriction on the encryption key that comes built into the JDK.

The reason for this is that some countries have restrictions on the permitted key strength used in encryption algorithms.

Again as per the documentation –

An “unlimited strength” version of these files indicating no restrictions on cryptographic strengths is available for those living in eligible countries (which is most countries). But only the “strong” version can be imported into those countries whose governments mandate restrictions. The JCE framework will enforce the restrictions specified in the installed jurisdiction policy files.

Update – Updates Since Java 8 and Java 9

There have been multiple updates since Java 8 and 9. Before you dive down into more details review this section based on the Java version you are using. I have shown how to resolve this issue with various Java versions in the video below.

Java 9 and higher :

The Unlimited Strength Jurisdiction Policy Files are included with Java 9 and used by default (see Security Updates in the Java 9 Migration Guide).

If you get this error with Java 9, it might mean the policy configuration has been changed to a more restrictive policy (limited), see the instructions from the migration guide:

It states –

JCE Jurisdiction Policy File Default is Unlimited

If your application previously required the Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files, then you no longer need to download or install them. They are included in the JDK and are activated by default.

If your country or usage requires a more restrictive policy, the limited Java cryptographic policy files are still available.

If you have requirements that are not met by either of the policy files provided by default, then you can customize these policy files to meet your needs.

See the crypto.policy Security property in the /conf/security/java.security file, or Cryptographic Strength Configurationin the Java Platform, Standard Edition Security Developer’s Guide.

Java 8 Update 161 and higher

Starting with Java 8 Update 161, Java 8 defaults to the Unlimited Strength Jurisdiction Policy. If you receive this error, it could indicate the configuration has been changed to limited. See instructions in the next section on Java 8 Update 151, or the previous section on Java 9, for changing this back to unlimited.

Java 8 Update 151 and higher

Starting with Java 8 Update 151, the Unlimited Strength Jurisdiction Policy is included with Java 8 but not used by default. To enable it, you need to edit the java.security file in /jre/lib/security (for JDK) or /lib/security (for JRE). Uncomment (or include) the line

crypto.policy=unlimited

Make sure you edit the file using an editor run as administrator.

The policy change only takes effect after restarting the JVM (this is especially important for long-running server processes like Tomcat).

For backward compatibility, installing the policy files as documented in the next section will still work as well.

Before Java 8 Update 151 – Removing the maximum key size restriction

You can remove the maximum key restriction by replacing the existing JCE jars with unlimited strength policy jars.

Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 6

Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 7 Download

Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 8 Download

Download the zip file extract the jars and replace them in your JDK/JRE.

For this Copy local_policy.jar and US_export_policy.jarextracted from above zip file to the $JAVA_HOME/jre/lib/security

Note: These jars will already be present there so you will have to overwrite them.

Then simply restart your java application and the Exception should be gone.

NOTE: If you are using Ubuntu and the webupd8 PPA, you can simply run –

apt-get install oracle-java8-unlimited-jce-policy

An alternate way to maximum encryption key size problem

This way is really a workaround. In fact, this approach is the workaround to all problems and it’s not straightforward. Yeah you must have guessed it by now – Reflection

You can override the restriction with Reflection as follows –

try {

Field field = Class.forName(“javax.crypto.JceSecurity”).getDeclaredField(“isRestricted”);

field.setAccessible(true);

field.set(null, java.lang.Boolean.FALSE);

}catch (Exception ex) {

ex.printStackTrace();

}

Note 1: I do not recommend the Reflection approach as it’s hacky. If you are using it keep it for testing only. Don’t put it in production code :)

Note 2:As the change of replacing policy files is in JDK itself you will have to do it in all your servers. Also, you will have to ask all your clients to do so.

Finding the maximum possible key length

To find maximum key length allowed by an encryption algorithm you can useCipher.getMaxAllowedKeyLength() method. For example, for AES algorithm you can do –

int maxKeyLength = Cipher.getMaxAllowedKeyLength(“AES”);