web-dev-qa-db-fra.com

Le moyen le plus simple de chiffrer un fichier texte en java

Pour mon projet School, je devais montrer que je pouvais utiliser la gestion de fichiers dans un programme. Pour cela, j'ai créé un processus de connexion très simple sur lequel vous pouvez créer un compte qui écrit un nom d'utilisateur et un mot de passe dans un fichier texte situé dans le dossier de ressources. Évidemment, cela n’a aucune sécurité, car il n’a pas été conçu pour être sécurisé, mais uniquement pour montrer la gestion des fichiers. Cependant, mon professeur a dit que je devrais essayer aussi d’ajouter un cryptage au fichier pour obtenir une meilleure note.

J'ai fait des recherches et beaucoup de gens recommandent le DES.

Le problème est que je n'ai plus beaucoup de temps pour mon projet et que je dois le terminer le plus rapidement possible. L'utilisation de DES semble implémenter un certain temps pour implémenter tout le code supplémentaire. 

Dans mon programme, j'utilise un simple lineNumberReader pour lire les fichiers ligne par ligne. Pour écrire dans les fichiers, j'utilise un BufferedWriter. 

Est-il possible de chiffrer ces données très simplement? Cela ne doit pas forcément être très sécurisé, mais je dois montrer que j'ai au moins tenté de chiffrer les données. Le chiffrement et le déchiffrement seraient tous effectués sur la même application, car les données ne sont pas transférées. 

Peut-être un moyen de créer moi-même un algorithme de cryptage et de décryptage très simple?

javasecurityencryptiontext-files
11
Patch

Essayez ceci, ... c'est assez 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");
        }
    }
}

Donc, fondamentalement, avant d’écrire dans un fichier, vous allez chiffrer et après avoir lu, vous devez le déchiffrer.

23
j4rey

Une méthode très basique consisterait à analyser les données avec une clé. Cette méthode est symétrique, c’est-à-dire que vous pouvez utiliser la même clé pour décoder en tant que codage.

Si nous choisissons une clé de 1 octet, c’est simple et assez beau pour le rendre illisible (mais pas du tout sécurisé!):

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

Vous pouvez utiliser un simple chiffre 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();
}
}

Trouvé à http://rosettacode.org/wiki/Caesar_cipher#Java

Notez que Java a des solutions natives pour le chiffrement et lorsqu'il est question de mots de passe, il est préférable de les hacher et de comparer les hachages, car il n'est généralement pas nécessaire de les déchiffrer.

2
flo

Un algorithme d'embrouillage facile et amusant serait la transformation Burrows-Wheeler . Pas vraiment un cryptage sécurisé, mais sérieusement, c'est un travail scolaire et c'est génial.

1
Olavi Mustanoja

utilisez un algorithme de cryptage de sous-titrage simple, modifiez chaque caractère en nombre ou en un autre caractère.

  1. obtenez tous les caractères de votre chaîne.
  2. récupère la valeur ascii de la chaîne.
  3. ajoute la valeur ascii avec un entier spécifique (ce sera votre clé de cryptage)
  4. afficher le résultat
1
pupil

Il y a trop de façons de chiffrer une chaîne simple en Java. S'il s'agit d'un projet scolaire, je ne pense vraiment pas que vous puissiez obtenir une bande supérieure en utilisant simplement des bibliothèques tierces pour terminer le travail crypté.

Si vous avez un peu de temps, vous pourriez essayer de comprendre le fonctionnement de Base64, puis essayez de créer vous-même un algorithme crypté.

Cependant, si vous insistez pour utiliser une API en Java, je dois dire que DES est un moyen vraiment ancien de chiffrer du texte. 3DE (DESede) ou AES seront meilleurs et plus sûrs, les deux étant déjà pris en charge depuis Java6.

Si vous devez importer la bibliothèque BouncyCastle, je préfère IDEA, qui est l’un des algorithmes les plus sûrs. Vous obtiendrez peut-être un bon score.

Je ne vous donnerai pas de code de démonstration, mais vous pouvez facilement en trouver quelques-uns avec Google tout l'algorithme que j'ai mentionné.

0
Bruce_Van

Je ne sais pas qui recommande DES de chiffrer le mot de passe ... Je vous suggère de suivre cette étape si vous voulez impressionner votre professeur:

Cette solution rend votre projet réel et vous pouvez le réutiliser pour passer l'examen de votre futur module de cryptographie :). Sinon, j'aime bien la solution proposée par StanislavL.

Prendre plaisir!

0
Aris2World

Bouncy Castle Crypto API est une API de cryptographie légère 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 ) );
        }
    }
0
Sanjay Kumar