private void CreateAesEncryptor()
{
int KeyLengthNeed = KeySize / 8;
byte[] KeyArray;
if (Key.Length > KeyLengthNeed)
{
KeyArray = Encoding.UTF8.GetBytes(Key.Substring(0, KeyLengthNeed));
}
else if (Key.Length < KeyLengthNeed)
{
KeyArray = Encoding.UTF8.GetBytes(Key.PadRight(KeyLengthNeed, '0'));
}
else
{
KeyArray = Encoding.UTF8.GetBytes(Key);
}
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider
{
KeySize = KeySize,
Mode = CipherMode.CBC,
Padding = Version > SLEVersion.Version_1_0_0 ? PaddingMode.PKCS7 : PaddingMode.Zeros,
Key = KeyArray,
IV = Encoding.UTF8.GetBytes(SecureAccessProvider.GetFileEncryptionAesIV(Package.Current))
})
{
TransformStream = new CryptoStream(BaseFileStream, AES.CreateEncryptor(), CryptoStreamMode.Write);
}
}
/// <summary>
/// 初始化MySQL实例
/// </summary>
private MySQL()
{
using (SecureString Secure = SecureAccessProvider.GetMySQLAccessCredential(Package.Current))
{
IntPtr Bstr = Marshal.SecureStringToBSTR(Secure);
string AccessCredential = Marshal.PtrToStringBSTR(Bstr);
try
{
Connection = new MySqlConnection($"{AccessCredential}CharSet=utf8mb4;Database=FeedBackDataBase;");
}
finally
{
Marshal.ZeroFreeBSTR(Bstr);
unsafe
{
fixed(char *ClearPtr = AccessCredential)
{
for (int i = 0; i < AccessCredential.Length; i++)
{
ClearPtr[i] = '\0';
}
}
}
}
}
}
private void CreateAesDecryptor()
{
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider
{
Mode = CipherMode.CBC,
Padding = Version > SLEVersion.Version_1_0_0 ? PaddingMode.PKCS7 : PaddingMode.Zeros,
KeySize = KeySize,
Key = KeyArray,
IV = Encoding.UTF8.GetBytes(SecureAccessProvider.GetFileEncryptionAesIV(Package.Current))
})
{
TransformStream = new CryptoStream(BaseFileStream, AES.CreateDecryptor(), CryptoStreamMode.Read);
}
}
public async Task <FileSystemStorageFile> DecryptAsync(string OutputDirectory, string Key, CancellationToken CancelToken = default)
{
if (string.IsNullOrWhiteSpace(OutputDirectory))
{
throw new ArgumentNullException(nameof(OutputDirectory), "Argument could not be null");
}
if (string.IsNullOrEmpty(Key))
{
throw new ArgumentNullException(nameof(Key), "Key could not be null or empty");
}
string IV = SecureAccessProvider.GetFileEncryptionAesIV(Package.Current);
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider
{
Mode = CipherMode.CBC,
Padding = PaddingMode.Zeros,
IV = Encoding.UTF8.GetBytes(IV)
})
{
using (FileStream EncryptFileStream = await GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(true))
{
StringBuilder Builder = new StringBuilder();
using (StreamReader Reader = new StreamReader(EncryptFileStream, Encoding.UTF8, true, 64, true))
{
for (int Count = 0; Reader.Peek() >= 0; Count++)
{
if (Count > 64)
{
throw new FileDamagedException("File damaged, could not be decrypted");
}
char NextChar = (char)Reader.Read();
if (Builder.Length > 0 && NextChar == '$')
{
Builder.Append(NextChar);
break;
}
else
{
Builder.Append(NextChar);
}
}
}
string RawInfoData = Builder.ToString();
if (string.IsNullOrWhiteSpace(RawInfoData))
{
throw new FileDamagedException("File damaged, could not be decrypted");
}
else
{
if (RawInfoData.Split('$', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() is string InfoData)
{
string[] InfoGroup = InfoData.Split('|');
if (InfoGroup.Length == 2)
{
string FileType = InfoGroup[1];
AES.KeySize = Convert.ToInt32(InfoGroup[0]);
int KeyLengthNeed = AES.KeySize / 8;
AES.Key = Key.Length > KeyLengthNeed?Encoding.UTF8.GetBytes(Key.Substring(0, KeyLengthNeed)) : Encoding.UTF8.GetBytes(Key.PadRight(KeyLengthNeed, '0'));
string DecryptedFilePath = System.IO.Path.Combine(OutputDirectory, $"{System.IO.Path.GetFileNameWithoutExtension(Name)}{FileType}");
if (await CreateAsync(DecryptedFilePath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(true) is FileSystemStorageFile DecryptedFile)
{
using (FileStream DecryptFileStream = await DecryptedFile.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(true))
using (ICryptoTransform Decryptor = AES.CreateDecryptor(AES.Key, AES.IV))
{
EncryptFileStream.Seek(RawInfoData.Length, SeekOrigin.Begin);
byte[] PasswordConfirm = new byte[16];
await EncryptFileStream.ReadAsync(PasswordConfirm, 0, PasswordConfirm.Length).ConfigureAwait(true);
if (Encoding.UTF8.GetString(Decryptor.TransformFinalBlock(PasswordConfirm, 0, PasswordConfirm.Length)) == "PASSWORD_CORRECT")
{
using (CryptoStream TransformStream = new CryptoStream(EncryptFileStream, Decryptor, CryptoStreamMode.Read))
{
await TransformStream.CopyToAsync(DecryptFileStream, 2048, CancelToken).ConfigureAwait(true);
}
}
else
{
throw new PasswordErrorException("Password is not correct");
}
}
return(DecryptedFile);
}
else
{
throw new Exception("Could not create a new file");
}
}
else
{
throw new FileDamagedException("File damaged, could not be decrypted");
}
}
else
{
throw new FileDamagedException("File damaged, could not be decrypted");
}
}
}
}
}
public async Task <FileSystemStorageFile> EncryptAsync(string OutputDirectory, string Key, int KeySize, CancellationToken CancelToken = default)
{
if (string.IsNullOrWhiteSpace(OutputDirectory))
{
throw new ArgumentNullException(nameof(OutputDirectory), "Argument could not be null");
}
if (KeySize != 256 && KeySize != 128)
{
throw new InvalidEnumArgumentException("AES密钥长度仅支持128或256任意一种");
}
if (string.IsNullOrEmpty(Key))
{
throw new ArgumentNullException(nameof(Key), "Parameter could not be null or empty");
}
int KeyLengthNeed = KeySize / 8;
byte[] KeyArray = Key.Length > KeyLengthNeed
? Encoding.UTF8.GetBytes(Key.Substring(0, KeyLengthNeed))
: Encoding.UTF8.GetBytes(Key.PadRight(KeyLengthNeed, '0'));
string EncryptedFilePath = System.IO.Path.Combine(OutputDirectory, $"{System.IO.Path.GetFileNameWithoutExtension(Name)}.sle");
if (await CreateAsync(EncryptedFilePath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(true) is FileSystemStorageFile EncryptedFile)
{
using (FileStream EncryptFileStream = await EncryptedFile.GetFileStreamFromFileAsync(AccessMode.Write).ConfigureAwait(true))
{
string IV = SecureAccessProvider.GetFileEncryptionAesIV(Package.Current);
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider
{
KeySize = KeySize,
Key = KeyArray,
Mode = CipherMode.CBC,
Padding = PaddingMode.Zeros,
IV = Encoding.UTF8.GetBytes(IV)
})
{
using (FileStream OriginFileStream = await GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(true))
using (ICryptoTransform Encryptor = AES.CreateEncryptor())
{
byte[] ExtraInfoPart1 = Encoding.UTF8.GetBytes($"${KeySize}|{System.IO.Path.GetExtension(Path)}$");
await EncryptFileStream.WriteAsync(ExtraInfoPart1, 0, ExtraInfoPart1.Length, CancelToken).ConfigureAwait(true);
byte[] PasswordConfirm = Encoding.UTF8.GetBytes("PASSWORD_CORRECT");
byte[] PasswordConfirmEncrypted = Encryptor.TransformFinalBlock(PasswordConfirm, 0, PasswordConfirm.Length);
await EncryptFileStream.WriteAsync(PasswordConfirmEncrypted, 0, PasswordConfirmEncrypted.Length, CancelToken).ConfigureAwait(true);
using (CryptoStream TransformStream = new CryptoStream(EncryptFileStream, Encryptor, CryptoStreamMode.Write))
{
await OriginFileStream.CopyToAsync(TransformStream, 2048, CancelToken).ConfigureAwait(true);
}
}
}
}
await EncryptedFile.RefreshAsync().ConfigureAwait(true);
return(EncryptedFile);
}
else
{
return(null);
}
}
/// <summary>
/// 根据指定的密钥解密密文
/// </summary>
/// <param name="OriginText">密文</param>
/// <param name="Key">密钥</param>
/// <returns></returns>
public static async Task <string> DecryptAsync(this string OriginText, string Key)
{
if (string.IsNullOrEmpty(OriginText))
{
throw new ArgumentNullException(nameof(OriginText), "Parameter could not be null or empty");
}
if (string.IsNullOrEmpty(Key))
{
throw new ArgumentNullException(nameof(Key), "Parameter could not be null or empty");
}
try
{
using (SecureString Secure = SecureAccessProvider.GetStringEncryptionAesIV(Package.Current))
{
IntPtr Bstr = Marshal.SecureStringToBSTR(Secure);
string IV = Marshal.PtrToStringBSTR(Bstr);
try
{
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider
{
KeySize = 128,
Key = Key.Length > 16 ? Encoding.UTF8.GetBytes(Key.Substring(0, 16)) : Encoding.UTF8.GetBytes(Key.PadRight(16, '0')),
Mode = CipherMode.CBC,
Padding = PaddingMode.PKCS7,
IV = Encoding.UTF8.GetBytes(IV)
})
{
using (MemoryStream DecryptStream = new MemoryStream(Convert.FromBase64String(OriginText)))
{
using (ICryptoTransform Decryptor = AES.CreateDecryptor())
using (CryptoStream TransformStream = new CryptoStream(DecryptStream, Decryptor, CryptoStreamMode.Read))
using (StreamReader Writer = new StreamReader(TransformStream, Encoding.UTF8))
{
return(await Writer.ReadToEndAsync().ConfigureAwait(false));
}
}
}
}
finally
{
Marshal.ZeroFreeBSTR(Bstr);
unsafe
{
fixed(char *ClearPtr = IV)
{
for (int i = 0; i < IV.Length; i++)
{
ClearPtr[i] = '\0';
}
}
}
}
}
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// 使用GoogleAPI自动检测语言并将文字翻译为对应语言
/// </summary>
/// <param name="Text">要翻译的内容</param>
/// <returns></returns>
public static Task <string> TranslateAsync(this string Text)
{
return(Task.Run(() =>
{
using (SecureString Secure = SecureAccessProvider.GetGoogleTranslateAccessKey(Package.Current))
{
IntPtr Bstr = Marshal.SecureStringToBSTR(Secure);
string APIKey = Marshal.PtrToStringBSTR(Bstr);
try
{
using (TranslationClient Client = TranslationClient.CreateFromApiKey(APIKey, TranslationModel.ServiceDefault))
{
Detection DetectResult = Client.DetectLanguage(Text);
string CurrentLanguage = string.Empty;
switch (Globalization.CurrentLanguage)
{
case LanguageEnum.English:
{
CurrentLanguage = LanguageCodes.English;
break;
}
case LanguageEnum.Chinese_Simplified:
{
CurrentLanguage = LanguageCodes.ChineseSimplified;
break;
}
case LanguageEnum.Chinese_Traditional:
{
CurrentLanguage = LanguageCodes.ChineseTraditional;
break;
}
case LanguageEnum.French:
{
CurrentLanguage = LanguageCodes.French;
break;
}
}
if (DetectResult.Language.StartsWith(CurrentLanguage))
{
return Text;
}
else
{
TranslationResult TranslateResult = Client.TranslateText(Text, CurrentLanguage, DetectResult.Language);
return TranslateResult.TranslatedText;
}
}
}
catch
{
return Text;
}
finally
{
Marshal.ZeroFreeBSTR(Bstr);
unsafe
{
fixed(char *ClearPtr = APIKey)
{
for (int i = 0; i < APIKey.Length; i++)
{
ClearPtr[i] = '\0';
}
}
}
}
}
}));
}
/// <summary>
/// 初始化MySQL实例
/// </summary>
public MySQL()
{
Connection = new MySqlConnection(SecureAccessProvider.GetMySQLAccessCredential(Package.Current));
}
public async Task <FileSystemStorageItemBase> DecryptAsync(string ExportFolderPath, string Key, CancellationToken CancelToken = default)
{
if (string.IsNullOrWhiteSpace(ExportFolderPath))
{
throw new ArgumentNullException(nameof(ExportFolderPath), "ExportFolder could not be null");
}
if (string.IsNullOrEmpty(Key))
{
throw new ArgumentNullException(nameof(Key), "Key could not be null or empty");
}
using (SecureString Secure = SecureAccessProvider.GetFileEncryptionAesIV(Package.Current))
{
IntPtr Bstr = Marshal.SecureStringToBSTR(Secure);
string IV = Marshal.PtrToStringBSTR(Bstr);
string DecryptedFilePath = string.Empty;
try
{
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider
{
Mode = CipherMode.CBC,
Padding = PaddingMode.Zeros,
IV = Encoding.UTF8.GetBytes(IV)
})
{
using (FileStream EncryptFileStream = GetFileStreamFromFile(AccessMode.Read))
{
StringBuilder Builder = new StringBuilder();
using (StreamReader Reader = new StreamReader(EncryptFileStream, Encoding.UTF8, true, 64, true))
{
for (int Count = 0; Reader.Peek() >= 0; Count++)
{
if (Count > 64)
{
throw new FileDamagedException("File damaged, could not be decrypted");
}
char NextChar = (char)Reader.Read();
if (Builder.Length > 0 && NextChar == '$')
{
Builder.Append(NextChar);
break;
}
else
{
Builder.Append(NextChar);
}
}
}
string RawInfoData = Builder.ToString();
if (string.IsNullOrWhiteSpace(RawInfoData))
{
throw new FileDamagedException("File damaged, could not be decrypted");
}
else
{
if (RawInfoData.Split('$', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() is string InfoData)
{
string[] InfoGroup = InfoData.Split('|');
if (InfoGroup.Length == 2)
{
string FileType = InfoGroup[1];
AES.KeySize = Convert.ToInt32(InfoGroup[0]);
int KeyLengthNeed = AES.KeySize / 8;
AES.Key = Key.Length > KeyLengthNeed?Encoding.UTF8.GetBytes(Key.Substring(0, KeyLengthNeed)) : Encoding.UTF8.GetBytes(Key.PadRight(KeyLengthNeed, '0'));
DecryptedFilePath = System.IO.Path.Combine(ExportFolderPath, $"{System.IO.Path.GetFileNameWithoutExtension(Name)}{FileType}");
if (Create(DecryptedFilePath, StorageItemTypes.File, CreateOption.GenerateUniqueName) is FileSystemStorageItemBase Item)
{
using (FileStream DecryptFileStream = Item.GetFileStreamFromFile(AccessMode.Exclusive))
using (ICryptoTransform Decryptor = AES.CreateDecryptor(AES.Key, AES.IV))
{
EncryptFileStream.Seek(RawInfoData.Length, SeekOrigin.Begin);
byte[] PasswordConfirm = new byte[16];
await EncryptFileStream.ReadAsync(PasswordConfirm, 0, PasswordConfirm.Length).ConfigureAwait(false);
if (Encoding.UTF8.GetString(Decryptor.TransformFinalBlock(PasswordConfirm, 0, PasswordConfirm.Length)) == "PASSWORD_CORRECT")
{
using (CryptoStream TransformStream = new CryptoStream(EncryptFileStream, Decryptor, CryptoStreamMode.Read))
{
await TransformStream.CopyToAsync(DecryptFileStream, 2048, CancelToken).ConfigureAwait(false);
}
}
else
{
throw new PasswordErrorException("Password is not correct");
}
}
return(Open(DecryptedFilePath, ItemFilters.File));
}
else
{
throw new Exception("Could not create a new file");
}
}
else
{
throw new FileDamagedException("File damaged, could not be decrypted");
}
}
else
{
throw new FileDamagedException("File damaged, could not be decrypted");
}
}
}
}
}
catch (Exception)
{
if (!string.IsNullOrEmpty(DecryptedFilePath))
{
WIN_Native_API.DeleteFromPath(DecryptedFilePath);
}
throw;
}
finally
{
Marshal.ZeroFreeBSTR(Bstr);
unsafe
{
fixed(char *ClearPtr = IV)
{
for (int i = 0; i < IV.Length; i++)
{
ClearPtr[i] = '\0';
}
}
}
}
}
}
