1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

 private void createBtn_Click(object sender, EventArgs e)
        {
            MemoryStream ms = new MemoryStream();
            StreamWriter sw = new StreamWriter(ms);

            Directory.CreateDirectory("profiles/" + profile_name.Text);

            sw.Write(CreateMD5Hash(master_psw.Text));
            sw.Close();

            StreamWriter sw2 = new StreamWriter("profiles/" + profile_name.Text + "/masterpsw.mpsw");

            sw2.Write(Crypten(ms));
            sw2.Close();

            this.Close();
        }

        public CryptoStream Crypten(MemoryStream ms)
        {
            RijndaelManaged RMCrypto = new RijndaelManaged();
            byte[] Key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
            byte[] IV = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };

            CryptoStream CryptStream = new CryptoStream(ms, RMCrypto.CreateEncryptor(Key, IV), CryptoStreamMode.Write);
    // hier passiert der fehler!!! er sagt mir dann Der Stream war nicht schreibbar. Parametername: stream

            return CryptStream;
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

        public String Crypten(MemoryStream ms)
        {
            RijndaelManaged RMCrypto = new RijndaelManaged();
            byte[] Key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
            byte[] IV = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };

            CryptoStream CryptStream = new CryptoStream(ms, RMCrypto.CreateEncryptor(Key, IV), CryptoStreamMode.Read);

            StreamReader sr = new StreamReader(CryptStream);
            String content = sr.ReadToEnd();
            return content;
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

        public String DeCrypten(MemoryStream ms)
        {
            RijndaelManaged RMCrypto = new RijndaelManaged();
            byte[] Key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
            byte[] IV = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };

            CryptoStream CryptStream = new CryptoStream(ms, RMCrypto.CreateDecryptor(Key, IV), CryptoStreamMode.Read);
            
            StreamReader sr = new StreamReader(CryptStream);
            String content = sr.ReadToEnd();
            return content;
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:

        private void createBtn_Click(object sender, EventArgs e)
        {
            Directory.CreateDirectory("profiles/" + profile_name.Text);

            FileStream fs = new FileStream("profiles/" + profile_name.Text + "/masterpsw.mpsw",FileMode.Create);
            StreamWriter sw = new StreamWriter(fs);


            label3.Text = DeCrypten(Crypten(CreateMD5Hash(master_psw.Text))); // TESTAUSGABE!

            //sw.Write(Crypten(CreateMD5Hash(master_psw.Text)));
            sw.Close();

            //this.Close();
        }

        public String Crypten(String toCrypt)
        {
            MemoryStream ms = new MemoryStream();
            StreamWriter sw = new StreamWriter(ms);
            sw.Write(toCrypt);

            RijndaelManaged RMCrypto = new RijndaelManaged();
            byte[] Key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
            byte[] IV = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };

            CryptoStream CryptStream = new CryptoStream(ms, RMCrypto.CreateEncryptor(Key, IV), CryptoStreamMode.Read);

            StreamReader sr = new StreamReader(CryptStream);
            String content = sr.ReadToEnd();
            return content;
        }

        public String DeCrypten(String toDeCrypt)
        {
            MemoryStream ms = new MemoryStream();
            StreamWriter sw = new StreamWriter(ms);
            sw.Write(toDeCrypt);

            RijndaelManaged RMCrypto = new RijndaelManaged();
            byte[] Key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
            byte[] IV = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };

            CryptoStream CryptStream = new CryptoStream(ms, RMCrypto.CreateDecryptor(Key, IV), CryptoStreamMode.Read);
            
            StreamReader sr = new StreamReader(CryptStream);
            String content = sr.ReadToEnd();
            return content;
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:

        public string AESencrypt(string originalstring, string passphrase)
        {
            byte[] initVectorBytes;
            byte[] saltValueBytes;
            byte[] origTextBytes;

            try
            {
                initVectorBytes = Encoding.UTF8.GetBytes("%1B2FdD4e5Fjh9H8"); // muss aus 16 Zeichen bestehen!
                saltValueBytes = Encoding.UTF8.GetBytes("ArcanumAES256"); // Passwort 2
                origTextBytes = Encoding.UTF8.GetBytes(originalstring);

                PasswordDeriveBytes pwd = new PasswordDeriveBytes(passphrase, saltValueBytes, "MD5", 2);
                byte[] keyBytes = pwd.GetBytes(256 / 8);
                RijndaelManaged symKey = new RijndaelManaged();

                symKey.Padding = PaddingMode.ISO10126;
                symKey.Mode = CipherMode.CBC;

                ICryptoTransform encryptor = symKey.CreateEncryptor(keyBytes, initVectorBytes);
                MemoryStream memstr = new MemoryStream();
                CryptoStream crypstr = new CryptoStream(memstr, encryptor, CryptoStreamMode.Write);

                crypstr.Write(origTextBytes, 0, origTextBytes.Length);
                crypstr.FlushFinalBlock();

                byte[] cipherTextBytes = memstr.ToArray();

                memstr.Close();
                crypstr.Close();

                return Convert.ToBase64String(cipherTextBytes);
            }
            catch
            {
                return originalstring;
            }
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:

        public static string encodeText(string sText, string sPassword)
        {
            if(sPassword == "") return "";

            int i=0, j=0, q=0;
            int nLetter;
            string buffer;
            string sResult1 = "", sResult2 = "";

            while (i < sText.Length)
            {
                nLetter = sText[i];
                nLetter += q + sPassword[j];
                buffer = nLetter.ToString("000");
                sResult1 += buffer;

                if (j < sPassword.Length - 1) j++; else j = 0;  
                i++;
                q = (int)Math.Abs(Math.Sin(i / 10.0f) * 5);
            }

            i=0;int k;
            while(i < sResult1.Length)
            {
                buffer = "";
                for(k=0;k<2;k++)
                {
                    if (i + k < sResult1.Length)
                        buffer += sResult1[i + k];
                    else
                    {
                        break;
                    }
                }

                nLetter = Convert.ToInt32(buffer);
                if(nLetter >= 58 && nLetter <= 99 || nLetter >= 33 && nLetter <= 47)
                    sResult2 += (char)nLetter;
                else if(nLetter >= 0 && nLetter <= 32 || nLetter >= 48 && nLetter <= 57 )
                    sResult2 += (char)(nLetter + 161);
                else
                    sResult2 += buffer;

                i+=2;
            }
            return sResult2;
        }

        public static string decodeText(string sText, string sPassword)
        {
            if(sPassword == "") return sText;

            int i=0, j=0;
            int nLetter;
            string buffer;
            string sResult1 = "", sResult2 = "";

            while (i < sText.Length)
            {
                nLetter = sText[i];
                if(nLetter >= 58 && nLetter <= 99 || nLetter >= 33 && nLetter <= 47)
                {
                    buffer = nLetter.ToString("00");
                    sResult1 += buffer;
                }
                else if(nLetter > 127)
                {
                    buffer = (nLetter - 161).ToString("00");
                    sResult1 += buffer;
                }
                else
                    sResult1 += sText[i];

                i++;
            }

            int nLen = sResult1.Length;
            char tmp;
            if(nLen % 3 != 0)
            {

                tmp = sResult1[nLen-1];
                sResult1 = sResult1.Remove(nLen - 2);
                sResult1 += tmp;
            }

            i = 0; int k, q = 0; 
            while (i < sResult1.Length)
            {
                buffer = "";
                for(k=0;k<3;k++)
                {
                    if (i + k < sResult1.Length)
                        buffer += sResult1[i + k];
                    else
                    {
                        break;
                    }
                }

                try
                {
                    nLetter = Convert.ToInt32(buffer) - q - sPassword[j];
                }
                catch
                {
                    return "";
                }

                sResult2 += (char)nLetter;

                if (j < sPassword.Length - 1) j++; else j = 0; 
                i+=3;
                q = (int)Math.Abs(Math.Sin(i / 30.0f) * 5);
            }
            return sResult2;
        }