Comment éviter d'installer des fichiers de stratégie JCE «Unlimited Strength» lors du déploiement d'une application?

J'ai une application qui utilise le cryptage AES 256 bits qui n'est pas pris en charge par Java prêt à l'emploi. Je sais que pour que cela fonctionne correctement, j'installe les pots JCE de force illimitée dans le dossier de sécurité. Cela me convient en tant que développeur, je peux les installer.

Ma question est que, puisque cette application sera distribuée, les utilisateurs finaux n'auront probablement pas ces fichiers de stratégie installés. Demander à l'utilisateur final de les télécharger uniquement pour faire fonctionner l'application n'est pas une solution attrayante.

Existe-t-il un moyen de faire fonctionner mon application sans écraser les fichiers sur la machine de l'utilisateur final? Un logiciel tiers capable de le gérer sans que les fichiers de stratégie ne soient installés? Ou un moyen de simplement référencer ces fichiers de stratégie à partir d'un JAR?

Il existe quelques solutions couramment citées à ce problème. Malheureusement, aucun de ces éléments n'est entièrement satisfaisant:

• Installez les fichiers de stratégie de force illimitée . Bien que ce soit probablement la bonne solution pour votre poste de travail de développement, il devient rapidement un problème majeur (sinon un obstacle) que des utilisateurs non techniques installent les fichiers sur chaque ordinateur. Il n'y a aucun moyen de 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).
• Ignorez l'API JCE et utilisez une autre bibliothèque de cryptographie telle que Bouncy Castle . Cette approche nécessite une bibliothèque supplémentaire de 1 Mo, ce qui peut représenter une charge importante en fonction de l'application. Il semble également ridicule de dupliquer les fonctionnalités incluses dans les bibliothèques standard. De toute évidence, l'API est également complètement différente de l'interface JCE habituelle. (BC implémente un fournisseur JCE, mais cela n'aide pas car les restrictions de force de clé sont appliquées avant de passer à l'implémentation.) Cette solution ne vous permettra pas non plus d'utiliser des suites de chiffrement TLS (SSL) 256 bits, car le Les bibliothèques TLS standard appellent le JCE en interne pour déterminer les restrictions.

Mais ensuite, il y a la réflexion. Y a-t-il quelque chose que vous ne pouvez pas faire en utilisant 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 autre avant d'effectuer des opérations cryptographiques.

La JceSecurity.isRestricted = falsepartie est tout ce qui est nécessaire pour utiliser directement les chiffrements 256 bits; cependant, sans les deux autres opérations, Cipher.getMaxAllowedKeyLength()continuera à rapporter 128, et les suites de chiffrement TLS 256 bits ne fonctionneront pas.

Ce code fonctionne sur Oracle Java 7 et 8 et ignore automatiquement le processus sur Java 9 et OpenJDK là où il n'est pas nécessaire. Étant un hack laid après tout, cela ne fonctionne probablement pas sur les VM d'autres fournisseurs.

Cela ne fonctionne pas non plus sur Oracle Java 6, car les classes JCE privées y sont masquées. L'obscurcissement ne change pas d'une version à l'autre, il est donc toujours techniquement possible de prendre en charge Java 6.

Ce n'est plus nécessaire pour Java 9 , ni pour aucune version récente de Java 6, 7 ou 8. Enfin! :)

Par JDK-8170157 , la politique cryptographique illimitée est désormais activée par défaut.

Versions spécifiques du problème JIRA:

• Java 9 (10, 11, etc.): Toute version officielle!
• Java 8u161 ou version ultérieure (disponible maintenant )
• Java 7u171 ou version ultérieure (uniquement disponible via 'My Oracle Support')
• Java 6u181 ou version ultérieure (uniquement disponible via 'My Oracle Support')

Notez que si, pour une raison étrange, l'ancien comportement est nécessaire dans Java 9, il peut être défini en utilisant:

Security.setProperty("crypto.policy", "limited");

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) {
    }
}

Bouncy Castle nécessite toujours des bocaux installés pour autant que je sache.

J'ai fait un petit test et cela a semblé le confirmer:

http://www.bouncycastle.org/wiki/display/JA1/Frequency+Asked+Questions

À partir du JDK 8u102, les solutions publiées reposant sur la réflexion ne fonctionneront plus: le champ que ces solutions définissent est maintenant final( https://bugs.openjdk.java.net/browse/JDK-8149417 ).

On dirait que c'est de retour soit (a) à l'aide de Bouncy Castle, soit (b) à l'installation des fichiers de stratégie JCE.

Pour une bibliothèque de cryptographie alternative, jetez un œil à Bouncy Castle . Il a AES et de nombreuses fonctionnalités supplémentaires. C'est une bibliothèque open source libérale. Vous devrez cependant utiliser l'API Bouncy Castle légère et propriétaire pour que cela fonctionne.

Vous pouvez utiliser la méthode

javax.crypto.Cipher.getMaxAllowedKeyLength(String transformation)

pour tester la longueur de clé disponible, utilisez-la et informez l'utilisateur de ce qui se passe. Quelque chose indiquant que votre application retombe aux clés de 128 bits en raison, par exemple, des fichiers de stratégie non installés. Les utilisateurs soucieux de la sécurité installeront les fichiers de stratégie, d'autres continueront à utiliser des clés plus faibles.

Pour notre application, nous avions une architecture client-serveur et nous n'autorisions le déchiffrement / chiffrement des données qu'au niveau du serveur. Par conséquent, les fichiers JCE ne sont nécessaires que là-bas.

Nous avons eu un autre problème où nous devions mettre à jour un fichier jar de sécurité sur les machines clientes, via JNLP, il écrase les bibliothèques ${java.home}/lib/security/et la JVM lors de la première exécution.

Cela l'a fait fonctionner.

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

Cette version fonctionne avec 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"));
}

Voici une version modifiée du code de @ ntoskrnl avec isRestrictedCryptographyvérification par journalisation slf4j réelleCipher.getMaxAllowedKeyLength et prise en charge de l'initialisation singleton à partir du démarrage de l'application comme ceci:

static {
    UnlimitedKeyStrengthJurisdictionPolicy.ensure();
}

Ce code arrêterait correctement de se gâter avec la réflexion lorsque la politique illimitée deviendrait disponible par défaut dans Java 8u162 comme le prédit la réponse de @ cranphin.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.security.NoSuchAlgorithmException;
import java.security.Permission;
import java.security.PermissionCollection;
import java.util.Map;

// /programming/1179672/how-to-avoid-installing-unlimited-strength-jce-policy-files-when-deploying-an
public class UnlimitedKeyStrengthJurisdictionPolicy {

    private static final Logger log = LoggerFactory.getLogger(UnlimitedKeyStrengthJurisdictionPolicy.class);

    private static boolean isRestrictedCryptography() throws NoSuchAlgorithmException {
        return Cipher.getMaxAllowedKeyLength("AES/ECB/NoPadding") <= 128;
    }

    private static void removeCryptographyRestrictions() {
        try {
            if (!isRestrictedCryptography()) {
                log.debug("Cryptography restrictions removal not needed");
                return;
            }
            /*
             * Do the following, but with reflection to bypass access checks:
             *
             * JceSecurity.isRestricted = false;
             * JceSecurity.defaultPolicy.perms.clear();
             * JceSecurity.defaultPolicy.add(CryptoAllPermission.INSTANCE);
             */
            Class<?> jceSecurity = Class.forName("javax.crypto.JceSecurity");
            Class<?> cryptoPermissions = Class.forName("javax.crypto.CryptoPermissions");
            Class<?> cryptoAllPermission = Class.forName("javax.crypto.CryptoAllPermission");

            Field isRestrictedField = jceSecurity.getDeclaredField("isRestricted");
            isRestrictedField.setAccessible(true);
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            modifiersField.setInt(isRestrictedField, isRestrictedField.getModifiers() & ~Modifier.FINAL);
            isRestrictedField.set(null, false);

            Field defaultPolicyField = jceSecurity.getDeclaredField("defaultPolicy");
            defaultPolicyField.setAccessible(true);
            PermissionCollection defaultPolicy = (PermissionCollection) defaultPolicyField.get(null);

            Field perms = cryptoPermissions.getDeclaredField("perms");
            perms.setAccessible(true);
            ((Map<?, ?>) perms.get(defaultPolicy)).clear();

            Field instance = cryptoAllPermission.getDeclaredField("INSTANCE");
            instance.setAccessible(true);
            defaultPolicy.add((Permission) instance.get(null));

            log.info("Successfully removed cryptography restrictions");
        } catch (Exception e) {
            log.warn("Failed to remove cryptography restrictions", e);
        }
    }

    static {
        removeCryptographyRestrictions();
    }

    public static void ensure() {
        // just force loading of this class
    }
}

Lors de l'installation de votre programme, demandez simplement à l'utilisateur de télécharger un script DOS Batch ou un script shell Bash et copiez le JCE dans l'emplacement système approprié.

J'avais l'habitude de le faire pour un service Web de serveur et au lieu d'un programme d'installation formel, je viens de fournir des scripts pour configurer l'application avant que l'utilisateur ne puisse l'exécuter. Vous pouvez rendre l'application non exécutable jusqu'à ce qu'elle exécute le script de configuration. Vous pouvez également faire en sorte que l'application se plaigne de l'absence de JCE, puis demander à télécharger et à redémarrer l'application?