[C# 2010] File Cryption Class

03/23/2013 13:47 King Sora#1
Heyho!

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.. :D

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:
[Only registered and activated users can see links. Click Here To Register...]

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;
        }
    }
} 
In der Klasse werden die WindowsForms nur für die Ausgabe der Fehler benutzt! Wenn ihr die Fehler anders ausgeben wollt, dann funktioniert sie problemlos auch ohne WindowsForms!

Im Anhang habe ich euch das Programm und die Klasse hochgeladen!
Ich wünsche euch viel Spaß damit und bitte euch um Feedback!!
[Only registered and activated users can see links. Click Here To Register...]

[Only registered and activated users can see links. Click Here To Register...]
03/23/2013 14:41 Schlüsselbein#2
Ohne mir die Verschlüsselung genauer angesehen zu haben:
Quote:
In der Klasse werden die WindowsForms nur für die Ausgabe der Fehler benutzt!
Das ist schlecht. Lass die Klasse ne Exception werfen oder so, aber lass sie unabängig ner GUI oder ähnlichem. Auch Messageboxen sind hier schlecht.

Benutze ausserdem die Standard-Notation von .NET. Klasse und Methoden also CamelCase formatieren.
03/23/2013 15:10 King Sora#3
Quote:
Originally Posted by Schlüsselbein View Post
Ohne mir die Verschlüsselung genauer angesehen zu haben:

Das ist schlecht. Lass die Klasse ne Exception werfen oder so, aber lass sie unabängig ner GUI oder ähnlichem. Auch Messageboxen sind hier schlecht.

Benutze ausserdem die Standard-Notation von .NET. Klasse und Methoden also CamelCase formatieren.
Ja... ich weiß!.. Desshalb habe ich das auch dazu geschrieben. Es war nur dazu gedacht, um Fehler deutlich anzuzeigen. Die Klasse funktionier auch sehr gut ohne.

Kannst du mir das genauer erklären? Entschuldige falls das Pflichtwissen ist.

Die WindowsForms werden nur wegen den Messageboxen benutzt. Wie gesagt, sie sollten die Fehler nur genau erklärn.. funktionieren würde es ohne sie auch.

Ich danke dir sehr für dein Feedback! Wenn du Zeit findest kannst du mir zur Verschlüsselung auch noch etwas schreiben :)

MfG. Sora
03/23/2013 15:20 Schlüsselbein#4
[Only registered and activated users can see links. Click Here To Register...]
Hier steht nach erstem Suchen eigentlich alles wichtige. Unten sind noch weiterführende Links. Vorteil ist halt ganz klar, dass man die Klasse dann auch einfach in ner Konsolen-, Web, -WPF, -GTK-Applikation benutzen kann.
Was, wenn jemand den Fehler anders behandeln will? Wenn jemand den Fehler einfach in nen Log schreiben möchte? Wenn jemand den Fehler in ner anderen Sprache ausgeben möchste usw. usf. ich denke du weißt, warum es wichtig ist.

Zum zweiten Punkt: [Only registered and activated users can see links. Click Here To Register...]

Quote:
Wenn du Zeit findest kannst du mir zur Verschlüsselung auch noch etwas schreiben
Zeitlich wirds eher schlecht. Aber es gibt hier genügend kompetente User, welche dazu sicher ihre Kritik abgeben werden.




Gruß
03/29/2013 04:00 King Sora#5
Danke für die Links! Haben geholfen :)

Quote:
Originally Posted by Schlüsselbein View Post
Aber es gibt hier genügend kompetente User, welche dazu sicher ihre Kritik abgeben werden.
Gruß
Das möchte ich hoffen... Mich würde es nämlich sehr interessieren was jemand darüber denkt der sich mit sowas sehr gut auskennt.

MfG.