it-swarm.com.de

Einfachste Möglichkeit, eine Textdatei in Java zu verschlüsseln

Für mein Schulprojekt musste ich zeigen, dass ich die Dateibearbeitung innerhalb eines Programms nutzen kann. Dafür habe ich einen sehr einfachen Anmeldeprozess vorgenommen, mit dem Sie ein Konto erstellen können, das einen Benutzernamen und ein Kennwort in eine Textdatei schreibt, die sich im Ressourcenordner befindet. Offensichtlich hat dies keinerlei Sicherheit, da es nicht darauf ausgelegt war, nur die Dateiverarbeitung zu demonstrieren. Mein Lehrer hat jedoch gesagt, ich sollte versuchen, die Datei auch mit einer Verschlüsselung zu versehen, um eine bessere Note zu erhalten.

Ich habe einige Nachforschungen angestellt und viele Leute empfehlen DES.

Das Problem, das ich habe, ist, dass ich nicht mehr viel Zeit für mein Projekt habe und es so schnell wie möglich beenden muss. Die Verwendung von DES scheint eine Weile zu dauern, um den zusätzlichen Code zu implementieren. 

In meinem Programm verwende ich einen einfachen lineNumberReader, um die Dateien Zeile für Zeile zu lesen. Um in die Dateien zu schreiben, verwende ich einen BufferedWriter. 

Gibt es sowieso sehr einfach, diese Daten zu verschlüsseln? Es muss nicht sehr sicher sein, aber ich muss zeigen, dass ich zumindest versucht habe, die Daten zu verschlüsseln. Die Ver- und Entschlüsselung würde in derselben Anwendung ausgeführt, da keine Daten übertragen werden. 

Möglicherweise kann ich selbst einen sehr einfachen Verschlüsselungs- und Entschlüsselungsalgorithmus erstellen?

11
Patch

Versuchen Sie das ... Es ist ziemlich einfach

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

Grundsätzlich werden Sie vor dem Schreiben in eine Datei verschlüsseln und nach dem Lesen müssen Sie sie entschlüsseln.

23
j4rey

Eine sehr grundlegende Methode wäre, die Daten mit einem Schlüssel zu kennzeichnen. Diese Methode ist symmetrisch, d. H. Sie können zum Kodieren denselben Schlüssel verwenden wie für die Kodierung.

Wenn wir einen 1-Byte-Schlüssel wählen, ist er nett und einfach genug, um ihn unlesbar zu machen (aber überhaupt nicht sicher!)

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

Sie könnten eine einfache Ceasar-Chiffre verwenden ( 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();
}
}

Gefunden bei http://rosettacode.org/wiki/Caesar_cipher#Java

Beachten Sie, dass Java native Lösungen für die Verschlüsselung bietet. Wenn es um Kennwörter geht, ist es viel besser, sie zu hashieren und Hashes zu vergleichen, da sie normalerweise nicht entschlüsselt werden müssen.

2
flo

Ein einfacher und unterhaltsamer Verschlüsselungsalgorithmus wäre die Burrows-Wheeler-Transformation . Nicht wirklich eine sichere Verschlüsselung, aber im Ernst, es ist eine Schularbeit und das ist großartig.

1
Olavi Mustanoja

verwenden Sie einfache Untertitelverschlüsselungsalgorithmen. Ändern Sie jedes Zeichen in ein anderes Zeichen.

  1. holen Sie sich jedes Zeichen Ihrer Zeichenfolge.
  2. ruft den ASCII-Wert der Zeichenfolge ab.
  3. addiere den ASCII-Wert mit einer bestimmten Ganzzahl (dies ist dein Verschlüsselungsschlüssel)
  4. ergebnis anzeigen
1
pupil

Es gibt zu viele Möglichkeiten, eine einfache Zeichenfolge in Java zu verschlüsseln. Wenn es sich um ein Schulprojekt handelt, glaube ich wirklich nicht, dass Sie eine höhere Band erreichen können, indem Sie einfach einige Drittanbieter-Libs verwenden, um die verschlüsselte Arbeit zu beenden.

Wenn Sie etwas Zeit haben, können Sie versuchen, die Funktionsweise von Base64 zu verstehen, und dann selbst einen verschlüsselten Algorithmus erstellen.

Wenn Sie jedoch darauf bestehen, eine API in Java zu verwenden, muss ich sagen, dass DES ein wirklich alter Weg zu verschlüsseltem Text ist seit Java6.

Wenn Sie die BouncyCastle-Bibliothek importieren müssen, bevorzuge ich IDEA. Dies ist einer der sichersten Algorithmen. Möglicherweise haben Sie eine gute Punktzahl erreicht.

Ich gebe Ihnen keinen Demo-Code, aber Sie können alle von mir genannten Algorithmen leicht finden.

0
Bruce_Van

Ich weiß nicht, wer empfiehlt DES, das Passwort zu verschlüsseln ... Ich empfehle Ihnen, diesen Schritt zu befolgen, wenn Sie Ihren Lehrer beeindrucken möchten:

  • nennen Sie Ihre Referenz als theoretische Unterstützung für Ihre kryptografische Lösung. Ich empfehle Ihnen dieses OWSAP - Kennwortspeicher-Spickzettel
  • erklären Sie, wo Ihr Code den Spezifikationen entspricht. Für ein gutes Tutorial mit Beispielcode empfehle ich Ihnen diesen Secure Password Hash

Diese Lösung macht Ihr Projekt real und Sie können es wiederverwenden, um die Prüfung Ihres zukünftigen Crypto-Moduls zu bestehen :). Ansonsten gefällt mir die von StanislavL vorgeschlagene Lösung.

Genießen!

0
Aris2World

Bouncy Castle Crypto API ist eine leichtgewichtige Kryptografie-API in 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 ) );
        }
    }
0
Sanjay Kumar

mit dieser Funktion können Sie einfachen Text ver- und entschlüsseln

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