the - Seguridad de Java: ¿Tamaño de clave ilegal o parámetros predeterminados?
oracle java cryptography extension jce (16)
Había hecho una pregunta sobre esto antes, pero no me respondieron bien y no me llevaron a ninguna parte.
Así que he aclarado algunos detalles sobre el problema y realmente me gustaría escuchar sus ideas sobre cómo podría solucionar esto o qué debería intentar.
Tengo Java 1.6.0.12 instalado en mi servidor Linux y el código siguiente se ejecuta perfectamente.
String key = "av45k1pfb024xa3bl359vsb4esortvks74sksr5oy4s5serondry84jsrryuhsr5ys49y5seri5shrdliheuirdygliurguiy5ru";
try {
Cipher c = Cipher.getInstance("ARCFOUR");
SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "ARCFOUR");
c.init(Cipher.DECRYPT_MODE, secretKeySpec);
return new String(c.doFinal(Hex.decodeHex(data.toCharArray())), "UTF-8");
} catch (InvalidKeyException e) {
throw new CryptoException(e);
}
Hoy instalé Java 1.6.0.26 en mi usuario del servidor y cuando intento ejecutar mi aplicación, obtengo la siguiente excepción. Mi conjetura sería que tiene algo que ver con la configuración de instalación de Java porque funciona en la primera, pero no funciona en la versión posterior.
Caused by: java.security.InvalidKeyException: Illegal key size or default parameters
at javax.crypto.Cipher.a(DashoA13*..) ~[na:1.6]
at javax.crypto.Cipher.a(DashoA13*..) ~[na:1.6]
at javax.crypto.Cipher.a(DashoA13*..) ~[na:1.6]
at javax.crypto.Cipher.init(DashoA13*..) ~[na:1.6]
at javax.crypto.Cipher.init(DashoA13*..) ~[na:1.6]
at my.package.Something.decode(RC4Decoder.java:25) ~[my.package.jar:na]
... 5 common frames omitted
La línea 25 es: c.init(Cipher.DECRYPT_MODE, secretKeySpec);
Notas:
* java.security en el directorio java 1.6.0.12 del servidor coincide casi completamente con el archivo java.security 1.6.0.26. No hay proveedores adicionales en el primero.
* La pregunta anterior está here .
"Archivos 6 de la Política de Jurisdicción de Fuerza Ilimitada de Extensión de Criptografía de Java (JCE)"
http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html
A partir de Java 9 o 8u151, puede usar comentar una línea en el archivo:
<JAVA_HOME>/jre/lib/security/java.security
Y cambio:
#crypto.policy=unlimited
a
crypto.policy=unlimited
Con Java 9, Java 8u161 , Java 7u171 y Java 6u181, la limitación ahora está deshabilitada de forma predeterminada. Ver problema en Java Bug Database .
A partir de oracle.com/technetwork/java/javase/8u151-relnotes-3850493.html puede desactivar la limitación programáticamente.
En versiones anteriores, los archivos de la jurisdicción de la JCE se tenían que descargar e instalar por separado para permitir que el JDK utilizara criptografía ilimitada. Los pasos de descarga e instalación ya no son necesarios.
En su lugar, ahora puede invocar la siguiente línea antes del primer uso de las clases JCE (es decir, preferiblemente justo después del inicio de la aplicación):
Security.setProperty("crypto.policy", "unlimited");
De forma predeterminada, Java solo admite tamaños de clave AES de 128 bits (16 bytes) para el cifrado. Si no necesita más que el soporte por defecto, puede recortar la clave al tamaño adecuado antes de usar Cipher . Ver javadoc para las claves soportadas por defecto.
Este es un ejemplo de generación de una clave que funcionaría con cualquier versión de JVM sin modificar los archivos de políticas. Utilice a su propia discreción.
Aquí hay un buen artículo sobre si las claves de 128 a 256 tamaños de clave son importantes en el blog de AgileBits
SecretKeySpec getKey() {
final pass = "47e7717f0f37ee72cb226278279aebef".getBytes("UTF-8");
final sha = MessageDigest.getInstance("SHA-256");
def key = sha.digest(pass);
// use only first 128 bit (16 bytes). By default Java only supports AES 128 bit key sizes for encryption.
// Updated jvm policies are required for 256 bit.
key = Arrays.copyOf(key, 16);
return new SecretKeySpec(key, AES);
}
El JDK predeterminado admite el cifrado solo a través de claves de 128 bits debido a las restricciones estadounidenses. Por lo tanto, para admitir el cifrado de una clave de 256 bits, debemos reemplazar local_policy.jar y US_export_policy.jars en la US_export_policy.jars $JAVA_HOME/java-8-oracle/jre/lib/security contrario dará:
java.security.InvalidKeyException: tamaño de clave no válido o predeterminado
Tanto los frascos como el concepto detallado se pueden entender desde el enlace:
En Java, de forma predeterminada, AES admite una clave de 128 bits. Si planea usar una clave de 192 bits o 256 bits, el compilador de Java lanzará una excepción de tamaño de clave ilegal, que está recibiendo.
La solución es como lo sugirieron Victor y James, deberá descargar JCE (Java Cryptography Extension) según su versión de JRE, (java6, java7 o java8).
El zip de JCE contiene el siguiente JAR:
- polica_jar local.jar
- US_export_policy.jar
Debe reemplazar estos archivos de forma jarra en su <JAVA_HOME>/jre/lib/security . si está en un sistema Unix, probablemente se refiera a /home/urs/usr/lib/jvm/java-<version>-oracle/
A veces, simplemente reemplazando local_policy.jar, US_export_policy.jar en la carpeta de seguridad no funciona en Unix, por lo que sugiero copiar primero la carpeta de seguridad a su escritorio, reemplazar la carpeta @ Desktop / security del jar, eliminar la carpeta de seguridad de / jre / lib / y mueva la carpeta de seguridad del escritorio a / jre / lib /.
por ejemplo: sudo mv security /usr/lib/jvm/java-7-oracle/jre/lib
Esta es una solución de código único . No es necesario descargar o desordenar los archivos de configuración.
Es una solución basada en la reflexión, probada en java 8.
Llame a este método una vez, al principio de su programa.
// Importaciones
import javax.crypto.Cipher;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Map;
//método
public static void fixKeyLength() {
String errorString = "Failed manually overriding key-length permissions.";
int newMaxKeyLength;
try {
if ((newMaxKeyLength = Cipher.getMaxAllowedKeyLength("AES")) < 256) {
Class c = Class.forName("javax.crypto.CryptoAllPermissionCollection");
Constructor con = c.getDeclaredConstructor();
con.setAccessible(true);
Object allPermissionCollection = con.newInstance();
Field f = c.getDeclaredField("all_allowed");
f.setAccessible(true);
f.setBoolean(allPermissionCollection, true);
c = Class.forName("javax.crypto.CryptoPermissions");
con = c.getDeclaredConstructor();
con.setAccessible(true);
Object allPermissions = con.newInstance();
f = c.getDeclaredField("perms");
f.setAccessible(true);
((Map) f.get(allPermissions)).put("*", allPermissionCollection);
c = Class.forName("javax.crypto.JceSecurityManager");
f = c.getDeclaredField("defaultPolicy");
f.setAccessible(true);
Field mf = Field.class.getDeclaredField("modifiers");
mf.setAccessible(true);
mf.setInt(f, f.getModifiers() & ~Modifier.FINAL);
f.set(null, allPermissions);
newMaxKeyLength = Cipher.getMaxAllowedKeyLength("AES");
}
} catch (Exception e) {
throw new RuntimeException(errorString, e);
}
if (newMaxKeyLength < 256)
throw new RuntimeException(errorString); // hack failed
}
Créditos: Delthas
Experimenté el mismo error al usar Windows 7 x64, Eclipse y JDK 1.6.0_30. En la carpeta de instalación de JDK hay una carpeta jre . Esto me desestimó al principio, ya que estaba agregando los archivos antes mencionados a la carpeta lib / security del JDK sin suerte. Ruta completa:
C:/Program Files/Java/jdk1.6.0_30/jre/lib/security
Descargue y extraiga los archivos contenidos en la carpeta jce de este archivo en esa carpeta.
Hay dos opciones para resolver este problema.
opción número 1: usar certificado con menos longitud RSA 2048
opción número 2: actualizará dos archivos jre/lib/security en jre/lib/security cualquiera que use java http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html
o utiliza IBM websphere o cualquier servidor de aplicaciones que use su java. el principal problema al que me enfrenté, utilicé la certificación con la máxima longitud, cuando implementé orejas en websphere se lanzó la misma excepción
Java Security: Illegal key size or default parameters?
Actualicé la carpeta java intsalled en websphere con dos archivos https://www14.software.ibm.com/webapp/iwm/web/reg/pick.do?source=jcesdk&lang=en_US
puede consultar la referencia en el enlace https://www-01.ibm.com/support/docview.wss?uid=swg21663373
Hay una breve discusión de lo que parece ser este problema here . La página a la que se enlaza parece haber desaparecido, pero una de las respuestas podría ser lo que necesita:
De hecho, copiar US_export_policy.jar y local_policy.jar de core / lib / jce a $ JAVA_HOME / jre / lib / security ayudó. Gracias.
Lo más probable es que no tenga el archivo de fuerza ilimitada instalado ahora.
Es posible que necesite descargar este archivo:
Archivos de la Política de Jurisdicción de Fuerza Ilimitada de la Extensión de Criptografía de Java (JCE) 8 Descarga (solo se requiere para versiones anteriores a Java 8 u162)
Extraiga los archivos jar del archivo zip y guárdelos en ${java.home}/jre/lib/security/ .
Los archivos de jurisdicción JRE / JDK / Java 8 se pueden encontrar aquí:
Como James dijo anteriormente:
Instale los archivos en ${java.home}/jre/lib/security/ .
Para JAVA 7 el enlace de descarga es jce-7-download
Copie los dos archivos descargados en Java / jdk1.7.0_10 / jre / lib / security
Tome una copia de seguridad de los tarros más viejos para estar en el lado seguro.
Para JAVA 8 el enlace de descarga es jce-8-download
Copie los archivos jar descargados en Java / jdk1.8.0_45 / jre / lib / security
Tome una copia de seguridad de los tarros más viejos para estar en el lado seguro.
Si está utilizando la distribución de Linux con apt y ha agregado el PPA de webupd8, simplemente puede ejecutar el comando
apt-get install oracle-java8-unlimited-jce-policy
Otras actualizaciones:
- Los archivos de política de jurisdicción de fuerza ilimitada se incluyen con Java 9 y se usan de forma predeterminada
- A partir de la actualización 161 de Java 8, Java 8 adopta de manera predeterminada la Política de jurisdicción de fuerza ilimitada.
A partir de la Actualización 151 de Java 8 , la Política de Jurisdicción de Fuerza Ilimitada se incluye con Java 8 pero no se utiliza de forma predeterminada. Para habilitarlo, debe editar el archivo java.security en
<java_home>/jre/lib/security(para JDK) o<java_home>/lib/security(para JRE). Descomentar (o incluir) la líneacrypto.policy=unlimitedAsegúrese de editar el archivo utilizando un editor ejecutado como administrador. El cambio de política solo surte efecto después de reiniciar la JVM
Antes de Java 8 Update 151, el resto de las respuestas son válidas. Descargue los archivos de política de jurisdicción de fuerza ilimitada de JCE y sustitúyalos.
También obtuve el problema, pero después de reemplazar uno existente con el descargado (de JCE), se resolvió el problema. Los nuevos archivos criptográficos proporcionaron fuerza ilimitada.
el problema es el contenido del archivo default_local.policy en local_policy.jar en la carpeta jre / lib / security , si instala el JRE:
// Some countries have import limits on crypto strength. This policy file
// is worldwide importable.
grant {
permission javax.crypto.CryptoPermission "DES", 64;
permission javax.crypto.CryptoPermission "DESede", *;
permission javax.crypto.CryptoPermission "RC2", 128,
"javax.crypto.spec.RC2ParameterSpec", 128;
permission javax.crypto.CryptoPermission "RC4", 128;
permission javax.crypto.CryptoPermission "RC5", 128,
"javax.crypto.spec.RC5ParameterSpec", *, 12, *;
permission javax.crypto.CryptoPermission "RSA", *;
permission javax.crypto.CryptoPermission *, 128;
};
Si no necesita una configuración válida en todo el mundo, simplemente puede editar este archivo y cambiar el contenido a
// Country-specific policy file for countries with no limits on crypto strength.
grant {
// There is no restriction to any algorithms.
permission javax.crypto.CryptoAllPermission;
};
esto es lo que obtienes si descargas la JCE desde Oracle.