diff --git a/.gitignore b/.gitignore index 4fd3a32..d84a951 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,9 @@ ################################################################################ /RedpilledOuttaCucktown/obj/Debug +/RedpilledOuttaCucktown/bin/Debug +/Client/obj/Debug +/Client/bin/Debug +/Server/bin/Debug +/Server/obj/Debug +/.vs/RedpilledOuttaCucktown/v15 diff --git a/Client/App.config b/Client/App.config new file mode 100644 index 0000000..731f6de --- /dev/null +++ b/Client/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Client/Client.csproj b/Client/Client.csproj new file mode 100644 index 0000000..00a94a4 --- /dev/null +++ b/Client/Client.csproj @@ -0,0 +1,58 @@ + + + + + Debug + AnyCPU + {38A048D3-55C1-4F81-8E55-27ED0E54E1A9} + Exe + Client + Client + v4.6.1 + 512 + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + {216005DE-C35B-4CD3-8D27-0A49DEEDE62C} + Common + + + + \ No newline at end of file diff --git a/Client/Program.cs b/Client/Program.cs new file mode 100644 index 0000000..a5066ed --- /dev/null +++ b/Client/Program.cs @@ -0,0 +1,98 @@ +using System; +using System.Net; +using Tofvesson.Crypto; + +namespace Client +{ + class Program + { + static void Main(string[] args) + { + byte result = AESFunctions.GF28Mod(12); + bool connected = false; + + AES symCrypto = LoadAES(); + if (symCrypto == null) + { + Console.Write("Enter AES password: "); + symCrypto = new AES(Console.ReadLine()); + Console.Write("Would you like to save the generated AES keys? (y/N): "); + if (Console.In.ReadYNBool("y")) + { + Console.Write("Enter the base file name to be used: "); + try + { + symCrypto.Save(Console.ReadLine(), true); + } + catch (Exception) { Console.WriteLine("An error ocurred while attempting to save keys!"); } + } + } + + NetClient client = new NetClient(symCrypto, ParseIP(), ParsePort(), (string message, out bool keepAlive) => + { + Console.Write("Got message: "+message+"\nResponse (blank to exit): "); + string response = Console.ReadLine(); + keepAlive = response.Length!=0; + return keepAlive?response:null; + }, cli => + { + Console.WriteLine("Connected to server!"); + connected = true; + }); + client.Connect(); + + Console.WriteLine("Connecting..."); + while (!connected) System.Threading.Thread.Sleep(125); + + Console.Write("Message to send to server: "); + string s = Console.ReadLine(); + if (s.Length == 0) s += '\0'; + client.Send(s); + + while (client.IsAlive) System.Threading.Thread.Sleep(250); + } + + public static IPAddress ParseIP() + { + IPAddress addr = IPAddress.None; + do + { + Console.Write("Enter server IP: "); + } while (!IPAddress.TryParse(Console.ReadLine(), out addr)); + return addr; + } + + public static short ParsePort() + { + short s; + do + { + Console.Write("Enter server port: "); + } while (!short.TryParse(Console.ReadLine(), out s)); + return s; + } + + + + static AES LoadAES() + { + AES sym = null; + Console.Write("Would you like to load AES keys from files? (y/N): "); + while (Console.In.ReadYNBool("y")) + { + try + { + Console.Write("Enter base file name: "); + sym = AES.Load(Console.ReadLine()); + Console.WriteLine("Sucessfully loaded keys!"); + break; + } + catch (Exception) + { + Console.Write("One or more of the required key files could not be located. Would you like to retry? (y/N): "); + } + } + return sym; + } + } +} diff --git a/Client/Properties/AssemblyInfo.cs b/Client/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..0fb31fb --- /dev/null +++ b/Client/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Client")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Client")] +[assembly: AssemblyCopyright("Copyright © 2018")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("38a048d3-55c1-4f81-8e55-27ed0e54e1a9")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/RedpilledOuttaCucktown.sln b/RedpilledOuttaCucktown.sln new file mode 100644 index 0000000..325ee1d --- /dev/null +++ b/RedpilledOuttaCucktown.sln @@ -0,0 +1,37 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.27130.2020 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Common", "RedpilledOuttaCucktown\Common.csproj", "{216005DE-C35B-4CD3-8D27-0A49DEEDE62C}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Server", "Server\Server.csproj", "{4C426072-E087-431B-A8BC-4BA675C6D06A}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Client", "Client\Client.csproj", "{38A048D3-55C1-4F81-8E55-27ED0E54E1A9}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {216005DE-C35B-4CD3-8D27-0A49DEEDE62C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {216005DE-C35B-4CD3-8D27-0A49DEEDE62C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {216005DE-C35B-4CD3-8D27-0A49DEEDE62C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {216005DE-C35B-4CD3-8D27-0A49DEEDE62C}.Release|Any CPU.Build.0 = Release|Any CPU + {4C426072-E087-431B-A8BC-4BA675C6D06A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4C426072-E087-431B-A8BC-4BA675C6D06A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4C426072-E087-431B-A8BC-4BA675C6D06A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4C426072-E087-431B-A8BC-4BA675C6D06A}.Release|Any CPU.Build.0 = Release|Any CPU + {38A048D3-55C1-4F81-8E55-27ED0E54E1A9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {38A048D3-55C1-4F81-8E55-27ED0E54E1A9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {38A048D3-55C1-4F81-8E55-27ED0E54E1A9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {38A048D3-55C1-4F81-8E55-27ED0E54E1A9}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {A16DA980-2F28-410E-9D96-8713564D73D9} + EndGlobalSection +EndGlobal diff --git a/RedpilledOuttaCucktown/AES.cs b/RedpilledOuttaCucktown/AES.cs new file mode 100644 index 0000000..cd83255 --- /dev/null +++ b/RedpilledOuttaCucktown/AES.cs @@ -0,0 +1,318 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Numerics; +using System.Security.Cryptography; +using System.Text; + +namespace Tofvesson.Crypto +{ + public sealed class AES + { + public static readonly byte[] DEFAULT_SALT = new byte[] { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5 }; + public static readonly Encoding DEFAULT_ENCODING = Encoding.UTF8; + public static readonly CryptoPadding DEFAULT_PADDING = new PassthroughPadding(); + private const int BUFFER_SIZE = 2048; + + public byte[] Key { get; private set; } + public byte[] IV { get; private set; } + + public AES() { + using (RijndaelManaged r = new RijndaelManaged()) { + r.GenerateKey(); + r.GenerateIV(); + Key = r.Key; + IV = r.IV; + } + if (Key.Length == 0 || IV.Length == 0) throw new SystemException("Invalid parameter length!"); + } + + public AES(byte[] seed, byte[] salt) + { + var keyGenerator = new Rfc2898DeriveBytes(seed, salt, 300); + using (RijndaelManaged r = new RijndaelManaged()) + { + r.GenerateIV(); + Key = keyGenerator.GetBytes(32); + IV = r.IV; + } + if (Key.Length == 0 || IV.Length == 0) throw new SystemException("Invalid parameter length!"); + } + public static AES Load(byte[] key, byte[] iv) => new AES(key, iv, false); + public AES(byte[] seed) : this(seed, DEFAULT_SALT) { } + public AES(string password, Encoding e) : this(e.GetBytes(password)) { } + public AES(string password) : this(DEFAULT_ENCODING.GetBytes(password), DEFAULT_SALT) { } + private AES(byte[] k, byte[] i, bool b) + { + Key = k; + IV = i; + if (Key.Length == 0 || IV.Length == 0) throw new SystemException("Invalid parameter length!"); + } + + + public byte[] Encrypt(string message) => Encrypt(message, DEFAULT_ENCODING, DEFAULT_PADDING); + public byte[] Encrypt(string message, Encoding e, CryptoPadding padding) => Encrypt(e.GetBytes(message), padding); + public byte[] Encrypt(byte[] data, CryptoPadding padding) + { + data = padding.Pad(data); + if (data.Length == 0) throw new SystemException("Invalid message length"); + byte[] result; + using (RijndaelManaged rijAlg = new RijndaelManaged()) + { + rijAlg.Key = Key; + rijAlg.IV = IV; + + using (MemoryStream msEncrypt = new MemoryStream()) + { + using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV), CryptoStreamMode.Write)) + { + using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) + { + swEncrypt.Write(DEFAULT_ENCODING.GetChars(data)); + } + result = msEncrypt.ToArray(); + } + } + } + return result; + } + + public string DecryptString(byte[] data) => DecryptString(data, DEFAULT_ENCODING, DEFAULT_PADDING); + public string DecryptString(byte[] data, Encoding e, CryptoPadding padding) => new string(e.GetChars(Decrypt(data, padding))); + public byte[] Decrypt(byte[] data, CryptoPadding padding) + { + if (data.Length == 0) throw new SystemException("Invalid message length"); + List read = new List(); + using (RijndaelManaged rijAlg = new RijndaelManaged()) + { + rijAlg.Key = Key; + rijAlg.IV = IV; + using (MemoryStream msDecrypt = new MemoryStream(data)) + { + using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, rijAlg.CreateDecryptor(Key, IV), CryptoStreamMode.Read)) + { + byte[] buf = new byte[BUFFER_SIZE]; + int test; + int count; + do + { + count = csDecrypt.Read(buf, 0, buf.Length); + if (count == 0) + { + if ((test = csDecrypt.ReadByte()) == -1) break; + read.Add((byte)test); + } + else for (int i = 0; i < count; ++i) read.Add(buf[i]); + } while (true); + } + } + } + return padding.Unpad(read.ToArray()); + } + + public void Save(string baseName, bool force = false) + { + if (force || !File.Exists(baseName + ".key")) File.WriteAllBytes(baseName + ".key", Key); + if (force || !File.Exists(baseName + ".iv")) File.WriteAllBytes(baseName + ".iv", IV); + } + + public byte[] Serialize() => Support.SerializeBytes(new byte[][] { Key, IV }); + public static AES Deserialize(byte[] message, out int read) + { + byte[][] output = Support.DeserializeBytes(message, 2); + read = output[0].Length + output[1].Length + 8; + return new AES(output[0], output[1], false); + } + + public static AES Load(string baseName) + { + if (!File.Exists(baseName + ".iv") || !File.Exists(baseName + ".key")) throw new SystemException("Required files could not be located"); + return new AES(File.ReadAllBytes(baseName + ".key"), File.ReadAllBytes(baseName + ".iv"), false); + } + } + + + public static class AESFunctions + { + // Substitution box generated for all 256 possible input bytes from a part of a state + // Generated by getting the multiplicative inverse over GF(2^8) (i.e. the "prime polynomial" x^8 + x^4 + x^3 + x + 1) and applying the affine transformation + // Used to increase diffusion during encryption, but affine is also used to increase confusion by preventing mathematically aimed attacks + private static readonly byte[] rijndael_sbox = new byte[] + { + 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, + 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, + 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, + 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, + 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, + 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, + 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, + 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, + 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, + 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB, + 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, + 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08, + 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, + 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, + 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, + 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 + }; + + // MixColumns matrix basis. Used for multiplication over GF(2^8) i.e. mod P(x) where P(x) = x^8 + x^4 + x^3 + x + 1 + private static readonly byte[] mix_matrix = new byte[] { 2, 3, 1, 1 }; + + public static byte[] SBox(byte[] state) + { + for (int i = 0; i < state.Length; ++i) state[i] = rijndael_sbox[state[i]]; + return state; + } + + // The AES state is a column-first 4x4 matrix. Demonstrated below are the decimal indices, as would be represented in the state: + // 00 04 08 12 + // 01 05 09 13 + // 02 06 10 14 + // 03 07 11 15 + + // Shiftrows applied to state above: + // 00 04 08 12 - No change + // 05 09 13 01 - Shifted 1 to the left + // 10 14 02 06 - Shifted 2 to the left + // 15 03 07 11 - Shifted 3 to the left + public static byte[] ShiftRows(byte[] state) + { + for(int i = 1; i<4; ++i) + { + byte tmp = state[i]; + for(int j = 0; j<3; ++j) state[i + j*4] = state[i + ((j + i)%4)*4]; + state[i + 12] = tmp; + } + return state; + } + + // MixColumns provides strong diffusion + public static byte[] MixColumns(byte[] state) + { + byte[] res = new byte[16]; + + // Simplified matrix multiplication under GF(2^8) + for(int i = 0; i<4; ++i) + { + for(int j = 0; j<4; ++j) + { + for (int k = 0; k < 4; ++k) + { + int idx = 4 - j; + int r = ((state[k + i * 4] * (mix_matrix[(k + idx) % 4] & 1)) ^ ((state[k + i * 4] << 1) * ((mix_matrix[(k + idx) % 4]>>1)&1))); + if (r > 0b100011011) r ^= 0b100011011; + res[j + i * 4] ^= (byte) r; + } + } + } + return res; + } + + public static byte[] AddRoundKey(byte[] state, byte[] subkey) + { + for (int i = 0; i < state.Length; ++i) state[i] ^= subkey[i]; + return state; + } + + /// + /// Rotate bits to the left by 8 bits. This means that, for example, "0F AB 09 16" becomes "AB 09 16 0F" + /// + /// + /// + public static int Rotate(int i) => ((i >> 24) & 255) & ((i << 8) & ~255); + + public static Tuple DeriveKey(string message) => + new Tuple( + new SHA1CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(message)).ToLength(128), + new RegularRandomProvider(new Random((int)(new BigInteger(Encoding.UTF8.GetBytes(message)) % int.MaxValue))).GetBytes(new byte[128]) + ); + + + + + // Finite field arithmetic helper methods + private static byte RCON(int i) => i<=0?(byte)0x8d:GF28Mod(i - 1); + + public static byte GF28Mod(int pow) + { + byte[] val = new byte[1+(pow/8)]; + val[pow / 8] |= (byte)(1 << (pow % 8)); + return GF28Mod(val); + } + private static byte GF28Mod(byte[] value) + { + byte[] CA_l; + while (GT(value, CA_max, true)) + { + CA_l = NeedsAlignment(value) ? AlignCA(value) : CA; + byte[] res = new byte[CA_l.Length]; + for (int i = 0; i < CA_l.Length; ++i) res[i] = (byte)(value[i] ^ CA_l[i]); + value = ClipZeroes(res); + } + return value[0]; + } + + /// + /// GF(2^8) uses the irreducible polynomial x^8 + x^4 + x^3 + x^1 + x^0 which can be represented as 0001 0001 1011 due to the characteristic of the field + /// + private static readonly byte[] CA = new byte[] { 0b0001_1011, 0b0000_0001 }; + private static readonly byte[] CA_max = new byte[] { 0b0000_0000, 0b0000_0001 }; + private static readonly int CA_FSB = 8; + private static byte[] AlignCA(byte[] value) => SHL((byte[])CA.Clone(), GetFirstSetBit(value) - CA_FSB); + private static bool NeedsAlignment(byte[] b) => b.Length > 1 && GetFirstSetBit(b) > CA_FSB; + private static bool GT(byte[] v1, byte[] v2, bool eq) + { + byte[] bigger = v1.Length > v2.Length ? v1 : v2; + byte[] smaller = v1.Length > v2.Length ? v2 : v1; + for (int i = Math.Max(bigger.Length, smaller.Length)-1; i >= 0; --i) + if (i >= smaller.Length && bigger[i] != 0) + return bigger == v1; + else if (i < smaller.Length && bigger[i] != smaller[i]) + return (bigger[i] > smaller[i]) ^ (bigger != v1); + return eq; + } + private static byte[] ClipZeroes(byte[] val) + { + int i = 0; + for(int j = val.Length-1; j>=0; --j) if (val[j] != 0) { i = j; break; } + byte[] res = new byte[i+1]; + Array.Copy(val, res, res.Length); + return res; + } + + private static int GetFirstSetBit(byte[] b) + { + for (int i = (b.Length * 8) - 1; i >= 0; --i) if ((b[i / 8] & (1 << (i % 8))) != 0) return i; + return -1; + } + + private static byte ShiftedBitmask(int start) + { + byte res = 0; + for (int i = start; i > 0; --i) res = (byte)((res >> 1) | 128); + return res; + } + + private static byte[] SHL(byte[] value, int shift) + { + int set = shift / 8; + int sub = shift % 8; + byte bm = ShiftedBitmask(sub); + byte ibm = (byte) ~bm; + byte carry = 0; + int fsb1 = GetFirstSetBit(value); + if (fsb1 == -1) return value; + byte fsb = (byte)(fsb1 % 8); + byte[] create = new byte[value.Length + set + (fsb + set >= 7 ? 1: 0)]; + for(int i = set; i> (8-sub)); + } + create[create.Length - 1] |= carry; + return create; + } + } +} diff --git a/RedpilledOuttaCucktown/App.config b/RedpilledOuttaCucktown/App.config new file mode 100644 index 0000000..731f6de --- /dev/null +++ b/RedpilledOuttaCucktown/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/RedpilledOuttaCucktown/Common.csproj b/RedpilledOuttaCucktown/Common.csproj new file mode 100644 index 0000000..de37a5a --- /dev/null +++ b/RedpilledOuttaCucktown/Common.csproj @@ -0,0 +1,61 @@ + + + + + Debug + AnyCPU + {216005DE-C35B-4CD3-8D27-0A49DEEDE62C} + Library + Tofvesson.Crypto + Tofvesson.Crypto + v4.6.1 + 512 + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/RedpilledOuttaCucktown/Crypto.cs b/RedpilledOuttaCucktown/Crypto.cs new file mode 100644 index 0000000..abfb8ef --- /dev/null +++ b/RedpilledOuttaCucktown/Crypto.cs @@ -0,0 +1,172 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Numerics; +using System.Text; + +namespace Tofvesson.Crypto +{ + public class RSA + { + private static readonly PassthroughPadding NO_PADDING = new PassthroughPadding(); + private static readonly Encoding DEFAULT_ENCODING = Encoding.UTF8; + + private readonly RandomProvider provider = new CryptoRandomProvider(); + + private readonly BigInteger e; + private readonly BigInteger n; + private readonly BigInteger d; + + public bool CanEncrypt { get; private set; } + public bool CanDecrypt { get; private set; } + + public RSA(int byteSize, int margin, int threads, int certainty) + { + // Choose primes + BigInteger p = Support.GeneratePrime(threads, byteSize, margin, certainty, provider); + BigInteger q = Support.GeneratePrime(threads, byteSize, margin, certainty, provider); + + + // For optimization + BigInteger p_1 = p - 1; + BigInteger q_1 = q - 1; + + // Calculate needed values + n = p * q; + BigInteger lcm = (p_1 * q_1) / Support.GCD(p_1, q_1); + + // Generate e such that is is less than and coprime to lcm + do + { + e = RandomSupport.GenerateBoundedRandom(lcm, provider); + } while (e == lcm || Support.GCD(e, lcm) != 1); + + // Generate the modular multiplicative inverse + d = Support.Dio(e, lcm).Key + lcm; + CanEncrypt = true; + CanDecrypt = true; + } + + private RSA(string e_file, string n_file, string d_file) + { + if (!File.Exists(e_file)) throw new SystemException($"Could not load from file \"{e_file}\""); + if (!File.Exists(n_file)) throw new SystemException($"Could not load from file \"{n_file}\""); + if (!File.Exists(d_file)) throw new SystemException($"Could not load from file \"{d_file}\""); + e = new BigInteger(File.ReadAllBytes(e_file)); + n = new BigInteger(File.ReadAllBytes(n_file)); + d = new BigInteger(File.ReadAllBytes(d_file)); + CanEncrypt = true; + CanDecrypt = true; + } + + public RSA(RSA copy) + { + e = copy.e; + n = copy.n; + d = copy.d; + CanEncrypt = copy.CanEncrypt; + CanDecrypt = copy.CanDecrypt; + } + + private RSA(byte[] e, byte[] n) + { + this.e = new BigInteger(e); + this.n = new BigInteger(n); + this.d = BigInteger.Zero; + CanEncrypt = true; + CanDecrypt = false; + } + + public byte[] EncryptString(string message) => Encrypt(DEFAULT_ENCODING.GetBytes(message)); + public byte[] EncryptString(string message, Encoding encoding) => Encrypt(encoding.GetBytes(message)); + public byte[] EncryptString(string message, CryptoPadding padding) => Encrypt(DEFAULT_ENCODING.GetBytes(message), padding); + public byte[] EncryptString(string message, Encoding encoding, CryptoPadding padding) => Encrypt(encoding.GetBytes(message), padding); + public byte[] Encrypt(byte[] message) => Encrypt(message, NO_PADDING); + public byte[] Encrypt(byte[] message, CryptoPadding padding) + { + // Apply dynamic padding + message = padding.Pad(message); + + // Apply fixed padding + byte[] b1 = new byte[message.Length + 1]; + Array.Copy(message, b1, message.Length); + b1[message.Length] = 1; + message = b1; + + // Represent message as a number + BigInteger m = new BigInteger(message); + + // Encrypt message + BigInteger cryptomessage = Support.ModExp(m, e, n); + + // Convert encrypted message back to bytes + return cryptomessage.ToByteArray(); + } + + public string DecryptString(byte[] message) => new string(DEFAULT_ENCODING.GetChars(Decrypt(message, NO_PADDING))); + public string DecryptString(byte[] message, Encoding encoding) => new string(encoding.GetChars(Decrypt(message, NO_PADDING))); + public string DecryptString(byte[] message, Encoding encoding, CryptoPadding padding) => new string(encoding.GetChars(Decrypt(message, padding))); + public string DecryptString(byte[] message, CryptoPadding padding) => new string(DEFAULT_ENCODING.GetChars(Decrypt(message, padding))); + public byte[] Decrypt(byte[] message) => Decrypt(message, NO_PADDING); + public byte[] Decrypt(byte[] message, CryptoPadding padding) + { + // Reinterpret encrypted message as a number + BigInteger cryptomessage = new BigInteger(message); + + // Reverse encryption + message = Support.ModExp(cryptomessage, d, n).ToByteArray(); + + // Remove fixed padding + byte[] b1 = new byte[message.Length - 1]; + Array.Copy(message, b1, message.Length - 1); + message = b1; + + // Remove dynamic padding + message = padding.Unpad(message); + + return message; + } + + public byte[] GetPK() => e.ToByteArray(); + + public void Save(string fileNameBase, bool force = false) + { + if (force || !File.Exists(fileNameBase + ".e")) File.WriteAllBytes(fileNameBase + ".e", e.ToByteArray()); + if (force || !File.Exists(fileNameBase + ".n")) File.WriteAllBytes(fileNameBase + ".n", n.ToByteArray()); + if (force || !File.Exists(fileNameBase + ".d")) File.WriteAllBytes(fileNameBase + ".d", d.ToByteArray()); + } + + public byte[] Serialize() => Support.SerializeBytes(new byte[][] { e.ToByteArray(), n.ToByteArray() }); + + public static RSA Deserialize(byte[] function, out int read) + { + byte[][] rd = Support.DeserializeBytes(function, 2); + read = rd[0].Length + rd[1].Length + 8; + return new RSA(rd[0], rd[1]); + } + public static bool CanDeserialize(IEnumerable data) + { + try + { + int size = Support.ReadInt(data, 0), size2; + if (size >= data.Count() - 8) return false; + size2 = Support.ReadInt(data, 4 + size); + if (size2 > data.Count() - size - 8) return false; + return true; + } + catch (Exception) { } + return false; + } + public static RSA TryLoad(string fileNameBase) => TryLoad(fileNameBase + ".e", fileNameBase + ".n", fileNameBase + ".d"); + public static RSA TryLoad(string e_file, string n_file, string d_file) + { + try + { + return new RSA(e_file, n_file, d_file); + } + catch (Exception) { } + return null; + } + } +} diff --git a/RedpilledOuttaCucktown/Maths.cs b/RedpilledOuttaCucktown/Maths.cs new file mode 100644 index 0000000..f502562 --- /dev/null +++ b/RedpilledOuttaCucktown/Maths.cs @@ -0,0 +1,237 @@ +using System.Collections.Generic; + +namespace Tofvesson.Crypto +{ + + /* + * ----------------------------------------------- + * WARNING WARNING WARNING WARNING WARNING WARNING + * ----------------------------------------------- + * + * If you are looking for useful code that is feasibly usable in the application of RSA, you are in the wrong place! + * This code is not intended to be executed (despite the stability and functionality). The code featured below is + * created with the sole purpose of modelling a C++ representation in a higher language (for simplicity). + * + * Note: The below model is no longer of any use, as the idea, that this model was to represent a part, of has been scrapped. + * + * + * + * Proof-of-concept for a simplified BigInteger to be implemented in C++ in an OpenCL kernel. + * This has been opted agains due to the concerns regarding varying hardware implementations what this program should be applicable on. + * The implementation would almost surely have been modified to be classless in the OpenCL implementation, but would otherwise follow the model below fairly strictly. + */ + class Integer + { + // Some nice constants + public static readonly Integer ONE = new Integer(1); + public static readonly Integer ZERO = new Integer(); + public static readonly Integer MINUS_ONE = new Integer(-1); + + + private List val = new List(); + + public bool IsNegative { get; private set; } + + public Integer() { } + public Integer(int value) + { + if ((IsNegative = value < 0)) value *= -1; + for (int i = 0; i < 4; ++i) val.Add((byte)((value >> i * 8) & 255)); + ClipZeroes(); + } + public Integer(List l) { val.AddRange(l); } + public Integer(Integer i) : this(i.val) { IsNegative = i.IsNegative; } + + public Integer Add(Integer other) + { + Integer result = new Integer(this); + result._Add(other); + return result; + } + + public Integer Sub(Integer other) + { + Integer result = new Integer(this); + result._Sub(other); + return result; + } + + // Tests equality + public bool Equ(Integer other) + { + if (IsNegative != other.IsNegative || val.Count!=other.val.Count) return false; + for (int i = 0; i < val.Count; ++i) if (val[i] != other.val[i]) return false; + return true; + } + + // Tests lack of equality + public bool Neq(Integer other) => !Equ(other); + + // Checks if this is greather than the given value + public bool Gre(Integer other) => _Cmp(other, true) == 1; + + // Performs a greater-than-or-equal-to comparison + public bool Grq(Integer other) => _Cmp(other, true) != 0; + + // Checks if this is less than the given value + public bool Let(Integer other) => _Cmp(other, false) == 1; + + // Performs a less-than-or-equal-to comparison + public bool Leq(Integer other) => _Cmp(other, false) != 0; + + // Performs a numerical comparison based on the "greater than" comparison + private int _Cmp(Integer other, bool grt) + { + // If the other number is less than zero and this is a positive number, this number is larger and vice versa + if (other.IsNegative && !IsNegative && other.val.Count != 0) return grt ? 1 : 0; + if (IsNegative && !other.IsNegative && val.Count != 0) return grt ? 0 : 1; + long l1, l2; + long idx = 0; + while ((l1=GetNthSetBit(idx, false))==(l2=other.GetNthSetBit(idx, false))) { + ++idx; + if (l1 == -1) return 2; + } + return ((l1 > l2 && (!IsNegative == grt)) || ((IsNegative == grt) && l1 < l2)) ? 1 : 0; + } + + private void _Sub(Integer other) + { + bool neg; + if (other.IsNegative ^ IsNegative) // this - (-other) = this + other + { + neg = IsNegative; + IsNegative = false; + other.IsNegative = false; + _Add(other); + other.IsNegative = !neg; + IsNegative = neg; + return; + } + if (IsNegative) // -this - (-other) = -this + other = other - this + { + Integer res = new Integer(other); + res.IsNegative = false; + this.IsNegative = false; + res._Sub(this); + IsNegative = res.IsNegative; + val = res.val; + } + else if (Let(other)) // this - other (where other>this) + { + Integer res = new Integer(other); + res._Sub(this); + this.IsNegative = true; + val = res.val; + } + else // this - other (where other<=this) + { + // Get two's complement of the other value + Integer tc = new Integer(other); + tc.TwosComplement(); + tc._Add(this); + long idx = tc.GetNthSetBit(0, false); + if (idx != -1) tc.val[(int)(idx / 8L)] &= (byte) ~(1 << (int)(idx % 8)); + tc.ClipZeroes(); + val = tc.val; + } + } + + private void _Add(Integer other) + { + if (other.IsNegative != IsNegative) + { + if (other.IsNegative) + { + other.IsNegative = false; + _Sub(other); + other.IsNegative = true; + } + else + { + Integer tmp = new Integer(other); + tmp._Sub(this); + IsNegative = tmp.IsNegative; + val = tmp.val; + } + return; + } + bool carry = false; + bool greater = other.val.Count > val.Count; + int min = greater ? val.Count : other.val.Count; + Integer larger = greater ? other : other.val.Count < this.val.Count ? this : null; + + for(int i = 0; i 255; + val[i] = (byte)(res % 256); + } + if (larger == other) + { + for(int i = min; i 0 ? "-" : val.Count == 0 ? "0" : ""; + for (int i = (val.Count) * 8 - 1; i>=0; --i) s += (val[i / 8] & (1 << (i % 8))) >> (i % 8); + return s; + } + + private long GetNthSetBit(long index, bool minFirst) + { + long target = index+1; + for(long l = minFirst?0:(val.Count*8)-1; (minFirst && l=0) ; l += minFirst ? 1 : -1) + { + if ((val[(int)(l / 8)] & (1 << (int)(l % 8))) != 0 && --target == 0) return l; + } + return -1; + } + + public int FirstSetBit + { + get + { + for (int i = 0; i < val.Count * 8; ++i) if ((val[i / 8] & (1 << (i % 8))) != 0) return i; + return -1; + } + } + + // Pruning methods + private void ClipZeroes() + { + for (int i = val.Count - 1; i >= 0; --i) + if (val[i] == 0) val.RemoveAt(i); + else break; + } + } +} diff --git a/RedpilledOuttaCucktown/Net.cs b/RedpilledOuttaCucktown/Net.cs new file mode 100644 index 0000000..ebb67cb --- /dev/null +++ b/RedpilledOuttaCucktown/Net.cs @@ -0,0 +1,376 @@ +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Tofvesson.Crypto +{ + public delegate string OnMessageRecieved(string request, out bool stayAlive); + public delegate void OnClientConnect(NetClient client); + public sealed class NetServer + { + private readonly short port; + private readonly object state_lock = new object(); + private readonly List clients = new List(); + private readonly OnMessageRecieved callback; + private readonly OnClientConnect onConn; + private readonly IPAddress ipAddress; + private Socket listener; + private readonly RSA crypto; + private readonly byte[] ser_cache; + private readonly int bufSize; + + private bool state_running = false; + private Thread listenerThread; + + + public int Count + { + get + { + return clients.Count; + } + } + + public bool Running + { + get + { + lock (state_lock) return state_running; + } + + private set + { + lock (state_lock) state_running = value; + } + } + + public NetServer(RSA crypto, short port, OnMessageRecieved callback, OnClientConnect onConn, int bufSize = 16384) + { + this.callback = callback; + this.onConn = onConn; + this.bufSize = bufSize; + this.crypto = crypto; + this.port = port; + this.ser_cache = crypto.Serialize(); // Keep this here so we don't wastefully re-serialize every time we get a new client + + IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); + this.ipAddress = ipHostInfo.GetIPV4(); + if (ipAddress == null) + ipAddress = IPAddress.Parse("127.0.0.1"); // If there was no IPv4 result in dns lookup, use loopback address + } + + public void StartListening() + { + bool isAlive = false; + object lock_await = new object(); + if(!Running && (listenerThread==null || !listenerThread.IsAlive)) + { + Running = true; + listenerThread = new Thread(() => + { + + this.listener = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp) + { + Blocking = false // When calling Accept() with no queued sockets, listener throws an exception + }; + IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port); + listener.Bind(localEndPoint); + listener.Listen(100); + + byte[] buffer = new byte[bufSize]; + lock (lock_await) isAlive = true; + while (Running) + { + // Accept clients + try + { + Socket s = listener.Accept(); + s.Blocking = false; + clients.Add(new ClientStateObject(new NetClient(s, crypto, callback, onConn), buffer)); + } + catch (Exception) + { + if(clients.Count==0) + Thread.Sleep(25); // Wait a bit before trying to accept another client + } + + // Update clients + foreach (ClientStateObject cli in clients.ToArray()) + // Ensure we are still connected to client + if (!(cli.IsConnected() && !cli.Update())) + { + clients.Remove(cli); + continue; + } + } + }) + { + Priority = ThreadPriority.Highest, + Name = $"NetServer-${port}" + }; + listenerThread.Start(); + } + + bool rd; + do + { + Thread.Sleep(25); + lock (lock_await) rd = isAlive; + } while (!rd); + } + + public Task StopRunning() + { + Running = false; + + return new TaskFactory().StartNew(() => + { + listenerThread.Join(); + return null; + }); + } + + private class ClientStateObject + { + private NetClient client; + private bool hasCrypto = false; // Whether or not encrypted communication has been etablished + private Queue buffer = new Queue(); // Incoming data buffer + public long lastComm; // Latest comunication event (in ticks) + private int expectedSize = 0; // Expected size of next message + private readonly byte[] buf; + + public ClientStateObject(NetClient client, byte[] buf) + { + this.client = client; + this.buf = buf; + lastComm = DateTime.UtcNow.Ticks; // 1/10,000,000 seconds + } + + public bool Update() + { + bool stop = client.SyncListener(hasCrypto, expectedSize, out hasCrypto, out expectedSize, out bool read, buffer, buf); + if (read) lastComm = DateTime.UtcNow.Ticks; + return stop; + } + public bool IsConnected() => client.IsConnected; + } + } + + public class NetClient + { + // Thread state lock for primitive values + private readonly object state_lock = new object(); + + // Primitive state values + private bool state_running = false; + + // Socket event listener + private Thread eventListener; + + // Communication parameters + protected readonly Queue messageBuffer = new Queue(); + protected readonly OnMessageRecieved handler; + protected readonly OnClientConnect onConn; + protected readonly IPAddress target; + protected readonly int bufSize; + protected readonly RSA decrypt; + + // Connection to peer + protected Socket Connection { get; private set; } + + // State/connection parameters + protected AES Crypto { get; private set; } + public short Port { get; } + protected bool Running + { + get + { + lock (state_lock) return state_running; + } + private set + { + lock (state_lock) state_running = value; + } + } + + protected internal bool IsConnected + { + get + { + return Connection != null && Connection.Connected && !(Connection.Poll(1, SelectMode.SelectRead) && Connection.Available == 0); + } + } + + public bool IsAlive + { + get + { + return Running || (Connection != null && Connection.Connected) || (eventListener != null && eventListener.IsAlive); + } + } + + protected bool ServerSide { get; private set; } + + + public NetClient(AES crypto, IPAddress target, short port, OnMessageRecieved handler, OnClientConnect onConn, int bufSize = 16384) + { +#pragma warning disable CS0618 // Type or member is obsolete + if (target.AddressFamily==AddressFamily.InterNetwork && target.Address == 16777343) +#pragma warning restore CS0618 // Type or member is obsolete + { + IPAddress addr = Dns.GetHostEntry(Dns.GetHostName()).GetIPV4(); + if (addr != null) target = addr; + } + this.target = target; + Crypto = crypto; + this.bufSize = bufSize; + this.handler = handler; + this.onConn = onConn; + Port = port; + ServerSide = false; + } + + internal NetClient(Socket sock, RSA crypto, OnMessageRecieved handler, OnClientConnect onConn) + : this(null, ((IPEndPoint)sock.RemoteEndPoint).Address, (short) ((IPEndPoint)sock.RemoteEndPoint).Port, handler, onConn, -1) + { + decrypt = crypto; + Connection = sock; + Running = true; + ServerSide = true; + + // Initiate crypto-handshake by sending public keys + Connection.Send(NetSupport.WithHeader(crypto.Serialize())); + } + + public virtual void Connect() + { + if (ServerSide) throw new SystemException("Serverside socket cannot connect to a remote peer!"); + NetSupport.DoStateCheck(IsAlive || (eventListener != null && eventListener.IsAlive), false); + Running = true; + Connection = new Socket(SocketType.Stream, ProtocolType.Tcp); + Connection.Connect(target, Port); + eventListener = new Thread(() => + { + bool cryptoEstablished = false; + int mLen = 0; + Queue ibuf = new Queue(); + byte[] buffer = new byte[bufSize]; + while (Running) + if (SyncListener(cryptoEstablished, mLen, out cryptoEstablished, out mLen, out bool _, ibuf, buffer)) + break; + if (ibuf.Count != 0) Console.WriteLine("Client socket closed with unread data!"); + }) + { + Priority = ThreadPriority.Highest, + Name = $"NetClient-${target}:${Port}" + }; + eventListener.Start(); + } + + protected internal bool SyncListener(bool cryptoEstablished, int mLen, out bool cE, out int mL, out bool acceptedData, Queue ibuf, byte[] buffer) + { + cE = cryptoEstablished; + mL = mLen; + if (cryptoEstablished) + { + lock (messageBuffer) + { + foreach (byte[] message in messageBuffer) Connection.Send(NetSupport.WithHeader(message)); + messageBuffer.Clear(); + } + } + if (acceptedData = Connection.Available > 0) + { + int read = Connection.Receive(buffer); + ibuf.EnqueueAll(buffer, 0, read); + } + if (mLen == 0 && ibuf.Count >= 4) + mL = mLen = Support.ReadInt(ibuf.Dequeue(4), 0); + if (mLen != 0 && ibuf.Count >= mLen) + { + // Got a full message. Parse! + byte[] message = ibuf.Dequeue(mLen); + + if (!cryptoEstablished) + { + if (ServerSide) + { + Crypto = AES.Deserialize(decrypt.Decrypt(message), out int _); + } + else + { + // Reconstruct RSA object from remote public keys and use it to encrypt our serialized AES key/iv + byte[] b1 = NetSupport.WithHeader(RSA.Deserialize(message, out int _).Encrypt(Crypto.Serialize())); + Connection.Send(b1); + } + cE = true; + onConn(this); + } + else + { + string response = handler(Crypto.DecryptString(message), out bool live); + if (response != null) Connection.Send(NetSupport.WithHeader(Crypto.Encrypt(response))); + if (!live) + { + Running = false; + try + { + Connection.Close(); + } + catch (Exception) { } + return true; + } + } + + // Reset expexted message length + mL = 0; + } + return false; + } + + public virtual async Task Disconnect() + { + NetSupport.DoStateCheck(IsAlive, true); + Running = false; + + + return await new TaskFactory().StartNew(() => { eventListener.Join(); return null; }); + } + + public bool TrySend(string message) => TrySend(Encoding.UTF8.GetBytes(message)); + public bool TrySend(byte[] message) + { + try + { + Send(message); + return true; + } + catch (InvalidOperationException) { return false; } + } + public virtual void Send(string message) => Send(Encoding.UTF8.GetBytes(message)); + public virtual void Send(byte[] message) { + NetSupport.DoStateCheck(IsAlive, true); + lock (messageBuffer) messageBuffer.Enqueue(Crypto.Encrypt(message, new PassthroughPadding())); + } + } + + public static class NetSupport + { + internal static byte[] WithHeader(string message) => WithHeader(Encoding.UTF8.GetBytes(message)); + internal static byte[] WithHeader(byte[] message) + { + byte[] nmsg = new byte[message.Length + 4]; + Support.WriteToArray(nmsg, message.Length, 0); + Array.Copy(message, 0, nmsg, 4, message.Length); + return nmsg; + } + + internal static void DoStateCheck(bool state, bool target) { + if (state != target) throw new InvalidOperationException("Bad state!"); + } + } +} diff --git a/RedpilledOuttaCucktown/Padding.cs b/RedpilledOuttaCucktown/Padding.cs new file mode 100644 index 0000000..2c33aa6 --- /dev/null +++ b/RedpilledOuttaCucktown/Padding.cs @@ -0,0 +1,376 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Text.RegularExpressions; +using System.Xml; + +namespace Tofvesson.Crypto +{ + public interface CryptoPadding + { + byte[] Pad(byte[] message); + byte[] Unpad(byte[] message); + PaddingIdentifier GetParameters(); + } + + public sealed class PaddingIdentifier + { + private readonly Dictionary> attributes = new Dictionary>(); + private readonly Dictionary nests = new Dictionary(); + + public string Name { get; private set; } + + public List AttributeKeys + { + get + { + List keys = new List(); + keys.AddRange(attributes.Keys); + return keys; + } + } + + public List NestedKeys + { + get + { + List keys = new List(); + keys.AddRange(nests.Keys); + return keys; + } + } + + public PaddingIdentifier(string name) { this.Name = name; } + public void AddAttribute(string attr, byte[] data) => attributes.Add(attr, new Tuple(ParameterTypes.BYTES, Support.ArrayToString(data))); + public void AddAttribute(string attr, int data) => attributes.Add(attr, new Tuple(ParameterTypes.NUMBER, data.ToString())); + public void AddAttribute(string attr, PaddingIdentifier data) => nests.Add(attr, data); + + public Tuple GetAttribute(string key) + { + if (attributes.ContainsKey(key)) return attributes[key]; + return null; + } + + public PaddingIdentifier GetNested(string key) + { + if (nests.ContainsKey(key)) return nests[key]; + return null; + } + + public XmlElement Compile(XmlDocument writeTo) + { + XmlElement root = writeTo.CreateElement(Name); + foreach (string key in attributes.Keys) + { + XmlElement attr = writeTo.CreateElement(key); + attr.SetAttribute("type", attributes[key].Item1.ToString()); + attr.InnerText = attributes[key].Item2; + root.AppendChild(attr); + } + + foreach (string key in nests.Keys) root.AppendChild(nests[key].Compile(writeTo)); + return root; + } + } + + public enum ParameterTypes { NUMBER, BYTES, NESTED } + + public sealed class RandomLengthPadding : CryptoPadding + { + private const ushort DEFAULT_MAX = 12; + + private readonly RandomProvider provider; + private readonly byte[] delimiter; + private readonly ushort maxLen; + + public RandomLengthPadding(RandomProvider provider, byte[] delimiter, ushort maxLen = DEFAULT_MAX) + { + this.provider = provider; + this.delimiter = delimiter; + this.maxLen = maxLen; + } + + public RandomLengthPadding(byte[] delimiter, ushort maxLen = DEFAULT_MAX) + : this(new RegularRandomProvider(), delimiter, maxLen) + { } + + + public byte[] Pad(byte[] message) + { + // Generate padding + byte[] prepadding = GenerateSequence(); + byte[] postpadding = GenerateSequence(); + + // Allocate output array + byte[] result = new byte[message.Length + prepadding.Length + postpadding.Length + delimiter.Length * 2]; + + // Assemble padding + int index = 0; + Array.Copy(prepadding, 0, result, 0, -(index - (index += prepadding.Length))); + Array.Copy(delimiter, 0, result, index, -(index - (index += delimiter.Length))); + Array.Copy(message, 0, result, index, -(index - (index += message.Length))); + Array.Copy(delimiter, 0, result, index, -(index - (index += delimiter.Length))); + Array.Copy(postpadding, 0, result, index, -(index - (index += postpadding.Length))); + + return result; + } + + public byte[] Unpad(byte[] message) + { + int index = Support.ArrayContains(message, delimiter); + if (index == -1) throw new InvalidPaddingException("Preceding delimiter could not be found"); + byte[] result_stage1 = new byte[message.Length - 1 - index]; + Array.Copy(message, index + 1, result_stage1, 0, message.Length - 1 - index); + index = Support.ArrayContains(result_stage1, delimiter, false); + if (index == -1) throw new InvalidPaddingException("Trailing delimeter could not be found"); + byte[] result_stage2 = new byte[index]; + Array.Copy(result_stage1, 0, result_stage2, 0, index); + return result_stage2; + } + + private byte[] GenerateSequence() + { + // Generate between 0 and maxLen random bytes to be used as padding + byte[] padding = provider.GetBytes(provider.NextUShort((ushort)(maxLen + 1))); + + // Remove instances of the delimiter sequence from the padding + int idx; + while ((idx = Support.ArrayContains(padding, delimiter)) != -1) + foreach (byte val in provider.GetBytes(delimiter.Length)) + padding[idx++] = val; + return padding; + } + + public PaddingIdentifier GetParameters() + { + PaddingIdentifier id = new PaddingIdentifier("R"); + id.AddAttribute("delimiter", delimiter); + id.AddAttribute("maxLen", maxLen); + return id; + } + } + + public sealed class IncrementalPadding : CryptoPadding + { + private const int DEFAULT_INCREMENT = 12; + + private readonly RandomProvider provider; + private readonly int increments; + private readonly int determiner; + + + public IncrementalPadding(RandomProvider provider, int determiner, int increments = DEFAULT_INCREMENT) + { + this.provider = provider; + this.increments = increments * determiner; + this.determiner = determiner; + if (increments < 0) throw new InvalidPaddingException("Increments cannot be negative!"); + if (determiner <= 1) throw new InvalidPaddingException("Determiner must be a positive value larger than 1!"); + if (increments * determiner < 0) throw new InvalidPaddingException("Increment-Delimiter pair is too large!"); + } + + public byte[] Pad(byte[] message) + { + if (message.Length % determiner != 0) + { + byte[] result = new byte[message.Length + increments]; + Array.Copy(message, result, message.Length); + Array.Copy(provider.GetBytes(increments), 0, result, message.Length, increments); + return result; + } + else return message; + } + + public byte[] Unpad(byte[] message) + { + if (message.Length % determiner == 0) return message; + byte[] result = new byte[message.Length - increments]; + Array.Copy(message, result, result.Length); + return result; + } + + public PaddingIdentifier GetParameters() + { + PaddingIdentifier id = new PaddingIdentifier("I"); + id.AddAttribute("increments", increments / determiner); + id.AddAttribute("determiner", determiner); + return id; + } + } + + public sealed class SequentialPadding : CryptoPadding + { + private readonly List pads = new List(); + + public SequentialPadding WithPadding(CryptoPadding padding) + { + pads.Add(padding); + return this; + } + + public byte[] Pad(byte[] message) + { + for (int i = 0; i < pads.Count; ++i) message = pads[i].Pad(message); + return message; + } + + public byte[] Unpad(byte[] message) + { + for (int i = pads.Count - 1; i >= 0; --i) message = pads[i].Unpad(message); + return message; + } + + public PaddingIdentifier GetParameters() + { + PaddingIdentifier id = new PaddingIdentifier("S"); + for (int i = 0; i < pads.Count; ++i) id.AddAttribute(i.ToString(), pads[i].GetParameters()); + return id; + } + } + + public sealed class PassthroughPadding : CryptoPadding + { + public byte[] Pad(byte[] message) => message; + public byte[] Unpad(byte[] message) => message; + public PaddingIdentifier GetParameters() => new PaddingIdentifier("P"); + } + + public static class PaddingSupport + { + private static readonly Regex byteFinder = new Regex("(\\d{0,3})[,\\]]"); + + + public static string SerializePadding(CryptoPadding padding) + { + XmlDocument doc = new XmlDocument(); + doc.AppendChild(padding.GetParameters().Compile(doc)); + + string output; + using (var stream = new MemoryStream()) + { + XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8); + doc.WriteTo(writer); + writer.Flush(); + stream.Position = 0; + using (var reader = new StreamReader(stream)) + { + output = reader.ReadToEnd(); + } + } + return output; + } + + // WIP + public static string NetSerialize(CryptoPadding padding) => NetSerialize(padding.GetParameters(), new StringBuilder()).ToString(); + public static string NetSerialize(PaddingIdentifier padding) => NetSerialize(padding, new StringBuilder()).ToString(); + public static StringBuilder NetSerialize(PaddingIdentifier id, StringBuilder builder) + { + builder.Append(id.Name).Append('{'); + foreach (string key in id.AttributeKeys) builder.Append(id.GetAttribute(key).Item2).Append(','); + foreach (string key in id.NestedKeys) NetSerialize(id.GetNested(key), builder).Append(','); + if (id.AttributeKeys.Count > 0 || id.NestedKeys.Count > 0) builder.Remove(builder.Length - 1, 1); // Remove last ',' + builder.Append('}'); + return builder; + } + + // Works but is really large + public static CryptoPadding DeserializePadding(string ser) => DeserializePadding(ser, new DummyRandomProvider()); + public static CryptoPadding DeserializePadding(string ser, RandomProvider provider) + { + XmlDocument doc = new XmlDocument(); + doc.LoadXml(ser); + XmlNodeList lst = doc.ChildNodes; + if (lst.Count != 1) throw new XMLCryptoParseException("Cannot have more than one root node!"); + return ParseNode(lst.Item(0), provider); + } + + + private static CryptoPadding ParseNode(XmlNode el, RandomProvider provider) + { + XmlNodeList lst; + switch (el.Name) + { + case "P": + return new PassthroughPadding(); + case "S": + { + SequentialPadding seq = new SequentialPadding(); + if (el.HasChildNodes) + { + lst = el.ChildNodes; + foreach (XmlNode subNode in lst) seq.WithPadding(ParseNode(subNode, provider)); + } + return seq; + } + case "I": + { + if (el.HasChildNodes && (lst = el.ChildNodes).Count == 2) + { + int increments; + if (!TryParseNumberNode("increments", lst, out increments)) + throw new XMLCryptoParseException("Invalid parameter supplied"); + int determiner; + if (!TryParseNumberNode("determiner", lst, out determiner)) + throw new XMLCryptoParseException("Invalid parameter supplied"); + return new IncrementalPadding(provider, determiner, increments); + } + else throw new XMLCryptoParseException("No parameters supplied"); + } + case "R": + { + if (el.HasChildNodes && (lst = el.ChildNodes).Count == 2) + { + byte[] delimiter = TryParseByteNode("delimiter", lst); + if (delimiter == null) throw new XMLCryptoParseException("Invalid parameter supplied"); + int maxLen; + if (!TryParseNumberNode("maxLen", lst, out maxLen)) + throw new XMLCryptoParseException("Invalid parameter supplied"); + return new RandomLengthPadding(provider, delimiter, (ushort)maxLen); + } + else throw new XMLCryptoParseException("No parameters supplied"); + } + default: + throw new XMLCryptoParseException($"Unrecognized padding algorithm \"{el.Name}\""); + + } + } + + private static bool TryParseNumberNode(string name, XmlNodeList from, out int val) + { + XmlNode node = Support.ContainsNamedNode(name, from); + val = 0; + return node != null && int.TryParse(node.InnerText, out val); + } + + public static byte[] TryParseByteNode(string name, XmlNodeList from) + { + XmlNode node = Support.ContainsNamedNode(name, from); + if (node == null) return null; + List collect = new List(); + Match m = byteFinder.Match(node.InnerText); + while (m.Success) + { + collect.Add(byte.Parse(m.Groups[1].Value)); + m = m.NextMatch(); + } + return collect.ToArray(); + } + + + public class XMLCryptoParseException : SystemException + { + public XMLCryptoParseException() { } + public XMLCryptoParseException(string message) : base(message) { } + public XMLCryptoParseException(string message, Exception innerException) : base(message, innerException) { } + } + } + + // Exception related to padding errors + public class InvalidPaddingException : SystemException + { + public InvalidPaddingException() { } + public InvalidPaddingException(string message) : base(message) { } + public InvalidPaddingException(string message, Exception innerException) : base(message, innerException) { } + } +} diff --git a/RedpilledOuttaCucktown/Properties/AssemblyInfo.cs b/RedpilledOuttaCucktown/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..0339f7c --- /dev/null +++ b/RedpilledOuttaCucktown/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("RSAProject")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("RSAProject")] +[assembly: AssemblyCopyright("Copyright © 2018")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("216005de-c35b-4cd3-8d27-0a49deede62c")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/RedpilledOuttaCucktown/Support.cs b/RedpilledOuttaCucktown/Support.cs new file mode 100644 index 0000000..e96a14a --- /dev/null +++ b/RedpilledOuttaCucktown/Support.cs @@ -0,0 +1,425 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Net; +using System.Numerics; +using System.Security.Cryptography; +using System.Text; +using System.Threading.Tasks; +using System.Xml; + +namespace Tofvesson.Crypto +{ + public static class Support + { + // -- Math -- + public static BigInteger Invert(BigInteger b) + { + byte[] arr = b.ToByteArray(); + for (int i = 0; i < arr.Length; ++i) arr[i] ^= 255; + BigInteger integer = new BigInteger(arr); + integer += 1; + return integer; + } + + public static BigInteger ModExp(BigInteger b, BigInteger e, BigInteger m) + { + int count = e.ToByteArray().Length * 8; + BigInteger result = BigInteger.One; + b = b % m; + while (count>0) + { + if (e % 2 != 0) result = (result * b) % m; + b = (b * b) % m; + e >>= 1; + --count; + } + return result; + } + + /// + /// Uses the fermat test a given amount of times to test whether or not a supplied interger is probably prime. + /// + /// Value to test primality of + /// Random provider used to generate values to test b against + /// How many times the test should be performed. More iterations means higher certainty, but at the cost of performance! + /// Whether or not the given value is probably prime or not + public static bool IsProbablePrime(BigInteger b, RandomProvider provider, int certainty) + { + BigInteger e = b - 1; + byte[] b1 = b.ToByteArray(); + byte last = b1[b1.Length-1]; + int len = b1.Length - 1; + for (int i = 0; i < certainty; ++i) + { + byte[] gen = new byte[provider.NextInt(len)+1]; + provider.GetBytes(gen); + if (last != 0 && gen.Length==len+1) gen[gen.Length - 1] %= last; + else gen[gen.Length - 1] &= 127; + + BigInteger test = new BigInteger(gen); + if (ModExp(test, e, b) != 1) return false; + } + return true; + } + + /// + /// Calculate the greatest common divisor for two values. + /// + /// First value + /// Second value + /// The greatest common divisor + public static BigInteger GCD(BigInteger b1, BigInteger b2) + { + BigInteger tmp; + while ((tmp = b1 % b2) != 0) + { + b1 = b2; + b2 = tmp; + } + return b2; + } + + /// + /// Linear diophantine equations. Calculates the modular multiplicative inverse for a given value and a given modulus. + /// For: ax + by = 1 + /// Where 'a' and 'b' are known factors + /// + /// First known factor (a) + /// Second known factor (b) + /// A pair of factors that fulfill the aforementioned equations (if possible), where Item1 corresponds to 'x' and Item2 corresponds to 'y'. If the two supplied known factors are not coprime, both factors will be 0 + public static KeyValuePair Dio(BigInteger in1, BigInteger in2) + { + // Euclidean algorithm + BigInteger tmp; + var i1 = in1; + var i2 = in2; + if (i1 <= BigInteger.Zero || i2 <= BigInteger.Zero || i1 == i2 || i1 % i2 == BigInteger.Zero || i2 % i1 == BigInteger.Zero) + { + return new KeyValuePair(BigInteger.Zero, BigInteger.Zero); + } + var minusOne = new BigInteger(-1); + var e_m = new BigInteger(-1L); + var collect = new Stack(); + while ((e_m = i1 % i2) != BigInteger.Zero) + { + collect.Push(i1 / i2 * minusOne); + i1 = i2; + i2 = e_m; + } + + // There are no solutions because 'a' and 'b' are not coprime + if (i2 != BigInteger.One) + return new KeyValuePair(BigInteger.Zero, BigInteger.Zero); + + + // Extended euclidean algorithm + var restrack_first = BigInteger.One; + var restrack_second = collect.Pop(); + + while (collect.Count > 0) + { + tmp = restrack_second; + restrack_second = restrack_first + restrack_second * collect.Pop(); + restrack_first = tmp; + } + return new KeyValuePair(restrack_first, restrack_second); + } + + /// + /// Generate a prime number using with a given approximate length and byte length margin + /// + /// How many threads to use to generate primes + /// The byte array length around which the prime generator will select lengths + /// Allowed deviation of byte length from approximateByteCount + /// How many iterations of the fermat test should be run to test primailty for each generated number + /// Random provider that will be used to generate random primes + /// A prime number that is aproximately approximateByteCount long + public static BigInteger GeneratePrime(int threads, int approximateByteCount, int byteMargin, int certainty, RandomProvider provider) + { + var found = false; + BigInteger result = BigInteger.Zero; + for(int i = 0; i + { + char left = '\0'; + byte rand = 0; + BigInteger b = BigInteger.Zero; + while (!found) + { + if (left == 0) + { + rand = provider.GetBytes(1)[0]; + left = (char)8; + } + + byte[] b1 = provider.GetBytes(approximateByteCount + (provider.GetBytes(1)[0] % byteMargin) * (rand % 2 == 1 ? 1 : -1)); + b1[0] |= 1; // Always odd + b1[b1.Length - 1] &= 127; // Always positive + b = new BigInteger(b1); + rand >>= 1; + --left; + if (IsProbablePrime(b, provider, certainty)) + { + found = true; + result = b; + } + } + }); + while (!found) System.Threading.Thread.Sleep(125); + return result; + } + + + + // -- Net -- + /// + /// Finds an IPv4a address in the address list. + /// + /// IPHostEntry to get the address from + /// An IPv4 address if available, otherwise null + public static IPAddress GetIPV4(this IPHostEntry entry) + { + foreach (IPAddress addr in entry.AddressList) + if (addr.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) + return addr; + return null; + } + + + // -- Arrays/Collections -- + /// + /// Pad or truncate this array to the specified length. Padding is performed by filling the new indicies with 0's. Truncation removes bytes from the end. + /// + /// The array type + /// The array to resize + /// Target length + /// A resized array + public static T[] ToLength(this T[] t, int length) + { + var t1 = new T[length]; + Array.Copy(t, t1, Math.Min(length, t.Length)); + return t1; + } + + /// + /// Reads a serialized 32-bit integer from the byte collection + /// + /// + /// + /// + public static int ReadInt(IEnumerable data, int offset) + { + int result = 0; + for (int i = 0; i < 4; ++i) + result |= data.ElementAt(i + offset) << (i * 8); + return result; + } + + public static int ArrayContains(byte[] b, byte[] seq, bool fromStart = true) + { + int track = 0; + for (int i = fromStart ? 0 : b.Length - 1; (fromStart && i < b.Length) || (!fromStart && i >= 0); i+=fromStart?1:-1) + if (b[i] == seq[fromStart?track:seq.Length - 1 - track]) + { + if (++track == seq.Length) return i; + } + else track = 0; + return -1; + } + + public static byte[] WriteToArray(byte[] target, int data, int offset) + { + for (int i = 0; i < 4; ++i) + target[i + offset] = (byte)((data >> (i * 8))&255); + return target; + } + + public static void ArrayCopy(IEnumerable source, int sourceOffset, T[] destination, int offset, int length) + { + for (int i = 0; i < length; ++i) destination[i + offset] = source.ElementAt(i+sourceOffset); + } + + public static string ArrayToString(byte[] array) + { + StringBuilder builder = new StringBuilder().Append('['); + for (int i = 0; i < array.Length; ++i) + { + builder.Append(array[i]); + if (i != array.Length - 1) builder.Append(", "); + } + return builder.Append(']').ToString(); + } + + public static void EnqueueAll(this Queue q, IEnumerable items, int offset, int length) + { + for (int i = 0; i < length; ++i) q.Enqueue(items.ElementAt(i+offset)); + } + public static T[]Dequeue(this Queue q, int count) + { + T[] t = new T[count]; + for (int i = 0; i < count; ++i) t[i] = q.Dequeue(); + return t; + } + + public static byte[] SerializeBytes(byte[][] bytes) + { + int collectSize = 0; + for (int i = 0; i < bytes.Length; ++i) collectSize += bytes[i].Length; + byte[] output = new byte[collectSize + 4*bytes.Length]; + collectSize = 0; + for(int i = 0; i message.Length - offset - 4 || (i!=messageCount-1 && size==message.Length-offset-4)) + throw new IndexOutOfRangeException("Attempted to read more bytes than are available"); + offset += 4; + output[i] = new byte[size]; + Array.Copy(message, offset, output[i], 0, size); + offset += size; + } + return output; + } + + + // -- Misc -- + // Allows deconstruction when iterating over a collection of Tuples + public static void Deconstruct(this Tuple tuple, out T1 key, out T2 value) + { + key = tuple.Item1; + value = tuple.Item2; + } + public static XmlNode ContainsNamedNode(string name, XmlNodeList lst) + { + for (int i = lst.Count - 1; i >= 0; --i) + if (lst.Item(i).Name.Equals(name)) + return lst.Item(i); + return null; + } + + public static bool ReadYNBool(this TextReader reader, string nonDefault) => reader.ReadLine().ToLower().Equals(nonDefault); + } + + public static class RandomSupport + { + public static BigInteger GenerateBoundedRandom(BigInteger max, RandomProvider provider) + { + byte[] b = max.ToByteArray(); + byte maxLast = b[b.Length - 1]; + provider.GetBytes(b); + if(maxLast!=0) b[b.Length - 1] %= maxLast; + b[b.Length - 1] |= 127; + return new BigInteger(b); + } + } + + public sealed class RegularRandomProvider : RandomProvider + { + private Random rand; + public RegularRandomProvider(Random rand) { this.rand = rand; } + public RegularRandomProvider() : this(new Random(Environment.TickCount)) {} + + // Copy our random reference to the other provider: share a random object + public void share(RegularRandomProvider provider) => provider.rand = this.rand; + + public override byte[] GetBytes(int count) => GetBytes(new byte[count]); + + public override byte[] GetBytes(byte[] buffer) + { + rand.NextBytes(buffer); + return buffer; + } + } + + public sealed class CryptoRandomProvider : RandomProvider + { + private RNGCryptoServiceProvider rand; + public CryptoRandomProvider(RNGCryptoServiceProvider rand) { this.rand = rand; } + public CryptoRandomProvider() : this(new RNGCryptoServiceProvider()) { } + + // Copy our random reference to the other provider: share a random object + public void share(CryptoRandomProvider provider) => provider.rand = this.rand; + + public override byte[] GetBytes(int count) => GetBytes(new byte[count]); + + public override byte[] GetBytes(byte[] buffer) + { + rand.GetBytes(buffer); + return buffer; + } + } + + public sealed class DummyRandomProvider : RandomProvider + { + public override byte[] GetBytes(int count) => new byte[count]; + + public override byte[] GetBytes(byte[] buffer) + { + for (int i = 0; i < buffer.Length; ++i) buffer[i] = 0; + return buffer; + } + } + + public abstract class RandomProvider + { + public abstract byte[] GetBytes(int count); + public abstract byte[] GetBytes(byte[] buffer); + + // Randomly generates a shortinteger bounded by the supplied integer. If bounding value is <= 0, it will be ignored + public ushort NextUShort(ushort bound = 0) + { + byte[] raw = GetBytes(2); + ushort result = 0; + for (byte s = 0; s < 2; ++s) + { + result <<= 8; + result |= raw[s]; + } + return (ushort) (bound > 0 ? result % bound : result); + } + + // Randomly generates an integer bounded by the supplied integer. If bounding value is <= 0, it will be ignored + public uint NextUInt(uint bound = 0) + { + byte[] raw = GetBytes(4); + uint result = 0; + for (byte s = 0; s < 4; ++s) + { + result <<= 8; + result |= raw[s]; + } + return bound > 0 ? result % bound : result; + } + + // Randomly generates a long integer bounded by the supplied integer. If bounding value is <= 0, it will be ignored + public ulong NextULong(ulong bound = 0) + { + byte[] raw = GetBytes(8); + ulong result = 0; + for (byte s = 0; s < 8; ++s) + { + result <<= 8; + result |=raw[s]; + } + return bound > 0 ? result % bound : result; + } + + public short NextShort(short bound = 0) => (short)NextUInt((ushort)bound); + public int NextInt(int bound = 0) => (int) NextUInt((uint) bound); + public long NextLong(long bound = 0) => (long)NextULong((ulong)bound); + } +} diff --git a/Server/App.config b/Server/App.config new file mode 100644 index 0000000..731f6de --- /dev/null +++ b/Server/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Server/Program.cs b/Server/Program.cs new file mode 100644 index 0000000..3816274 --- /dev/null +++ b/Server/Program.cs @@ -0,0 +1,96 @@ +using Tofvesson.Crypto; +using System; + +namespace Server +{ + class Program + { + static void Main(string[] args) + { + bool verbose = false; + // Prepare crypto + RandomProvider provider = new RegularRandomProvider(); + RSA func = LoadRSA(provider); + if (func == null) func = GenerateRSA(); + + Console.WriteLine("Server starting!\nType \"help\" for a list of serverside commands"); + + NetServer server = new NetServer(func, 1337, (string message, out bool keepAlive) => + { + if(verbose) Console.WriteLine("Got message from client: " + message); + keepAlive = true; + return "Alright!"; + }, + client => + { + if (verbose) Console.WriteLine($"Client has connected: {client.ToString()}"); + }); + server.StartListening(); + + while (server.Running) + { + string s = Console.ReadLine().ToLower(); + if (s.Equals("help")) + Console.WriteLine("Available commands:\n\tcount\t\t-\tShow active client count\n\tstop\t\t-\tStop server\n\ttv\t\t-\tToggle server verbosity\n\tsv\t\t-\tDisplay current server verbosity setting"); + else if (s.Equals("count")) + Console.WriteLine("Active client count: " + server.Count); + else if (s.Equals("stop")) + { + Console.WriteLine("Stopping server..."); + server.StopRunning(); + } + else if (s.Equals("tv")) Console.WriteLine("Set verbosity to: " + (verbose = !verbose)); + else if (s.Equals("sv")) Console.WriteLine("Current server verbosity: " + verbose); + } + } + + + public static RSA LoadRSA(RandomProvider provider) + { + RSA func = null; + Console.Write("Would you like to load RSA keys from files? (y/N): "); + while (Console.In.ReadYNBool("y")) + { + try + { + Console.Write("Enter base file name: "); + func = RSA.TryLoad(Console.ReadLine()); + if (func.GetPK() == null) throw new NullReferenceException(); + Console.WriteLine("Sucessfully loaded keys!"); + break; + } + catch (Exception) + { + Console.Write("One or more of the required key files could not be located. Would you like to retry? (y/N): "); + } + } + return func; + } + + public static RSA GenerateRSA() + { + RSA func; + int read; + do + { + Console.Write("Enter encryption key size (bytes >= 96): "); + } while (!int.TryParse(Console.ReadLine(), out read) || read < 96); + + Console.WriteLine("Generating keys..."); + + func = new RSA(read, 4, 8, 20); + + Console.Write("Done! Would you like to save the keys? (y/N): "); + if (Console.In.ReadYNBool("y")) + { + Console.Write("Enter the base file name to be used: "); + try + { + func.Save(Console.ReadLine(), true); + } + catch (Exception) { Console.WriteLine("An error ocurred while attempting to save keys!"); } + } + return func; + } + } +} diff --git a/Server/Properties/AssemblyInfo.cs b/Server/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..92a892b --- /dev/null +++ b/Server/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Server")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Server")] +[assembly: AssemblyCopyright("Copyright © 2018")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("4c426072-e087-431b-a8bc-4ba675c6d06a")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Server/Server.csproj b/Server/Server.csproj new file mode 100644 index 0000000..c880380 --- /dev/null +++ b/Server/Server.csproj @@ -0,0 +1,58 @@ + + + + + Debug + AnyCPU + {4C426072-E087-431B-A8BC-4BA675C6D06A} + Exe + Server + Server + v4.6.1 + 512 + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + {216005DE-C35B-4CD3-8D27-0A49DEEDE62C} + Common + + + + \ No newline at end of file diff --git a/ServerProject b/ServerProject new file mode 160000 index 0000000..9963345 --- /dev/null +++ b/ServerProject @@ -0,0 +1 @@ +Subproject commit 996334583daebe9450069e5d6316d2daf88dd27f