Manière la plus simple de crypter un fichier texte dans Java

Essayer cela,... 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 en gros, avant d'écrire sur le fichier vous permet de chiffrer et après lecture, vous aurez besoin de le décrypter.

Un très de base de la méthode de xor les données avec une clé. Cette méthode est symétrique, j'.e, vous pouvez utiliser la même clé pour décoder comme de l'encodage.

Si l'on choisit 1 octet de clé, il est agréable et simple, assez 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);
}

utilisation simple subtitute algorithme de chiffrement, de changer à chaque personnage dans un numéro ou une autre caractère.

1. obtenir tous les caractères de votre chaîne.
2. obtenir la valeur ascii de la chaîne.
3. ajouter la valeur ascii spécifique entier (ce sera votre clé de cryptage).
4. afficher le résultat

Château gonflable Crypto API est un léger cryptography API 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 ) );
}
}

Ma suggestion: ne pas utiliser le chiffrement.
Voici quelque chose de mieux:(je l'espère)

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

Ainsi, vous pouvez réellement savoir si l'utilisateur a modifié le fichier texte avec les détails et afficher un message d'erreur si la altéré compte est utilisé.
Toutefois, Cela n'empêche pas l'utilisateur de modifier le fichier, il suffit de prévenir une altéré compte soit utilisé....Je pense que votre ordinateur enseignant pourrait ressembler à cela.
Vous pouvez aussi faire:
f.setReadOnly();
et quand vous écrivez dans le fichier,
f.setWritable(true,true),
puis, après la fermeture du flux de sortie,
f.setReadOnly();
une fois de plus...
Mais le fichier peut toujours être remplacé, donc le 1er et le plus
Efficace.
Grâce