public BigInteger[] GetDecryptedKeyMaterial(string strPassphrase) { BigInteger[] biKeys = new BigInteger[0]; if (this.bIsEncrypted) { SharpPrivacy.Cipher.SymmetricAlgorithm saAlgo; switch (this.SymmetricalAlgorithm) { case SymAlgorithms.AES128: saAlgo = Rijndael.Create(); saAlgo.BlockSize = 128; saAlgo.KeySize = 128; break; case SymAlgorithms.AES192: saAlgo = Rijndael.Create(); saAlgo.BlockSize = 128; saAlgo.KeySize = 192; break; case SymAlgorithms.AES256: saAlgo = Rijndael.Create(); saAlgo.BlockSize = 128; saAlgo.KeySize = 256; break; case SymAlgorithms.Triple_DES: saAlgo = TripleDES.Create(); saAlgo.KeySize = 192; break; case SymAlgorithms.CAST5: saAlgo = CAST5.Create(); break; default: throw(new System.NotSupportedException("Sorry, but the Algorithm that was used to encrypt the secret key data is not (yet) supported by SharpPrivacy!")); } saAlgo.Mode = CipherMode.CFB; saAlgo.Key = this.S2KSpecifier.GetKey(strPassphrase, saAlgo.KeySize); if (this.PublicKey.Version == PublicKeyPacketVersionNumbers.v3) { throw(new System.NotImplementedException("Sorry, but we have not yet implemented the decryption of v3 keys!")); } else if (this.PublicKey.Version == PublicKeyPacketVersionNumbers.v4) { //In v4 keys, everything - including mpi headers and checksum //is encrypted. Should be a heck of a lot easier than for //v3 keys. saAlgo.IV = this.InitialVector; saAlgo.Padding = PaddingMode.None; byte[] bOutput = new byte[this.bEncryptedKeyMaterial.Length]; ICryptoTransform ictDec = saAlgo.CreateDecryptor(); ictDec.TransformBlock(bEncryptedKeyMaterial, 0, bEncryptedKeyMaterial.Length, ref bOutput, 0); int iCurrentChecksum = 0; for (int i = 0; i < bOutput.Length; i++) { iCurrentChecksum = (iCurrentChecksum + bOutput[i]) % 65536; } if (pkpPublicKey.Algorithm == AsymAlgorithms.DSA || pkpPublicKey.Algorithm == AsymAlgorithms.ElGama_Encrypt_Sign || pkpPublicKey.Algorithm == AsymAlgorithms.ElGamal_Encrypt_Only) { biKeys = new BigInteger[1]; try { biKeys = BigInteger.ParseMPIs(bOutput, 1); } catch (Exception) { throw new Exception("Invalid Passphrase!"); } } else if (pkpPublicKey.Algorithm == AsymAlgorithms.RSA_Encrypt_Only || pkpPublicKey.Algorithm == AsymAlgorithms.RSA_Encrypt_Sign || pkpPublicKey.Algorithm == AsymAlgorithms.RSA_Sign_Only) { biKeys = new BigInteger[4]; try { biKeys = BigInteger.ParseMPIs(bOutput, 4); } catch (Exception) { throw new Exception("Invalid Passphrase!"); } } } } else { //Key Material is not encrypted anyway biKeys = this.DecryptedKeyMaterial; } return(biKeys); }
public static object CreateFromKnownName(string name) { switch (name) { case "http://www.w3.org/TR/2001/REC-xml-c14n-20010315": return(new XmlDsigC14NTransform()); case "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments": return(new XmlDsigC14NWithCommentsTransform()); case "http://www.w3.org/2001/10/xml-exc-c14n#": return(new XmlDsigExcC14NTransform()); case "http://www.w3.org/2001/10/xml-exc-c14n#WithComments": return(new XmlDsigExcC14NWithCommentsTransform()); case "http://www.w3.org/2000/09/xmldsig#base64": return(new XmlDsigBase64Transform()); case "http://www.w3.org/TR/1999/REC-xpath-19991116": return(new XmlDsigXPathTransform()); case "http://www.w3.org/TR/1999/REC-xslt-19991116": return(new XmlDsigXsltTransform()); case "http://www.w3.org/2000/09/xmldsig#enveloped-signature": return(new XmlDsigEnvelopedSignatureTransform()); case "http://www.w3.org/2002/07/decrypt#XML": return(new XmlDecryptionTransform()); case "urn:mpeg:mpeg21:2003:01-REL-R-NS:licenseTransform": return(new XmlLicenseTransform()); case "http://www.w3.org/2000/09/xmldsig# X509Data": return(new KeyInfoX509Data()); case "http://www.w3.org/2000/09/xmldsig# KeyName": return(new KeyInfoName()); case "http://www.w3.org/2000/09/xmldsig# KeyValue/DSAKeyValue": return(new DSAKeyValue()); case "http://www.w3.org/2000/09/xmldsig# KeyValue/RSAKeyValue": return(new RSAKeyValue()); case "http://www.w3.org/2000/09/xmldsig# RetrievalMethod": return(new KeyInfoRetrievalMethod()); case "http://www.w3.org/2001/04/xmlenc# EncryptedKey": return(new KeyInfoEncryptedKey()); case "http://www.w3.org/2000/09/xmldsig#dsa-sha1": return(new DSASignatureDescription()); case "System.Security.Cryptography.DSASignatureDescription": return(new DSASignatureDescription()); case "http://www.w3.org/2000/09/xmldsig#rsa-sha1": return(new RSAPKCS1SHA1SignatureDescription()); case "System.Security.Cryptography.RSASignatureDescription": return(new RSAPKCS1SHA1SignatureDescription()); case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256": return(new RSAPKCS1SHA256SignatureDescription()); case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha384": return(new RSAPKCS1SHA384SignatureDescription()); case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha512": return(new RSAPKCS1SHA512SignatureDescription()); // workarounds for issue https://github.com/dotnet/corefx/issues/16563 // remove attribute from this method when removing them case "http://www.w3.org/2000/09/xmldsig#sha1": return(SHA1.Create()); case "MD5": return(MD5.Create()); case "http://www.w3.org/2001/04/xmldsig-more#hmac-md5": return(new HMACMD5()); case "http://www.w3.org/2001/04/xmlenc#tripledes-cbc": return(TripleDES.Create()); } return(null); }
public void EncryptKeyMaterial(BigInteger[] biGivenKeyMaterial, string strPassphrase) { this.biDecryptedKeyMaterial = biGivenKeyMaterial; if (!bIsEncrypted) { return; } if (this.PublicKey.Version == PublicKeyPacketVersionNumbers.v4) { int iKeyMaterialLength = 0; for (int i = 0; i < this.biDecryptedKeyMaterial.Length; i++) { iKeyMaterialLength += biDecryptedKeyMaterial[i].GetMPI().Length; } byte[] bData = new byte[iKeyMaterialLength + 2]; int iPos = 0; for (int i = 0; i < this.biDecryptedKeyMaterial.Length; i++) { byte[] bMPI = biDecryptedKeyMaterial[i].GetMPI(); Array.Copy(bMPI, 0, bData, iPos, bMPI.Length); iPos += bMPI.Length; } int iChecksum = 0; for (int i = 0; i < bData.Length - 2; i++) { iChecksum = (iChecksum + bData[i]) % 65536; } bData[iPos++] = (byte)((iChecksum >> 8) & 0xFF); bData[iPos++] = (byte)(iChecksum & 0xFF); SharpPrivacy.Cipher.SymmetricAlgorithm saAlgo; switch (this.SymmetricalAlgorithm) { case SymAlgorithms.AES128: saAlgo = Rijndael.Create(); saAlgo.BlockSize = 128; saAlgo.KeySize = 128; break; case SymAlgorithms.AES192: saAlgo = Rijndael.Create(); saAlgo.BlockSize = 128; saAlgo.KeySize = 192; break; case SymAlgorithms.AES256: saAlgo = Rijndael.Create(); saAlgo.BlockSize = 128; saAlgo.KeySize = 256; break; case SymAlgorithms.Triple_DES: saAlgo = TripleDES.Create(); saAlgo.KeySize = 192; break; case SymAlgorithms.CAST5: saAlgo = CAST5.Create(); break; default: throw(new System.NotSupportedException("Sorry, but the Algorithm that was used to encrypt the secret key data is not (yet) supported by SharpPrivacy!")); } saAlgo.Mode = CipherMode.CFB; saAlgo.Key = this.S2KSpecifier.GetKey(strPassphrase, saAlgo.KeySize); saAlgo.IV = this.InitialVector; saAlgo.Padding = PaddingMode.None; byte[] bOutput = new byte[bData.Length]; ICryptoTransform ictEnc = saAlgo.CreateEncryptor(); ictEnc.TransformBlock(bData, 0, bData.Length, ref bOutput, 0); byte[] bTmp = new byte[bData.Length]; Array.Copy(bOutput, 0, bTmp, 0, bTmp.Length); bOutput = bTmp; if (bOutput.Length != bData.Length) { throw new Exception("Encryption of the secret Key material did not work correctly. Look at the file SecretKeyPacket, function EncryptKeyMaterial()"); } bEncryptedKeyMaterial = bOutput; } else { throw new Exception("Sorry, but we don't support v3 secret keys so far!"); } this.bIsUpdated = true; }
public void TripleDES_CFB() { Assert.AreEqual("89-9F-00-9D-26-BB-21-59-85-6D-A2-BF-15-FE-73-53-1F-CE-35-26-5B-DF-43-26", Roundtrip(TripleDES.Create(), CipherMode.CFB), "Encrypted data"); }
public void TripleDES_CTS() { Assert.AreEqual("not implemented in any released framework", Roundtrip(TripleDES.Create(), CipherMode.CTS), "Encrypted data"); }
public async Task TestDefaultBehaviorAsync() { // arrange var obj = new { username = "******" }; var repository = new Mock <IRepository>(); var settings = new ApplicationSettings(); var validationService = new Mock <ValidationService>(repository.Object, settings); var administrationService = new Mock <AdministrationService>(repository.Object, validationService.Object); var mailService = new Mock <MailService>(repository.Object); var user = new User { Username = obj.username }; var request = new UserRequest { Id = 1, Username = obj.username, RequestType = UserRequestType.Activation }; var userSet = TestUtilities.CreateDbSetMock(new List <User> { user }); repository .Setup(x => x.AsQueryable <User>()) .Returns(userSet.Object); repository .Setup(x => x.GetAsync <User>(1)) .ReturnsAsync(user); repository .Setup(x => x.GetAsync <UserRequest>(1)) .ReturnsAsync(request); var password = Guid.NewGuid().ToString(); var credentials = JObject.FromObject(new { obj.username, password }); string q; using (var algorithm = TripleDES.Create()) { request.Key = algorithm.Key; request.IV = algorithm.IV; request.Password = CryptoUtilities.CreateHash(password); var ciphertext = CryptoUtilities.Encrypt(credentials.ToString(), algorithm.Key, algorithm.IV); q = 1 + ":" + ciphertext; } dynamic model = JObject.FromObject(new { q }); var accountService = new AccountService(repository.Object, validationService.Object, administrationService.Object, mailService.Object); // act await TestUtilities.DoesNotThrowAsync(async() => await accountService.ActivateAsync(model)); // assert Assert.True(user.Enabled); repository.Verify(x => x.GetAsync <UserRequest>(It.IsAny <int>()), Times.Once); repository.Verify(x => x.AsQueryable <User>(), Times.Once); repository.Verify(x => x.UpdateAsync(user), Times.Once()); repository.Verify(x => x.UpdateAsync(request), Times.Once()); }
public static byte[] OWHF2_8_2(KernelDatabaseBase database, byte[] pd) { int pl = database.Get(EMVTagsEnum.DS_ID_9F5E_KRN2).Value.Length; byte[] dsid = database.Get(EMVTagsEnum.DS_ID_9F5E_KRN2).Value; byte[] dspkl = new byte[6]; byte[] dspkr = new byte[6]; for (int i = 0; i < 6; i++) { dspkl[i] = (byte)(((dsid[i] / 16) * 10 + (dsid[i] % 16)) * 2); dspkr[i] = (byte)(((dsid[pl - 6 + i] / 16) * 10 + (dsid[pl - 6 + i] % 16)) * 2); } byte[] oid = new byte[8]; if (database.IsNotEmpty(EMVTagsEnum.DS_SLOT_MANAGEMENT_CONTROL_9F6F_KRN2.Tag) && (database.Get(EMVTagsEnum.DS_SLOT_MANAGEMENT_CONTROL_9F6F_KRN2).Value[0] & 0x80) == 0x80 && // Permanent slot type (database.Get(EMVTagsEnum.DS_ODS_INFO_DF62_KRN2).Value[0] & 0x40) == 0x40 //Volatile slot type ) { oid = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; } else { oid = database.Get(EMVTagsEnum.DS_REQUESTED_OPERATOR_ID_9F5C_KRN2).Value; } byte[] kl = new byte[8]; byte[] kr = new byte[8]; for (int i = 0; i < 6; i++) { kl[i] = dspkl[i]; kr[i] = dspkr[i]; } for (int i = 6; i < 8; i++) { kl[i] = oid[i - 2]; kr[i] = oid[i]; } TripleDES des = TripleDES.Create(); List <byte[]> keyComps = new List <byte[]>(); keyComps.Add(kl); keyComps.Add(kr); keyComps.Add(kl); byte[] key = keyComps.SelectMany(x => x).ToArray(); des.Key = key; des.Mode = CipherMode.CBC; des.Padding = PaddingMode.None; byte[] exOrData = XOR(oid, pd); MemoryStream ms = new MemoryStream(); using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(exOrData, 0, exOrData.Length); } byte[] r = ms.ToArray(); ms.Dispose(); return(XOR(r, pd)); }
protected override Stream Decrypt(Stream input) => new CryptoStream(input, TripleDES.Create().CreateDecryptor(_key, _iv), CryptoStreamMode.Read);
protected override Stream Encrypt(Stream output) => new CryptoStream(output, TripleDES.Create().CreateEncryptor(_key, _iv), CryptoStreamMode.Write);
/// Encodes the specified string. /// @param text The string to encode. /// @returns The encoded string. public string Encode(string text) { var bytes = Encoding.Default.GetBytes(text); return(Convert.ToBase64String(TripleDES.Create().CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length))); }
internal static TripleDES CreateTripleDES() { return(TripleDES.Create()); }
private static SymmetricAlgorithm PrepareCipher(byte[] decodedKey, Cipher cipher, byte[] iv, Options options) { // Pad key out to KeyLength in bytes if its too short or trancuate if it is too long int KeyLengthInBytes = cipher.KeyLength / 8; if (decodedKey.Length < KeyLengthInBytes || decodedKey.Length > KeyLengthInBytes) { var resizedKey = new byte[KeyLengthInBytes]; Buffer.BlockCopy(decodedKey, 0, resizedKey, 0, Math.Min(decodedKey.Length, resizedKey.Length)); decodedKey = resizedKey; } var iVector = new byte[cipher.IVLength]; if (!ArrayUtils.IsNullOrEmpty(iv)) { var ivLength = iv.Length; if (ivLength != cipher.IVLength) { if (ivLength < cipher.IVLength) // Pad zeros { if ((options & Options.OPENSSL_DONT_ZERO_PAD_KEY) != 0 /* && !EVP_CIPHER_CTX_set_key_length(ivLength)*/) { // Warning: Key length cannot be set for the cipher method throw new CryptographicException(Resources.LibResources.openssl_cannot_set_iv_length); } PhpException.Throw(PhpError.E_WARNING, Resources.LibResources.openssl_short_iv, iv.Length.ToString(), cipher.IVLength.ToString()); } else if (ivLength > cipher.IVLength) // Trancuate { PhpException.Throw(PhpError.E_WARNING, Resources.LibResources.openssl_long_iv, iv.Length.ToString(), cipher.IVLength.ToString()); ivLength = cipher.IVLength; } } Buffer.BlockCopy(iv, 0, iVector, 0, ivLength); } SymmetricAlgorithm alg = null; switch (cipher.Type) { case CipherType.AES: if (cipher.Mode == SupportedCipherMode.CTR) { alg = new AesCounterMode(); } else { alg = new RijndaelManaged { Padding = PaddingMode.PKCS7, KeySize = cipher.KeyLength } }; break; case CipherType.DES: alg = DES.Create(); break; case CipherType.TripleDES: alg = TripleDES.Create(); break; } if (TryGetDotNetCipherMode(cipher.Mode, out var cipherMode)) { alg.Mode = cipherMode; } alg.Key = decodedKey; alg.IV = iVector; if ((options & Options.OPENSSL_ZERO_PADDING) == Options.OPENSSL_ZERO_PADDING) { alg.Padding = PaddingMode.None; } return(alg); }
private void createDecryptionCipher() { // Create and configure the symmetric algorithm switch (CipherAlgorithmType) { case CipherAlgorithmType.Des: decryptionAlgorithm = DES.Create(); break; case CipherAlgorithmType.Rc2: decryptionAlgorithm = RC2.Create(); break; case CipherAlgorithmType.Rc4: decryptionAlgorithm = new M.ARC4Managed(); break; case CipherAlgorithmType.TripleDes: decryptionAlgorithm = TripleDES.Create(); break; case CipherAlgorithmType.Rijndael: // only AES is really used - and we can use CommonCrypto for iOS and OSX this way decryptionAlgorithm = Aes.Create(); break; } // If it's a block cipher if (CipherMode == CipherMode.CBC) { // Configure encrypt algorithm decryptionAlgorithm.Mode = CipherMode; decryptionAlgorithm.Padding = PaddingMode.None; decryptionAlgorithm.KeySize = ExpandedKeyMaterialSize * 8; decryptionAlgorithm.BlockSize = blockSize * 8; } // Set the key and IV for the algorithm if (Context is ClientContext) { decryptionAlgorithm.Key = Context.ServerWriteKey; decryptionAlgorithm.IV = Context.ServerWriteIV; } else { decryptionAlgorithm.Key = Context.ClientWriteKey; decryptionAlgorithm.IV = Context.ClientWriteIV; } // Create decryption cipher DecryptionCipher = decryptionAlgorithm.CreateDecryptor(); // Create the HMAC if (Context is ClientContext) { ServerHMAC = new HMAC( CreateHashAlgorithm(), Context.Negotiating.ServerWriteMAC); } else { ClientHMAC = new HMAC( CreateHashAlgorithm(), Context.Negotiating.ClientWriteMAC); } }
public async Task Run() { const string pwd1 = "mypassword"; // Create a byte array to hold the random value. var salt1 = new byte[8]; using (var rngCsp = new RNGCryptoServiceProvider()) { // Fill the array with a random value. rngCsp.GetBytes(salt1); } //data1 can be a string or contents of a file. const string data1 = "Some test data"; //The default iteration count is 1000 so the two methods use the same iteration count. const int myIterations = 1000; try { var k1 = new Rfc2898DeriveBytes(pwd1, salt1, myIterations); var k2 = new Rfc2898DeriveBytes(pwd1, salt1); // Encrypt the data. var encAlg = TripleDES.Create(); encAlg.Key = k1.GetBytes(16); var encryptionStream = new MemoryStream(); var encrypt = new CryptoStream(encryptionStream, encAlg.CreateEncryptor(), CryptoStreamMode.Write); var utfD1 = new UTF8Encoding(false).GetBytes(data1); encrypt.Write(utfD1, 0, utfD1.Length); encrypt.FlushFinalBlock(); encrypt.Close(); var edata1 = encryptionStream.ToArray(); k1.Reset(); // Try to decrypt, thus showing it can be round-tripped. var decAlg = TripleDES.Create(); decAlg.Key = k2.GetBytes(16); decAlg.IV = encAlg.IV; var decryptionStreamBacking = new MemoryStream(); var decrypt = new CryptoStream(decryptionStreamBacking, decAlg.CreateDecryptor(), CryptoStreamMode.Write); decrypt.Write(edata1, 0, edata1.Length); decrypt.Flush(); decrypt.Close(); k2.Reset(); var data2 = new UTF8Encoding(false).GetString(decryptionStreamBacking.ToArray()); if (!data1.Equals(data2)) { Console.WriteLine("Error: The two values are not equal."); } else { Console.WriteLine("The two values are equal."); Console.WriteLine("k1 iterations: {0}", k1.IterationCount); Console.WriteLine("k2 iterations: {0}", k2.IterationCount); } } catch (Exception e) { Console.WriteLine(e); } }
static FormsAuthenticationTicket Decrypt2(byte [] bytes) { if (protection == FormsProtectionEnum.None) { return(FormsAuthenticationTicket.FromByteArray(bytes)); } #if NET_2_0 MachineKeySection config = (MachineKeySection)WebConfigurationManager.GetWebApplicationSection(machineKeyConfigPath); #else MachineKeyConfig config = HttpContext.GetAppConfig(machineKeyConfigPath) as MachineKeyConfig; #endif bool all = (protection == FormsProtectionEnum.All); byte [] result = bytes; if (all || protection == FormsProtectionEnum.Encryption) { ICryptoTransform decryptor; decryptor = TripleDES.Create().CreateDecryptor(GetDecryptionKey(config), init_vector); result = decryptor.TransformFinalBlock(bytes, 0, bytes.Length); bytes = null; } if (all || protection == FormsProtectionEnum.Validation) { int count; MachineKeyValidation validationType; #if NET_2_0 validationType = config.Validation; #else validationType = config.ValidationType; #endif if (validationType == MachineKeyValidation.MD5) { count = MD5_hash_size; } else { count = SHA1_hash_size; // 3DES and SHA1 } #if NET_2_0 byte [] vk = MachineKeySectionUtils.ValidationKeyBytes(config); #else byte [] vk = config.ValidationKey; #endif byte [] mix = new byte [result.Length - count + vk.Length]; Buffer.BlockCopy(result, 0, mix, 0, result.Length - count); Buffer.BlockCopy(vk, 0, mix, result.Length - count, vk.Length); byte [] hash = null; switch (validationType) { case MachineKeyValidation.MD5: hash = MD5.Create().ComputeHash(mix); break; // From MS docs: "When 3DES is specified, forms authentication defaults to SHA1" case MachineKeyValidation.TripleDES: case MachineKeyValidation.SHA1: hash = SHA1.Create().ComputeHash(mix); break; } if (result.Length < count) { throw new ArgumentException("Error validating ticket (length).", "encryptedTicket"); } int i, k; for (i = result.Length - count, k = 0; k < count; i++, k++) { if (result [i] != hash [k]) { throw new ArgumentException("Error validating ticket.", "encryptedTicket"); } } } return(FormsAuthenticationTicket.FromByteArray(result)); }
public void TripleDES_ECB() { Assert.AreEqual("89-4B-C3-08-54-26-A4-41-89-4B-C3-08-54-26-A4-41-A3-CF-6E-C8-8B-D9-7D-73", Roundtrip(TripleDES.Create(), CipherMode.ECB), "Encrypted data"); }
public async Task TestWithInvalidPasswordAsync() { // arrange var obj = new { username = "******", password = "******" }; var repository = new Mock <IRepository>(); var settings = new ApplicationSettings(); var validationService = new Mock <ValidationService>(repository.Object, settings); var administrationService = new Mock <AdministrationService>(repository.Object, validationService.Object); var mailService = new Mock <MailService>(repository.Object); validationService .SetupGet(x => x.Bundles) .Returns(new ValidationBundles(validationService.Object)); var user = new User { Username = obj.username }; var request = new UserRequest { Id = 1, Username = obj.username, RequestType = UserRequestType.ResetPassword }; var userSet = TestUtilities.CreateDbSetMock(new List <User> { user }); repository .Setup(x => x.AsQueryable <User>()) .Returns(userSet.Object); repository .Setup(x => x.GetAsync <UserRequest>(1)) .ReturnsAsync(request); var password = Guid.NewGuid().ToString(); var credentials = JObject.FromObject(obj); string q; using (var algorithm = TripleDES.Create()) { request.Key = algorithm.Key; request.IV = algorithm.IV; request.Password = CryptoUtilities.CreateHash(password); var ciphertext = CryptoUtilities.Encrypt(credentials.ToString(), algorithm.Key, algorithm.IV); q = 1 + ":" + ciphertext; } dynamic model = JObject.FromObject(new { q }); var accountService = new AccountService(repository.Object, validationService.Object, administrationService.Object, mailService.Object); // act var exception = await TestUtilities.ThrowsAsync <ServiceException>(async() => await accountService.ResetPasswordAsync(model)); // assert Assert.Equal(ServiceReason.ResetPasswordError, exception.Reason); Assert.Null(user.Password); repository.Verify(x => x.GetAsync <UserRequest>(It.IsAny <int>()), Times.Once); repository.Verify(x => x.AsQueryable <User>(), Times.Never); repository.Verify(x => x.UpdateAsync(user), Times.Never()); repository.Verify(x => x.UpdateAsync(request), Times.Never()); }
public void TripleDES_CBC() { Assert.AreEqual("89-4B-C3-08-54-26-A4-41-06-8E-DF-B5-F0-23-AB-B4-76-40-68-9A-26-7D-8D-6E", Roundtrip(TripleDES.Create(), CipherMode.CBC), "Encrypted data"); }
static void Main(string[] args) { /* Readme examples */ // Create encrypter with default algorithm (AES) and generate a new random key var encrypter = new EasyEncrypt(); // Encrypt and decrypt a string var encryptedString = encrypter.Encrypt("Example data"); var decryptedString = encrypter.Decrypt(encryptedString); /* AES encryption */ // Get key from encrypter byte[] key = encrypter.GetKey(); // Create encrypter with default algorithm (AES) and use an existing key using var encrypterWithKey = new EasyEncrypt(key: key); // Create encrypter with default algorithm (AES) and create encryption key from password and salt (with PBKDF2) using var encrypterWithPassword = new EasyEncrypt("Password", "Salt12345678"); // Encrypt and decrypt a byte[] var encryptedArray = encrypter.Encrypt(Encoding.UTF8.GetBytes("Example data")); var decryptedArray = encrypter.Decrypt(encryptedArray); /* Custom algorithms encryption */ // Create encrypter with DES encryption using var DESencrypter = new EasyEncrypt(DES.Create()); // Create encryptor with TripleDES encryption and create encryption key from password and salt (with PBKDF2) using var tripleDeSencrypter = new EasyEncrypt("Password", "Salt12345678", TripleDES.Create()); /* Encrypting streams */ // Readable input stream, gets disposed when encrypted using var inputStream = new MemoryStream(Encoding.UTF8.GetBytes("Example data")); // Writable output stream, encrypted data gets written to this stream using var encryptedStream = new MemoryStream(); // Encrypt our stream encrypter.EncryptStream(inputStream, encryptedStream); // Writable output stream, decrypted data gets written to this stream using var decryptedStream = new MemoryStream(); // Decrypt our stream, encrypted data gets disposed encrypter.DecryptStream(encryptedStream, decryptedStream); /* Encrypting files */ const string inputFile = "Data.txt", encryptedFile = "EncryptedData.txt", decryptedFile = "DecryptedData.txt"; // Encrypt a file, encrypted file gets created with encrypted data encrypter.EncryptFile(inputFile, encryptedFile); // Decrypt a file, decrypted file gets created with decrypted data encrypter.DecryptFile(encryptedFile, decryptedFile); }
public TripleDES Create() { return(TripleDES.Create()); }