Enctypting stuff

[joppiesaus]

Hi, I am working on a class to encrypt my save files for a console RPG.
Right now it works simple: Characters are just getting replaced by other characters.

Spoiler:

Code: Select all

        public string convert(string pathFrom, bool from)
        {
            check(pathFrom);
            string result;

            using (StreamReader read = new StreamReader(pathFrom))
            {
                result = read.ReadToEnd();
            }


            if (from)
            {
                result = result.Replace('0', '-');
                result = result.Replace('1', '_');
                result = result.Replace('2', '+');
                result = result.Replace('3', '|');
                result = result.Replace('4', '\\');
                result = result.Replace('5', '{');
                result = result.Replace('6', '}');
                result = result.Replace('7', ',');
                result = result.Replace('8', '.');
                result = result.Replace('9', '"');
                result = result.Replace('[', '\'');
                result = result.Replace(']', 'ä');
                result = result.Replace('=', 'ç');

                result = result.Replace('a', '»');
                result = result.Replace('b', '%');
                result = result.Replace('c', ';');
                result = result.Replace('d', '©');
                result = result.Replace('e', 'ð');
                result = result.Replace('f', '¿');
                result = result.Replace('g', 'å');
                result = result.Replace('h', '~');
                result = result.Replace('i', '¼');
                result = result.Replace('j', '«');
                result = result.Replace('k', ':');
                result = result.Replace('l', '¶');
                result = result.Replace('m', 'ö');
                result = result.Replace('n', '’');
                result = result.Replace('o', '¾');
                result = result.Replace('p', '×');
                result = result.Replace('q', '@');
                result = result.Replace('r', '²');
                result = result.Replace('s', '¡');
                result = result.Replace('t', '!');
                result = result.Replace('u', '³');
                result = result.Replace('v', '#');
                result = result.Replace('w', '¤');
                result = result.Replace('x', '€');
                result = result.Replace('y', '^');
                result = result.Replace('z', 'æ');
                result = result.Replace(' ', 'í');
            }
            else
            {
                result = result.Replace('-', '0');
                result = result.Replace('_', '1');
                result = result.Replace('+', '2');
                result = result.Replace('|', '3');
                result = result.Replace('\\', '4');
                result = result.Replace('{', '5');
                result = result.Replace('}', '6');
                result = result.Replace(',', '7');
                result = result.Replace('.', '8');
                result = result.Replace('"', '9');
                result = result.Replace('\'', '[');
                result = result.Replace('ä', ']');
                result = result.Replace('ç', '=');

                result = result.Replace('»', 'a');
                result = result.Replace('%', 'b');
                result = result.Replace(';', 'c');
                result = result.Replace('©', 'd');
                result = result.Replace('ð', 'e');
                result = result.Replace('¿', 'f');
                result = result.Replace('å', 'g');
                result = result.Replace('~', 'h');
                result = result.Replace('¼', 'i');
                result = result.Replace('«', 'j');
                result = result.Replace(':', 'k');
                result = result.Replace('¶', 'l');
                result = result.Replace('ö', 'm');
                result = result.Replace('’', 'n');
                result = result.Replace('¾', 'o');
                result = result.Replace('×', 'p');
                result = result.Replace('@', 'q');
                result = result.Replace('²', 'r');
                result = result.Replace('¡', 's');
                result = result.Replace('!', 't');
                result = result.Replace('³', 'u');
                result = result.Replace('#', 'v');
                result = result.Replace('¤', 'w');
                result = result.Replace('€', 'x');
                result = result.Replace('^', 'y');
                result = result.Replace('æ', 'z');
                result = result.Replace('í', ' ');
            }

            return result;
        }
    }

Spoiler:

So this:

Code: Select all

[victim]
name=you can decrypt me easyly
age=12
money=10000
weapon=none
armor=none
power=being decrypted easyly
awards=none
won=0


Becomes this:

Code: Select all

'#¼;!¼öä
’»öðç^¾³í;»’í©ð;²^×!íöðíð»¡^¶^
»åðç_+
ö¾’ð^ç_----
¤ð»×¾’ç’¾’ð
»²ö¾²ç’¾’ð
×¾¤ð²ç%ð¼’åí©ð;²^×!ð©íð»¡^¶^
»¤»²©¡ç’¾’ð
¤¾’ç-


Is there any way to make it harder to decrypt?(Not that a character is just replaced by another and that is always the same, but more random).

[ismellike]

This is something similar to what I used for encrypting my save file.

http://support.microsoft.com/kb/307010

[joppiesaus]

Thank you! I think I would use this.

[joppiesaus]

I didn't use your encryption stuff, but instead I coded myself one, I need only to randomize it more(the hard part)
It works great. No errors, but you can change the first part in the TXT file if you know the codes, but later not(see the random outputint)
I want to improve that.

Spoiler:

Code: Select all

using System;
using System.Numerics;

namespace Encryption
{
    /// <summary>
    /// Generates a new class "Communicate64Encryption". Made by: Joppiesaus
    /// </summary>
    public class Communicate64Encryption
    {
        public Communicate64Encryption()
        {

        }

        /// <summary>
        /// Encrypts the string to Communicate64.
        /// </summary>
        /// <param name="input">Input string that needs to be encrypted</param>
        /// <returns>Output string that is encrypted to Communicate64</returns>
        public string encrypt(string input)
        {
            input = input.ToLower();
            input = input.Replace(",", "");

            //numbers
            input = input.Replace(System.Environment.NewLine, "ENTER");
            input = input.Replace(" ", "SPACE");
            input = input.Replace("0", "ZERO");
            input = input.Replace("1", "ONE");
            input = input.Replace("2", "TWO");
            input = input.Replace("3", "THREE");
            input = input.Replace("4", "FOUR");
            input = input.Replace("5", "FIVE");
            input = input.Replace("6", "SIX");
            input = input.Replace("7", "SEVEN");
            input = input.Replace("8", "EIGHT");
            input = input.Replace("9", "NINE");

            //char's
            input = input.Replace("a", "12");
            input = input.Replace("b", "13");
            input = input.Replace("c", "14");
            input = input.Replace("d", "15");
            input = input.Replace("e", "16");
            input = input.Replace("f", "17");
            input = input.Replace("g", "18");
            input = input.Replace("h", "19");
            input = input.Replace("i", "20");
            input = input.Replace("j", "21");
            input = input.Replace("k", "22");
            input = input.Replace("l", "23");
            input = input.Replace("m", "24");
            input = input.Replace("n", "25");
            input = input.Replace("o", "26");
            input = input.Replace("p", "27");
            input = input.Replace("q", "28");
            input = input.Replace("r", "29");
            input = input.Replace("s", "30");
            input = input.Replace("t", "31");
            input = input.Replace("u", "32");
            input = input.Replace("v", "33");
            input = input.Replace("w", "34");
            input = input.Replace("x", "35");
            input = input.Replace("y", "36");
            input = input.Replace("z", "37");

            //div
            input = input.Replace("!", "38");
            input = input.Replace("[", "39");
            input = input.Replace("]", "40");
            input = input.Replace("=", "41");
            input = input.Replace(".", "42");
            input = input.Replace("&", "43");
            input = input.Replace("@", "44");

            input = input.Replace("ENTER", "00");
            input = input.Replace("SPACE", "01");
            input = input.Replace("ZERO", "02");
            input = input.Replace("ONE", "03");
            input = input.Replace("TWO", "04");
            input = input.Replace("THREE", "05");
            input = input.Replace("FOUR", "06");
            input = input.Replace("FIVE", "07");
            input = input.Replace("SIX", "08");
            input = input.Replace("SEVEN", "09");
            input = input.Replace("EIGHT", "10");
            input = input.Replace("NINE", "11");

            input = input.Insert(0, "1");


            //tweak the length
            int length = input.Length;
            while (length < 7)
            {
                length++;
            }

            //secret formulla
            BigInteger outputInt = BigInteger.Parse(input);

            Random rand = new Random(length);

            outputInt += (rand.Next(1, 10000000)^9);

            return outputInt.ToString();
        }

        /// <summary>
        /// Decrypts the string from Communicate64 to a string.
        /// </summary>
        /// <param name="input">Input string that needs to be decrypted</param>
        /// <returns>Output string that is decrypted to a normal string</returns>
        public string decrypt(string input)
        {
            input = input.ToLower().Replace(",", "").Replace(" ", "");

            BigInteger outputInt = BigInteger.Parse(input);
            Random rand = new Random(input.Length);
            outputInt -= (rand.Next(1, 10000000)^9);
            string output = outputInt.ToString().Remove(0, 1);

            //insert "," so numbers wont be messed up.
            for (int i = 0; i < output.Length; i += 3)
            {
                output = output.Insert(i, ",");
            }
            output = output.Remove(0, 1);

            //numbers
            output = output.Replace("00", System.Environment.NewLine);
            output = output.Replace("01", " ");
            output = output.Replace("02", "0");
            output = output.Replace("03", "1");
            output = output.Replace("04", "2");
            output = output.Replace("05", "3");
            output = output.Replace("06", "4");
            output = output.Replace("07", "5");
            output = output.Replace("08", "6");
            output = output.Replace("09", "7");
            output = output.Replace("10", "8");
            output = output.Replace("11", "9");

            //char's
            output = output.Replace("12", "a");
            output = output.Replace("13", "b");
            output = output.Replace("14", "c");
            output = output.Replace("15", "d");
            output = output.Replace("16", "e");
            output = output.Replace("17", "f");
            output = output.Replace("18", "g");
            output = output.Replace("19", "h");
            output = output.Replace("20", "i");
            output = output.Replace("21", "j");
            output = output.Replace("22", "k");
            output = output.Replace("23", "l");
            output = output.Replace("24", "m");
            output = output.Replace("25", "n");
            output = output.Replace("26", "o");
            output = output.Replace("27", "p");
            output = output.Replace("28", "q");
            output = output.Replace("29", "r");
            output = output.Replace("30", "s");
            output = output.Replace("31", "t");
            output = output.Replace("32", "u");
            output = output.Replace("33", "v");
            output = output.Replace("34", "w");
            output = output.Replace("35", "x");
            output = output.Replace("36", "y");
            output = output.Replace("37", "z");

            //div
            output = output.Replace("38", "!");
            output = output.Replace("39", "[");
            output = output.Replace("40", "]");
            output = output.Replace("41", "=");
            output = output.Replace("42", ".");
            output = output.Replace("43", "&");
            output = output.Replace("44", "@");


            return output.Replace(",", "");
        }
    }
}


[Conor]

Looks nice. Replacing characters would be easily decrypted by somebody if they really wanted to get to the information. But there probably aren't many people who are going to spend time trying to figure your files out so don't worry

I made this class a while ago, I basically used all the methods from the admin password system in MCForge. I'll post it here in case you want to use it.

Its simple usage, Encryption.Encrypt(string) and Encryption.Decrypt(string)

Code: Select all

public class Encryption
    {
        // Set your own codes for the encryption, don't tell anybody.
        private static string EncryptionCode = "CHANGEME";
        private static byte[] _salt = Encoding.ASCII.GetBytes("CHANGEME");

        public static string Encrypt(string toEncrypt)
        {
            try
            {
                string outStr = null;
                RijndaelManaged aesAlg = null;

                try
                {
                    Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(EncryptionCode, _salt);

                    aesAlg = new RijndaelManaged();
                    aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
                    aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);

                    ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                    using (MemoryStream msEncrypt = new MemoryStream())
                    {
                        using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                        {
                            using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                            {
                                swEncrypt.Write(toEncrypt);
                            }
                        }
                        outStr = Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
                finally
                {
                    if (aesAlg != null)
                        aesAlg.Clear();
                }
                return outStr;
            }
            catch { return "Error"; }
        }

        public static string Decrypt(string toDecrypt)
        {
            try
            {
                RijndaelManaged aesAlg = null;
                string DecryptedString = null;

                try
                {
                    Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(EncryptionCode, _salt);

                    aesAlg = new RijndaelManaged();
                    aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
                    aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);

                    ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

                    byte[] bytes = Convert.FromBase64String(toDecrypt);
                    using (MemoryStream msDecrypt = new MemoryStream(bytes))
                    {
                        using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                        {
                            using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                                DecryptedString = srDecrypt.ReadToEnd();
                        }
                    }
                }
                finally
                {
                    if (aesAlg != null)
                        aesAlg.Clear();
                }
                return DecryptedString;
            }
            catch { return "Error"; }
        }
    }


[joppiesaus]

Thanks Conor for your class,
My system isn't fully charreplacement. At the end of the encrypted string is something else, but I want to make a formula that changes everything.
But if I multiply it and then devide it, it wont work.

[Conor]

Thanks Conor for your class,
My system isn't fully charreplacement. At the end of the encrypted string is something else, but I want to make a formula that changes everything.
But if I multiply it and then devide it, it wont work.

Why won't it work? I haven't looked into it too much but I noticed you used the Random class - maybe this has something to do with why you can't return to the same value, as you don't know what the random number was?