numeros - Cómo encriptar Cadena en Java
encriptar y desencriptar rsa en java (14)
Esta es la primera página que se muestra a través de Google y las vulnerabilidades de seguridad en todas las implementaciones me hacen temblar, así que estoy publicando esto para agregar información sobre cifrado para otros, ya que han pasado 7 años desde la publicación original. Tengo una Maestría en Ingeniería Informática y pasé mucho tiempo estudiando y aprendiendo criptografía, así que estoy tirando mis dos centavos para hacer de internet un lugar más seguro.
Además, tenga en cuenta que una gran cantidad de implementación podría ser segura para una situación determinada, pero ¿por qué usar esos y accidentalmente cometer un error? Use las herramientas más fuertes que tenga disponibles a menos que tenga una razón específica para no hacerlo. En general, le recomiendo usar una biblioteca y mantenerse alejado de los detalles esenciales si es posible.
ACTUALIZACIÓN 4/5/18: Reescribí algunas partes para que fueran más Jasypt entender y cambié la biblioteca recomendada de Jasypt a la nueva biblioteca de Google. Tink , recomendaría eliminar por completo Jasypt de una configuración existente.
Prefacio
Describiré a continuación los conceptos básicos de la criptografía simétrica segura y señalaré los errores comunes que veo en línea cuando las personas implementan criptografía por sí mismas con la biblioteca Java estándar. Si quieres omitir todos los detalles, ejecuta la nueva biblioteca de Google. Tink importa eso en tu proyecto y usa el modo AES-GCM para todas tus encriptaciones y estarás seguro.
Ahora, si quieres aprender los detalles esenciales sobre cómo encriptar en java sigue leyendo :)
Cifras de bloque
Lo primero es lo primero que debe elegir una clave simétrica Block Cipher. Un Cifrado de Bloque es una función / programa de computadora usado para crear Pseudo-Aleatoriedad. Pseudo-Aleatoriedad es una aleatoriedad falsa que ninguna computadora que no sea Computadora Cuántica podrá distinguir entre ella y la aleatoriedad real. El Cifrado de bloques es como la piedra angular de la criptografía, y cuando se utiliza con diferentes modos o esquemas, podemos crear encriptaciones.
Ahora, con respecto a los Algoritmos de Cifrado de Bloque disponibles hoy, asegúrese de NUNCA , repito NUNCA use DES , incluso diría NUNCA use 3DES . El único Cifrado de Bloque que incluso el lanzamiento de NSA de Snowden fue capaz de verificar lo más parecido posible a AES es AES . También existe AES 128, la diferencia es que AES 256 funciona en bloques de 256 bits, mientras que AES 128 funciona en 128 bloques. Con todo, AES 128 se considera seguro, aunque se han descubierto algunas debilidades, pero 256 es lo más sólido posible.
DES La NSA rompió el DES hechos cuando se fundó inicialmente y en realidad se mantuvo en secreto durante algunos años y aunque algunas personas aún afirman que 3DES es seguro, hay bastantes trabajos de investigación que han encontrado y analizado las debilidades en 3DES .
Modos de encriptación
El cifrado se crea cuando toma un cifrado de bloques y utiliza un esquema específico para que la aleatoriedad se combine con una clave para crear algo que sea reversible siempre que conozca la clave. Esto se conoce como un Modo de Encriptación.
Aquí hay un ejemplo de un modo de encriptación y el modo más simple conocido como ECB solo para que pueda entender visualmente lo que está sucediendo:
Los modos de encriptación que verá más comúnmente en línea son los siguientes:
BCE CTR, CBC, GCM
Existen otros modos fuera de los enumerados y los investigadores siempre están trabajando en 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 los datos repetidos como lo muestra el famoso pingüino de Linux .
Al implementar en Java, tenga en cuenta que si usa el siguiente código, el modo ECB se configura de manera predeterminada:
Cipher cipher = Cipher.getInstance("AES");
... PELIGRO ESTA 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 el modo ECB, se crearon también nombres conocidos como IV. La idea es que generemos una nueva variable aleatoria y la adjuntemos a cada encriptación para que cuando encripte dos mensajes que son iguales salgan diferentes. La belleza detrás de esto es que una IV o nonce es conocimiento público. Eso significa que un atacante puede tener acceso a esto, pero mientras no tengan tu llave, no pueden hacer nada con ese conocimiento.
Los problemas comunes que veré es que las personas establecerán 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 repites uno, comprometes la seguridad total de tu encriptación.
Generando una IV aleatoria
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 la manera de implementar SHA256 en este caso de uso correctamente, así que si alguien quiere analizar esto y actualizarlo, ¡sería increíble! Además, los ataques SHA1 siguen siendo poco convencionales ya que pueden pasar varios años en un clúster enorme para agrietarse. Vea los detalles aquí.
Implementación de CTR
No se requiere relleno para el modo CTR.
Cipher cipher = Cipher.getInstance("AES/NoPadding");
Implementación de CBC
Si elige implementar el modo CBC, hágalo con PKCS7Padding de la siguiente manera:
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
Vulnerabilidad de CBC y CTR y por qué debería usar GCM
Aunque algunos otros modos, como CBC y CTR, son seguros, se topan con el problema por el cual un atacante puede voltear los datos cifrados, cambiando su valor cuando se descifra. Digamos que cifras un mensaje bancario imaginario "Vender 100", tu mensaje cifrado se ve como "eu23ng", el atacante cambia un poco a "eu53ng" y, de repente, cuando descifra tu mensaje, se lee como "Vender 900".
Para evitar esto, la mayoría de Internet usa GCM, y cada vez que ve HTTPS probablemente estén usando GCM. GCM firma el mensaje cifrado con un hash y verifica que el mensaje no se haya modificado con esta firma.
Evitaría implementar GCM debido a su complejidad. Es mejor que utilices la nueva biblioteca de Googles, Tink, porque una vez más, si accidentalmente repites una IV, comprometes la clave en el caso con GCM, que es la máxima falla de seguridad. Los nuevos investigadores están trabajando para lograr modos de encriptación IV resistentes a la repetición, en los que incluso si se repite el IV, la clave no está en peligro, pero esto todavía no se ha generalizado.
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 se implementa correctamente, pero se basa la base. También tenga en cuenta que con GCM no hay relleno.
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
Claves contra 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 considerarse segura. Es por eso que debe asegurarse de usar las bibliotecas criptográficas adecuadas para generar la clave para usted.
Entonces, realmente tiene dos implementaciones que puede hacer aquí, la primera es usar el código que se encuentra en este hilo de StackOverflow para la generación de claves aleatorias . Esta solución utiliza un generador seguro de números aleatorios para crear una clave desde el principio que pueda 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 la fortalece. Aquí hay una implementación de StackOverflow que me gustó . Sin embargo, la biblioteca de Google Tink tiene todo esto integrado y deberías aprovecharlo.
Desarrolladores de Android
Un punto importante para señalar aquí es saber que su código de Android es de ingeniería inversa y en la mayoría de los casos, la mayoría del código de Java también lo es. Eso significa que si almacena la contraseña en texto sin formato en su código. Un hacker puede recuperarlo fácilmente. Por lo general, para este tipo de encriptación, desea utilizar Criptografía asimétrica, etc. Esto está fuera del alcance de esta publicación, así que evitaré sumergirme en ella.
Una lectura interesante de 2013 : señala que el 88% de las implementaciones de Crypto en Android se realizaron de forma incorrecta.
Pensamientos finales
Una vez más sugeriría evitar implementar directamente la biblioteca java para cifrado y usar Google Tink , ya que le ahorrará el dolor de cabeza ya que realmente han hecho un buen trabajo al implementar todos los algoritmos correctamente. Y aun así asegúrate de verificar los problemas que aparecen en Tink github, las vulnerabilidades emergentes aquí y allá.
Si tiene alguna pregunta o comentario, ¡no dude en comentar! La seguridad siempre está cambiando y debes hacer todo lo posible para mantenerte al día :)
Lo que necesito es cifrar la cadena que aparecerá en el código de barras 2D (PDF-417), de modo que cuando alguien tenga una idea para escanear no obtenga nada legible.
Otros requerimientos:
- no debería ser complicado
- no debe consistir en infraestructura RSA, PKI, pares de claves, etc.
Debe ser lo suficientemente simple como para deshacerse de la gente fisgoneando y fácil de descifrar para otras compañías interesadas en obtener esa información. Nos llaman, les decimos el estándar o les damos una clave simple que luego se puede utilizar para descifrado.
Probablemente esas compañías podrían usar diferentes tecnologías, por lo que sería bueno apegarse a algún estándar que no esté vinculado a alguna plataforma o tecnología especial.
¿Que sugieres? ¿Existe alguna clase de Java que haga encrypt () decrypt () sin mucha complicación para lograr altos estándares de seguridad?
Advertencia
No use esto como un tipo de medida de seguridad.
El mecanismo de encriptación en esta publicación es una plataforma única, lo que significa que la clave secreta puede ser recuperada fácilmente por un atacante utilizando 2 mensajes cifrados. XOR 2 mensajes cifrados y obtendrá la clave. ¡Así de simple!
Señalado por Moussa
Estoy usando Base64Encoder / Decoder de Sun que se encuentra en Sun''s JRE, para evitar otro JAR en lib. Eso es peligroso desde el punto de usar OpenJDK o JRE de algún otro. Además de eso, ¿hay alguna otra razón por la que debería considerar usar la lib de commons de Apache con Encoder / Decoder?
public class EncryptUtils {
public static final String DEFAULT_ENCODING = "UTF-8";
static BASE64Encoder enc = new BASE64Encoder();
static BASE64Decoder dec = new BASE64Decoder();
public static String base64encode(String text) {
try {
return enc.encode(text.getBytes(DEFAULT_ENCODING));
} catch (UnsupportedEncodingException e) {
return null;
}
}//base64encode
public static String base64decode(String text) {
try {
return new String(dec.decodeBuffer(text), DEFAULT_ENCODING);
} catch (IOException e) {
return null;
}
}//base64decode
public static void main(String[] args) {
String txt = "some text to be encrypted";
String key = "key phrase used for XOR-ing";
System.out.println(txt + " XOR-ed to: " + (txt = xorMessage(txt, key)));
String encoded = base64encode(txt);
System.out.println(" is encoded to: " + encoded + " and that is decoding to: " + (txt = base64decode(encoded)));
System.out.print("XOR-ing back to original: " + xorMessage(txt, key));
}
public static String xorMessage(String message, String key) {
try {
if (message == null || key == null) return null;
char[] keys = key.toCharArray();
char[] mesg = message.toCharArray();
int ml = mesg.length;
int kl = keys.length;
char[] newmsg = new char[ml];
for (int i = 0; i < ml; i++) {
newmsg[i] = (char)(mesg[i] ^ keys[i % kl]);
}//for i
return new String(newmsg);
} catch (Exception e) {
return null;
}
}//xorMessage
}//class
Aquí está mi implementación de meta64.com como Spring Singleton. Si desea crear una instancia de ciper para cada llamada que también funcione, y luego puede eliminar las llamadas "sincronizadas", pero tenga en cuenta que "cifrar" 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;
// }
}
Aquí hay algunos enlaces, puede leer lo que Java soporta
Encriptar / descifrar una secuencia de datos.
Este ejemplo demuestra cómo cifrar (utilizando un algoritmo de cifrado simétrico como AES, Blowfish, RC2, 3DES, etc.) una gran cantidad de datos. Los datos se pasan en fragmentos 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). Las propiedades FirstChunk y LastChunk se utilizan para indicar si un fragmento es el primero, medio o último en una secuencia para ser encriptado. De manera predeterminada, FirstChunk y LastChunk son verdaderos, lo que significa que los datos pasados son la cantidad total.
Aquí una solución simple con solo dependencias java.* Y javax.crypto.* Para el cifrado de bytes que proporciona confidencialidad e integridad . Será indistinguible bajo un ataque de texto claro elegido .
Utiliza AES en el modo GCM sin relleno, una clave de 128 bits se deriva de PBKDF2 con muchas iteraciones y una sal estática de la contraseña proporcionada. Esto asegura que las contraseñas de forzar bruto sean difíciles y distribuye la entropía sobre la clave completa.
Se genera un vector de inicialización aleatorio (IV) y se antepone al texto cifrado. Además, el byte estático 0x01 se antepone como el primer byte como una ''versión''.
Todo el mensaje va al código de autenticación de mensaje (MAC) generado por AES/GCM .
Aquí va, la clase de cifrado de cero dependencias externas proporciona confidencialidad e 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;
}
}
Here the entire project with a nice CLI: https://github.com/trichner/tcrypt
Consideraría usar algo como https://www.bouncycastle.org/ Es una biblioteca precompilada que te permite encriptar lo que quieras con un número de Cifrados diferentes. Entiendo que solo quieres protegerlo de fisgoneo, pero si realmente lo haces quiere proteger la información, usar Base64 en realidad no lo protegerá.
Puedes usar Jasypt
Con Jasypt, encriptar y verificar 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''
caracteristicas:
Jasypt le proporciona técnicas sencillas de cifrado unidireccional (digest) y bidireccional.
API abierta para usar con cualquier proveedor de JCE, y no solo el VM de Java predeterminado. Jasypt se puede utilizar fácilmente con proveedores conocidos como Bouncy Castle. Aprende más.
Mayor seguridad para las contraseñas de sus usuarios. Aprende más.
Soporte de cifrado binario. Jasypt permite el resumen y el cifrado de binarios (matrices de bytes). Cifre sus objetos o archivos cuando sea necesario (para ser enviados a través de la red, por ejemplo).
Número de cifrado compatible. Además de textos y binarios, permite el resumen y el cifrado de valores numéricos (BigInteger y BigDecimal, otros tipos numéricos son compatibles al encriptar para la persistencia de Hibernate). Aprende más.
Completamente seguro para hilos.
Soporte para agrupamiento de encriptador / digestor, para lograr un alto rendimiento en sistemas multiprocesador / multi-core.
Incluye una versión liviana ("ligera") de la biblioteca para una mejor administración en entornos de tamaño restrictivo, como las plataformas móviles.
Proporciona herramientas de cifrado sencillas y sin configuración para usuarios nuevos en el cifrado, y también herramientas de cifrado estándar altamente configurables para usuarios avanzados.
Integración opcional de Hibernate 3 y 4 para los campos persistentes de las entidades asignadas de forma encriptada. El cifrado de campos se define en los archivos de mapeo de Hibernate y permanece transparente para el resto de la aplicación (útil para datos personales confidenciales, bases de datos con muchos usuarios habilitados para lectura ...). Encripte textos, binarios, números, booleanos, fechas ... Obtenga más información.
Perfectamente integrable en una aplicación de Spring, con funciones de integración específicas para Spring 2, Spring 3.0 y Spring 3.1. Todos los digestores y encriptadores en jasypt están diseñados para ser fácilmente utilizados (instanciados, inyectados por dependencia ...) desde Spring. Y, debido a que son seguros para subprocesos, se pueden usar sin preocupaciones de sincronización en un entorno orientado a singleton como Spring. Conozca más: Spring 2, Spring 3.0, Spring 3.1.
Spring Security (anteriormente Acegi Security) integración opcional para realizar cifrado de contraseñas y tareas de coincidencia 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 seguras y proporcionándole un mayor grado de configuración y control. Aprende más.
Proporciona una funcionalidad avanzada para encriptar todo o parte de los archivos de configuración de una aplicación, incluida información confidencial como contraseñas de base de datos. Integre sin problemas la configuración encriptada en aplicaciones simples, basadas en Spring y / o Hibernate. Aprende más.
Proporciona herramientas 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. Aprende más.
Se integra en Wicket de Apache para obtener un cifrado de URL más sólido en sus aplicaciones seguras.
Guías completas y documentación de javadoc, para permitir a los desarrolladores comprender mejor lo que realmente están haciendo con sus datos.
Soporte robusto de juego de caracteres, diseñado para encriptar y digerir textos adecuadamente, cualquiera que sea el juego de caracteres original. Soporte completo para idiomas como japonés, coreano, árabe ... sin problemas de codificación o plataforma.
Nivel muy alto de capacidades de configuración: el desarrollador puede implementar trucos como instruir a un "encriptador" para solicitar a un servidor remoto HTTPS la contraseña que se utilizará para el cifrado. Le permite satisfacer sus necesidades de seguridad.
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.
Recomiendo 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, existen montones de implementaciones y solo se necesita dar la clave a cualquiera que se suponga que descifre la información en el código de barras. javax.crypto.Cipher es con lo que quieres trabajar aquí.
Supongamos que los bytes para encriptar están en
byte[] input;
A continuación, necesitará la clave y los bytes del vector de inicialización
byte[] keyBytes;
byte[] ivBytes;
Ahora puede inicializar el Cipher 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");
La encriptación 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 descifrado como este:
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);
gracias he hecho esta clase usando tu código tal vez alguien lo encuentre útil
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();
}
}
This is method i used.this is simple but it has better protection. https://github.com/chamikaras/simpleEncryptor
Read readme on this project.This is simple to used.
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();
}
}
You might want to consider some automated tool to do the encryption / decryption code generation eg. https://www.stringencrypt.com/java-encryption/
It can generate different encryption and decryption code each time for the string or file encryption.
It''s pretty handy when it comes to fast string encryption without using RSA, AES etc.
Sample results:
// 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);
We use it all the time in our company.
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); }
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;
}