Comment éviter d'installer “Force irrésistible” JCE fichiers de stratégie de déploiement d'une application?

Il y a quelques couramment cité des solutions à ce problème. Malheureusement, aucune de ces sont entièrement satisfaisant:

• Installer le force illimitée de la politique de fichiers. Alors que c'est probablement la solution idéale pour votre station de travail de développement, il devient rapidement un problème majeur (si ce n'est un obstacle) pour avoir les utilisateurs non-techniques de l'installation des fichiers sur tous les ordinateurs. Il est aucun moyen distribuer les fichiers avec votre programme; ils doivent être installés dans le répertoire JRE (qui peut même être en lecture seule en raison des autorisations).
• Ignorer l'entreprise criminelle commune, l'API et utiliser une autre bibliothèque de cryptographie comme Château Gonflable. Cette approche nécessite un supplément de 1 MO de la bibliothèque, qui peut être une charge importante en fonction de l'application. Il se sent aussi stupide pour dupliquer les fonctionnalités incluses dans les bibliothèques standard. De toute évidence, l'API est également complètement différent de l'habituel l'entreprise criminelle commune de l'interface. (BC ne mettre en œuvre un JCE fournisseur, mais qui n'aide pas parce que la force de la clé de restrictions sont appliquées avant de la remise à la mise en œuvre.) Cette solution est également de ne pas permettre l'utilisation de 256 bits TLS (SSL) les suites de chiffrement, parce que la norme TLS bibliothèques appel de la JCE en interne pour déterminer toutes les restrictions.

Mais ensuite, il y a de la réflexion. Est-ce que vous ne pouvez pas le faire à l'aide de la réflexion?

private static void removeCryptographyRestrictions() {
if (!isRestrictedCryptography()) {
logger.fine("Cryptography restrictions removal not needed");
return;
}
try {
/*
* Do the following, but with reflection to bypass access checks:
*
* JceSecurity.isRestricted = false;
* JceSecurity.defaultPolicy.perms.clear();
* JceSecurity.defaultPolicy.add(CryptoAllPermission.INSTANCE);
*/
final Class<?> jceSecurity = Class.forName("javax.crypto.JceSecurity");
final Class<?> cryptoPermissions = Class.forName("javax.crypto.CryptoPermissions");
final Class<?> cryptoAllPermission = Class.forName("javax.crypto.CryptoAllPermission");
final Field isRestrictedField = jceSecurity.getDeclaredField("isRestricted");
isRestrictedField.setAccessible(true);
final Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(isRestrictedField, isRestrictedField.getModifiers() & ~Modifier.FINAL);
isRestrictedField.set(null, false);
final Field defaultPolicyField = jceSecurity.getDeclaredField("defaultPolicy");
defaultPolicyField.setAccessible(true);
final PermissionCollection defaultPolicy = (PermissionCollection) defaultPolicyField.get(null);
final Field perms = cryptoPermissions.getDeclaredField("perms");
perms.setAccessible(true);
((Map<?, ?>) perms.get(defaultPolicy)).clear();
final Field instance = cryptoAllPermission.getDeclaredField("INSTANCE");
instance.setAccessible(true);
defaultPolicy.add((Permission) instance.get(null));
logger.fine("Successfully removed cryptography restrictions");
} catch (final Exception e) {
logger.log(Level.WARNING, "Failed to remove cryptography restrictions", e);
}
}
private static boolean isRestrictedCryptography() {
//This matches Oracle Java 7 and 8, but not Java 9 or OpenJDK.
final String name = System.getProperty("java.runtime.name");
final String ver = System.getProperty("java.version");
return name != null && name.equals("Java(TM) SE Runtime Environment")
&& ver != null && (ver.startsWith("1.7") || ver.startsWith("1.8"));
}

Appelez simplement removeCryptographyRestrictions() à partir d'un initialiseur statique ou tel avant d'effectuer des opérations cryptographiques.

La JceSecurity.isRestricted = false partie est tout ce qui est nécessaire pour l'utilisation de 256 bits algorithmes directement; cependant, sans les deux autres opérations, Cipher.getMaxAllowedKeyLength() sera toujours maintenir les rapports de 128 et 256-bit de chiffrement TLS suites ne fonctionne pas.

Ce code fonctionne sur Oracle Java 7 et 8, et saute automatiquement le processus de Java 9 et OpenJDK où il n'est pas nécessaire. Étant un vilain hack après tout, cela ne fonctionne pas sur les autres fournisseurs de machines virtuelles.

Il ne fonctionne pas sur Oracle Java 6, parce que le privé JCE classes sont obscurcis là. La dissimulation ne change pas d'une version à l'autre, donc il est toujours techniquement possible à l'appui de Java 6.

Voici la solution: http://middlesphere-1.blogspot.ru/2014/06/this-code-allows-to-break-limit-if.html

//this code allows to break limit if client jdk/jre has no unlimited policy files for JCE.
//it should be run once. So this static section is always execute during the class loading process.
//this code is useful when working with Bouncycastle library.
static {
try {
Field field = Class.forName("javax.crypto.JceSecurity").getDeclaredField("isRestricted");
field.setAccessible(true);
field.set(null, java.lang.Boolean.FALSE);
} catch (Exception ex) {
}
}

De JDK 8u102, la posté des solutions en s'appuyant sur la réflexion ne fonctionne plus: le champ de ces solutions est maintenant final (https://bugs.openjdk.java.net/browse/JDK-8149417).

On dirait qu'il est de retour soit (un) à l'aide de Château Gonflable, ou (b) l'installation de l'entreprise criminelle commune, la politique de fichiers.

Vous pouvez utiliser la méthode

javax.crypto.Cipher.getMaxAllowedKeyLength(String transformation)

pour tester la disponible la longueur de la clé, l'utiliser et d'en informer l'utilisateur sur ce qui se passe. Quelque chose indiquant que votre demande est en recul pour les clés 128 bits en raison de la politique de fichiers n'étant pas installé, par exemple. Conscientes de la sécurité des utilisateurs va installer les fichiers de stratégie, d'autres vont continuer à utiliser les plus faibles clés.

Voici une version mise à jour de ntoskrnl réponse.
Il contient en outre une fonction pour supprimer le dernier modificateur comme Arjan mentionné dans les commentaires.

Cette version fonctionne avec le JRE 8u111 ou plus récent.

private static void removeCryptographyRestrictions() {
if (!isRestrictedCryptography()) {
return;
}
try {
/*
* Do the following, but with reflection to bypass access checks:
* 
* JceSecurity.isRestricted = false; JceSecurity.defaultPolicy.perms.clear();
* JceSecurity.defaultPolicy.add(CryptoAllPermission.INSTANCE);
*/
final Class<?> jceSecurity = Class.forName("javax.crypto.JceSecurity");
final Class<?> cryptoPermissions = Class.forName("javax.crypto.CryptoPermissions");
final Class<?> cryptoAllPermission = Class.forName("javax.crypto.CryptoAllPermission");
Field isRestrictedField = jceSecurity.getDeclaredField("isRestricted");
isRestrictedField.setAccessible(true);
setFinalStatic(isRestrictedField, true);
isRestrictedField.set(null, false);
final Field defaultPolicyField = jceSecurity.getDeclaredField("defaultPolicy");
defaultPolicyField.setAccessible(true);
final PermissionCollection defaultPolicy = (PermissionCollection) defaultPolicyField.get(null);
final Field perms = cryptoPermissions.getDeclaredField("perms");
perms.setAccessible(true);
((Map<?, ?>) perms.get(defaultPolicy)).clear();
final Field instance = cryptoAllPermission.getDeclaredField("INSTANCE");
instance.setAccessible(true);
defaultPolicy.add((Permission) instance.get(null));
}
catch (final Exception e) {
e.printStackTrace();
}
}
static void setFinalStatic(Field field, Object newValue) throws Exception {
field.setAccessible(true);
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
field.set(null, newValue);
}
private static boolean isRestrictedCryptography() {
//This simply matches the Oracle JRE, but not OpenJDK.
return "Java(TM) SE Runtime Environment".equals(System.getProperty("java.runtime.name"));
}

Lors de l'installation de votre programme, il suffit de demander à l'utilisateur et avoir un DOS script Batch ou un shell Bash script de téléchargement et la copie de la JCE dans le bon emplacement du système.

J'ai l'habitude de le faire pour un serveur webservice et au lieu d'une mise en installer, je viens de scripts fournis pour l'installation de l'application avant que l'utilisateur puisse l'exécuter. Vous pouvez faire de l'application de l'onu-praticable jusqu'à ce qu'ils exécutez le script d'installation. Vous pouvez également en faire l'application se plaignent que la JCE est manquant et ensuite demander de télécharger et redémarrez l'application?