public void Should_Decrypt_Identity_Card_Element_Document()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
RSA key = EncryptionKey.ReadAsRsa();
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, key);
EncryptedPassportElement idCardEl = Assert.Single(passportData.Data, el => el.Type == "identity_card");
IdDocumentData documentData = decrypter.DecryptData <IdDocumentData>(
idCardEl.Data,
credentials.SecureData.IdentityCard.Data
);
Assert.NotEmpty(documentData.DocumentNo);
if (string.IsNullOrEmpty(documentData.ExpiryDate))
{
Assert.Null(documentData.Expiry);
}
else
{
Assert.NotNull(documentData.Expiry);
}
}
public async Task Should_Decrypt_Front_Side_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);
File encryptedFileInfo;
string decryptedFilePath = System.IO.Path.GetTempFileName();
using (System.IO.Stream decryptedFile = System.IO.File.OpenWrite(decryptedFilePath))
{
encryptedFileInfo = await BotClient.DownloadAndDecryptPassportFileAsync(
element.FrontSide,
credentials.SecureData.DriverLicense.FrontSide,
decryptedFile
);
}
_output.WriteLine("Front side JPEG file is written to \"{0}\".", decryptedFilePath);
Assert.NotEmpty(encryptedFileInfo.FilePath);
Assert.NotEmpty(encryptedFileInfo.FileId);
Assert.InRange(encryptedFileInfo.FileSize, 1_000, 50_000_000);
}
public void Should_Decrypt_Personal_Details_Element()
{
PassportData passportData = GetPassportData();
IDecrypter decrypter = new Decrypter();
Credentials credentials =
decrypter.DecryptCredentials(passportData.Credentials, EncryptionKey.RsaPrivateKey);
EncryptedPassportElement element = Assert.Single(passportData.Data, el => el.Type == "personal_details");
PersonalDetails personalDetails = decrypter.DecryptData <PersonalDetails>(
encryptedData: element.Data,
dataCredentials: credentials.SecureData.PersonalDetails.Data
);
Assert.Equal("Poulad", personalDetails.FirstName);
Assert.Equal("Ashrafpour", personalDetails.LastName);
Assert.Equal("پولاد", personalDetails.FirstNameNative);
Assert.Equal("اشرف پور", personalDetails.LastNameNative);
Assert.Empty(personalDetails.MiddleName);
Assert.Empty(personalDetails.MiddleNameNative);
Assert.Equal("male", personalDetails.Gender);
Assert.Equal(PassportEnums.Gender.Male, personalDetails.Gender);
Assert.Equal("US", personalDetails.CountryCode); // U.S.A
Assert.Equal("IR", personalDetails.ResidenceCountryCode); // Iran
Assert.Equal("30.07.1990", personalDetails.BirthDate);
Assert.InRange(personalDetails.Birthdate, new DateTime(1990, 7, 30), new DateTime(1990, 7, 30, 1, 0, 0));
}
public void Should_Decrypt_Data()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
EncryptedPassportElement element = passportData.Data.Single();
RSA key = EncryptionKey.ReadAsRsa();
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, key);
PersonalDetails personalDetails = decrypter.DecryptData <PersonalDetails>(
element.Data,
credentials.SecureData.PersonalDetails.Data
);
Assert.NotNull(personalDetails);
Assert.NotEmpty(personalDetails.FirstName);
Assert.NotEmpty(personalDetails.Gender);
Assert.NotEmpty(personalDetails.CountryCode);
Assert.Equal(2, personalDetails.CountryCode.Length);
Assert.NotEmpty(personalDetails.ResidenceCountryCode);
Assert.Equal(2, personalDetails.ResidenceCountryCode.Length);
Assert.NotEmpty(personalDetails.BirthDate);
Assert.InRange(personalDetails.Birthdate, new DateTime(1900, 1, 1), DateTime.Today);
}
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 async Task Should_Decrypt_Identity_Card_Element_Selfie()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
RSA key = EncryptionKey.ReadAsRsa();
EncryptedPassportElement idCardEl = Assert.Single(passportData.Data, el => el.Type == "identity_card");
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, key);
byte[] encryptedContent;
using (System.IO.MemoryStream stream = new System.IO.MemoryStream(idCardEl.Selfie.FileSize))
{
await BotClient.GetInfoAndDownloadFileAsync(
idCardEl.Selfie.FileId,
stream
);
encryptedContent = stream.ToArray();
}
byte[] content = decrypter.DecryptFile(
encryptedContent,
credentials.SecureData.IdentityCard.Selfie
);
Assert.NotEmpty(content);
}
public async Task Should_Decrypt_Identity_Card_Element_Reverse_Side()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
RSA key = EncryptionKey.ReadAsRsa();
EncryptedPassportElement idCardEl = Assert.Single(passportData.Data, el => el.Type == "identity_card");
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, key);
string botToken = ConfigurationProvider.TestConfigurations.ApiToken;
File encFileInfo = await BotClient.GetFileAsync(idCardEl.ReverseSide.FileId);
HttpClient http = new HttpClient();
System.IO.Stream encFileStream = await http.GetStreamAsync(
$"https://api.telegram.org/file/bot{botToken}/{encFileInfo.FilePath}"
);
string destFilePath = System.IO.Path.GetTempFileName();
using (encFileStream)
using (System.IO.Stream reverseSideFile = System.IO.File.OpenWrite(destFilePath))
{
await decrypter.DecryptFileAsync(
encFileStream,
credentials.SecureData.IdentityCard.ReverseSide,
reverseSideFile
);
Assert.InRange(reverseSideFile.Length, encFileInfo.FileSize - 256, encFileInfo.FileSize + 256);
}
_output.WriteLine("Reverse side photo is written to file \"{0}\".", destFilePath);
}
public void Should_validate_passport_message()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
EncryptedPassportElement phoneElement = Assert.Single(passportData.Data, el => el.Type == "phone_number");
Assert.NotNull(phoneElement);
Assert.Equal(PassportEnums.Scope.PhoneNumber, phoneElement.Type);
Assert.NotEmpty(phoneElement.PhoneNumber);
Assert.True(long.TryParse(phoneElement.PhoneNumber, out _));
Assert.NotEmpty(phoneElement.Hash);
EncryptedPassportElement emailElement = Assert.Single(passportData.Data, el => el.Type == "email");
Assert.NotNull(emailElement);
Assert.Equal(PassportEnums.Scope.Email, emailElement.Type);
Assert.NotEmpty(emailElement.Email);
Assert.NotEmpty(emailElement.Hash);
Assert.NotNull(passportData.Credentials);
Assert.NotEmpty(passportData.Credentials.Data);
Assert.NotEmpty(passportData.Credentials.Hash);
Assert.NotEmpty(passportData.Credentials.Secret);
}
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);
}
public void Should_Validate_Passport_Update()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
EncryptedPassportElement encryptedElement = Assert.Single(passportData.Data);
Assert.Equal("personal_details", encryptedElement.Type);
Assert.Equal(PassportEnums.Scope.PersonalDetails, encryptedElement.Type);
Assert.NotEmpty(encryptedElement.Data);
Assert.NotEmpty(encryptedElement.Hash);
Assert.NotNull(passportData.Credentials);
Assert.NotEmpty(passportData.Credentials.Data);
Assert.NotEmpty(passportData.Credentials.Hash);
Assert.NotEmpty(passportData.Credentials.Secret);
}
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());
}
}
public void Should_Decrypt_Element_Document()
{
PassportData passportData = GetPassportData();
IDecrypter decrypter = new Decrypter();
Credentials credentials =
decrypter.DecryptCredentials(passportData.Credentials, EncryptionKey.RsaPrivateKey);
EncryptedPassportElement idCardEl = Assert.Single(passportData.Data, el => el.Type == "identity_card");
IdDocumentData documentData = decrypter.DecryptData <IdDocumentData>(
idCardEl.Data,
credentials.SecureData.IdentityCard.Data
);
Assert.Equal("9999R", documentData.DocumentNo);
Assert.Empty(documentData.ExpiryDate);
Assert.Null(documentData.Expiry);
}
public void Should_Validate_Passport_Update()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
EncryptedPassportElement encryptedElement = Assert.Single(passportData.Data);
Assert.NotNull(encryptedElement);
Assert.Equal("driver_license", encryptedElement.Type);
Assert.Equal(PassportEnums.Scope.DriverLicense, encryptedElement.Type);
Assert.NotEmpty(encryptedElement.Data);
Assert.NotEmpty(encryptedElement.Hash);
Assert.NotNull(encryptedElement.FrontSide);
Assert.NotEmpty(encryptedElement.FrontSide.FileId);
Assert.InRange(encryptedElement.FrontSide.FileSize, 1_000, 50_000_000);
Assert.NotNull(encryptedElement.ReverseSide);
Assert.NotEmpty(encryptedElement.ReverseSide.FileId);
Assert.InRange(encryptedElement.ReverseSide.FileSize, 1_000, 50_000_000);
Assert.NotNull(encryptedElement.Selfie);
Assert.NotEmpty(encryptedElement.Selfie.FileId);
Assert.InRange(encryptedElement.Selfie.FileSize, 1_000, 50_000_000);
Assert.NotNull(encryptedElement.Translation);
Assert.NotEmpty(encryptedElement.Translation);
Assert.All(encryptedElement.Translation, Assert.NotNull);
Assert.All(
encryptedElement.Translation,
translation => Assert.NotEmpty(translation.FileId)
);
Assert.All(
encryptedElement.Translation,
translation => Assert.InRange(translation.FileSize, 1_000, 50_000_000)
);
Assert.NotNull(passportData.Credentials);
Assert.NotEmpty(passportData.Credentials.Data);
Assert.NotEmpty(passportData.Credentials.Hash);
Assert.NotEmpty(passportData.Credentials.Secret);
}
public async Task Should_Decrypt_Selfie_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);
byte[] encryptedContent;
{
File encryptedFileInfo = await BotClient.GetFileAsync(element.Selfie.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[] selfieContent = decrypter.DecryptFile(
encryptedContent,
credentials.SecureData.DriverLicense.Selfie
);
Assert.NotEmpty(selfieContent);
using (System.IO.Stream stream = new System.IO.MemoryStream(selfieContent))
{
await BotClient.SendPhotoAsync(
_fixture.SupergroupChat,
stream,
"selfie with driver license",
replyToMessageId : update.Message.MessageId
);
}
}
public void Should_Decrypt_Document_Data()
{
PassportData passportData = GetPassportData();
IDecrypter decrypter = new Decrypter();
Credentials credentials =
decrypter.DecryptCredentials(passportData.Credentials, EncryptionKey.RsaPrivateKey);
EncryptedPassportElement licenseEl = Assert.Single(passportData.Data, el => el.Type == "driver_license");
IdDocumentData licenseDoc = decrypter.DecryptData <IdDocumentData>(
encryptedData: licenseEl.Data,
dataCredentials: credentials.SecureData.DriverLicense.Data
);
Assert.Equal("G544-061", licenseDoc.DocumentNo);
Assert.Equal("26.11.2022", licenseDoc.ExpiryDate);
Assert.NotNull(licenseDoc.Expiry);
Assert.InRange(licenseDoc.Expiry.Value, new DateTime(2022, 11, 26), new DateTime(2022, 11, 26, 0, 0, 1));
}
public void Should_Decrypt_Data()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
EncryptedPassportElement element = passportData.Data.Single();
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, EncryptionKey.ReadAsRsa());
ResidentialAddress residentialAddress = decrypter.DecryptData <ResidentialAddress>(
element.Data,
credentials.SecureData.Address.Data
);
Assert.NotNull(residentialAddress);
Assert.NotEmpty(residentialAddress.StreetLine1);
Assert.NotEmpty(residentialAddress.City);
Assert.NotEmpty(residentialAddress.PostCode);
Assert.Equal(2, residentialAddress.CountryCode.Length);
}
public async Task Should_Decrypt_Identity_Card_Element_Reverse_Side()
{
PassportData passportData = GetPassportData();
EncryptedPassportElement idCardEl = Assert.Single(passportData.Data, el => el.Type == "identity_card");
Assert.NotNull(idCardEl.ReverseSide);
Assert.Equal("DgADAQADKAADNfRARK9jbzh5AAFqvAI", idCardEl.ReverseSide.FileId);
Assert.InRange(idCardEl.ReverseSide.FileDate, new DateTime(2018, 8, 30), new DateTime(2018, 8, 31));
Assert.Equal(0, idCardEl.ReverseSide.FileSize);
IDecrypter decrypter = new Decrypter();
Credentials credentials =
decrypter.DecryptCredentials(passportData.Credentials, EncryptionKey.RsaPrivateKey);
byte[] encryptedContent =
await System.IO.File.ReadAllBytesAsync("Files/identity_card-reverse_side.jpg.enc");
byte[] content = decrypter.DecryptFile(
encryptedContent,
credentials.SecureData.IdentityCard.ReverseSide
);
Assert.NotEmpty(content);
await System.IO.File.WriteAllBytesAsync("Files/identity_card-reverse_side.jpg", encryptedContent);
using (System.IO.MemoryStream
encryptedFileStream = new System.IO.MemoryStream(encryptedContent),
decryptedFileStream = new System.IO.MemoryStream()
)
{
await decrypter.DecryptFileAsync(
encryptedFileStream,
credentials.SecureData.IdentityCard.ReverseSide,
decryptedFileStream
);
Assert.Equal(content, decryptedFileStream.ToArray());
}
}
static async Task DecryptPassportDataAsync(Message message)
{
IDecrypter decrypter = new Decrypter();
// Step 1: Decrypt credentials
Credentials credentials = decrypter.DecryptCredentials(
message.PassportData.Credentials,
GetRsaPrivateKey()
);
// Step 2: Validate nonce
if (credentials.Nonce != "Test nonce for this demo")
{
throw new Exception($"Invalid nonce: \"{credentials.Nonce}\".");
}
// Step 3: Decrypt residential address using credentials
EncryptedPassportElement addressElement = message.PassportData.Data.Single(
el => el.Type == PassportEnums.Scope.Address
);
ResidentialAddress address = decrypter.DecryptData <ResidentialAddress>(
encryptedData: addressElement.Data,
dataCredentials: credentials.SecureData.Address.Data
);
// Step 4: Get phone number
string phoneNumber = message.PassportData.Data.Single(
el => el.Type == PassportEnums.Scope.PhoneNumber
).PhoneNumber;
await _botClient.SendTextMessageAsync(
message.From.Id,
"Your 🏠 address is:\n" +
$"{address.StreetLine1}\n" +
$"{address.City}, {address.CountryCode}\n" +
$"{address.PostCode}\n\n" +
$"📱 {phoneNumber}"
);
}
public void Should_decrypt_address_element()
{
PassportData passportData = GetPassportData();
IDecrypter decrypter = new Decrypter();
Credentials credentials =
decrypter.DecryptCredentials(passportData.Credentials, EncryptionKey.RsaPrivateKey);
EncryptedPassportElement addressEl = Assert.Single(passportData.Data, el => el.Type == "address");
ResidentialAddress residentialAddress = decrypter.DecryptData <ResidentialAddress>(
encryptedData: addressEl.Data,
dataCredentials: credentials.SecureData.Address.Data
);
Assert.Equal("123 Maple Street", residentialAddress.StreetLine1);
Assert.Equal("Unit 4", residentialAddress.StreetLine2);
Assert.Equal("A1A 1A1", residentialAddress.PostCode);
Assert.Equal("Toronto", residentialAddress.City);
Assert.Equal("Ontario", residentialAddress.State);
Assert.Equal("CA", residentialAddress.CountryCode);
}
public void Should_Decrypt_Credentials()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
EncryptedPassportElement element = passportData.Data.Single();
RSA key = EncryptionKey.ReadAsRsa();
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, key);
Assert.NotNull(credentials);
Assert.Equal("Test nonce for driver license", credentials.Nonce);
Assert.NotNull(credentials.SecureData);
// decryption of document data in 'driver_license' element requires accompanying DataCredentials
Assert.NotNull(credentials.SecureData.DriverLicense);
Assert.NotNull(credentials.SecureData.DriverLicense.Data);
Assert.NotEmpty(credentials.SecureData.DriverLicense.Data.Secret);
Assert.NotEmpty(credentials.SecureData.DriverLicense.Data.DataHash);
// decryption of front side file in 'driver_license' element requires accompanying FileCredentials
Assert.NotNull(credentials.SecureData.DriverLicense.FrontSide);
Assert.NotEmpty(credentials.SecureData.DriverLicense.FrontSide.Secret);
Assert.NotEmpty(credentials.SecureData.DriverLicense.FrontSide.FileHash);
// decryption of optional selfie file in 'driver_license' element requires accompanying FileCredentials
Assert.NotNull(credentials.SecureData.DriverLicense.Selfie);
Assert.NotEmpty(credentials.SecureData.DriverLicense.Selfie.Secret);
Assert.NotEmpty(credentials.SecureData.DriverLicense.Selfie.FileHash);
// decryption of optional translation file in 'driver_license' element requires accompanying FileCredentials
Assert.Equal(
element.Translation.Length,
credentials.SecureData.DriverLicense.Translation.Length
);
}
public void Should_Decrypt_Document_Data()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
EncryptedPassportElement element = passportData.Data.Single();
RSA key = EncryptionKey.ReadAsRsa();
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(passportData.Credentials, key);
IdDocumentData licenseDoc = decrypter.DecryptData <IdDocumentData>(
encryptedData: element.Data,
dataCredentials: credentials.SecureData.DriverLicense.Data
);
Assert.NotEmpty(licenseDoc.DocumentNo);
if (string.IsNullOrEmpty(licenseDoc.ExpiryDate))
{
Assert.Null(licenseDoc.Expiry);
}
else
{
Assert.NotNull(licenseDoc.Expiry);
}
}