private static byte[] Crypto(byte[] target, byte[] key, byte[] iv, CryptoMode mode)
{
byte[] buffer;
try
{
ICryptoTransform transform;
TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
MemoryStream stream = new MemoryStream();
if (mode == CryptoMode.Encrypt)
{
transform = provider.CreateEncryptor(key, iv);
}
else
{
transform = provider.CreateDecryptor(key, iv);
}
CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Write);
stream2.Write(target, 0, target.Length);
stream2.Close();
buffer = stream.ToArray();
stream.Close();
}
catch
{
buffer = new byte[1];
}
return(buffer);
}
internal WinZipAesCipherStream(Stream s, WinZipAesCrypto cryptoParams, CryptoMode mode)
{
_params = cryptoParams;
_s = s;
_mode = mode;
_nonce = 1;
if (_params == null)
{
throw new BadPasswordException("Supply a password to use AES encryption.");
}
int num = _params.KeyBytes.Length * 8;
if (num != 256 && num != 128 && num != 192)
{
throw new ArgumentOutOfRangeException("keysize", "size of key must be 128, 192, or 256");
}
_mac = new HMACSHA1(_params.MacIv);
_aesCipher = new RijndaelManaged();
_aesCipher.BlockSize = 128;
_aesCipher.KeySize = num;
_aesCipher.Mode = CipherMode.ECB;
_aesCipher.Padding = PaddingMode.None;
byte[] rgbIV = new byte[16];
_xform = _aesCipher.CreateEncryptor(_params.KeyBytes, rgbIV);
if (_mode == CryptoMode.Encrypt)
{
_iobuf = new byte[2048];
_PendingWriteBlock = new byte[16];
}
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="s">The underlying stream</param>
/// <param name="mode">To either encrypt or decrypt.</param>
/// <param name="cipher">The pre-initialized ZipCrypto object.</param>
public ZipCipherStream(System.IO.Stream s, ZipCrypto cipher, CryptoMode mode)
: base()
{
_cipher = cipher;
_s = s;
_mode = mode;
}
/// <summary> The constructor. </summary>
/// <param name="s">The underlying stream</param>
/// <param name="mode">To either encrypt or decrypt.</param>
/// <param name="cipher">The pre-initialized ZipCrypto object.</param>
public ZipCipherStream(System.IO.Stream s, ZipCrypto cipher, CryptoMode mode)
: base()
{
_cipher = cipher;
_s = s;
_mode = mode;
}
public static void SaveCryptoStatus(string directory, CryptoMode mode, string password)
{
Mode = mode;
Password = password;
try
{
EnsureGitRepository(directory);
var path = Path.Combine(directory, ".git/password.sync");
switch (mode)
{
case CryptoMode.None:
File.Delete(path);
break;
case CryptoMode.Encrypt:
File.WriteAllLines(path, new[] { "ENC", password }, Encoding.UTF8);
break;
case CryptoMode.Decrypt:
File.WriteAllLines(path, new[] { "DEC", password }, Encoding.UTF8);
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
}
}
catch
{
// ignore
}
}
private byte[] ServiceProcessing(byte[] byteData, string password, CryptoMode mode)
{
using MemoryStream memoryStream = new MemoryStream();
using CryptoStream crypteStream = new CryptoStream(memoryStream, GetCryptoTransform(mode, password), CryptoStreamMode.Write);
crypteStream.Write(byteData, 0, byteData.Length);
crypteStream.Close();
return(memoryStream.ToArray());
}
/// <summary> The constructor. </summary>
/// <param name="s">The underlying stream</param>
/// <param name="mode">To either encrypt or decrypt.</param>
/// <param name="cipher">The pre-initialized ZipCrypto object.</param>
public ZipCipherStream(System.IO.Stream s, ZipCrypto cipher, CryptoMode mode)
{
if (s == null)
{
throw new ArgumentNullException("s");
}
_cipher = cipher;
_s = s;
_mode = mode;
}
private ICryptoTransform GetCryptoTransform(CryptoMode mode, string password)
{
using Aes cryptoService = Aes.Create();
Rfc2898DeriveBytes byteDeriver = new Rfc2898DeriveBytes(password, GetSalt);
cryptoService.Key = byteDeriver.GetBytes(32);
cryptoService.IV = byteDeriver.GetBytes(16);
return(mode switch
{
CryptoMode.Decrypt => cryptoService.CreateDecryptor(),
_ => cryptoService.CreateEncryptor(),
});
internal WinZipAesCipherStream(System.IO.Stream s, WinZipAesCrypto cryptoParams, CryptoMode mode)
: base()
{
TraceOutput("-------------------------------------------------------");
TraceOutput("Create {0:X8}", this.GetHashCode());
_params = cryptoParams;
_s = s;
_mode = mode;
_nonce = 1;
if (_params == null)
{
throw new BadPasswordException("Supply a password to use AES encryption.");
}
int keySizeInBits = _params.KeyBytes.Length * 8;
if (keySizeInBits != 256 && keySizeInBits != 128 && keySizeInBits != 192)
{
throw new ArgumentOutOfRangeException("keysize",
"size of key must be 128, 192, or 256");
}
_mac = new HMACSHA1(_params.MacIv);
_aesCipher = new System.Security.Cryptography.RijndaelManaged();
_aesCipher.BlockSize = 128;
_aesCipher.KeySize = keySizeInBits; // 128, 192, 256
_aesCipher.Mode = CipherMode.ECB;
_aesCipher.Padding = PaddingMode.None;
byte[] iv = new byte[BLOCK_SIZE_IN_BYTES]; // all zeroes
// Create an ENCRYPTOR, regardless whether doing decryption or encryption.
// It is reflexive.
_xform = _aesCipher.CreateEncryptor(_params.KeyBytes, iv);
if (_mode == CryptoMode.Encrypt)
{
_iobuf = new byte[2048];
_PendingWriteBlock = new byte[BLOCK_SIZE_IN_BYTES];
}
#if WANT_TRACE
traceFileUntransformed = "unpack\\WinZipAesCipherStream.trace.untransformed.out";
traceFileTransformed = "unpack\\WinZipAesCipherStream.trace.transformed.out";
untransformed = System.IO.File.Create(traceFileUntransformed);
transformed = System.IO.File.Create(traceFileTransformed);
#endif
}
public CryptoValue(
byte[] original,
byte[] cipher,
CryptoMode direction,
Dictionary <string, object> contextData, TrimOptions options)
{
OriginalData = original;
CipherData = cipher;
Direction = direction;
CryptoContextData = contextData ?? new Dictionary <string, object>();
_options = options ?? TrimOptions.Instance;
}
/// <summary>
/// 获取DES或TripleDES加密解密对象
/// </summary>
/// <param name="cryptoName"></param>
/// <returns></returns>
public static IDES Create(CryptoMode cryptoName)
{
IDES CryptoInstance;
if (CryptoMode.TripleDES == cryptoName)
{
CryptoInstance = TripleDES.Instance;
}
else
{
CryptoInstance = DES.Instance;
}
return(CryptoInstance);
}
/// <summary>
/// Shift
/// Author: Omar-Salem
/// </summary>
/// <param name="token"></param>
/// <param name="key"></param>
/// <param name="mode"></param>
/// <param name="alphabetSortedDict"></param>
/// <returns></returns>
internal static string Shift(string token, string key, CryptoMode mode, Dictionary<char, int> alphabetSortedDict)
{
var sbRet = new StringBuilder();
for (var i = 0; i < token.Length; i++)
{
var resPosition = GetAlphabetPositionFunc()
(alphabetSortedDict[token[i]]) /*text position*/
(alphabetSortedDict[key[i]]) /*key position*/
(mode); /*encryption algorithm mode*/
sbRet.Append(alphabetSortedDict.Keys.ElementAt(resPosition));
}
return sbRet.ToString();
}
/// <summary>
/// 将密码文本解密为明文
/// </summary>
/// <param name="cryptoText">密码文本</param>
/// <param name="cryptoMode">加密方式</param>
public string Decrypt(string cryptoText, CryptoMode cryptoMode)
{
string plainText = string.Empty;
switch (cryptoMode)
{
case CryptoMode.DES:
plainText = SimpleDESCryptoServiceProvider.Decrypt(cryptoText, Resources.DefaultDESCryptoKey);
break;
case CryptoMode.RC2:
plainText = SimpleRC2CryptoServiceProvider.Decrypt(cryptoText, Resources.DefaultRC2CryptoKey);
break;
case CryptoMode.RSA:
plainText = SimpleRSACryptoServiceProvider.Decrypt(cryptoText, Resources.DefaultRSACryptoPrivateKey);
break;
}
return plainText;
}
public frmCryptoInput(CryptoMode Modes, IEnumerable <RSAKey> Keys)
{
InitializeComponent();
RsaKeys = Keys == null ? null : Keys.ToArray();
if (!Modes.HasFlag(CryptoMode.Keyfile))
{
cbKeyfile.Enabled = tbKeyfile.Enabled = btnKeyfile.Enabled = false;
}
if (!Modes.HasFlag(CryptoMode.Password))
{
cbPassword.Enabled = tbPassword.Enabled = false;
}
if (!Modes.HasFlag(CryptoMode.RSA) || Keys == null)
{
cbRSA.Enabled = lblRSAName.Enabled = btnRSA.Enabled = false;
}
}
public (bool, byte[]) GetDecryptedPassword(byte[] key)
{
if (_mode == CryptoMode.Encryption)
{
throw new InvalidOperationException("Password can't be decrypted when constructed for encryption");
}
var decryptedPass = key.Xor(EncryptedPassword);
var hash = GeneratePasswordHash(decryptedPass);
if (hash.ContentEqualTo(AuthenticationHash))
{
_mode = CryptoMode.Encryption;
Password = decryptedPass;
return(true, decryptedPass);
}
return(false, new byte[0]);
}
public SymmetricCrypto(CryptoMode cryptoMode)
{
switch (cryptoMode)
{
case CryptoMode.AES:
m_symAlgorithm = new RijndaelManaged();
m_symAlgorithm.GenerateKey();
m_symAlgorithm.GenerateIV();
break;
case CryptoMode.DES:
m_symAlgorithm = new DESCryptoServiceProvider();
m_symAlgorithm.GenerateKey();
m_symAlgorithm.GenerateIV();
break;
default:
throw new Exception("It doesn't support this SymmetricAlgorithm！");
}
}
internal WinzipAesCryptoStream(Stream stream, WinzipAesEncryptionData winzipAesEncryptionData, long length,
CryptoMode mode)
{
this.mode = mode;
this.stream = stream;
totalBytesLeftToRead = length;
hmac = new HMACSHA1(winzipAesEncryptionData.IvBytes);
cipher = CreateCipher(winzipAesEncryptionData);
var iv = new byte[BLOCK_SIZE_IN_BYTES];
transform = cipher.CreateEncryptor(winzipAesEncryptionData.KeyBytes, iv);
//if (_mode == CryptoMode.Encrypt)
//{
// _iobuf = new byte[2048];
// _PendingWriteBlock = new byte[BLOCK_SIZE_IN_BYTES];
//}
}
public frmCryptoModeSelect(AppSettings Settings, CryptoMode AllowedModes = CryptoMode._ALL, CryptoMode PreselectedModes = 0)
{
InitializeComponent();
this.Settings = Settings;
//Set enabled controls
cbUserAccount.Enabled = AllowedModes.HasFlag(CryptoMode.CryptUser);
cbComputerAccount.Enabled = AllowedModes.HasFlag(CryptoMode.CryptMachine);
cbKeyfile.Enabled = AllowedModes.HasFlag(CryptoMode.Keyfile);
cbPassword.Enabled = AllowedModes.HasFlag(CryptoMode.Password);
cbRSA.Enabled = AllowedModes.HasFlag(CryptoMode.RSA);
//Set checked controls
cbUserAccount.Checked = cbUserAccount.Enabled && PreselectedModes.HasFlag(CryptoMode.CryptUser);
cbComputerAccount.Checked = cbComputerAccount.Enabled && PreselectedModes.HasFlag(CryptoMode.CryptMachine);
cbKeyfile.Checked = cbKeyfile.Enabled && PreselectedModes.HasFlag(CryptoMode.Keyfile);
cbPassword.Checked = cbPassword.Enabled && PreselectedModes.HasFlag(CryptoMode.Password);
cbRSA.Checked = cbRSA.Enabled && PreselectedModes.HasFlag(CryptoMode.RSA);
}
internal WinzipAesCryptoStream(Stream stream, WinzipAesEncryptionData winzipAesEncryptionData, long length,
CryptoMode mode)
{
//this.mode = mode;
this.stream = stream;
totalBytesLeftToRead = length;
hmac = new HMACSHA1(winzipAesEncryptionData.IvBytes);
cipher = CreateCipher(winzipAesEncryptionData);
var iv = new byte[BLOCK_SIZE_IN_BYTES];
transform = cipher.CreateEncryptor(winzipAesEncryptionData.KeyBytes, iv);
//if (_mode == CryptoMode.Encrypt)
//{
// _iobuf = new byte[2048];
// _PendingWriteBlock = new byte[BLOCK_SIZE_IN_BYTES];
//}
}
private void SaveFile(CryptoMode mode, string text)
{
// Displays a SaveFileDialog so the user can save the encrypted text
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
if (mode == CryptoMode.Encrypt)
{
saveFileDialog1.Title = "Save encrypted file";
}
else if (mode == CryptoMode.Decrypt)
{
saveFileDialog1.Title = "Save decrypted file";
//saveFileDialog1.f
}
saveFileDialog1.ShowDialog();
// If the file name is not an empty string open it for saving.
if (saveFileDialog1.FileName != "")
{
File.WriteAllText(saveFileDialog1.FileName, text);
}
}
public static void LoadCryptoStatus(string directory)
{
Mode = CryptoMode.None;
Password = "";
try
{
EnsureGitRepository(directory);
var path = Path.Combine(directory, ".git/password.sync");
if (!File.Exists(path))
{
return;
}
var lines = File.ReadLines(path, Encoding.UTF8).ToArray();
if (lines.Length < 2)
{
return;
}
if (lines[0] == "ENC")
{
Mode = CryptoMode.Encrypt;
Password = lines[1];
return;
}
if (lines[0] == "DEC")
{
Mode = CryptoMode.Decrypt;
Password = lines[1];
}
}
catch
{
// ignore
}
}
/// <summary>
/// Checks if the given provider is registered
/// </summary>
/// <param name="M">Single provider</param>
/// <returns>true, if the provider exists</returns>
public bool HasProvider(CryptoMode M)
{
return(Providers.Any(m => m.Mode == M));
}
public PkwareTraditionalCryptoStream(Stream stream, PkwareTraditionalEncryptionData encryptor, CryptoMode mode)
{
this.encryptor = encryptor;
this.stream = stream;
this.mode = mode;
}
public SignableCryptoValue(byte[] original, byte[] cipher, CryptoMode direction, Dictionary <string, object> contextData, TrimOptions options)
: base(original, cipher, direction, contextData, options)
{
}
/// <summary>
/// Encrypts the given data using the given methods
/// </summary>
/// <param name="Modes">Encryption modes</param>
/// <param name="Content">Data to encrypt</param>
/// <param name="ModeParams">Parameter for the supplied modes (for those that require parameters)</param>
/// <returns>Encrypted and serializable data</returns>
/// <remarks>See the <see cref="CryptoMode"/> enumeration for required arguments</remarks>
public static EncryptedData Encrypt(CryptoMode Modes, byte[] Content, IDictionary <CryptoMode, object> ModeParams = null)
{
var ED = new EncryptedData();
var AesKey = ED.AesKey = GetRandomKey();
var MacKey = ED.MacKey = GetRandomKey();
var KeyBlob = Encoding.ASCII.GetBytes(Convert.ToBase64String(AesKey) + ":" + Convert.ToBase64String(MacKey));
var EncModes = Tools.FlagsToArray(Modes);
ED.Data = EncryptWithKey(Content, AesKey, MacKey);
ED.Providers = EncModes.Select(m => new KeyProvider()
{
Mode = m
}).ToArray();
for (var i = 0; i < ED.Providers.Length; i++)
{
var P = ED.Providers[i];
var Data = new AesCryptoData();
var Param = ModeParams == null ? null : (ModeParams.ContainsKey(P.Mode) ? ModeParams[P.Mode] : null);
switch (P.Mode)
{
case CryptoMode.CryptUser:
Data.Salt = Data.IV = null;
Data.Data = ProtectData(false, KeyBlob);
break;
case CryptoMode.CryptMachine:
Data.Salt = Data.IV = null;
Data.Data = ProtectData(true, KeyBlob);
break;
case CryptoMode.RSA:
if (Param == null || Param.GetType() != typeof(RSAParameters))
{
throw new ArgumentException("RSA mode requires an RSAParameters structure as argument");
}
Data = EncryptWithRSAKey(KeyBlob, (RSAParameters)Param);
break;
case CryptoMode.Keyfile:
if (Param == null || Param.GetType() != typeof(string))
{
throw new ArgumentException("Keyfile mode requires a file name argument");
}
Data = EncryptWithKeyfile(KeyBlob, Param.ToString());
break;
case CryptoMode.Password:
if (Param == null || Param.GetType() != typeof(string))
{
throw new ArgumentException("Password mode requires a password argument");
}
Data = EncryptWithPassword(KeyBlob, Param.ToString());
break;
default:
throw new NotImplementedException($"Algorithm {P.Mode} is not implemented");
}
P.KeyData = Data;
}
return(ED);
}
/// <summary> The constructor. </summary>
/// <param name="s">The underlying stream</param>
/// <param name="mode">To either encrypt or decrypt.</param>
/// <param name="cipher">The pre-initialized ZipCrypto object.</param>
public ZipCipherStream(System.IO.Stream s, ZipCrypto cipher, CryptoMode mode)
{
if (s == null) throw new ArgumentNullException("s");
_cipher = cipher;
_s = s;
_mode = mode;
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="s">The underlying stream</param>
/// <param name="mode">To either encrypt or decrypt.</param>
/// <param name="cryptoParams">The pre-initialized WinZipAesCrypto object.</param>
/// <param name="length">The maximum number of bytes to read from the stream.</param>
internal WinZipAesCipherStream(Stream s, WinZipAesCrypto cryptoParams, long length, CryptoMode mode)
: this(s, cryptoParams, mode)
{
if (s == null)
{
throw new ArgumentNullException("s");
}
// don't read beyond this limit!
_length = length;
//Console.WriteLine("max length of AES stream: {0}", _length);
}
/// <summary>
/// 将明文加密为密码文本
/// </summary>
/// <param name="plaintext">明文文本</param>
/// <param name="cryptoMode">加密方式</param>
public string Encrypt(string plainText,CryptoMode cryptoMode)
{
string cryptoText = string.Empty;
switch (cryptoMode)
{
case CryptoMode.DES:
cryptoText = SimpleDESCryptoServiceProvider.Encrypt(plainText, Resources.DefaultDESCryptoKey);
break;
case CryptoMode.RC2:
cryptoText = SimpleRC2CryptoServiceProvider.Encrypt(plainText, Resources.DefaultRC2CryptoKey);
break;
case CryptoMode.RSA:
cryptoText = SimpleRSACryptoServiceProvider.Encrypt(plainText, Resources.DefaultRSACryptoPublicKey);
break;
case CryptoMode.MD5:
cryptoText = SimpleMD5CryptoServiceProvider.Encrypt(plainText, Resources.DefaultMD5CryptoKey);
break;
}
return cryptoText;
}
public DummySwitchInfo(CryptoMode cryptoMode, string targetFile, ConsoleMode consoleMode)
{
Mode = cryptoMode;
TargetFile = targetFile;
ConsoleMode = consoleMode;
}
public MasterPassword()
{
Password = CryptoRNG.GetRandomBytes(AesSizes.Key);
AuthenticationHash = GeneratePasswordHash(Password);
_mode = CryptoMode.Encryption;
}
public MasterPassword(byte[] authenticationHash, byte[] encryptedPassword)
{
AuthenticationHash = authenticationHash;
EncryptedPassword = encryptedPassword;
_mode = CryptoMode.Decryption;
}
internal WinZipAesCipherStream(System.IO.Stream s, WinZipAesCrypto cryptoParams, CryptoMode mode)
: base()
{
TraceOutput("-------------------------------------------------------");
TraceOutput("Create {0:X8}", this.GetHashCode());
_params = cryptoParams;
_s = s;
_mode = mode;
_nonce = 1;
if (_params == null)
throw new BadPasswordException("Supply a password to use AES encryption.");
int keySizeInBits = _params.KeyBytes.Length * 8;
if (keySizeInBits != 256 && keySizeInBits != 128 && keySizeInBits != 192)
throw new ArgumentException("keysize");
_mac = new HMACSHA1(_params.MacIv);
_aesCipher = new System.Security.Cryptography.RijndaelManaged();
_aesCipher.BlockSize = 128;
_aesCipher.KeySize = keySizeInBits; // 128, 192, 256
_aesCipher.Mode = CipherMode.ECB;
_aesCipher.Padding = PaddingMode.None;
byte[] iv = new byte[BLOCK_SIZE_IN_BYTES]; // all zeroes
// Create an ENCRYPTOR, regardless whether doing decryption or encryption.
// It is reflexive.
_xform = _aesCipher.CreateEncryptor(_params.KeyBytes, iv);
if (_mode == CryptoMode.Encrypt)
_PendingWriteBuffer = new byte[BLOCK_SIZE_IN_BYTES];
#if WANT_TRACE
traceFileUntransformed = "unpack\\WinZipAesCipherStream.trace.untransformed.out";
traceFileTransformed = "unpack\\WinZipAesCipherStream.trace.transformed.out";
untransformed = System.IO.File.Create(traceFileUntransformed);
transformed = System.IO.File.Create(traceFileTransformed);
#endif
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="s">The underlying stream</param>
/// <param name="mode">To either encrypt or decrypt.</param>
/// <param name="cryptoParams">The pre-initialized WinZipAesCrypto object.</param>
/// <param name="length">The maximum number of bytes to read from the stream.</param>
internal WinZipAesCipherStream(System.IO.Stream s, WinZipAesCrypto cryptoParams, long length, CryptoMode mode)
: this(s, cryptoParams, mode)
{
// don't read beyond this limit!
_length = length;
//Console.WriteLine("max length of AES stream: {0}", _length);
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="s">The underlying stream</param>
/// <param name="mode">To either encrypt or decrypt.</param>
/// <param name="cryptoParams">The pre-initialized WinZipAesCrypto object.</param>
/// <param name="length">The maximum number of bytes to read from the stream.</param>
internal WinZipAesCipherStream(System.IO.Stream s, WinZipAesCrypto cryptoParams, long length, CryptoMode mode)
: this(s, cryptoParams, mode)
{
// don't read beyond this limit!
_length = length;
//Console.WriteLine("max length of AES stream: {0}", _length);
}
// Token: 0x06000D22 RID: 3362 RVA: 0x0004C3C6 File Offset: 0x0004A5C6
public ZipCipherStream(Stream s, ZipCrypto cipher, CryptoMode mode)
{
this._cipher = cipher;
this._s = s;
this._mode = mode;
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="s">The underlying stream</param>
/// <param name="mode">To either encrypt or decrypt.</param>
/// <param name="cryptoParams">The pre-initialized WinZipAesCrypto object.</param>
/// <param name="length">The maximum number of bytes to read from the stream.</param>
internal WinZipAesCipherStream(Stream s, WinZipAesCrypto cryptoParams, long length, CryptoMode mode)
: this(s, cryptoParams, mode)
{
if (s == null) throw new ArgumentNullException("s");
// don't read beyond this limit!
_length = length;
//Console.WriteLine("max length of AES stream: {0}", _length);
}
internal WinZipAesCipherStream(Stream s, WinZipAesCrypto cryptoParams, long length, CryptoMode mode)
: this(s, cryptoParams, mode)
{
_length = length;
}
public PkwareTraditionalCryptoStream(Stream stream, PkwareTraditionalEncryptionData encryptor, CryptoMode mode)
{
this.encryptor = encryptor;
this.stream = stream;
this.mode = mode;
}
/// <summary>
/// Encrypts the given data using the given methods
/// </summary>
/// <param name="Modes">Encryption modes</param>
/// <param name="Content">Data to encrypt</param>
/// <param name="ModeParams">Parameter for the supplied modes (for those that require parameters)</param>
/// <returns>Encrypted and serializable data</returns>
/// <remarks>See the <see cref="CryptoMode"/> enumeration for required arguments</remarks>
public static EncryptedData Encrypt(CryptoMode Modes, byte[] Content, IDictionary <CryptoMode, object> ModeParams = null)
{
var ED = new EncryptedData();
var AesKey = ED.AesKey = GetRandomKey();
var MacKey = ED.MacKey = GetRandomKey();
var KeyBlob = Encoding.ASCII.GetBytes(Convert.ToBase64String(AesKey) + ":" + Convert.ToBase64String(MacKey));
//var EncModes = Tools.FlagsToArray(Modes);
ED.Data = EncryptWithKey(Content, AesKey, MacKey);
var Providers = new List <KeyProvider>();
foreach (var ModeParam in ModeParams.Where(m => Modes.HasFlag(m.Key)))
{
switch (ModeParam.Key)
{
case CryptoMode.CryptUser:
Providers.Add(new KeyProvider()
{
Mode = ModeParam.Key,
KeyData = new AesCryptoData()
{
Salt = null,
IV = null,
Data = ProtectData(false, KeyBlob)
}
});
break;
case CryptoMode.CryptMachine:
Providers.Add(new KeyProvider()
{
Mode = ModeParam.Key,
KeyData = new AesCryptoData()
{
Salt = null,
IV = null,
Data = ProtectData(true, KeyBlob)
}
});
break;
case CryptoMode.RSA:
if (ModeParam.Value == null || !(ModeParam.Value is IEnumerable <RSAParameters>))
{
throw new ArgumentException("RSA mode requires an RSAParameters structure as argument");
}
foreach (var key in (IEnumerable <RSAParameters>)ModeParam.Value)
{
Providers.Add(new KeyProvider()
{
Mode = ModeParam.Key,
KeyData = EncryptWithRSAKey(KeyBlob, key)
});
}
break;
case CryptoMode.Keyfile:
if (ModeParam.Value == null || ModeParam.Value.GetType() != typeof(string))
{
throw new ArgumentException("Keyfile mode requires a file name argument");
}
Providers.Add(new KeyProvider()
{
Mode = ModeParam.Key,
KeyData = EncryptWithKeyfile(KeyBlob, ModeParam.Value.ToString())
});
break;
case CryptoMode.Password:
if (ModeParam.Value == null || ModeParam.Value.GetType() != typeof(string))
{
throw new ArgumentException("Password mode requires a password argument");
}
Providers.Add(new KeyProvider()
{
Mode = ModeParam.Key,
KeyData = EncryptWithPassword(KeyBlob, ModeParam.Value.ToString())
});
break;
default:
throw new NotImplementedException($"Algorithm {ModeParam.Key} is not implemented");
}
}
ED.Providers = Providers.ToArray();
return(ED);
}
