Cómo cifrar cadenas en Java

Recomendaría usar algún cifrado simétrico estándar que esté ampliamente disponible como DES, 3DES o AES. Si bien ese no es el algoritmo más seguro, hay un montón de implementaciones y solo tendría que dar la clave a cualquiera que se supone que debe descifrar la información en el código de barras. [12] javax.criptografía.Cipher es con lo que quieres trabajar aquí.

Supongamos que los bytes a cifrar están en

byte[] input;

A continuación, necesita la clave y vector de inicialización bytes

byte[] keyBytes;
byte[] ivBytes;

Ahora puede inicializar el Cifrado para el algoritmo que seleccione:

// wrap key data in Key/IV specs to pass to cipher
SecretKeySpec key = new SecretKeySpec(keyBytes, "DES");
IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
// create the cipher with the algorithm you choose
// see javadoc for Cipher class for more info, e.g.
Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");

El cifrado sería así:

cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
byte[] encrypted= new byte[cipher.getOutputSize(input.length)];
int enc_len = cipher.update(input, 0, input.length, encrypted, 0);
enc_len += cipher.doFinal(encrypted, enc_len);

Y descifrar así:

cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
byte[] decrypted = new byte[cipher.getOutputSize(enc_len)];
int dec_len = cipher.update(encrypted, 0, enc_len, decrypted, 0);
dec_len += cipher.doFinal(decrypted, dec_len);

Esta es la primera página que aparece a través de Google y la seguridad vulnerabilidades en todas las implementaciones me hacen temblar así que estoy publicar esto para agregar información sobre el cifrado para otros, ya que ha sido 7 Años desde el post original. Tengo una Maestría en Ingeniería informática y pasó mucho tiempo estudiando y aprendiendo Criptografía así que estoy lanzando mis dos centavos para hacer de Internet un lugar más seguro.

También, tenga en cuenta que un gran parte de la implementación podría ser segura para un determinado situación, pero ¿por qué utilizar los y potencialmente accidentalmente hacer un error? Utilice las herramientas más fuertes que tenga disponibles a menos que tenga una razón específica para no hacerlo. En general, recomiendo encarecidamente el uso de una biblioteca y mantente alejado de los detalles esenciales si puedes.

ACTUALIZACIÓN 4/5/18: Reescribí algunas partes para hacerlas más fáciles de entender y cambié la biblioteca recomendada de Jasypt a La nueva de Google library Tink , recomendaría eliminar completamente Jasypt de una configuración existente.

Prólogo

Describiré los conceptos básicos de la criptografía simétrica segura a continuación y señalaré los errores comunes que veo en línea cuando las personas implementan criptografía por su cuenta con la biblioteca Java estándar. Si desea omitir todos los detalles, ejecute La nueva biblioteca de Google Tink importe eso en su proyecto y use el modo AES-GCM para todos sus encriptaciones y usted estará seguro.

Ahora, si quieres aprender los detalles esenciales sobre cómo cifrar en java, sigue leyendo:)

Cifrados en bloque

Lo primero primero que necesita para elegir un cifrado de bloque clave simétrica. Un Cifrado por bloques es una función / programa informático utilizado para crear Pseudo-Aleatoriedad. Pseudo-aleatoriedad es falsa aleatoriedad que ninguna otra computadora que no sea una Computadora Cuántica sería capaz de decir la diferencia entre ella y la aleatoriedad real. bloque El cifrado es como el bloque de construcción de la criptografía, y cuando se usa con diferentes modos o esquemas podemos crear cifrados.

Ahora con respecto a los Algoritmos de Cifrado por bloques disponibles en la actualidad, Asegúrese de NUNCA, repito NUNCA use DES, incluso diría QUE NUNCA use 3DES. El único Cifrado en Bloque que incluso la publicación de la NSA de Snowden fue capaz de verificar que era realmente lo más cercano posible a Pseudo-Aleatorio es AES 256. También existe AES 128, el la diferencia es que AES 256 funciona en bloques de 256 bits, mientras que AES 128 funciona en bloques de 128. En general, AES 128 se considera seguro, aunque se han descubierto algunas debilidades, pero 256 es tan sólido como se pone.

Dato curioso DES fue roto por la NSA cuando se fundó inicialmente y en realidad mantuvo un secreto durante unos años y aunque algunas personas todavía afirman 3DES es seguro, hay bastantes artículos de investigación que han encontrado y analizado debilidades en 3DES.

Modos de cifrado

El cifrado se crea cuando se toma un cifrado por bloques y se utiliza un esquema específico para que la aleatoriedad se combine con una clave para crear algo que sea reversible siempre y cuando se conozca la clave. Esto se conoce como un Modo de cifrado.

Aquí hay un ejemplo de un modo de cifrado y el modo más simple conocido como ECB solo para que pueda entender visualmente lo que está sucediendo:

El los modos de cifrado que verá más comúnmente en línea son los siguientes:

ECB CTR, CBC, GCM

Existen otros modos fuera de los enumerados y los investigadores siempre están trabajando hacia nuevos modos para mejorar los problemas existentes.

Ahora pasemos a las implementaciones y lo que es seguro. NUNCA use ECB esto es malo para ocultar datos repetidos como lo muestra el famoso Linux penguin.

Al implementar en Java, tenga en cuenta que si utiliza el siguiente código, el modo ECB está configurado de forma predeterminada:

Cipher cipher = Cipher.getInstance("AES");

... PELIGRO ESTO ES UNA VULNERABILIDAD! y desafortunadamente, esto se ve en todo StackOverflow y en línea en tutoriales y ejemplos.

Nonces y IVs

En respuesta al problema encontrado con los sustantivos de modo ECB también conocidos como IVs fueron creados. La idea es que generemos una nueva variable aleatoria y la adjuntemos a cada cifrado para que al cifrar dos mensajes que sean iguales salen diferentes. La belleza detrás de esto es que un IV o nonce es de conocimiento público. Eso significa que un atacante puede tener acceso a esto, pero mientras no tengan su clave, no pueden hacer nada con ese conocimiento.

Los problemas comunes que veré es que la gente establecerá el IV como un valor estático como en el mismo valor fijo en su código. y aquí está la trampa para IVs en el momento en que repite uno que realmente comprometer toda la seguridad de su cifrado.

Generando Un IV Aleatorio

SecureRandom randomSecureRandom = SecureRandom.getInstance("SHA1PRNG");
byte[] iv = new byte[cipher.getBlockSize()];
randomSecureRandom.nextBytes(iv);
IvParameterSpec ivParams = new IvParameterSpec(iv);

Nota: SHA1 está roto, pero no pude encontrar cómo implementar SHA256 en este caso de uso correctamente, por lo que si alguien quiere tomar una grieta en este y actualizar sería impresionante! También los ataques SHA1 todavía no son convencionales, ya que puede tomar algunos años en un gran grupo para romperse. Echa un vistazo a los detalles aquí.

CTR Implementation

No se requiere relleno para CTR modo.

 Cipher cipher = Cipher.getInstance("AES/NoPadding");

CBC Implementation

Si elige implementar el modo CBC, hágalo con PKCS7Padding de la siguiente manera:

 Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");

Vulnerabilidad CBC y CTR y Por qué Debe Usar GCM

Aunque algunos otros modos como CBC y CTR son seguros, se encuentran con el problema de que un atacante puede voltear los datos cifrados, cambiando su valor cuando se descifra. Así que digamos que encriptas un mensaje de banco imaginario "Vender 100", tu mensaje encriptado se ve así "eu23ng "el atacante cambia un bit a" eu53ng "y, de repente, cuando se descifra su mensaje, se lee como"Vender 900".

Para evitar esto, la mayoría de Internet utiliza GCM, y cada vez que vea HTTPS probablemente estén usando GCM. GCM firma el mensaje cifrado con un hash y comprueba que el mensaje no se ha cambiado con esta firma.

Evitaría la implementación de GCM debido a su complejidad. Es mejor usar Googles nueva biblioteca Tink porque aquí de nuevo, si accidentalmente repite una vía intravenosa, está comprometiendo la clave en el caso de GCM, que es el fallo de seguridad definitivo. Los nuevos investigadores están trabajando para IV repetir modos de cifrado resistentes donde incluso si se repite el IV la clave no está en peligro, pero esto aún no ha llegado a la corriente principal.

Ahora, si desea implementar GCM, aquí hay un enlace a una buena implementación de GCM. Sin embargo, no puedo garantizar la seguridad o si su su correctamente implementado pero baja la base. También tenga en cuenta que con GCM no hay relleno.

Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");

Claves vs Contraseñas

Otra nota muy importante, es que cuando se trata de criptografía una Clave y una Contraseña no son las mismas cosas. Una clave en criptografía necesita tener una cierta cantidad de entropía y aleatoriedad para ser considerada segura. Esta es la razón por la que necesita asegurarse de utilizar las bibliotecas criptográficas adecuadas para generar la clave para usted.

Así que realmente tienes dos implementaciones que puede hacer aquí, la primera es usar el código que se encuentra en este hilo StackOverflow para la Generación Aleatoria de Claves. Esta solución utiliza un generador de números aleatorios seguro para crear una clave desde cero que puede usar.

La otra opción menos segura es usar la entrada del usuario, como una contraseña. El problema que discutimos es que la contraseña no tiene suficiente entropía, por lo que tendríamos que usar PBKDF2, un algoritmo que toma la contraseña y fortalece se. Aquí hay una implementación de StackOverflow que me gustó. Sin embargo, la biblioteca de Google Tink tiene todo esto incorporado y debe aprovecharlo.

Desarrolladores de Android

Un punto importante a señalar aquí es saber que su código de Android es reverse engineerable y la mayoría de los casos la mayoría del código java también lo es. Eso significa que si almacena la contraseña en texto plano en su código. Un hacker puede recuperarlo fácilmente. Por lo general, para este tipo de cifrado, desea utilizar Criptografía asimétrica y así sucesivamente. Esto está fuera del alcance de este post, así que evitaré sumergirme en él.

Una lectura interesante de 2013 : Señala que el 88% de las implementaciones de Cripto en Android se hicieron incorrectamente.

Pensamientos Finales

Una vez más, sugeriría evitar la implementación de la biblioteca java para cripto directamente y usar Google Tink, le ahorrará el dolor de cabeza, ya que realmente han hecho un buen trabajo de implementación de todos los algoritmos correctamente. E incluso entonces asegúrese de revisar los problemas planteados en el Tink github, vulnerabilidades emergente aquí y allá.

Si usted tiene alguna pregunta o retroalimentación no dude en comentar! La seguridad siempre está cambiando y debe hacer todo lo posible para mantenerse al día con ella:)

Gracias he hecho esta clase usando su código tal vez alguien lo encuentra userfull

Objeto crypter

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;


public class ObjectCrypter {

private Cipher deCipher;
private Cipher enCipher;
private SecretKeySpec key;
private IvParameterSpec ivSpec;


public ObjectCrypter(byte[] keyBytes,   byte[] ivBytes) {
    // wrap key data in Key/IV specs to pass to cipher


     ivSpec = new IvParameterSpec(ivBytes);
    // create the cipher with the algorithm you choose
    // see javadoc for Cipher class for more info, e.g.
    try {
         DESKeySpec dkey = new  DESKeySpec(keyBytes);
          key = new SecretKeySpec(dkey.getKey(), "DES");
         deCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
         enCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
    } catch (NoSuchAlgorithmException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (NoSuchPaddingException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (InvalidKeyException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
public byte[] encrypt(Object obj) throws InvalidKeyException, InvalidAlgorithmParameterException, IOException, IllegalBlockSizeException, ShortBufferException, BadPaddingException {
    byte[] input = convertToByteArray(obj);
    enCipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);

    return enCipher.doFinal(input);




//  cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
//  byte[] encypted = new byte[cipher.getOutputSize(input.length)];
//  int enc_len = cipher.update(input, 0, input.length, encypted, 0);
//  enc_len += cipher.doFinal(encypted, enc_len);
//  return encypted;


}
public Object decrypt( byte[]  encrypted) throws InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException, IOException, ClassNotFoundException {
    deCipher.init(Cipher.DECRYPT_MODE, key, ivSpec);

    return convertFromByteArray(deCipher.doFinal(encrypted));

}



private Object convertFromByteArray(byte[] byteObject) throws IOException,
        ClassNotFoundException {
    ByteArrayInputStream bais;

    ObjectInputStream in;
    bais = new ByteArrayInputStream(byteObject);
    in = new ObjectInputStream(bais);
    Object o = in.readObject();
    in.close();
    return o;

}



private byte[] convertToByteArray(Object complexObject) throws IOException {
    ByteArrayOutputStream baos;

    ObjectOutputStream out;

    baos = new ByteArrayOutputStream();

    out = new ObjectOutputStream(baos);

    out.writeObject(complexObject);

    out.close();

    return baos.toByteArray();

}


}

¿qué tal esto:

private static byte[] xor(final byte[] input, final byte[] secret) {
    final byte[] output = new byte[input.length];
    if (secret.length == 0) {
        throw new IllegalArgumentException("empty security key");
    }
    int spos = 0;
    for (int pos = 0; pos < input.length; ++pos) {
        output[pos] = (byte) (input[pos] ^ secret[spos]);
        ++spos;
        if (spos >= secret.length) {
            spos = 0;
        }
    }
    return output;
}

Funciona bien para mí y es bastante compacto.

Aquí está mi implementación de meta64.com como un Singleton Primaveral. Si desea crear una instancia de ciper para cada llamada que también funcionaría, y luego podría eliminar las llamadas 'sincronizadas', pero tenga cuidado con' cipher ' no es seguro para subprocesos.

import java.security.Key;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("singleton")
public class Encryptor {

    @Value("${aeskey}")
    private String keyStr;

    private Key aesKey = null;
    private Cipher cipher = null;

    synchronized private void init() throws Exception {
        if (keyStr == null || keyStr.length() != 16) {
            throw new Exception("bad aes key configured");
        }
        if (aesKey == null) {
            aesKey = new SecretKeySpec(keyStr.getBytes(), "AES");
            cipher = Cipher.getInstance("AES");
        }
    }

    synchronized public String encrypt(String text) throws Exception {
        init();
        cipher.init(Cipher.ENCRYPT_MODE, aesKey);
        return toHexString(cipher.doFinal(text.getBytes()));
    }

    synchronized public String decrypt(String text) throws Exception {
        init();
        cipher.init(Cipher.DECRYPT_MODE, aesKey);
        return new String(cipher.doFinal(toByteArray(text)));
    }

    public static String toHexString(byte[] array) {
        return DatatypeConverter.printHexBinary(array);
    }

    public static byte[] toByteArray(String s) {
        return DatatypeConverter.parseHexBinary(s);
    }

    /*
     * DO NOT DELETE
     * 
     * Use this commented code if you don't like using DatatypeConverter dependency
     */
    // public static String toHexStringOld(byte[] bytes) {
    // StringBuilder sb = new StringBuilder();
    // for (byte b : bytes) {
    // sb.append(String.format("%02X", b));
    // }
    // return sb.toString();
    // }
    //
    // public static byte[] toByteArrayOld(String s) {
    // int len = s.length();
    // byte[] data = new byte[len / 2];
    // for (int i = 0; i < len; i += 2) {
    // data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i +
    // 1), 16));
    // }
    // return data;
    // }
}

Consideraría usar algo como https://www.bouncycastle.org / Es una biblioteca predefinida que te permite cifrar lo que quieras con un número de cifrados diferentes Entiendo que solo quieres protegerte del espionaje, pero si realmente quieres proteger la información, usar Base64 en realidad no te protegerá.

Aquí hay algunos enlaces que puede leer lo que Java soporta

Cifrar / descifrar un flujo de datos.

Este ejemplo muestra cómo cifrar (usando un cifrado simétrico algoritmo como AES, Blowfish, RC2, 3DES, etc), una gran cantidad de datos. El los datos se pasan en trozos a uno de los métodos de cifrado: EncryptBytes, EncryptString, EncryptBytesENC, o EncryptStringENC. (El nombre del método indica el tipo de entrada (cadena o matriz de bytes) y el tipo de retorno (cadena codificada o matriz de bytes). El Propiedades FirstChunk y LastChunk se utilizan para indicar si un trozo es el primero, medio o último en un stream a cifrar. Predeterminada, tanto FirstChunk como LastChunk son iguales verdadero meaning lo que significa que los datos pasados es la cantidad total.

JCERefGuide

Ejemplos de cifrado Java

Puedes usar Jasypt

Con Jasypt, cifrar y comprobar una contraseña puede ser tan simple como...

StrongTextEncryptor textEncryptor = new StrongTextEncryptor();
textEncryptor.setPassword(myEncryptionPassword);

Cifrado:

String myEncryptedText = textEncryptor.encrypt(myText);

Descifrado:

String plainText = textEncryptor.decrypt(myEncryptedText);

Gradle:

compile group: 'org.jasypt', name: 'jasypt', version: '1.9.2'

Características:

Jasypt le proporciona técnicas de cifrado fáciles unidireccionales (digest) y bidireccionales.

Abra la API para usarla con cualquier proveedor de JCE, y no solo con la máquina virtual Java predeterminada. Jasypt puede ser utilizado fácilmente con los abastecedores bien conocidos como castillo animoso. Más información.

Mayor seguridad para las contraseñas de sus usuarios. Más información.

Soporte de cifrado binario. Jasypt permite el digest y cifrado de binarios (matrices de bytes). Cifrar sus objetos o archivos cuando sea necesario (para ser enviado a través de la red, por ejemplo).

Soporte de cifrado de números. Además de textos y binarios, permite el digest y cifrado de valores numéricos (BigInteger y BigDecimal, se admiten otros tipos numéricos al cifrar la persistencia de hibernación). Más información.

Completamente seguro para hilos.

Soporte para cifrado/digestor pooling, con el fin de lograr un alto rendimiento en sistemas multiprocesador/multinúcleo.

Incluye una versión ligera ("lite") de la biblioteca para una mejor capacidad de gestión en entornos con restricciones de tamaño como plataformas móviles.

Proporciona herramientas de cifrado fáciles y sin configuración para usuarios nuevos en cifrado, y también herramientas de cifrado estándar altamente configurables, para usuarios avanzados.

Hibernar 3 y 4 integración opcional para conservar los campos de las entidades asignadas de forma cifrada. El cifrado de campos se define en los archivos de asignación de hibernación, y permanece transparente para el resto de la aplicación (útil para datos personales confidenciales, bases de datos con muchos usuarios habilitados para lectura...). Cifrar textos, binarios, números, booleanos, fechas... Más información.

Perfectamente integrable en una aplicación de resorte, con características de integración específicas para Spring 2, Spring 3.0 y Spring 3.1. Todos los digestores y cifradores en jasypt están diseñados para ser utilizados fácilmente (instanciados, inyectados por dependencias... desde la Primavera. Y, debido a que son seguros para roscas, se pueden usar sin preocupaciones de sincronización en un entorno orientado a singleton como Spring. Más información: Primavera 2, Primavera 3.0, Primavera 3.1.

Spring Security (anteriormente Acegi Security) integración opcional para realizar tareas de cifrado de contraseñas y emparejamiento para el marco de seguridad, mejorando la seguridad de las contraseñas de sus usuarios mediante el uso de mecanismos de cifrado de contraseñas más seguros y proporcionándole un mayor grado de configuración y control. Más información.

Proporciona una funcionalidad avanzada para cifrar todos o parte de los archivos de configuración de una aplicación, incluyendo información confidencial como contraseñas de bases de datos. Integre a la perfección la configuración cifrada en aplicaciones simples, basadas en muelles y / o habilitadas para hibernación. Más información.

Proporciona herramientas de CLI (Interfaz de línea de comandos) fáciles de usar para permitir a los desarrolladores inicializar sus datos cifrados e incluir operaciones de cifrado/descifrado/resumen en tareas de mantenimiento o scripts. Más información.

Se integra en Apache Wicket, para un cifrado más robusto de las URL en sus aplicaciones seguras.

Guías completas y documentación javadoc, para permitir a los desarrolladores comprender mejor lo que realmente están haciendo con sus datos.

Robusto soporte de charset, diseñado para cifrar y digerir adecuadamente los textos, cualquiera que sea el charset original. Soporte completo para idiomas como Japonés, Coreano, Árabe... sin problemas de codificación o plataforma.

Muy alto nivel de capacidades de configuración: El desarrollador puede implementar trucos como instruir a un "encryptor" para pedir a un, por ejemplo, servidor HTTPS remoto la contraseña que se utilizará para el cifrado. Le permite satisfacer sus necesidades de seguridad.

Aquí una solución simple con sólo java.* y javax.crypto.* dependencias para el cifrado de bytes proporcionar confidencialidad y integridad. Será indistinguible bajo un ataque de texto plano elegido .

Utiliza AES en el modo GCM sin relleno, una clave de 128 bits se deriva por PBKDF2 con un montón de iteraciones y una sal estática de la contraseña proporcionada. Esto asegura que las contraseñas de forzamiento bruto sean difíciles y distribuya la entropía por todo el clave.

Se genera un vector de inicialización aleatorio (IV) que se antepondrá al texto cifrado. Además, el byte estático 0x01 se antepone como el primer byte como una 'versión'.

El mensaje completo entra en el código de autenticación de mensajes (MAC) generado por AES/GCM.

Aquí va, cero dependencias externas clase de cifrado que proporciona confidencialidad y integridad :

package cryptor;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * This class implements AES-GCM symmetric key encryption with a PBKDF2 derived password.
 * It provides confidentiality and integrity of the plaintext.
 *
 * @created 2018-02-25
 */
public class AesGcmCryptor {

    // https://crypto.stackexchange.com/questions/26783/ciphertext-and-tag-size-and-iv-transmission-with-aes-in-gcm-mode
    private static final byte VERSION_BYTE = 0x01;
    private static final int VERSION_BYTE_LENGTH = 1;
    private static final int AES_KEY_BITS_LENGTH = 128;
    private static final int GCM_IV_BYTES_LENGTH = 12;
    private static final int GCM_TAG_BYTES_LENGTH = 16;

    private static final int PBKDF2_ITERATIONS = 16384;

    private static final byte[] PBKDF2_SALT = hexStringToByteArray("4d3fe0d71d2abd2828e7a3196ea450d4");

    /**
     * Decrypts an AES-GCM encrypted ciphertext and is
     * the reverse operation of {@link AesGcmCryptor#encrypt(char[], byte[])}
     *
     * @param password   passphrase for decryption
     * @param ciphertext encrypted bytes
     *
     * @return plaintext bytes
     *
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws NoSuchProviderException
     * @throws InvalidKeySpecException
     * @throws InvalidAlgorithmParameterException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws IllegalArgumentException           if the length or format of the ciphertext is bad
     */
    public byte[] decrypt(char[] password, byte[] ciphertext)
            throws NoSuchPaddingException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException,
            InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException,
            BadVersionException {

        // input validation
        if (ciphertext == null) {
            throw new IllegalArgumentException("Ciphertext cannot be null.");
        }

        if (ciphertext.length <= VERSION_BYTE_LENGTH + GCM_IV_BYTES_LENGTH + GCM_TAG_BYTES_LENGTH) {
            throw new IllegalArgumentException("Ciphertext too short.");
        }

        // the version must match, we don't decrypt other versions
        if (ciphertext[0] != VERSION_BYTE) {
            throw new BadVersionException();
        }

        // input seems legit, lets decrypt and check integrity

        // derive key from password
        SecretKey key = deriveAesKey(password, PBKDF2_SALT, AES_KEY_BITS_LENGTH);

        // init cipher
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "SunJCE");
        GCMParameterSpec params = new GCMParameterSpec(GCM_TAG_BYTES_LENGTH * 8,
                ciphertext,
                VERSION_BYTE_LENGTH,
                GCM_IV_BYTES_LENGTH
        );
        cipher.init(Cipher.DECRYPT_MODE, key, params);

        final int ciphertextOffset = VERSION_BYTE_LENGTH + GCM_IV_BYTES_LENGTH;

        // add version and IV to MAC
        cipher.updateAAD(ciphertext, 0, ciphertextOffset);

        // decipher and check MAC
        return cipher.doFinal(ciphertext, ciphertextOffset, ciphertext.length - ciphertextOffset);
    }

    /**
     * Encrypts a plaintext with a password.
     *
     * The encryption provides the following security properties:
     * Confidentiality + Integrity
     *
     * This is achieved my using the AES-GCM AEAD blockmode with a randomized IV.
     *
     * The tag is calculated over the version byte, the IV as well as the ciphertext.
     *
     * Finally the encrypted bytes have the following structure:
     * <pre>
     *          +-------------------------------------------------------------------+
     *          |         |               |                             |           |
     *          | version | IV bytes      | ciphertext bytes            |    tag    |
     *          |         |               |                             |           |
     *          +-------------------------------------------------------------------+
     * Length:     1B        12B            len(plaintext) bytes            16B
     * </pre>
     * Note: There is no padding required for AES-GCM, but this also implies that
     * the exact plaintext length is revealed.
     *
     * @param password  password to use for encryption
     * @param plaintext plaintext to encrypt
     *
     * @throws NoSuchAlgorithmException
     * @throws NoSuchProviderException
     * @throws NoSuchPaddingException
     * @throws InvalidAlgorithmParameterException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws InvalidKeySpecException
     */
    public byte[] encrypt(char[] password, byte[] plaintext)
            throws NoSuchAlgorithmException, NoSuchProviderException, NoSuchPaddingException,
            InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException,
            InvalidKeySpecException {

        // initialise random and generate IV (initialisation vector)
        SecretKey key = deriveAesKey(password, PBKDF2_SALT, AES_KEY_BITS_LENGTH);
        final byte[] iv = new byte[GCM_IV_BYTES_LENGTH];
        SecureRandom random = SecureRandom.getInstanceStrong();
        random.nextBytes(iv);

        // encrypt
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "SunJCE");
        GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_BYTES_LENGTH * 8, iv);
        cipher.init(Cipher.ENCRYPT_MODE, key, spec);

        // add IV to MAC
        final byte[] versionBytes = new byte[] { VERSION_BYTE };
        cipher.updateAAD(versionBytes);
        cipher.updateAAD(iv);

        // encrypt and MAC plaintext
        byte[] ciphertext = cipher.doFinal(plaintext);

        // prepend VERSION and IV to ciphertext
        byte[] encrypted = new byte[1 + GCM_IV_BYTES_LENGTH + ciphertext.length];
        int pos = 0;
        System.arraycopy(versionBytes, 0, encrypted, 0, VERSION_BYTE_LENGTH);
        pos += VERSION_BYTE_LENGTH;
        System.arraycopy(iv, 0, encrypted, pos, iv.length);
        pos += iv.length;
        System.arraycopy(ciphertext, 0, encrypted, pos, ciphertext.length);

        return encrypted;
    }

    /**
     * We derive a fixed length AES key with uniform entropy from a provided
     * passphrase. This is done with PBKDF2/HMAC256 with a fixed count
     * of iterations and a provided salt.
     *
     * @param password passphrase to derive key from
     * @param salt     salt for PBKDF2 if possible use a per-key salt, alternatively
     *                 a random constant salt is better than no salt.
     * @param keyLen   number of key bits to output
     *
     * @return a SecretKey for AES derived from a passphrase
     *
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    private SecretKey deriveAesKey(char[] password, byte[] salt, int keyLen)
            throws NoSuchAlgorithmException, InvalidKeySpecException {

        if (password == null || salt == null || keyLen <= 0) {
            throw new IllegalArgumentException();
        }
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        KeySpec spec = new PBEKeySpec(password, salt, PBKDF2_ITERATIONS, keyLen);
        SecretKey pbeKey = factory.generateSecret(spec);

        return new SecretKeySpec(pbeKey.getEncoded(), "AES");
    }

    /**
     * Helper to convert hex strings to bytes.
     *
     * May be used to read bytes from constants.
     */
    private static byte[] hexStringToByteArray(String s) {

        if (s == null) {
            throw new IllegalArgumentException("Provided `null` string.");
        }

        int len = s.length();
        if (len % 2 != 0) {
            throw new IllegalArgumentException("Invalid length: " + len);
        }

        byte[] data = new byte[len / 2];
        for (int i = 0; i < len - 1; i += 2) {
            byte b = (byte) toHexDigit(s, i);
            b <<= 4;
            b |= toHexDigit(s, i + 1);
            data[i / 2] = b;
        }
        return data;
    }

    private static int toHexDigit(String s, int pos) {
        int d = Character.digit(s.charAt(pos), 16);
        if (d < 0) {
            throw new IllegalArgumentException("Cannot parse hex digit: " + s + " at " + pos);
        }
        return d;
    }
}

Aquí todo el proyecto con una buena CLI: https://github.com/trichner/tcrypt

Este es el método que usé.esto es simple, pero tiene mejor protección. https://github.com/chamikaras/simpleEncryptor

Read readme en este proyecto.Esto es simple de usar.

public SimpleEncryptor(int MaximumLength) {
    //initialize encryption Key pattern variable
    pattern = new Integer[MaximumLength];
    //Generate pattern
    pattern =GenarateEncryptionPattern(MaximumLength);
}

private Integer[] GenarateEncryptionPattern(int Length) {
    Integer[] randomPattern = new Integer[Length];
    //generate encryption pattern
    for (int i = 0; i < Length; i++) {
        //make random encrypt key
        Random random = new Random();
        randomPattern[i] = random.nextInt(9);
    }
    return randomPattern;
}

public void simpleEncryptData(String data) {

    for (int i=0; i<data.length();i++){
        //get character from data
        char character = data.charAt(i);
        //convert character to ascii
        int ascii = (int) character;
        //decrypt data with random generated text
        int encryptedascii = ascii + pattern[i];
        //convert ascii to char
        char encryptedchar = (char)encryptedascii;
        //append string with char
        encryptedData += encryptedchar;

    }
}

private String convertKey(){
    //convert key to String
    String key = "";
    for (int i = 0;i<pattern.length;i++){
        key += String.valueOf(pattern[i]);
    }
  return key;
}


public String getDecryptData(String data, String key){
    String decryptedData = "";
    for (int i=0;i<data.length();i++){
        //get current key from decryptkey
        String number = key.substring(i,i+1);
        //get char from encrypeddata
        char encryptedchar = data.charAt(i);
        //convert char to ascii
        int encryptedascii = (char)encryptedchar;
        //decrypt encrypted char
        int decryptedascii = encryptedascii - Integer.valueOf(number);
        //convert ascii to char
        char decryptedchar = (char)decryptedascii;
        //append decrypted string
        decryptedData += decryptedchar;
    }
    return decryptedData;
}
public String getDecryptData(String data, Integer[] key){
    String decryptedData = "";
    for (int i=0;i<data.length();i++){
        //get char from encrypeddata
        char encryptedchar = data.charAt(i);
        //convert char to ascii
        int encryptedascii = (char)encryptedchar;
        //decrypt encrypted char
        int decryptedascii = encryptedascii - key[i];
        //convert ascii to char
        char decryptedchar = (char)decryptedascii;
        //append decrypted string
        decryptedData += decryptedchar;
    }
    return decryptedData;
}

public String getEncryptedData(){
    //return encryptedData
    return encryptedData;
}
public Integer[] getRawDecryptKey(){
    //return rawkey
    return pattern;
}
public String getStringDecryptKey(){
    //return string key
    return convertKey();
}

}

Como muchos de los chicos ya han dicho, usted debe utilizar un cifrado estándar que se utiliza demasiado como DES o AES.

Un ejemplo sencillo de cómo puede cifrar y descifrar una cadena en java utilizando AES.

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class EncryptorDemo {

    public static String encrypt(String key, String randomVector, String value) {
        try {
            IvParameterSpec iv = new IvParameterSpec(randomVector.getBytes("UTF-8"));
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
            byte[] encrypted = cipher.doFinal(value.getBytes());
            System.out.println("encrypted text: "  + Base64.encodeBase64String(encrypted));
            return Base64.encodeBase64String(encrypted);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String decrypt(String key, String randomVector, String encrypted) {
        try {
            IvParameterSpec iv = new IvParameterSpec(randomVector.getBytes("UTF-8"));
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
            byte[] originalText = cipher.doFinal(Base64.decodeBase64(encrypted));
            System.out.println("decrypted text: "  + new String(originalText));
            return new String(originalText);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        String key = "JavasEncryptDemo"; // 128 bit key
        String randomVector = "RandomJavaVector"; // 16 bytes IV
        decrypt(key, randomVector, encrypt(key, randomVector, "Anything you want to encrypt!"));

    }
}

String s1="arshad"; 
char[] s2=s1.toCharArray(); 
int s3= s2.length; 

  System.out.println(s3);
 int i=0; 

// for(int j=0;j<s3;j++) 
// System.out.println(s2[j]); 

for(i=0;i<((s3)/2);i++) { 

char z,f=10; 
z=(char) (s2[i] * f); 
s2[i]=s2[(s3-1)-i]; 
s2[(s3-1)-i]=z; 

String b=new String(s2);

 print(b);  }

Es posible que desee considerar alguna herramienta automatizada para hacer la generación de código de cifrado / descifrado, por ejemplo. https://www.stringencrypt.com/java-encryption /

Puede generar diferentes códigos de cifrado y descifrado cada vez para el cifrado de cadenas o archivos.

Es bastante útil cuando se trata de encriptación de cadena rápida sin usar RSA, AES, etc.

Resultados de la muestra:

// encrypted with https://www.stringencrypt.com (v1.1.0) [Java]
// szTest = "Encryption in Java!"
String szTest = "\u9E3F\uA60F\uAE07\uB61B\uBE1F\uC62B\uCE2D\uD611" +
                "\uDE03\uE5FF\uEEED\uF699\uFE3D\u071C\u0ED2\u1692" +
                "\u1E06\u26AE\u2EDC";

for (int iatwS = 0, qUJQG = 0; iatwS < 19; iatwS++)
{
        qUJQG = szTest.charAt(iatwS);
        qUJQG ++;
        qUJQG = ((qUJQG << 5) | ( (qUJQG & 0xFFFF) >> 11)) & 0xFFFF;
        qUJQG -= iatwS;
        qUJQG = (((qUJQG & 0xFFFF) >> 6) | (qUJQG << 10)) & 0xFFFF;
        qUJQG ^= iatwS;
        qUJQG -= iatwS;
        qUJQG = (((qUJQG & 0xFFFF) >> 3) | (qUJQG << 13)) & 0xFFFF;
        qUJQG ^= 0xFFFF;
        qUJQG ^= 0xB6EC;
        qUJQG = ((qUJQG << 8) | ( (qUJQG & 0xFFFF) >> 8)) & 0xFFFF;
        qUJQG --;
        qUJQG = (((qUJQG & 0xFFFF) >> 5) | (qUJQG << 11)) & 0xFFFF;
        qUJQG ++;
        qUJQG ^= 0xFFFF;
        qUJQG += iatwS;
        szTest = szTest.substring(0, iatwS) + (char)(qUJQG & 0xFFFF) + szTest.substring(iatwS + 1);
}

System.out.println(szTest);

Lo usamos todo el tiempo en nuestra empresa.

public static String encryptParams(String myTextInput) {

        String myKey = "40674244454045cb9a70040a30e1c007";
        String myVector = "@1B2c3D4e5F6g7H8";

        String encData = "";

        try{
            JavaEncryprtionUtil encUtil = new JavaEncryprtionUtil();
            encData = Base64.encodeToString(encUtil.encrypt(myTextInput.getBytes("UTF-8"), myKey.getBytes("UTF-8"), myVector.getBytes("UTF-8")),Base64.DEFAULT);
            System.out.println(encData);
        }catch(NoSuchAlgorithmException ex){
            ex.printStackTrace();
        }catch(NoSuchPaddingException ex){
            ex.printStackTrace();
        }catch(InvalidKeyException ex){
            ex.printStackTrace();
        }catch(InvalidAlgorithmParameterException ex){
            ex.printStackTrace();
        }catch(IllegalBlockSizeException ex){
            ex.printStackTrace();
        }catch(BadPaddingException ex){
            ex.printStackTrace();
        }catch(UnsupportedEncodingException ex){
            ex.printStackTrace();
        }

        return encData;
    }