La forma más simple de encriptar un archivo de texto en Java

Para el proyecto de mi escuela, tuve que demostrar que puedo utilizar el manejo de archivos dentro de un progtwig. Para esto hice un proceso de inicio de sesión muy simple en el que puede crear una cuenta que escribe un nombre de usuario y contraseña para un archivo de texto ubicado en la carpeta de recursos. Obviamente, esto no tiene ningún tipo de seguridad, ya que no fue diseñado para ser seguro solo para mostrar el manejo de archivos. Sin embargo, mi maestra ha dicho que debería intentar agregar algo de encriptación al archivo para obtener una mejor calificación.

He realizado algunas investigaciones y muchas personas recomiendan DES.

El problema que tengo es que no me queda mucho tiempo para mi proyecto y necesito terminarlo lo antes posible. El uso de DES parece que llevaría un tiempo implementar todo el código adicional.

En mi progtwig, estoy usando un simple lineNumberReader para leer los archivos línea por línea. Para escribir en los archivos, estoy usando un BufferedWriter.

¿Hay alguna forma de encriptar estos datos de manera muy simple? No tiene que ser muy seguro, pero tengo que demostrar que al menos he intentado encriptar los datos. El cifrado y el descifrado se completarán en la misma aplicación ya que los datos no se transfieren.

¿Potencialmente puedo crear un algoritmo de cifrado y descifrado muy simple?

Prueba esto … Es bastante simple

import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; public class HelloWorld{ public static void main(String[] args) { try{ KeyGenerator keygenerator = KeyGenerator.getInstance("DES"); SecretKey myDesKey = keygenerator.generateKey(); Cipher desCipher; desCipher = Cipher.getInstance("DES"); byte[] text = "No body can see me.".getBytes("UTF8"); desCipher.init(Cipher.ENCRYPT_MODE, myDesKey); byte[] textEncrypted = desCipher.doFinal(text); String s = new String(textEncrypted); System.out.println(s); desCipher.init(Cipher.DECRYPT_MODE, myDesKey); byte[] textDecrypted = desCipher.doFinal(textEncrypted); s = new String(textDecrypted); System.out.println(s); }catch(Exception e) { System.out.println("Exception"); } } } 

Entonces, básicamente, antes de escribir en un archivo cifrará y después de leer tendrá que descifrarlo.

Puede usar un simple cifrado ceasar ( http://en.wikipedia.org/wiki/Caesar_cipher )

 public class Cipher { public static void main(String[] args) { String str = "The quick brown fox Jumped over the lazy Dog"; System.out.println( Cipher.encode( str, 12 )); System.out.println( Cipher.decode( Cipher.encode( str, 12), 12 )); } public static String decode(String enc, int offset) { return encode(enc, 26-offset); } public static String encode(String enc, int offset) { offset = offset % 26 + 26; StringBuilder encoded = new StringBuilder(); for (char i : enc.toCharArray()) { if (Character.isLetter(i)) { if (Character.isUpperCase(i)) { encoded.append((char) ('A' + (i - 'A' + offset) % 26 )); } else { encoded.append((char) ('a' + (i - 'a' + offset) % 26 )); } } else { encoded.append(i); } } return encoded.toString(); } } 

Encontrado en http://rosettacode.org/wiki/Caesar_cipher#Java

Tenga en cuenta que Java tiene soluciones nativas para el cifrado y, en lo que respecta a las contraseñas, es mucho mejor simplemente mezclarlas y comparar hashes, ya que normalmente no es necesario descifrarlas.

Un método muy básico sería relacionar los datos con una clave. Este método es simétrico, es decir, puede usar la misma clave para decodificar como encoding.

Si elegimos una clave de 1 byte, es agradable y simple, suficiente para que no se pueda leer (¡pero no para nada segura!):

 private void encodeDecode(byte[] bytes, byte key) { for(int i=0; i 

Un algoritmo de aleatorización fácil y divertido sería la transformación de Burrows-Wheeler . No es realmente una encriptación segura, pero en serio, es un trabajo escolar y esto es increíble.

use algoritmo de encriptación de subtitutas simples, cambie cada carácter en número u otro carácter.

  1. obtener todos los caracteres de su cadena.
  2. obtener el valor de ascii de la cadena.
  3. agregue el valor de ascii con un entero específico (esta será su clave de cifrado)
  4. mostrar el resultado

No sé quién recomienda DES para cifrar la contraseña. Te sugiero que sigas estos pasos si quieres impresionar a tu maestra:

  • cite su referencia como soporte teórico para su solución criptográfica. Te sugiero este OWSAP – Hoja de trucos para almacenamiento de contraseñas
  • explique dónde su código cumple con la especificación. Para un buen tutorial con código de ejemplo, te sugiero esta contraseña segura hash

Esta solución hace que su proyecto sea real y puede reutilizarlo para pasar el examen de su futuro Módulo Crypto :). De lo contrario, me gusta la solución propuesta por StanislavL.

¡Disfrutar!

Bouncy Castle Crypto API es una API ligera de criptografía en Java.

  import org.bouncycastle.crypto.*; import org.bouncycastle.crypto.engines.*; import org.bouncycastle.crypto.modes.*; import org.bouncycastle.crypto.params.*; // A simple example that uses the Bouncy Castle // lightweight cryptography API to perform DES // encryption of arbitrary data. public class Encryptor { private BufferedBlockCipher cipher; private KeyParameter key; // Initialize the cryptographic engine. // The key array should be at least 8 bytes long. public Encryptor( byte[] key ){ /* cipher = new PaddedBlockCipher( new CBCBlockCipher(new DESEngine())); */ cipher = new PaddedBlockCipher( new CBCBlockCipher(new BlowfishEngine())); this.key = new KeyParameter( key ); } // Initialize the cryptographic engine. // The string should be at least 8 chars long. public Encryptor( String key ){ this( key.getBytes()); } // Private routine that does the gritty work. private byte[] callCipher( byte[] data ) throws CryptoException { int size = cipher.getOutputSize( data.length ); byte[] result = new byte[ size ]; int olen = cipher.processBytes(data,0,data.length result, 0); olen += cipher.doFinal( result, olen ); if( olen < size ){ byte[] tmp = new byte[ olen ]; System.arraycopy( result, 0, tmp, 0, olen ); result = tmp; } return result; } // Encrypt arbitrary byte array, returning the // encrypted data in a different byte array. public synchronized byte[] encrypt( byte[] data ) throws CryptoException { if( data == null || data.length == 0 ){ return new byte[0]; } cipher.init( true, key ); return callCipher( data ); } // Encrypts a string. public byte[] encryptString( String data ) throws CryptoException { if( data == null || data.length() == 0 ){ return new byte[0]; } return encrypt( data.getBytes() ); } // Decrypts arbitrary data. public synchronized byte[] decrypt( byte[] data ) throws CryptoException { if( data == null || data.length == 0 ){ return new byte[0]; } cipher.init( false, key ); return callCipher( data ); } // Decrypts a string that was previously encoded // using encryptString. public String decryptString( byte[] data ) throws CryptoException { if( data == null || data.length == 0 ){ return ""; } return new String( decrypt( data ) ); } } 

Hay muchas formas de encriptar una cadena simple en Java. Si se trata de un proyecto de la escuela, realmente no creo que puedas obtener una banda más alta simplemente usando algunas librerías de tercera parte para terminar el trabajo encriptado.

Si tiene algo de tiempo, podría tratar de entender cómo funciona Base64, luego intente crear algún algoritmo encriptado usted mismo.

Sin embargo, si insistes en usar alguna API en Java, debo decir que DES es realmente una forma antigua de texto encriptado, las 3DE (DESede) o AES serán mejores y más seguras, ambas ya han recibido soporte desde Java6.

Si tiene que importar la lib de BouncyCastle, prefiero IDEA, es uno de los algoritmos más seguros, puede lograr un buen puntaje.

No le daré ningún código de demostración, pero puede encontrar fácilmente en Google todo el algoritmo que he mencionado.

Mi sugerencia: no use el cifrado en absoluto. Aquí hay algo mejor: (espero)

 Scanner sc=new Scanner(System.in); String name=sc.next(); //for inputting user name File f= new File("d://"+name+".txt"); if(f.exists()) { if(f.lastModified()!=0) { System.out.println("Account data tampered...cannot be accessed"); } else{ String data=""; System.out.println(data); //data should contain //data from file read using BufferedReader f.setLastModified(0); } } else { f.createNewFile();//Write whatever you want to to the file f.setLastModified(0); } 

Por lo tanto, puede saber efectivamente si el usuario ha manipulado el archivo de texto con los detalles y mostrar un mensaje de error si se usa la cuenta alterada. Sin embargo, esto no impide que el usuario cambie el archivo, solo evitará que se use una cuenta alterada … Creo que a su profesor de informática le puede gustar esto. También podría hacer: f.setReadOnly (); y cuando escribe en el archivo, f.setWritable (true, true), luego de cerrar el flujo de salida, f.setReadOnly (); de nuevo … Pero el archivo aún puede ser reemplazado, por lo tanto, el primero y es más eficaz. Gracias

 public class CryptoUtils { public static void encrypt(String key, File inputFile, File outputFile) throws CryptoException { doCrypto(Cipher.ENCRYPT_MODE, key, inputFile, outputFile); } public static void decrypt(String key, File inputFile, File outputFile) throws CryptoException { doCrypto(Cipher.DECRYPT_MODE, key, inputFile, outputFile); } private static void doCrypto(int cipherMode, String key, File inputFile, File outputFile) throws CryptoException { try { Key secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM); Cipher cipher = Cipher.getInstance(TRANSFORMATION); cipher.init(cipherMode, secretKey); FileInputStream inputStream = new FileInputStream(inputFile); byte[] inputBytes = new byte[(int) inputFile.length()]; inputStream.read(inputBytes); byte[] outputBytes = cipher.doFinal(inputBytes); FileOutputStream outputStream = new FileOutputStream(outputFile); outputStream.write(outputBytes); inputStream.close(); outputStream.close(); } catch (NoSuchPaddingException | NoSuchAlgorithmException | InvalidKeyException | BadPaddingException | IllegalBlockSizeException | IOException ex) { throw new CryptoException("Error encrypting/decrypting file", ex); } } } 

 package net.codejava.crypto; import java.io.File; public class CryptoException extends Exception { public CryptoException() { } public CryptoException(String message, Throwable throwable) { super(message, throwable); } public static void main(String[] args) { String key = "Mary has one cat1"; File inputFile = new File("document.txt"); File encryptedFile = new File("document.encrypted"); File decryptedFile = new File("document.decrypted"); try { CryptoUtils.encrypt(key, inputFile, encryptedFile); CryptoUtils.decrypt(key, encryptedFile, decryptedFile); } catch (CryptoException ex) { System.out.println(ex.getMessage()); ex.printStackTrace(); } } }