コード例 #1
0
        /// <inheritdoc/>
        protected override void UpdateSettingsFrom1To2(XElement root)
        {
            base.UpdateSettingsFrom1To2(root);

            // Handle protected password
            XElement oldPasswortElement  = root.Element("cloud_storage")?.Element("cloud_password");
            XElement cloudStorageAccount = root.Element("cloud_storage_account");

            if ((oldPasswortElement != null) && (cloudStorageAccount != null))
            {
                // Deobfuscate old password
                EncryptorDecryptor decryptor    = new EncryptorDecryptor("snps");
                byte[]             binaryCipher = CryptoUtils.Base64StringToBytes(oldPasswortElement.Value);
                byte[]             unprotectedBinaryPassword = decryptor.Decrypt(binaryCipher, snpsk);

                // Protect with new data protection service and add to XML
                char[] unprotectedChars           = Encoding.UTF8.GetChars(unprotectedBinaryPassword);
                byte[] unprotectedUnicodePassword = Encoding.Unicode.GetBytes(unprotectedChars);
                string protectedPassword          = _dataProtectionService.Protect(unprotectedUnicodePassword);
                cloudStorageAccount.Add(new XElement("protected_password", protectedPassword));
                CryptoUtils.CleanArray(unprotectedBinaryPassword);
                CryptoUtils.CleanArray(unprotectedChars);
                CryptoUtils.CleanArray(unprotectedUnicodePassword);
            }
        }
コード例 #2
0
ファイル: Program.cs プロジェクト: RahulGo8u/devtools
        void PasswordEncryptorDecryptor()
        {
            Console.WriteLine("Please enter a passphrase to use:");
            string password = Console.ReadLine();

            Console.WriteLine("Please enter your string to encrypt:");
            string plaintext = Console.ReadLine();

            Console.WriteLine("");

            Console.WriteLine("Your encrypted string is:");
            string encryptedstring = EncryptorDecryptor.Encrypt(plaintext, password);

            Console.WriteLine(encryptedstring);
            Console.WriteLine("");

            Console.WriteLine("Your decrypted string is:");
            string decryptedstring = EncryptorDecryptor.Decrypt(encryptedstring, password);

            Console.WriteLine(decryptedstring);
            Console.WriteLine("");

            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();
        }
コード例 #3
0
        public void OkEncodeDecodeReplace()
        {
            // arrange
            var    encryptorDecryptor = new EncryptorDecryptor();
            var    inputFilePath      = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName, "CustomXdtTransforms.Tests", "TestAppConfigs", "TestApp.config");
            var    transformFilePath  = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName, "CustomXdtTransforms.Tests", "TestAppConfigs", "TestApp.Debug.config");
            string result;

            // act
            using (var input = new XmlTransformableDocument())
                using (var transformer = new XmlTransformation(transformFilePath))
                {
                    input.Load(inputFilePath);
                    transformer.Apply(input);

                    using (var stringWriter = new StringWriter())
                        using (var xmlWriter = XmlWriter.Create(stringWriter))
                        {
                            input.WriteContentTo(xmlWriter);
                            xmlWriter.Flush();
                            result = stringWriter.ToString();

                            var xmlDoc = XDocument.Parse(result);

                            var root = xmlDoc.Root;

                            // assert
                            var ecnrypteNode2          = root.Descendants("setting").Single(x => x.Attribute("name").Value == "ExpectedEncrypted2");
                            var ecnrypteNode2Attrubute = ecnrypteNode2.Attribute("serializeAs").Value;
                            encryptorDecryptor.Decrypt(ecnrypteNode2Attrubute).Should().Be("String");
                            var encryptedNode2Value = ecnrypteNode2.Value;
                            encryptorDecryptor.Decrypt(encryptedNode2Value).Should().Be("SomeNewEncryptedValue2");
                        }
                }
        }
コード例 #4
0
 public AuthenticationAuthorizationController(ICustomTokenManager customTokenManager, EncryptorDecryptor encryptorDecryptor, IAsyncContactRepository <SuperAdmin> superAdmin, IAsyncContactRepository <Tenant> tenantRepository, IAsyncContactRepository <User> userRepository)
 {
     _customTokenManager = customTokenManager;
     _encryptorDecryptor = encryptorDecryptor;
     _superAdmin         = superAdmin;
     _tenantRepository   = tenantRepository;
     _userRepository     = userRepository;
 }
コード例 #5
0
        public void TestEncryptionOfString()
        {
            string testSample = "this text is decrypted ok";
            string result     = EncryptorDecryptor.Encrypt(testSample);

            result = EncryptorDecryptor.Decrypt(result);
            Assert.True(result.Equals(testSample), "encryption/decryption failed");
        }
コード例 #6
0
        internal static byte[] EncryptRepository(NoteRepositoryModel repository, string transferCode, ICryptoRandomService randomService, string encryptionAlgorithm)
        {
            byte[]             binaryRepository = XmlUtils.SerializeToXmlBytes(repository);
            EncryptorDecryptor encryptor        = new EncryptorDecryptor("SilentNotes");

            // The key derivation cost is set to low, because we can be sure that the transferCode
            // is a very strong password, and to not overload slow mobile devices.
            return(encryptor.Encrypt(binaryRepository, transferCode, Crypto.KeyDerivation.KeyDerivationCostType.Low, randomService, encryptionAlgorithm));
        }
コード例 #7
0
ファイル: CryptoTest.cs プロジェクト: jitterfrei/SilentNotes
        public void EnsureLongTimeDecryptionOfAesGcm()
        {
            // Ensure that a once stored cipher can always be decrypted even after changes in the liberary
            string base64Cipher = "dW5pdHRlc3QkYWVzX2djbSQ0NG04QXBFU1ptcXhnYll2OE5wcWl3PT0kcGJrZGYyJGgwSDdxSGZnVFlXNzBKS3lEb0JLeFE9PSQxMDAwJJsMDjdYEYXYmcqTOFRbge6iVfWo/iny4nrIOMVuoqYak6xB/MAe53G5H3AyxiTi8OENJbi9tzZStpe3p3nlDB7l+J8=";

            byte[]             cipher           = CryptoUtils.Base64StringToBytes(base64Cipher);
            EncryptorDecryptor decryptor        = new EncryptorDecryptor("unittest");
            string             decryptedMessage = CryptoUtils.BytesToString(decryptor.Decrypt(cipher, "brownie"));

            Assert.AreEqual("The brown fox jumps over the lazy 🐢🖐🏿 doc.", decryptedMessage);
        }
コード例 #8
0
        private static byte[] CreateEncryptedRepository(string password, NoteRepositoryModel repository = null)
        {
            if (repository == null)
            {
                repository = new NoteRepositoryModel();
            }
            byte[]             serializedRepository = XmlUtils.SerializeToXmlBytes(repository);
            EncryptorDecryptor encryptor            = new EncryptorDecryptor("SilentNotes");

            return(encryptor.Encrypt(serializedRepository, password, SilentNotes.Crypto.KeyDerivation.KeyDerivationCostType.Low, CommonMocksAndStubs.CryptoRandomService(), BouncyCastleTwofishGcm.CryptoAlgorithmName));
        }
コード例 #9
0
        public void ReplaceAndEncryptTest()
        {
            // arrange
            var encryptorDecryptor = new EncryptorDecryptor();

            // assert
            Configuration config      = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            var           appSettings = (AppSettingsSection)config.GetSection("appSettings");

            encryptorDecryptor.Decrypt(appSettings.Settings["location"].Value).Should().Be("Canandaigua");
        }
コード例 #10
0
ファイル: CryptoTest.cs プロジェクト: jitterfrei/SilentNotes
        public void EnsureLongTimeDecryptionOfTwofishGcm()
        {
            // Ensure that a once stored cipher can always be decrypted even after changes in the liberary
            string base64Cipher = "dW5pdHRlc3QkdHdvZmlzaF9nY20kZHhMWFh4K0UrZ2MzWHdWc01rWUFxQT09JHBia2RmMiRma1BCWTdDWXp1OG5YUlJtYk9DUlp3PT0kMTAwMCRRc0ETSqDekQuBgKJ5x4Mvy02OHsivm0uJ9KchKdpGk+pmbF4Kq/EDbx9Uw54uEZUQLnK70dNKSEVtb1GyUOX1mitr";

            byte[]             cipher           = CryptoUtils.Base64StringToBytes(base64Cipher);
            EncryptorDecryptor decryptor        = new EncryptorDecryptor("unittest");
            string             decryptedMessage = CryptoUtils.BytesToString(decryptor.Decrypt(cipher, "brownie"));

            Assert.AreEqual("The brown fox jumps over the lazy 🐢🖐🏿 doc.", decryptedMessage);
        }
コード例 #11
0
ファイル: CryptoTest.cs プロジェクト: jitterfrei/SilentNotes
        public void CryptoTestEncryptor()
        {
            EncryptorDecryptor   encryptor       = new EncryptorDecryptor("sugus");
            ICryptoRandomService randomGenerator = CommonMocksAndStubs.CryptoRandomService();
            string message = "Der schnelle Fuchs stolpert über den faulen Hund.";

            byte[] binaryMessage = CryptoUtils.StringToBytes(message);
            string password      = "******";

            byte[] cipher           = encryptor.Encrypt(binaryMessage, password, KeyDerivationCostType.Low, randomGenerator, BouncyCastleTwofishGcm.CryptoAlgorithmName);
            byte[] decryptedMessage = encryptor.Decrypt(cipher, password);
            Assert.AreEqual(binaryMessage, decryptedMessage);
        }
コード例 #12
0
 /// <summary>
 /// Adopts the encryption mode to the settings, if the settings are set accordingly and the
 /// mode differs from the stored one.
 /// </summary>
 /// <param name="settings">Settings to update.</param>
 /// <param name="encryptor">The eccryptor.</param>
 /// <param name="binaryCloudRepository">The repository containing the encryption mode.</param>
 /// <returns>Returns true if the encryption mode was adopted, otherwise false.</returns>
 private static bool AdoptEncryptionMode(SettingsModel settings, EncryptorDecryptor encryptor, byte[] binaryCloudRepository)
 {
     if (settings.AdoptCloudEncryptionAlgorithm)
     {
         string cloudEncryptionAlgorithm = encryptor.ExtractAlgorithmName(binaryCloudRepository);
         if (!string.Equals(settings.SelectedEncryptionAlgorithm, cloudEncryptionAlgorithm, StringComparison.OrdinalIgnoreCase))
         {
             settings.SelectedEncryptionAlgorithm = cloudEncryptionAlgorithm;
             return(true);
         }
     }
     return(false);
 }
コード例 #13
0
        public void OkEncodeDecodeAppSettings()
        {
            // arrange
            var encryptorDecryptor = new EncryptorDecryptor();

            // assert
            Configuration config      = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            var           appSettings = (AppSettingsSection)config.GetSection("appSettings");

            encryptorDecryptor.Decrypt(appSettings.Settings["KeyToEncrypt1"].Value).Should().Be("PlainValue1");
            encryptorDecryptor.Decrypt(appSettings.Settings["KeyToEncrypt2"].Value).Should().Be("PlainValue2");
            appSettings.Settings["UnTouchedKey1"].Value.Should().Be("UnTouchedValue1");
            appSettings.Settings["UnTouchedKey2"].Value.Should().Be("UnTouchedValue2");
        }
コード例 #14
0
        public void OkEncodeDecodeInnerText()
        {
            // arrange
            var encryptorDecryptor = new EncryptorDecryptor();

            // assert
            encryptorDecryptor.Decrypt(ConfigurationManager.ConnectionStrings["KeyToEncrypt1"].ConnectionString)
            .Should().Be("Data Source=SomeServer;Initial Catalog=EncryptDB1;Integrated Security=True");
            encryptorDecryptor.Decrypt(ConfigurationManager.ConnectionStrings["KeyToEncrypt2"].ConnectionString)
            .Should().Be("Data Source=SomeServer;Initial Catalog=EncryptDB2;Integrated Security=True");
            ConfigurationManager.ConnectionStrings["UnTouchedKey1"].ConnectionString
            .Should().Be("Data Source=SomeServer;Initial Catalog=SomeDB1;Integrated Security=True");
            ConfigurationManager.ConnectionStrings["UnTouchedKey2"].ConnectionString
            .Should().Be("Data Source=SomeServer;Initial Catalog=SomeDB2;Integrated Security=True");
        }
コード例 #15
0
 private bool TryDecryptRepositoryWithTransfercode(EncryptorDecryptor encryptor, byte[] binaryCloudRepository, string transferCode, out byte[] decryptedRepository)
 {
     try
     {
         decryptedRepository = encryptor.Decrypt(binaryCloudRepository, transferCode);
         return(true);
     }
     catch (CryptoExceptionInvalidCipherFormat)
     {
         // If the downloaded repository is invalid, this is serioud and we should not continue
         throw;
     }
     catch (Exception)
     {
         // Could not decrypt with this transfercode
         decryptedRepository = null;
         return(false);
     }
 }
コード例 #16
0
ファイル: Program.cs プロジェクト: Hans-455/ScrambleEncrypt
        static void StringEncryptDecrypt()
        {
            KeyBlock encKey = new KeyBlock(64, "SeedPassword123*");

            string Original1 = "Some string shorter than 64";
            string Original2 = "Some string longer than 64 which is the same as the shorter one but with extra words to make it longer.";
            string Original3 = "Some string longer than 64 which is the same as the shorter one but with extra words to make it longer but I want to go all the way past 128.";

            Console.WriteLine();
            Console.WriteLine(Original1);
            Console.WriteLine(Original2);
            Console.WriteLine(Original3);

            byte[] scrambleBytes1 = EncryptorDecryptor.ScrambleEncrypt(Encoding.UTF8.GetBytes(Original1), encKey);
            byte[] scrambleBytes2 = EncryptorDecryptor.ScrambleEncrypt(Encoding.UTF8.GetBytes(Original2), encKey);
            byte[] scrambleBytes3 = EncryptorDecryptor.ScrambleEncrypt(Encoding.UTF8.GetBytes(Original3), encKey);

            string scrambleString1 = Encoding.UTF8.GetString(scrambleBytes1);
            string scrambleString2 = Encoding.UTF8.GetString(scrambleBytes2);
            string scrambleString3 = Encoding.UTF8.GetString(scrambleBytes3);

            Console.WriteLine();
            Console.WriteLine(scrambleString1);
            Console.WriteLine(scrambleString2);
            Console.WriteLine(scrambleString3);

            KeyBlock decKey = new KeyBlock(64, "SeedPassword123*");

            byte[] deScrambled1 = EncryptorDecryptor.ScrambleDecrypt(scrambleBytes1, decKey);
            byte[] deScrambled2 = EncryptorDecryptor.ScrambleDecrypt(scrambleBytes2, decKey);
            byte[] deScrambled3 = EncryptorDecryptor.ScrambleDecrypt(scrambleBytes3, decKey);

            string deScrambledString1 = Encoding.UTF8.GetString(deScrambled1);
            string deScrambledString2 = Encoding.UTF8.GetString(deScrambled2);
            string deScrambledString3 = Encoding.UTF8.GetString(deScrambled3);

            Console.WriteLine();
            Console.WriteLine(deScrambledString1);
            Console.WriteLine(deScrambledString2);
            Console.WriteLine(deScrambledString3);
        }
コード例 #17
0
        public void OkEncodeDecodeReplaceAttributeAndInnerTextByXPath()
        {
            // arrange
            var encryptorDecryptor = new EncryptorDecryptor();

            var dllPath       = Assembly.GetAssembly(typeof(TestEnvironmentForEncode)).EscapedCodeBase.TrimStart("file:///".ToArray());
            var appConfigPath = string.Format("{0}.config", dllPath);


            using (var input = new XmlTransformableDocument())
            {
                input.Load(appConfigPath);

                using (var stringWriter = new StringWriter())
                    using (var xmlWriter = XmlWriter.Create(stringWriter))
                    {
                        input.WriteContentTo(xmlWriter);
                        xmlWriter.Flush();
                        var result = stringWriter.ToString();

                        var doc = XDocument.Parse(result);

                        var root = doc.Root;

                        // assert
                        var encryptedNode1          = root.Descendants("setting").Single(x => x.Attribute("name").Value == "ExpectedEncrypted1");
                        var encryptedNode1Attribute = encryptedNode1.Attribute("serializeAs").Value;
                        encryptorDecryptor.Decrypt(encryptedNode1Attribute).Should().Be("String");
                        var encryptedNode1Value = encryptedNode1.Value;
                        encryptorDecryptor.Decrypt(encryptedNode1Value).Should().Be("SomeNewEncryptedValue1");

                        var encryptedNode2          = root.Descendants("setting").Single(x => x.Attribute("name").Value == "ExpectedEncrypted2");
                        var encryptedNode2Attribute = encryptedNode2.Attribute("serializeAs").Value;
                        encryptorDecryptor.Decrypt(encryptedNode2Attribute).Should().Be("String");
                        var encryptedNode2Value = encryptedNode2.Value;
                        encryptorDecryptor.Decrypt(encryptedNode2Value).Should().Be("EncryptedValue2");
                    }
            }
        }
コード例 #18
0
            /// <summary>
            /// Test the password update from Version1 in Android to Version2
            /// </summary>
            /// <param name="root"></param>
            protected override void UpdateSettingsFrom1To2(XElement root)
            {
                base.UpdateSettingsFrom1To2(root);
                const string snpsk = "53EC49B1-6600+406b;B84F-0B9CFA1D2BE1";

                // Handle protected password
                XElement oldPasswortElement  = root.Element("cloud_storage")?.Element("cloud_password");
                XElement cloudStorageAccount = root.Element("cloud_storage_account");

                if ((oldPasswortElement != null) && (cloudStorageAccount != null))
                {
                    // Deobfuscate old password
                    EncryptorDecryptor decryptor    = new EncryptorDecryptor("snps");
                    byte[]             binaryCipher = CryptoUtils.Base64StringToBytes(oldPasswortElement.Value);
                    byte[]             unprotectedBinaryPassword = decryptor.Decrypt(binaryCipher, snpsk);

                    // Protect with new data protection service and add to XML
                    string protectedPassword = _dataProtectionService.Protect(unprotectedBinaryPassword);
                    cloudStorageAccount.Add(new XElement("protected_password", protectedPassword));
                    CryptoUtils.CleanArray(unprotectedBinaryPassword);
                }
            }
コード例 #19
0
        /// <inheritdoc/>
        public override async Task Run()
        {
            try
            {
                SettingsModel settings = _settingsService.LoadSettingsOrDefault();
                byte[]        binaryCloudRepository = StoryBoard.LoadFromSession <byte[]>(SynchronizationStorySessionKey.BinaryCloudRepository.ToInt());
                List <string> transferCodesToTry    = ListTransferCodesToTry(settings);

                // Try to decode with all possible transfer codes
                EncryptorDecryptor encryptor           = new EncryptorDecryptor("SilentNotes");
                byte[]             decryptedRepository = null;
                bool successfullyDecryptedRepository   = false;
                int  index = 0;
                while (!successfullyDecryptedRepository && index < transferCodesToTry.Count)
                {
                    string transferCodeCandidate = transferCodesToTry[index];
                    successfullyDecryptedRepository = TryDecryptRepositoryWithTransfercode(encryptor, binaryCloudRepository, transferCodeCandidate, out decryptedRepository);
                    if (successfullyDecryptedRepository)
                    {
                        // Store transfercode and encryption mode if necessary
                        if (AdoptTransferCode(settings, transferCodeCandidate) ||
                            AdoptEncryptionMode(settings, encryptor, binaryCloudRepository))
                        {
                            _settingsService.TrySaveSettingsToLocalDevice(settings);
                        }
                    }
                    index++;
                }

                if (successfullyDecryptedRepository)
                {
                    // Deserialize and update repository
                    XDocument cloudRepositoryXml = XmlUtils.LoadFromXmlBytes(decryptedRepository);
                    if (_noteRepositoryUpdater.IsTooNewForThisApp(cloudRepositoryXml))
                    {
                        throw new SynchronizationStoryBoard.UnsuportedRepositoryRevisionException();
                    }

                    _noteRepositoryUpdater.Update(cloudRepositoryXml);
                    NoteRepositoryModel cloudRepository = XmlUtils.DeserializeFromXmlDocument <NoteRepositoryModel>(cloudRepositoryXml);

                    // Continue with next step
                    StoryBoard.StoreToSession(SynchronizationStorySessionKey.CloudRepository.ToInt(), cloudRepository);
                    await StoryBoard.ContinueWith(SynchronizationStoryStepId.IsSameRepository.ToInt());
                }
                else
                {
                    bool existsUserEnteredTransferCode = StoryBoard.TryLoadFromSession <string>(SynchronizationStorySessionKey.UserEnteredTransferCode.ToInt(), out _);
                    if (existsUserEnteredTransferCode)
                    {
                        // Keep transfercode page open and show message
                        _feedbackService.ShowToast(_languageService["sync_error_transfercode"]);
                    }
                    else
                    {
                        // Open transfercode page
                        await StoryBoard.ContinueWith(SynchronizationStoryStepId.ShowTransferCode.ToInt());
                    }
                }
            }
            catch (Exception ex)
            {
                // Keep the current page open and show the error message
                ShowExceptionMessage(ex, _feedbackService, _languageService);
            }
        }
コード例 #20
0
 public BouncyCastleAesStream(Stream stream, byte[] key)
 {
     Stream = stream;
     ED     = new EncryptorDecryptor(key);
 }
コード例 #21
0
 public BouncyCastleAesStream(Socket client, byte[] key)
 {
     Stream = new NetworkStream(client);
     ED     = new EncryptorDecryptor(key);
 }
コード例 #22
0
ファイル: UserController.cs プロジェクト: RanchCoder/swabhav
 public UserController(IAsyncContactRepository <User> userRepository, IAsyncContactRepository <Tenant> tenantRespository, EncryptorDecryptor encryptorDecryptor)
 {
     _encryptorDecryptor = encryptorDecryptor;
     _tenantRepository   = tenantRespository;
     _userRepository     = userRepository;
 }