![[C# 2010] File Cryption Class](https://www.elitepvpers.com/forum/iconimages/coding-releases/c-2010-file-cryption-class_ltr.gif){kind=small}
Das hier ist mein erstes release in der Coding-Section! Ich habe mich in meiner Freizeit mal für eine kurze Zeit hingesetzt und ein Programm zum verschlüsseln von Dateien geschrieben!
Ich release hier die Klasse zum ver- und entschlüsseln und das Programm.
Das Programm ist komplett selbst geschrieben, ich habe keine ausschnitte aus Google o.ä. benutzt!
Es ist mein erster Versuch etwas zu verschlüsseln und ich würde euch bitten mir ein
Feedback zu dieser Verschlüsselung zu geben! (sicher, unsicher, gut, schlecht)
Ich kann das nämlich noch nicht zu gut einschätzen..
Um das Programm ausführen zu können, braucht ihr Framework 4.0 oder höher!
Das Programm kann gleichzeitig ent- und verschlüsseln!
Screen:
fileCryption Class:
PHP Code:
using System;
using System.IO;
using System.Windows.Forms;
class fileCryption
{
/*############################# */
/*########### Core ############ */
/*############################# */
public bool enCode(string srcFile, string dstFile, string _key, bool repRequest)
{
if (this.enC_check(srcFile, dstFile, _key) == false)
{ return false; }
FileInfo fileinfo = new FileInfo(srcFile);
char[] key = _key.ToCharArray();
byte[] originalBytes = File.ReadAllBytes(srcFile);
byte[] verschlBytes = new byte[originalBytes.Length + (fileinfo.Name.Length - fileinfo.Extension.Length) + fileinfo.Extension.Length + 3];
char[] srcNam = fileinfo.Name.ToCharArray();
this.enCode_originalBytes(originalBytes, verschlBytes, this.key_calcValue(key));
this.enCode_srcNam(originalBytes, verschlBytes, srcNam);
this.enCode_reverse_verschlBytes(originalBytes, verschlBytes);
Array.Reverse(verschlBytes);
this.enCode_permutation(ref verschlBytes, key);
if (this.fileWrite(dstFile, verschlBytes, repRequest) == false)
{ return false; }
else
{ return true; }
}
public bool deCode(string srcFile, string dstPath, string _key, bool repRequest)
{
if (this.deC_check(srcFile, dstPath, _key) == false)
{ return false; }
FileInfo fileinfo = new FileInfo(srcFile);
char[] key = _key.ToCharArray();
byte[] verschlBytes = File.ReadAllBytes(srcFile);
this.deCode_permutation(ref verschlBytes, key);
Array.Reverse(verschlBytes);
this.deCode_reverse_verschlBytes(verschlBytes);
string srcNam = this.deCode_srcNam(verschlBytes);
if (srcNam == null || srcNam == "")
{ MessageBox.Show("Die Datei hat das falsche Format oder der Schlüssel ist falsch!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return false; }
dstPath += srcNam;
this.deCode_srcNam_bytes(ref verschlBytes, srcNam);
this.deCode_verschlBytes(ref verschlBytes, this.key_calcValue(key));
if (this.fileWrite(dstPath, verschlBytes, repRequest) == false)
{ return false; }
else
{ return true; }
}
public bool fileWrite(string dstFile, byte[] verschlBytes, bool repRequest)
{
if (!File.Exists(dstFile))
{
try
{ File.WriteAllBytes(dstFile, verschlBytes); return true; }
catch
{ return false; }
}
else
{
if (repRequest == true)
{
DialogResult ersetzen = MessageBox.Show("Die Datei:" + "\n" + dstFile + "\n" + "existiert bereits, möchtest du diese Datei ersetzen?", "Datei ersetzen", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2);
if (ersetzen == DialogResult.Yes)
{
try
{ File.WriteAllBytes(dstFile, verschlBytes); return true; }
catch
{ return false; }
}
else if (ersetzen == DialogResult.No)
{ return false; }
}
else if (repRequest == false)
{
try
{ File.WriteAllBytes(dstFile, verschlBytes); return true; }
catch
{ return false; }
}
return false;
}
}
/*############################# */
/*###### Verschlüsselung ###### */
/*############################# */
private byte[] enCode_reverse_verschlBytes(byte[] originalBytes, byte[] verschlBytes)
{
int foreachCount = 0;
foreach (byte b in verschlBytes)
{
verschlBytes[foreachCount] = (byte)(~b);
foreachCount++;
}
return verschlBytes;
}
private byte[] enCode_srcNam(byte[] originalBytes, byte[] verschlBytes, char[] srcNam)
{
char[] namLen = srcNam.Length.ToString("000").ToCharArray();
for (int i = originalBytes.Length; i < verschlBytes.Length-3; i++)
{
verschlBytes[i] = (byte)((char)(srcNam[i - originalBytes.Length]));
}
for (int i = 0; i < 3; i++)
{
verschlBytes[(verschlBytes.Length - 3) +i] = (byte)(namLen[i]);
}
return verschlBytes;
}
private byte[] enCode_originalBytes(byte[] originalBytes, byte[] verschlBytes, int wert)
{
int foreachCount = 0;
foreach (byte b in originalBytes)
{
verschlBytes[foreachCount] = (byte)(this.byteOverflow(b + wert));
foreachCount++;
}
return verschlBytes;
}
private byte[] enCode_permutation(ref byte[] verschlBytes, char[] key)
{
int round_one = 0;
int round_two = 1;
int round_thr = 2;
int additiv = 3;
int foreachCount = 0;
foreach (byte b in verschlBytes)
{
if (foreachCount == round_one)
{
for (int i = 0; i < this.key_roundValue(key); i++)
{
verschlBytes[foreachCount] = (byte)((b >> 2 ^ b << 6) ^ (key[1]));
}
round_one += additiv;
}
if (foreachCount == round_two)
{
for (int i = 0; i < this.key_roundValue(key); i++)
{
verschlBytes[foreachCount] = (byte)((b >> 2 ^ b << 6) ^ (key[3]));
}
round_two += additiv;
}
if (foreachCount == round_thr)
{
for (int i = 0; i < this.key_roundValue(key); i++)
{
verschlBytes[foreachCount] = (byte)((b >> 2 ^ b << 6) ^ (key[5]));
}
round_thr += additiv;
}
foreachCount++;
additiv += 1;
}
return verschlBytes;
}
/*############################# */
/*###### Entschlüsselung ###### */
/*############################# */
private byte[] deCode_reverse_verschlBytes(byte[] verschlBytes)
{
int foreachCount = 0;
foreach (byte b in verschlBytes)
{
verschlBytes[foreachCount] = (byte)(~b);
foreachCount++;
}
return verschlBytes;
}
private string deCode_srcNam(byte[] verschlBytes)
{
string srcNam = null;
char[] sourceName;
char[] lenChars = new char[3];
for (int i = 0; i < 3; i++)
{
lenChars[i] = (char)(verschlBytes[(verschlBytes.Length - 3) + i]);
}
string dumpLen = null;
foreach (char c in lenChars)
{
dumpLen += (c.ToString());
}
int nameLength = 0;
try
{
nameLength = int.Parse(dumpLen);
}
catch
{
return null;
}
sourceName = new char[nameLength];
for (int i = 0; i < nameLength; i++ )
{
sourceName[i] = (char)verschlBytes[(verschlBytes.Length-3) - i-1];
}
Array.Reverse(sourceName);
for (int i = 0; i < nameLength; i++)
{
srcNam += sourceName[i].ToString();
}
return srcNam;
}
private byte[] deCode_srcNam_bytes(ref byte[] verschlBytes, string srcNam)
{
byte[] verschlBytes_new = verschlBytes;
verschlBytes = new byte[verschlBytes.Length - srcNam.Length - 3];
int foreachCount = 0;
foreach (byte b in verschlBytes)
{
verschlBytes[foreachCount] = verschlBytes_new[foreachCount];
foreachCount++;
}
return verschlBytes;
}
private byte[] deCode_verschlBytes(ref byte[] verschlBytes, int wert)
{
int foreachCount = 0;
foreach (byte b in verschlBytes)
{
verschlBytes[foreachCount] = (byte)(this.byteOverflow(b - wert));
foreachCount++;
}
return verschlBytes;
}
private byte[] deCode_permutation(ref byte[] verschlBytes, char[] key)
{
int round_one = 0;
int round_two = 1;
int round_thr = 2;
int additiv = 3;
int foreachCount = 0;
foreach (byte b in verschlBytes)
{
if (foreachCount == round_one)
{
for (int i = 0; i < this.key_roundValue(key); i++)
{
verschlBytes[foreachCount] = (byte)(b ^ (key[1]));
verschlBytes[foreachCount] = (byte)((verschlBytes[foreachCount] << 2 ^ verschlBytes[foreachCount] >> 6));
}
round_one += additiv;
}
if (foreachCount == round_two)
{
for (int i = 0; i < this.key_roundValue(key); i++)
{
verschlBytes[foreachCount] = (byte)(b ^ (key[3]));
verschlBytes[foreachCount] = (byte)((verschlBytes[foreachCount] << 2 ^ verschlBytes[foreachCount] >> 6));
}
round_two += additiv;
}
if (foreachCount == round_thr)
{
for (int i = 0; i < this.key_roundValue(key); i++)
{
verschlBytes[foreachCount] = (byte)(b ^ (key[5]));
verschlBytes[foreachCount] = (byte)((verschlBytes[foreachCount] << 2 ^ verschlBytes[foreachCount] >> 6));
}
round_thr += additiv;
}
foreachCount++;
additiv += 1;
}
return verschlBytes;
}
/*############################# */
/*######## Allgemeines ######## */
/*############################# */
private int key_calcValue(char[] key)
{
int calcValue = 0;
int foreachCount = 0;
foreach (byte b in key)
{
calcValue += (int)(b);
if (foreachCount == 3)
{
calcValue += (int)(b);
}
foreachCount++;
}
return calcValue;
}
private int key_roundValue(char[] key)
{
int rounds = 0;
foreach (byte b in key)
{
rounds += (int)((b/2) + Math.PI);
}
return rounds;
}
private byte byteOverflow(int oldByte)
{
byte newByte;
if (oldByte > 255)
{
newByte = (byte)(oldByte - 255);
}
else if (oldByte < 0)
{
newByte = (byte)(oldByte + 255);
}
else
{
newByte = (byte)oldByte;
}
return newByte;
}
/*############################# */
/*########### Checks ########## */
/*############################# */
private bool enC_check(string srcFile, string dstFile, string key)
{
if (srcFile == "" || !File.Exists(srcFile) == true)
{
MessageBox.Show("Bitte einen gültigen Dateipfad angeben!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
if (key == "" || key.Length != 6)
{
MessageBox.Show("Bitte einen gültigen Schlüssel angeben!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Stop);
return false;
}
if (dstFile == "")
{
MessageBox.Show("Bitte ein gültiges Speicherverzeichnis mit Dateinamen angeben!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
else
{
return true;
}
}
private bool deC_check(string srcFile, string dstPath, string key)
{
if (srcFile == "" || srcFile == "Datei per Drag & Drop reinziehen oder auswählen" || !File.Exists(srcFile) == true)
{
MessageBox.Show("Bitte einen gültigen Dateipfad angeben!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
if (key == "" || key.Length != 6)
{
MessageBox.Show("Bitte einen gültigen Entschlüsselungs-Schlüssel eingeben!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Stop);
return false;
}
if (dstPath == "" || !Directory.Exists(dstPath) == true)
{
MessageBox.Show("Das Ausgabeverzeichnis ist nicht verfügbar oder existiert nicht!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
else
{
return true;
}
}
}
Im Anhang habe ich euch das Programm und die Klasse hochgeladen!
Ich wünsche euch viel Spaß damit und bitte euch um Feedback!!
