Самый простой способ шифрования текстового файла в java

Ответ 1

Попробуйте это,... Его довольно простой

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

Таким образом, в основном перед записью в файл вы будете шифровать и после прочтения вам нужно будет расшифровать его.

Ответ 2

Вы можете использовать простой шифр 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();
}
}

Найдено http://rosettacode.org/wiki/Caesar_cipher#Java

Обратите внимание, что Java имеет встроенные решения для шифрования, и когда дело доходит до паролей, гораздо лучше просто хешировать их и сравнивать хэши, так как обычно их не нужно расшифровывать.

Ответ 3

используйте простой алгоритм шифрования субтитров, измените каждый символ на число или другой символ.

• получить каждый символ вашей строки.
• получить значение ascii строки.
• добавить значение ascii с определенным целым числом (это будет ваш ключ шифрования)
• отобразить результат

Ответ 4

Самый простой метод - это сопоставление данных с ключом. Этот метод является симметричным, то есть вы можете использовать тот же ключ для декодирования, что и для кодирования.

Если мы выберем 1-байтовый ключ, это будет хорошо и просто, достаточно, чтобы сделать его нечитаемым (но совсем не безопасным!):

private void encodeDecode(byte[] bytes, byte key) {
    for(int i=0; i<bytes.length; i++)
        bytes[i] = (byte) (bytes[i]^key);
}

Ответ 5

Легким и забавным алгоритмом скремблирования будет преобразование Burrows-Wheeler. Не совсем безопасное шифрование, но серьезно, это школьная работа, и это потрясающе.

Ответ 6

Bouncy Castle Crypto API - это легкий API криптографии в 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 ) );
        }
    }

Ответ 7

Я не знаю, кто рекомендует DES для шифрования пароля. Я предлагаю вам выполнить этот шаг, если вы хотите произвести впечатление на своего учителя:

• цитируйте вашу ссылку как теоретическую поддержку вашего криптографического решения. Я предлагаю вам этот OWSAP - Шифрование для хранения паролей
• объясните, где ваш код соответствует спецификации. Для хорошего учебника с образцом кода я предлагаю вам безопасный хеш-пароль

Это решение делает ваш проект реальным, и вы можете его повторно использовать, чтобы сдать экзамен вашего будущего Crypto Module:). В противном случае мне нравится решение, предложенное StanislavL.

Наслаждайтесь!

Ответ 8

Слишком много способов зашифрованной простой строки в Java. Если это школьный проект, я действительно не думаю, что вы можете получить более высокую группу, просто используя некоторые библиотеки третьей части, чтобы закончить зашифрованную работу.

Если у вас есть время, вы можете попытаться понять, как работает Base64, а затем попытаться создать какой-то зашифрованный алгоритм самостоятельно.

Как бы то ни было, если вы настаиваете на использовании какого-либо API в Java, я должен сказать, что DES действительно старый способ зашифрованного текста, 3DEs (DESede) или AES будет лучше и безопаснее, оба из них уже поддерживаются с тех пор Java6.

Если вам нужно импортировать BouncyCastle lib, я предпочитаю IDEA, это один из самых безопасных алгоритмов, возможно, вы достигли хорошего результата.

Я не дам вам никакого демонстрационного кода, но вы можете легко найти некоторые из них по всему алгоритму, о котором я упомянул.

Ответ 9

Вы можете использовать эти функции для шифрования и дешифрования простого текста

//Encrypt simple text
public String EncryptSimpleText (String text2Encrypt) throws Exception {
    byte[] encryptArray = Base64.getEncoder().encode(text2Encrypt.getBytes());
    return new String(encryptArray,"UTF-8");
}

//Decrypt simple text
public String Decrypt2SimpleText(String textEncrypted) throws Exception {
    byte[] dectryptArray = textEncrypted.getBytes();
    byte[] decarray = Base64.getDecoder().decode(dectryptArray);
    return new String(decarray,"UTF-8");
}

Ответ 10

Мое предложение: вообще не использовать шифрование. Здесь что-то лучше: (надеюсь)

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

Таким образом, вы можете эффективно узнать, вмешался ли пользователь в текстовый файл с подробной информацией и отобразил сообщение об ошибке, если используется измененная учетная запись. Однако это не мешает пользователю изменять файл, он просто предотвратит использование измененной учетной записи... Я думаю, что вашему компьютеру может понравиться это. Вы также можете сделать: f.setReadOnly(); и когда вы пишете файл, f.setWritable(true, true), то после закрытия выходного потока f.setReadOnly(); снова... Но файл все равно можно заменить, поэтому 1-й и более эффективен. благодаря

Ответ 11

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