Como evitar a instalação de arquivos de política JCE de "Força Ilimitada" ao implantar um aplicativo?

Eu tenho um aplicativo que usa criptografia AES de 256 bits, que não é suportada pelo Java imediatamente. Sei que para que isso funcione corretamente, instalo os frascos de força ilimitados do JCE na pasta de segurança. Isso é bom para mim, como desenvolvedor, posso instalá-los.

Minha pergunta é que, como esse aplicativo será distribuído, os usuários finais provavelmente não terão esses arquivos de política instalados. Fazer o download do usuário final apenas para que o aplicativo funcione não é uma solução atraente.

Existe uma maneira de executar meu aplicativo sem substituir arquivos na máquina do usuário final? Um software de terceiros que pode lidar com isso sem os arquivos de política instalados? Ou uma maneira de apenas referenciar esses arquivos de políticas de dentro de um JAR?

Existem algumas soluções comumente citadas para esse problema. Infelizmente, nenhum deles é totalmente satisfatório:

• Instale os arquivos de política de força ilimitados . Embora essa seja provavelmente a solução certa para sua estação de trabalho de desenvolvimento, ela rapidamente se torna um grande aborrecimento (se não um obstáculo) para que usuários não técnicos instalem os arquivos em todos os computadores. Não há como distribuir os arquivos com o seu programa; eles devem ser instalados no diretório JRE (que pode até ser somente leitura devido a permissões).
• Ignore a API do JCE e use outra biblioteca de criptografia como o Bouncy Castle . Essa abordagem requer uma biblioteca extra de 1 MB, que pode ser uma carga significativa, dependendo do aplicativo. Também é bobagem duplicar a funcionalidade incluída nas bibliotecas padrão. Obviamente, a API também é completamente diferente da interface JCE usual. (O BC implementa um provedor JCE, mas isso não ajuda, porque as restrições de força de chave são aplicadas antes da entrega à implementação.) Essa solução também não permitirá que você use conjuntos de cifras TLS (SSL) de 256 bits, porque o bibliotecas TLS padrão chamam o JCE internamente para determinar quaisquer restrições.

Mas depois há reflexão. Existe algo que você não possa fazer usando reflexão?

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"));
}

Simplesmente chame removeCryptographyRestrictions()de um inicializador estático ou algo semelhante antes de executar qualquer operação criptográfica.

A JceSecurity.isRestricted = falseparte é tudo o que é necessário para usar cifras de 256 bits diretamente; no entanto, sem as duas outras operações, Cipher.getMaxAllowedKeyLength()o relatório continuará sendo reportado por 128, e os conjuntos de criptografia TLS de 256 bits não funcionarão.

Esse código funciona no Oracle Java 7 e 8 e ignora automaticamente o processo no Java 9 e no OpenJDK onde não é necessário. Sendo um truque feio, afinal, provavelmente não funciona nas VMs de outros fornecedores.

Também não funciona no Oracle Java 6, porque as classes JCE privadas são ofuscadas por lá. A ofuscação não muda de versão para versão, portanto, ainda é tecnicamente possível oferecer suporte ao Java 6.

Agora, isso não é mais necessário para o Java 9 , nem para qualquer versão recente do Java 6, 7 ou 8. Finalmente! :)

De acordo com JDK-8170157 , a política criptográfica ilimitada agora está ativada por padrão.

Versões específicas do problema do JIRA:

• Java 9 (10, 11, etc.): Qualquer versão oficial!
• Java 8u161 ou posterior (disponível agora )
• Java 7u171 ou posterior (disponível apenas no 'Suporte do My Oracle')
• Java 6u181 ou posterior (disponível apenas no 'Suporte do My Oracle')

Observe que, por algum motivo estranho, o comportamento antigo é necessário no Java 9, ele pode ser configurado usando:

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

Aqui está a solução: 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) {
    }
}

O Bouncy Castle ainda requer jarros instalados até onde eu sei.

Fiz um pequeno teste e pareceu confirmar isso:

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

A partir do JDK 8u102, as soluções postadas baseadas na reflexão não funcionarão mais: o campo que essas soluções configuradas estão agora final( https://bugs.openjdk.java.net/browse/JDK-8149417 ).

Parece que voltou a (a) usar o Bouncy Castle ou (b) instalar os arquivos de políticas do JCE.

Para uma biblioteca de criptografia alternativa, dê uma olhada no Bouncy Castle . Possui AES e muitas funcionalidades adicionais. É uma biblioteca liberal de código aberto. Você precisará usar a API leve e proprietária do Bouncy Castle para que isso funcione.

Você poderia usar o método

javax.crypto.Cipher.getMaxAllowedKeyLength(String transformation)

para testar o comprimento da chave disponível, use isso e informe o usuário sobre o que está acontecendo. Algo que indica que seu aplicativo está retornando às chaves de 128 bits devido aos arquivos de política não estarem instalados, por exemplo. Usuários preocupados com segurança instalarão os arquivos de políticas, outros continuarão usando chaves mais fracas.

Para nosso aplicativo, tínhamos uma arquitetura de servidor cliente e permitíamos apenas descriptografar / criptografar dados no nível do servidor. Portanto, os arquivos JCE são necessários apenas lá.

Tivemos outro problema em que precisávamos atualizar um jar de segurança nas máquinas clientes, por meio do JNLP, ele substitui as bibliotecas ${java.home}/lib/security/e a JVM na primeira execução.

Isso fez funcionar.

Aqui está uma versão atualizada da resposta ntoskrnl . Além disso, contém uma função para remover o modificador final como o Arjan mencionado nos comentários.

Esta versão funciona com o JRE 8u111 ou mais recente.

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"));
}

Aqui está uma versão modificada do código do @ ntoskrnl, apresentando isRestrictedCryptographycheck por log slf4j realCipher.getMaxAllowedKeyLength e suporte à inicialização de singleton a partir do bootstrap do aplicativo como este:

static {
    UnlimitedKeyStrengthJurisdictionPolicy.ensure();
}

Esse código para de corrigir corretamente quando a política ilimitada se torna disponível por padrão no Java 8u162, como a resposta do @ cranphin prevê.

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

Durante a instalação do seu programa, basta solicitar ao usuário e fazer o download de um script de lote do DOS ou de shell do Bash e copiar o JCE no local apropriado do sistema.

Eu costumava fazer isso para um serviço da web do servidor e, em vez de um instalador formal, fornecia apenas scripts para configurar o aplicativo antes que o usuário pudesse executá-lo. Você pode tornar o aplicativo impossível de executar até que eles executem o script de instalação. Você também pode fazer com que o aplicativo reclame que o JCE está ausente e peça para baixar e reiniciar o aplicativo?