public async Task Should_decrypt_utility_bill_element_translation()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
RSA key = EncryptionKey.ReadAsRsa();
EncryptedPassportElement billElement = Assert.Single(passportData.Data, el => el.Type == "utility_bill");
PassportFile translationFile = Assert.Single(billElement.Translation);
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, key);
FileCredentials fileCredentials = Assert.Single(credentials.SecureData.UtilityBill.Translation);
File encryptedFileInfo;
using (System.IO.Stream decryptedFile = new System.IO.MemoryStream())
{
encryptedFileInfo = await BotClient.DownloadAndDecryptPassportFileAsync(
translationFile,
fileCredentials,
decryptedFile
);
Assert.InRange(decryptedFile.Length, translationFile.FileSize - 256, translationFile.FileSize + 256);
}
Assert.NotEmpty(encryptedFileInfo.FilePath);
Assert.NotEmpty(encryptedFileInfo.FileId);
Assert.InRange(encryptedFileInfo.FileSize, 1_000, 50_000_000);
}
public void Should_Validate_Passport_Message()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
#region identity card element validation
EncryptedPassportElement idCardEl = Assert.Single(passportData.Data, el => el.Type == "identity_card");
Assert.NotNull(idCardEl);
Assert.Equal(PassportEnums.Scope.IdentityCard, idCardEl.Type);
Assert.NotEmpty(idCardEl.Data);
Assert.NotEmpty(idCardEl.Hash);
Assert.NotNull(idCardEl.FrontSide);
Assert.NotEmpty(idCardEl.FrontSide.FileId);
Assert.InRange(idCardEl.FrontSide.FileDate, new DateTime(2018, 6, 1), DateTime.UtcNow);
Assert.NotNull(idCardEl.ReverseSide);
Assert.NotEmpty(idCardEl.ReverseSide.FileId);
Assert.InRange(idCardEl.ReverseSide.FileDate, new DateTime(2018, 6, 1), DateTime.UtcNow);
Assert.NotNull(idCardEl.Selfie);
Assert.NotEmpty(idCardEl.Selfie.FileId);
Assert.InRange(idCardEl.Selfie.FileDate, new DateTime(2018, 6, 1), DateTime.UtcNow);
#endregion
#region utility bill element validation
EncryptedPassportElement billElement = Assert.Single(passportData.Data, el => el.Type == "utility_bill");
Assert.NotNull(billElement);
Assert.Equal(PassportEnums.Scope.UtilityBill, billElement.Type);
Assert.NotEmpty(billElement.Hash);
Assert.Null(billElement.Data);
PassportFile billScanFile = Assert.Single(billElement.Files);
Assert.NotNull(billScanFile);
Assert.NotEmpty(billScanFile.FileId);
Assert.InRange(billScanFile.FileDate, new DateTime(2018, 6, 1), DateTime.UtcNow);
PassportFile billTranslationFile = Assert.Single(billElement.Files);
Assert.NotNull(billTranslationFile);
Assert.NotEmpty(billTranslationFile.FileId);
Assert.InRange(billTranslationFile.FileDate, new DateTime(2018, 6, 1), DateTime.UtcNow);
#endregion
Assert.NotNull(passportData.Credentials);
Assert.NotEmpty(passportData.Credentials.Data);
Assert.NotEmpty(passportData.Credentials.Hash);
Assert.NotEmpty(passportData.Credentials.Secret);
}
/// <summary>
/// Downloads an encrypted Passport file, decrypts it, and writes the content to
/// <paramref name="destination"/> stream
/// </summary>
/// <param name="botClient">Instance of bot client</param>
/// <param name="passportFile"></param>
/// <param name="fileCredentials"></param>
/// <param name="destination"></param>
/// <param name="cancellationToken">The cancellation token to cancel operation.</param>
/// <returns>File information of the encrypted Passport file on Telegram servers.</returns>
/// <exception cref="ArgumentNullException"></exception>
public static async Task <File> DownloadAndDecryptPassportFileAsync(
this ITelegramBotClient botClient,
PassportFile passportFile,
FileCredentials fileCredentials,
System.IO.Stream destination,
CancellationToken cancellationToken = default
)
{
if (passportFile == null)
{
throw new ArgumentNullException(nameof(passportFile));
}
if (fileCredentials == null)
{
throw new ArgumentNullException(nameof(fileCredentials));
}
if (destination == null)
{
throw new ArgumentNullException(nameof(destination));
}
File fileInfo;
var encryptedContentStream = passportFile.FileSize > 0
? new System.IO.MemoryStream(passportFile.FileSize)
: new System.IO.MemoryStream();
using (encryptedContentStream)
{
fileInfo = await botClient.GetInfoAndDownloadFileAsync(
passportFile.FileId,
encryptedContentStream,
cancellationToken
).ConfigureAwait(false);
encryptedContentStream.Position = 0;
await new Decrypter().DecryptFileAsync(
encryptedContentStream,
fileCredentials,
destination,
cancellationToken
).ConfigureAwait(false);
}
return(fileInfo);
}
public async Task Should_Decrypt_Translation_File()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
RSA key = EncryptionKey.ReadAsRsa();
EncryptedPassportElement element = passportData.Data.Single();
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, key);
for (int i = 0; i < element.Translation.Length; i++)
{
PassportFile passportFile = element.Translation[i];
FileCredentials fileCredentials = credentials.SecureData.DriverLicense.Translation[i];
byte[] encryptedContent;
{
File encryptedFileInfo = await BotClient.GetFileAsync(passportFile.FileId);
Assert.NotEmpty(encryptedFileInfo.FilePath);
Assert.NotEmpty(encryptedFileInfo.FileId);
Assert.InRange(encryptedFileInfo.FileSize, 1_000, 50_000_000);
using (System.IO.MemoryStream stream = new System.IO.MemoryStream(encryptedFileInfo.FileSize))
{
await BotClient.DownloadFileAsync(encryptedFileInfo.FilePath, stream);
encryptedContent = stream.ToArray();
}
}
byte[] translationContent = decrypter.DecryptFile(
encryptedContent,
fileCredentials
);
Assert.NotEmpty(translationContent);
string decryptedFilePath = System.IO.Path.GetTempFileName();
await System.IO.File.WriteAllBytesAsync(decryptedFilePath, translationContent);
_output.WriteLine("Translation JPEG file is written to \"{0}\".", decryptedFilePath);
}
}
public async Task Should_Decrypt_Utility_Bill_Element_Translation()
{
PassportData passportData = GetPassportData();
EncryptedPassportElement billElement = Assert.Single(passportData.Data, el => el.Type == "utility_bill");
Assert.NotNull(billElement.Translation);
PassportFile translationFile = Assert.Single(billElement.Translation);
Assert.Equal("DgADAQADOwADGV9BRP4b7RLGAtUKAg", translationFile.FileId);
Assert.InRange(translationFile.FileDate, new DateTime(2018, 8, 30), new DateTime(2018, 8, 31));
Assert.Equal(0, translationFile.FileSize);
IDecrypter decrypter = new Decrypter();
Credentials credentials =
decrypter.DecryptCredentials(passportData.Credentials, EncryptionKey.RsaPrivateKey);
FileCredentials translationFileCredentials = Assert.Single(credentials.SecureData.UtilityBill.Translation);
byte[] encryptedContent = await System.IO.File.ReadAllBytesAsync("Files/utility_bill-translation.jpg.enc");
byte[] content = decrypter.DecryptFile(
encryptedContent,
translationFileCredentials
);
Assert.NotEmpty(content);
await System.IO.File.WriteAllBytesAsync("Files/utility_bill-translation.jpg", content);
using (System.IO.MemoryStream
encryptedFileStream = new System.IO.MemoryStream(encryptedContent),
decryptedFileStream = new System.IO.MemoryStream()
)
{
await decrypter.DecryptFileAsync(
encryptedFileStream,
translationFileCredentials,
decryptedFileStream
);
Assert.Equal(content, decryptedFileStream.ToArray());
}
}
