Example #1
0
        /// <summary>
        /// <para>
        /// Upserts the cache entry with an expiration time defined by <see cref="Cache.DurationSeconds"/>.
        /// After this period, it's no longer possible to reconnect a Blazor session back to the server,
        /// so we remove the entry from the cache.
        /// </para>
        /// </summary>
        /// <param name="context">The <see cref="HttpContext"/>.</param>
        /// <param name="cache">The Cache.</param>
        /// <param name="cipher">The AES Cipher used to encrypt/decrypt cookies.</param>
        /// <param name="cacheOptions">The Cache options.</param>
        /// <param name="logger">The <see cref="INeonLogger"/></param>
        /// <returns></returns>
        public async Task InvokeAsync(
            HttpContext context,
            Service service,
            IDistributedCache cache,
            AesCipher cipher,
            DistributedCacheEntryOptions cacheOptions,
            INeonLogger logger)
        {
            await SyncContext.Clear;

            await _next(context);

            if (service.CurrentConnections.Contains(context.Connection.Id))
            {
                var cookie    = context.Request.Cookies.Where(c => c.Key == Service.SessionCookieName).First();
                var sessionId = cipher.DecryptStringFrom(cookie.Value);
                var session   = NeonHelper.JsonDeserialize <Session>(await cache.GetAsync(sessionId));

                if (session.ConnectionId == context.Connection.Id)
                {
                    await cache.SetAsync(session.Id, NeonHelper.JsonSerializeToBytes(session), cacheOptions);

                    WebsocketMetrics.CurrentConnections.Dec();
                    service.CurrentConnections.Remove(context.Connection.Id);
                }
            }
        }
Example #2
0
        public void UniqueOutput()
        {
            // Verify that we generate and use a unique IV for
            // every encryption run such that encrypting the same
            // data will return different results.  This is an
            // important security best practice.

            const int iterations = 1000;

            var decrypted   = "We hold these truths to be self-evident, that all men are created equal.";
            var encryptions = new HashSet <string>();

            using (var cipher = new AesCipher())
            {
                for (int i = 0; i < iterations; i++)
                {
                    var encrypted = cipher.EncryptToBase64(decrypted);

                    Assert.DoesNotContain(encrypted, encryptions);
                    Assert.Equal(decrypted, cipher.DecryptStringFrom(encrypted));

                    encryptions.Add(encrypted);
                }
            }
        }
Example #3
0
        public void UniqueKeys()
        {
            const int iterations = 1000;

            // Generate a number of keys of each valid size and ensure that each key is unique.

            foreach (var size in sizes)
            {
                var keys = new HashSet <string>();

                for (int i = 0; i < iterations; i++)
                {
                    var key = AesCipher.GenerateKey(size);

                    Assert.NotNull(key);

                    var keyBytes = Convert.FromBase64String(key);

                    Assert.Equal(size, keyBytes.Length * 8);
                    Assert.DoesNotContain(key, keys);

                    keys.Add(key);
                }
            }
        }
        public void AesCipher_Encryption_Test()
        {
            var encryption  = AesCipher.AESEncrypt("VeyselMUTLU");
            var descryption = AesCipher.AESDecrypt(encryption);

            Assert.AreEqual("VeyselMUTLU", descryption);
        }
Example #5
0
        static void Main(string[] args)
        {
            var userkey = new byte[] //europe maplestory key
            {
                0x13, 0x00, 0x00, 0x00,
                0x08, 0x00, 0x00, 0x00,
                0x06, 0x00, 0x00, 0x00,
                0xB4, 0x00, 0x00, 0x00,
                0x1B, 0x00, 0x00, 0x00,
                0x0F, 0x00, 0x00, 0x00,
                0x33, 0x00, 0x00, 0x00,
                0x52, 0x00, 0x00, 0x00
            };

            var aes = new AesCipher(userkey);

            var info = new ServerInfo()
            {
                Version    = 97,
                Subversion = "1",
                Locale     = 9
            };

            using (var acceptor = new Acceptor(info, aes, 8484))
            {
                acceptor.OnClientAccepted += OnClientAccepted;
                acceptor.Start();

                Console.ReadLine();
            }
        }
Example #6
0
        static VaultSecureContainer ConfigureContainer()
        {
            var vault  = new FileSystemVault(".", "store.vault");
            var cipher = new AesCipher();

            return(new VaultSecureContainer(vault, cipher));
        }
Example #7
0
        public void TamperDetection()
        {
            // Tamper with an encrypted payload and verify that this
            // is detected via the HMAC signature.

            using (var cipher = new AesCipher())
            {
                var decrypted = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
                var encrypted = cipher.EncryptToBytes(decrypted);

                Assert.Equal(decrypted, cipher.DecryptBytesFrom(encrypted));

                // Modify the last byte and ensure that decryption fails.

                var tampered = Clone(encrypted);

                tampered[encrypted.Length - 1] = (byte)(~tampered[encrypted.Length - 1]);

                Assert.Throws <CryptographicException>(() => cipher.DecryptBytesFrom(tampered));

                // Remove the last byte and ensure that decryption fails.

                tampered = new byte[encrypted.Length - 1];

                for (int i = 0; i < tampered.Length; i++)
                {
                    tampered[i] = encrypted[i];
                }

                Assert.Throws <CryptographicException>(() => cipher.DecryptBytesFrom(tampered));
            }
        }
        /* TODO ERROR: Skipped EndRegionDirectiveTrivia */
        /* TODO ERROR: Skipped RegionDirectiveTrivia */
        public environmentVarsCore load()
        {
            state.secretKey = state.SettingsSecretKey;
            var encryption   = new AesCipher(state);
            var settingsFile = new FileInfo(Path.Combine(state.libraryPath, "ScrewDriver.eon"));

            settingsFile.Refresh();
            if (settingsFile.Exists)
            {
                try
                {
                    var    bytes     = File.ReadAllBytes(Path.Combine(state.libraryPath, "ScrewDriver.eon"));
                    string encrypted = Convert.ToBase64String(bytes, 0, bytes.Length);
                    string decrypted = encryption.decrypt(encrypted);
                    var    data      = JsonConvert.DeserializeObject <Dictionary <string, object> >(decrypted);
                    state.country            = data["country"].ToString();
                    state.currentLang        = data["language"].ToString();
                    state.ServerBaseAddr     = data["serverAddress"].ToString();
                    state.ApiServerAddrPath  = data["ApiServerAddrPath"].ToString();
                    state.secretKey          = data["ApiEncryptionKey"].ToString();
                    state.SendDiagnosticData = Convert.ToBoolean(data["sendDiags"]);
                    state.SendCrashData      = Convert.ToBoolean(data["sendCrash"]);
                    return(state);
                }
                catch (Exception ex)
                {
                    hasError     = true;
                    errorMessage = ex.ToString();
                    return(default);
Example #9
0
        /// <summary>
        /// Encrypts packet data
        /// </summary>
        public Span <byte> Encrypt(ReadOnlySpan <byte> data, bool toClient)
        {
            if (!Handshaken || MapleIv == null)
            {
                return(null);
            }

            var newData = new byte[data.Length + 4].AsSpan();
            var header  = newData.Slice(0, 4);
            var content = newData.Slice(4, data.Length);

            data.CopyTo(content);

            if (toClient)
            {
                WriteHeaderToClient(header, data.Length);
            }
            else
            {
                WriteHeaderToServer(header, data.Length);
            }

            EncryptShanda(content);
            AesCipher?.AesTransform(content, MapleIv.Bytes);
            MapleIv.Shuffle();


            return(newData);
        }
Example #10
0
        public static byte[] GenerateRandomKey(int?keyLength = null, CipherMode?mode = null)
        {
            if (keyLength.HasValue)
            {
                ValidateKeyLength(keyLength.Value);
            }

            return(AesCipher.GenerateKey(mode, keyLength));
        }
Example #11
0
        public void DefaultKeySize()
        {
            // Verify that the default key size is 256 bits.

            var key = AesCipher.GenerateKey();

            Assert.NotNull(key);
            Assert.Equal(256, Convert.FromBase64String(key).Length * 8);
        }
Example #12
0
        public void AesCipherConstructorTest()
        {
            byte[]        key     = null; // TODO: Initialize to an appropriate value
            CipherMode    mode    = null; // TODO: Initialize to an appropriate value
            CipherPadding padding = null; // TODO: Initialize to an appropriate value
            AesCipher     target  = new AesCipher(key, mode, padding);

            Assert.Inconclusive("TODO: Implement code to verify target");
        }
Example #13
0
        static void Main()
        {
            cipher = new AesCipher(userKey);
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            client = new Client(IPAddress.Parse(loginIP), loginPort, cipher);
            gui    = new MainForm();
            Application.Run(gui);
        }
Example #14
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="logger"></param>
 /// <param name="logger"></param>
 public SessionTransformer(
     IDistributedCache cache,
     INeonLogger logger,
     DistributedCacheEntryOptions cacheOptions,
     AesCipher cipher)
 {
     this.cache        = cache;
     this.logger       = logger;
     this.cacheOptions = cacheOptions;
     this.cipher       = cipher;
 }
Example #15
0
        public void Encrypt_Input_128_CBC()
        {
            var input      = new byte[] { 0x00, 0x00, 0x00, 0x2c, 0x1a, 0x05, 0x00, 0x00, 0x00, 0x0c, 0x73, 0x73, 0x68, 0x2d, 0x75, 0x73, 0x65, 0x72, 0x61, 0x75, 0x74, 0x68, 0x30, 0x9e, 0xe0, 0x9c, 0x12, 0xee, 0x3a, 0x30, 0x03, 0x52, 0x1c, 0x1a, 0xe7, 0x3e, 0x0b, 0x9a, 0xcf, 0x9a, 0x57, 0x42, 0x0b, 0x4f, 0x4a, 0x15, 0xa0, 0xf5 };
            var key        = new byte[] { 0xe4, 0x94, 0xf9, 0xb1, 0x00, 0x4f, 0x16, 0x2a, 0x80, 0x11, 0xea, 0x73, 0x0d, 0xb9, 0xbf, 0x64 };
            var iv         = new byte[] { 0x74, 0x8b, 0x4f, 0xe6, 0xc1, 0x29, 0xb3, 0x54, 0xec, 0x77, 0x92, 0xf3, 0x15, 0xa0, 0x41, 0xa8 };
            var expected   = new byte[] { 0x19, 0x7f, 0x80, 0xd8, 0xc9, 0x89, 0xc4, 0xa7, 0xc6, 0xc6, 0x3f, 0x9f, 0x1e, 0x00, 0x1f, 0x72, 0xa7, 0x5e, 0xde, 0x40, 0x88, 0xa2, 0x72, 0xf2, 0xed, 0x3f, 0x81, 0x45, 0xb6, 0xbd, 0x45, 0x87, 0x15, 0xa5, 0x10, 0x92, 0x4a, 0x37, 0x9e, 0xa9, 0x80, 0x1c, 0x14, 0x83, 0xa3, 0x39, 0x45, 0x28 };
            var testCipher = new AesCipher(key, new CbcCipherMode(iv), null);

            var actual = testCipher.Encrypt(input);

            Assert.IsTrue(actual.IsEqualTo(expected));
        }
Example #16
0
        public void Decrypt_AES_128_CTR()
        {
            var input      = new byte[] { 0x00, 0x00, 0x00, 0x2c, 0x1a, 0x05, 0x00, 0x00, 0x00, 0x0c, 0x73, 0x73, 0x68, 0x2d, 0x75, 0x73, 0x65, 0x72, 0x61, 0x75, 0x74, 0x68, 0xb0, 0x74, 0x21, 0x87, 0x16, 0xb9, 0x69, 0x48, 0x33, 0xce, 0xb3, 0xe7, 0xdc, 0x3f, 0x50, 0xdc, 0xcc, 0xd5, 0x27, 0xb7, 0xfe, 0x7a, 0x78, 0x22, 0xae, 0xc8 };
            var key        = new byte[] { 0x17, 0x78, 0x56, 0xe1, 0x3e, 0xbd, 0x3e, 0x50, 0x1d, 0x79, 0x3f, 0x0f, 0x55, 0x37, 0x45, 0x54 };
            var iv         = new byte[] { 0xe6, 0x65, 0x36, 0x0d, 0xdd, 0xd7, 0x50, 0xc3, 0x48, 0xdb, 0x48, 0x07, 0xa1, 0x30, 0xd2, 0x38 };
            var output     = new byte[] { 0xca, 0xfb, 0x1c, 0x49, 0xbf, 0x82, 0x2a, 0xbb, 0x1c, 0x52, 0xc7, 0x86, 0x22, 0x8a, 0xe5, 0xa4, 0xf3, 0xda, 0x4e, 0x1c, 0x3a, 0x87, 0x41, 0x1c, 0xd2, 0x6e, 0x76, 0xdc, 0xc2, 0xe9, 0xc2, 0x0e, 0xf5, 0xc7, 0xbd, 0x12, 0x85, 0xfa, 0x0e, 0xda, 0xee, 0x50, 0xd7, 0xfd, 0x81, 0x34, 0x25, 0x6d };
            var testCipher = new AesCipher(key, new CtrCipherMode(iv), null);

            var actual = testCipher.Decrypt(output);

            Assert.IsTrue(input.IsEqualTo(actual));
        }
Example #17
0
            static void Test(AesProvider aesProvider)
            {
                var text   = Guid.NewGuid().ToString();
                var cipher = aesProvider.Encrypt(text.Bytes());

                var bytes   = cipher.ToBytes();
                var _cipher = new AesCipher().FromBytes(bytes);

                var source = aesProvider.Decrypt(_cipher).String();

                Assert.Equal(text, source);
            }
Example #18
0
        public void Streams()
        {
            // Verify that we can encrypt and decrypt streams.

            var decryptedBytes = new byte[32 * 1024];
            var encryptedBytes = (byte[])null;
            var key            = string.Empty;

            // Encrypt some bytes.

            for (int i = 0; i < decryptedBytes.Length; i++)
            {
                decryptedBytes[i] = (byte)i;
            }

            using (var decryptedStream = new MemoryStream(decryptedBytes))
            {
                using (var encryptedStream = new MemoryStream())
                {
                    using (var cipher = new AesCipher())
                    {
                        cipher.EncryptStream(decryptedStream, encryptedStream);

                        // Save the key and encrypted data so we can test decryption below.

                        encryptedBytes = encryptedStream.ToArray();
                        key            = cipher.Key;
                    }

                    // Verify that the two streams haven't been dispoed.

                    decryptedStream.Position = 0;
                    encryptedStream.Position = 0;
                }
            }

            // Decrypt the encypted data and verify.

            using (var encryptedStream = new MemoryStream(encryptedBytes))
            {
                using (var decryptedStream = new MemoryStream())
                {
                    using (var cipher = new AesCipher(key))
                    {
                        cipher.DecryptStream(encryptedStream, decryptedStream);
                    }

                    // Verify that the decrypted data matches the original.

                    Assert.Equal(decryptedBytes, decryptedStream.ToArray());
                }
            }
        }
        public bool Decrypt(EncryptedMessage encryptedMessage, int senderId, out string messageText)
        {
            if (encryptedMessage == null)
            {
                throw new ArgumentException("Encrypted message cannot be null");
            }

            if (encryptedMessage.Body == null || encryptedMessage.DigitalSignature == null ||
                encryptedMessage.SymmetricKey == null || encryptedMessage.Iv == null)
            {
                throw new ArgumentException("Not all encrypted message fields are initialized");
            }

            IContactModel senderContact = _storageService.GetContacts().FirstOrDefault(c => c.Id == senderId);

            if (senderContact == null)
            {
                throw new ArgumentException("Contact with id of senderId does not exist");
            }

            string receiverKeyPair = _storageService.GetUser().KeyPair;
            string senderPublicKey = senderContact.PublicKey;

            try
            {
                // decrypt symmetric key with receivers private key
                RsaCipher rsa = new RsaCipher(receiverKeyPair);
                byte[]    encryptedSymmetricKeyBytes = FormatConverter.String64ToBytes(encryptedMessage.SymmetricKey);
                byte[]    decryptedSymmetricKeyBytes = rsa.Decrypt(encryptedSymmetricKeyBytes);

                // decrypt message text with jsut decrypted symmetric key
                byte[]    ivBytes = FormatConverter.String64ToBytes(encryptedMessage.Iv);
                AesCipher aes     = new AesCipher(decryptedSymmetricKeyBytes, ivBytes);
                byte[]    encryptedMessageBytes = FormatConverter.String64ToBytes(encryptedMessage.Body);
                byte[]    decryptedMessageBytes = aes.Decrypt(encryptedMessageBytes);

                // set message text out parameter
                messageText = FormatConverter.BytesToString(decryptedMessageBytes);

                // verify digital signature
                rsa = new RsaCipher(senderPublicKey);
                byte[] digitalSignatureBytes = FormatConverter.String64ToBytes(encryptedMessage.DigitalSignature);
                bool   signatureOk           = rsa.VerifyDigitalSignature(decryptedMessageBytes, digitalSignatureBytes);

                return(signatureOk);
            }
            catch (Exception ex)
            {
                messageText = null;
                return(false);
            }
        }
Example #20
0
        internal Session(Socket socket, SessionType type, AesCipher aesCipher)
        {
            this.socket = socket;
            SessionType = type;

            Encrypted      = type != SessionType.CLIENT;
            this.aesCipher = aesCipher;
            Connected      = true;
            sendLock       = new object();
            packetBuffer   = new byte[RECEIVE_SIZE];
            recvBuffer     = new byte[RECEIVE_SIZE];
            cursor         = 0;
        }
Example #21
0
        public void Test_Cipher_AES_128_CBC()
        {
            var input      = new byte[] { 0x00, 0x00, 0x00, 0x2c, 0x1a, 0x05, 0x00, 0x00, 0x00, 0x0c, 0x73, 0x73, 0x68, 0x2d, 0x75, 0x73, 0x65, 0x72, 0x61, 0x75, 0x74, 0x68, 0x30, 0x9e, 0xe0, 0x9c, 0x12, 0xee, 0x3a, 0x30, 0x03, 0x52, 0x1c, 0x1a, 0xe7, 0x3e, 0x0b, 0x9a, 0xcf, 0x9a, 0x57, 0x42, 0x0b, 0x4f, 0x4a, 0x15, 0xa0, 0xf5 };
            var key        = new byte[] { 0xe4, 0x94, 0xf9, 0xb1, 0x00, 0x4f, 0x16, 0x2a, 0x80, 0x11, 0xea, 0x73, 0x0d, 0xb9, 0xbf, 0x64 };
            var iv         = new byte[] { 0x74, 0x8b, 0x4f, 0xe6, 0xc1, 0x29, 0xb3, 0x54, 0xec, 0x77, 0x92, 0xf3, 0x15, 0xa0, 0x41, 0xa8 };
            var output     = new byte[] { 0x19, 0x7f, 0x80, 0xd8, 0xc9, 0x89, 0xc4, 0xa7, 0xc6, 0xc6, 0x3f, 0x9f, 0x1e, 0x00, 0x1f, 0x72, 0xa7, 0x5e, 0xde, 0x40, 0x88, 0xa2, 0x72, 0xf2, 0xed, 0x3f, 0x81, 0x45, 0xb6, 0xbd, 0x45, 0x87, 0x15, 0xa5, 0x10, 0x92, 0x4a, 0x37, 0x9e, 0xa9, 0x80, 0x1c, 0x14, 0x83, 0xa3, 0x39, 0x45, 0x28 };
            var testCipher = new AesCipher(key, new CbcCipherMode(iv), null);
            var r          = testCipher.Encrypt(input);

            if (!r.SequenceEqual(output))
            {
                Assert.Fail("Invalid encryption");
            }
        }
Example #22
0
        protected void SerializeToFile(string filePath, object obj, ConfigurationFileInfo info)
        {
            Directory.CreateDirectory(Path.GetDirectoryName(filePath));
            StringWriter stringWriter = new StringWriter();
            JsonWriter   jsonWriter   = new JsonWriter(stringWriter);

            jsonWriter.Validate    = false;
            jsonWriter.PrettyPrint = true;
            JsonMapper.ToJson(obj, jsonWriter);
            string text     = stringWriter.ToString();
            string contents = (info.IsEncrypted ? AesCipher.Encrypt(text, info.EncryptionKey) : text);

            File.WriteAllText(filePath, contents);
        }
Example #23
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="aesCipher"></param>
 /// <param name="dexClient"></param>
 /// <param name="logger"></param>
 public SessionTransformer(
     IDistributedCache cache,
     AesCipher aesCipher,
     DexClient dexClient,
     INeonLogger logger,
     DistributedCacheEntryOptions cacheOptions)
 {
     this.cache        = cache;
     this.cipher       = aesCipher;
     this.dexClient    = dexClient;
     this.dexHost      = dexClient.BaseAddress.Host;
     this.logger       = logger;
     this.cacheOptions = cacheOptions;
 }
Example #24
0
        /// <inheritdoc/>
        protected async override Task <int> OnRunAsync()
        {
            await SetStatusAsync(NeonServiceStatus.Starting);

            Config = await ProxyConfig.FromFileAsync(GetConfigFilePath(ConfigFile));

            DnsClient = new LookupClient(new LookupClientOptions()
            {
                UseCache            = Config.Dns.UseCache,
                MaximumCacheTimeout = TimeSpan.FromSeconds(Config.Dns.MaximumCacheTimeoutSeconds),
                MinimumCacheTimeout = TimeSpan.FromSeconds(Config.Dns.MinimumCacheTimeoutSeconds),
                CacheFailedResults  = Config.Dns.CacheFailedResults
            });

            AesCipher = new AesCipher(GetEnvironmentVariable("COOKIE_CIPHER", AesCipher.GenerateKey(), redacted: !Log.IsLogDebugEnabled));

            CurrentConnections = new HashSet <string>();

            // Start the web service.

            webHost = new WebHostBuilder()
                      .ConfigureAppConfiguration(
                (hostingcontext, config) =>
            {
                config.Sources.Clear();
            })
                      .UseStartup <Startup>()
                      .UseKestrel(options => options.Listen(IPAddress.Any, Config.Port))
                      .ConfigureServices(services => services.AddSingleton(typeof(Service), this))
                      .UseStaticWebAssets()
                      .Build();

            _ = webHost.RunAsync();

            Log.LogInfo($"Listening on {IPAddress.Any}:{Config.Port}");

            // Indicate that the service is ready for business.

            await SetStatusAsync(NeonServiceStatus.Running);

            // Handle termination gracefully.

            await Terminator.StopEvent.WaitAsync();

            Terminator.ReadyToExit();

            return(0);
        }
Example #25
0
        /// <summary>
        /// Decrypts a maple packet contained in <paramref name="data"/>
        /// </summary>
        /// <param name="data">Data to decrypt</param>
        public Span <byte> Decrypt(Span <byte> data)
        {
            if (!Handshaken || MapleIv == null)
            {
                return(data);
            }

            var header  = data.Slice(0, 4);
            var length  = GetPacketLength(header);
            var content = data.Slice(4, length);

            AesCipher?.AesTransform(content, MapleIv.Bytes);
            MapleIv.Shuffle();
            DecryptShanda(content);

            return(content);
        }
 public OutputStreamEncryption(Stream outc, byte[] key, int off, int len, int revision)
 {
     Outc = outc;
     _aes = revision == Aes128;
     if (_aes)
     {
         byte[] iv   = IvGenerator.GetIv();
         byte[] nkey = new byte[len];
         Array.Copy(key, off, nkey, 0, len);
         Cipher = new AesCipher(true, nkey, iv);
         Write(iv, 0, iv.Length);
     }
     else
     {
         Arcfour = new ArcfourEncryption();
         Arcfour.PrepareArcfourKey(key, off, len);
     }
 }
Example #27
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="blazorProxyService">The <see cref="Service"/></param>
 /// <param name="config">The <see cref="ProxyConfig"/></param>
 /// <param name="httpClient">HttpClient for forwarding requests.</param>
 /// <param name="forwarder">The YARP forwarder.</param>
 /// <param name="cache">The cache used for storing session information.</param>
 /// <param name="aesCipher">The <see cref="AesCipher"/> used for cookie encryption.</param>
 /// <param name="dnsClient">The <see cref="LookupClient"/> for service discovery.</param>
 /// <param name="sessionTransformer">The <see cref="SessionTransformer"/>.</param>
 public BlazorController(
     Service blazorProxyService,
     ProxyConfig config,
     HttpMessageInvoker httpClient,
     IHttpForwarder forwarder,
     IDistributedCache cache,
     AesCipher aesCipher,
     LookupClient dnsClient,
     SessionTransformer sessionTransformer)
 {
     this.blazorProxyService = blazorProxyService;
     this.config             = config;
     this.httpClient         = httpClient;
     this.forwarder          = forwarder;
     this.cache       = cache;
     this.cipher      = aesCipher;
     this.transformer = sessionTransformer;
     this.dnsClient   = dnsClient;
 }
Example #28
0
        public void EncryptBlockTest()
        {
            byte[]        key     = null;                              // TODO: Initialize to an appropriate value
            CipherMode    mode    = null;                              // TODO: Initialize to an appropriate value
            CipherPadding padding = null;                              // TODO: Initialize to an appropriate value
            AesCipher     target  = new AesCipher(key, mode, padding); // TODO: Initialize to an appropriate value

            byte[] inputBuffer = null;                                 // TODO: Initialize to an appropriate value
            int    inputOffset = 0;                                    // TODO: Initialize to an appropriate value
            int    inputCount  = 0;                                    // TODO: Initialize to an appropriate value

            byte[] outputBuffer = null;                                // TODO: Initialize to an appropriate value
            int    outputOffset = 0;                                   // TODO: Initialize to an appropriate value
            int    expected     = 0;                                   // TODO: Initialize to an appropriate value
            int    actual;

            actual = target.EncryptBlock(inputBuffer, inputOffset, inputCount, outputBuffer, outputOffset);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }
Example #29
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="NeonSsoSessionProxyService"></param>
 /// <param name="httpClient"></param>
 /// <param name="forwarder"></param>
 /// <param name="cache"></param>
 /// <param name="aesCipher"></param>
 /// <param name="dexClient"></param>
 public AuthController(
     Service NeonSsoSessionProxyService,
     HttpMessageInvoker httpClient,
     IHttpForwarder forwarder,
     IDistributedCache cache,
     AesCipher aesCipher,
     DexClient dexClient,
     SessionTransformer sessionTransformer,
     DistributedCacheEntryOptions cacheOptions
     )
 {
     this.NeonSsoSessionProxyService = NeonSsoSessionProxyService;
     this.httpClient   = httpClient;
     this.forwarder    = forwarder;
     this.cache        = cache;
     this.cipher       = aesCipher;
     this.transformer  = sessionTransformer;
     this.dexClient    = dexClient;
     this.cacheOptions = cacheOptions;
 }
        public EncryptedMessage Encrypt(string messageText, int recieverId)
        {
            if (messageText == null)
            {
                throw new ArgumentException("Message text cannot be null");
            }

            IContactModel receiverContact = _storageService.GetContacts().FirstOrDefault(c => c.Id == recieverId);

            if (receiverContact == null)
            {
                throw new ArgumentException("Contact with id of receiverId does not exist");
            }

            EncryptedMessage encMsg = new EncryptedMessage();
            AesCipher        aes    = new AesCipher();

            // set initiazlization vector
            encMsg.Iv = FormatConverter.BytesToString64(aes.IV);

            // enccrypt message text symmetrically
            byte[] messageBytes          = FormatConverter.StringToBytes(messageText);
            byte[] encryptedMessageBytes = aes.Encrypt(messageBytes);
            encMsg.Body = FormatConverter.BytesToString64(encryptedMessageBytes);

            // encrypt symmetric key with receivers public key
            string    receiverPublicKey = receiverContact.PublicKey;
            RsaCipher rsa = new RsaCipher(receiverPublicKey);

            byte[] encryptedSymmetricKeyBytes = rsa.Encrypt(aes.Key);
            encMsg.SymmetricKey = FormatConverter.BytesToString64(encryptedSymmetricKeyBytes);

            // create digital signature of message text (using senders private key)
            string senderKeyPair = _storageService.GetUser().KeyPair;

            rsa = new RsaCipher(senderKeyPair);
            byte[] digitalSignatureBytes = rsa.CreateDigitalSignature(messageBytes);
            encMsg.DigitalSignature = FormatConverter.BytesToString64(digitalSignatureBytes);

            return(encMsg);
        }