Ich will ein kleines Programm schreiben, was eine Datei mit einen Schlüssel XOR-Verknüpft. Hat keinen tieferen Sinn, nur zum Spaß.
Bei Textdateien funktioniert es gut, nur bei Binärdateien kommen manchmal falsche Byte's raus.
Und ich habe keine Ahnung warum es bei den einen funktioniert und bei den anderen nicht.
Die Datei wird um zu verhindern dass der RAM ausgeht in 32Bit-Blöcken gelesen/verarbeitet/geschrieben.
Diese Klasse chiffriert die Blöcke.
Diese Klasse (die einzige public im Package) startet den Vorgang.
Diese ließt die Blöcke nacheinander ein:
Diese enthält einfach nur das Passwort.
Und diese schreibt anschließend die neuen Blöcke in die neue Datei:
Hat zufällig irgendjemand eine Idee, woran das liegen könnte?
Bei Textdateien funktioniert es gut, nur bei Binärdateien kommen manchmal falsche Byte's raus.
Und ich habe keine Ahnung warum es bei den einen funktioniert und bei den anderen nicht.
Die Datei wird um zu verhindern dass der RAM ausgeht in 32Bit-Blöcken gelesen/verarbeitet/geschrieben.
Diese Klasse chiffriert die Blöcke.
Java:
package crypt;
class Crypt
{
static String run(String block, Password password)
{
password.setPasswordLenght(block.length());
String pass = password.getPassword();
String result = null;
String cryptText = null;
for(int i = 0; i < block.length(); i++)
{
int blockPiece = (int)block.substring(i, i + 1).charAt(0);
int passPiece = (int)pass.substring(i, i + 1).charAt(0);
String binaryBlockPiece = Integer.toBinaryString(blockPiece);
while(binaryBlockPiece.length() < 8)
binaryBlockPiece = "0".concat(binaryBlockPiece);
String binaryPassPiece = Integer.toBinaryString(passPiece);
while(binaryPassPiece.length() < 8)
binaryPassPiece = "0".concat(binaryPassPiece);
for(int j = 0; j < 8; j++)
{
char binaryBlockPieceChar = binaryBlockPiece.charAt(j);
char binaryPassPieceChar = binaryPassPiece.charAt(j);
String value = "1";
if(binaryBlockPieceChar != binaryPassPieceChar)
value = "0";
if(cryptText == null)
cryptText = value;
else
cryptText = cryptText.concat(value);
}
}
for(int i = 0; i < cryptText.length(); i+=8)
{
int cryptTextPart = (int)Integer.parseInt(
cryptText.substring(i, i + 8), 2);
if(result == null)
result = String.valueOf((char)cryptTextPart);
else
result = result.concat(String.valueOf((char)cryptTextPart));
}
return(result);
}
}Diese Klasse (die einzige public im Package) startet den Vorgang.
Java:
package crypt;
import java.io.File;
public class StartCrypt
{
public StartCrypt(File f, String string)
{
ReadFile readFile = new ReadFile();
readFile.connect(f);
WriteFile writeFile = new WriteFile();
writeFile.connect(f);
Password pass = new Password(string);
String readLine = null;
while((readLine = readFile.read(f, 32, ReadFile.RETURN_TYP_AS_STRING))
!= null)
{
String cryptText = Crypt.run(readLine, pass);
writeFile.write(cryptText);
}
readFile.close();
writeFile.close();
}
}Diese ließt die Blöcke nacheinander ein:
Java:
package crypt;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
class ReadFile
{
private FileInputStream fileInputStream;
private BufferedInputStream bufferedInputStream;
static final byte RETURN_TYP_AS_STRING = 0;
public ReadFile()
{
super();
}
public void connect(File fileToOpen)
{
if(!fileToOpen.exists())
{
new FileNotFoundException("File not Found").printStackTrace();
return;
}
try
{
this.fileInputStream = new FileInputStream(fileToOpen);
this.bufferedInputStream = new BufferedInputStream(
this.fileInputStream);
}
catch(Exception e)
{
// TODO: handle exception
}
}
public String read(File fileToOpen, int blockLenght, byte returnTyp)
{
String line = null;
try
{
int readChar = 0;
for(int i = 0; i < blockLenght &&
((readChar = this.bufferedInputStream.read()) != -1); i++)
{
if(returnTyp == ReadFile.RETURN_TYP_AS_STRING)
{
if(line == null)
line = String.valueOf((char)readChar);
else
line = line.concat(String.valueOf((char)readChar));
}
}
}
catch(Exception e)
{
e.printStackTrace();
}
return(line);
}
public void close()
{
try
{
this.bufferedInputStream.close();
this.fileInputStream.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}Diese enthält einfach nur das Passwort.
Java:
package crypt;
class Password
{
private String password;
Password(String pass)
{
super();
this.password = pass;
}
public void setPasswordLenght(int keylenght)
{
if(this.password.length() != keylenght)
{
while(this.password.length() < keylenght)
this.password = this.password.concat(this.password);
this.password = this.password.substring(0, keylenght);
}
}
public String getPassword()
{
return(this.password);
}
}Und diese schreibt anschließend die neuen Blöcke in die neue Datei:
Java:
package crypt;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
class WriteFile
{
private FileOutputStream fileOutputStream;
private BufferedOutputStream bufferedOutputStream;
WriteFile()
{
super();
}
public void connect(File fileToOpen)
{
File newFile = new File(fileToOpen.getAbsolutePath().concat(".crypt"));
if(newFile.exists())
newFile.delete();
try
{
newFile.createNewFile();
}
catch(Exception e)
{
e.printStackTrace();
}
try
{
this.fileOutputStream = new FileOutputStream(newFile);
this.bufferedOutputStream = new BufferedOutputStream(
this.fileOutputStream);
}
catch(Exception e)
{
// TODO: handle exception
}
}
public void write(String toWrite)
{
try
{
this.bufferedOutputStream.write(toWrite.getBytes());
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void close()
{
try
{
this.bufferedOutputStream.flush();
this.fileOutputStream.flush();
this.bufferedOutputStream.close();
this.fileOutputStream.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}Hat zufällig irgendjemand eine Idee, woran das liegen könnte?
