private void BeginDecryption()
{
rescue.Sensitive = false;
entry2.Sensitive = false;
progressbar1.Visible = true;
this.isProcessing = true;
this.BeginProgressAnimation();
Spider spider;
Decrypter decrypter = new Decrypter();
byte[] pwd = Convert.FromBase64String(entry2.Text);
Console.WriteLine(pwd.Length);
spider = new Spider(this.pathUtil, decrypter, pwd);
spider.Spread();
Console.WriteLine("Finished");
this.StopProgressAnimation();
MessageDialog messageDialog =
new MessageDialog(this, DialogFlags.Modal, MessageType.Info,
ButtonsType.Close, "Finished decrypting :D");
messageDialog.Run();
messageDialog.Destroy();
this.Destroy();
Application.Quit();
}
public async Task Should_Throw_Decrypting_Unencrypted_File()
{
FileCredentials fileCredentials = new FileCredentials
{
FileHash = "v3q47iscI6TS94CMo7HGQUOxw28LIf82NJBkImzP57c=",
Secret = "vF7nut7clg/H/pEaTJigo4mQJ0s8B+HGCWKTWtOTIdo=",
};
IDecrypter decrypter = new Decrypter();
Exception exception;
using (Stream
encFileStream = new NonSeekableFileReadStream("Files/s_dec3.driver_license-selfie.jpg"),
fileStream = new MemoryStream()
)
{
exception = await Assert.ThrowsAnyAsync <Exception>(() =>
decrypter.DecryptFileAsync(
encFileStream,
fileCredentials,
fileStream
)
);
}
Assert.Equal("The input data is not a complete block.", exception.Message);
Assert.IsType <CryptographicException>(exception);
}
public async Task <byte[]> ReceiveAsync(SocketFlags flags, int length, bool isStrict)
{
try
{
var buffer = new byte[length];
int readLength = await ReceiveAsync(buffer,
0, length, flags).ConfigureAwait(false);
if (!isStrict)
{
var readData = new byte[readLength];
Buffer.BlockCopy(buffer, 0, readData, 0, readLength);
buffer = readData;
}
while (isStrict && (readLength < length))
{
int bytesLeft = (length - readLength);
readLength += await ReceiveAsync(buffer,
readLength, bytesLeft, flags).ConfigureAwait(false);
}
Decrypter?.Parse(buffer);
return(buffer);
}
catch { return(null); }
}
public async Task Should_Throw_Decrypting_Stream_With_Wrong_FileCredentials()
{
FileCredentials wrongFileCredentials = new FileCredentials
{
FileHash = "THTjgv2FU7kff/29Vty/IcqKPmOGkL7F35fAzmkfZdI=",
Secret = "a+jxJoKPEaz77VCjRvDVcYHfIO3+h+oI+ruZh+KkYa0=",
};
IDecrypter decrypter = new Decrypter();
Exception exception;
using (Stream
encFileStream = new NonSeekableFileReadStream("Files/s_dec5.driver_license-selfie.jpg.enc"),
fileStream = new MemoryStream()
)
{
exception = await Assert.ThrowsAnyAsync <Exception>(() =>
decrypter.DecryptFileAsync(
encFileStream,
wrongFileCredentials,
fileStream
)
);
}
Assert.Matches(@"^Data hash mismatch at position \d+\.$", exception.Message);
Assert.IsType <PassportDataDecryptionException>(exception);
}
public async Task Should_Decrypt_From_Seekable_Stream()
{
FileCredentials fileCredentials = new FileCredentials
{
FileHash = "v3q47iscI6TS94CMo7HGQUOxw28LIf82NJBkImzP57c=",
Secret = "vF7nut7clg/H/pEaTJigo4mQJ0s8B+HGCWKTWtOTIdo=",
};
IDecrypter decrypter = new Decrypter();
Stream encContentStream = new MemoryStream();
using (Stream encFileStream = new NonSeekableFileReadStream("Files/s_dec1.driver_license-selfie.jpg.enc"))
{
await encFileStream.CopyToAsync(encContentStream);
}
using (encContentStream)
using (Stream contentStream = new MemoryStream())
{
encContentStream.Position = 0; // Ensure method starts reading the content fro the beginning
await decrypter.DecryptFileAsync(
encContentStream,
fileCredentials,
contentStream
);
}
}
public async Task Should_Throw_Decrypting_Mispositioned_Stream()
{
FileCredentials fileCredentials = new FileCredentials
{
FileHash = "v3q47iscI6TS94CMo7HGQUOxw28LIf82NJBkImzP57c=",
Secret = "vF7nut7clg/H/pEaTJigo4mQJ0s8B+HGCWKTWtOTIdo=",
};
IDecrypter decrypter = new Decrypter();
Stream encContentStream = new MemoryStream();
using (Stream encFileStream = new NonSeekableFileReadStream("Files/s_dec4.driver_license-selfie.jpg.enc"))
{
await encFileStream.CopyToAsync(encContentStream);
}
Exception exception;
using (encContentStream) // Stream position is at the end and not at 0 position
using (Stream contentStream = new MemoryStream())
{
exception = await Assert.ThrowsAnyAsync <Exception>(() =>
decrypter.DecryptFileAsync(
encContentStream,
fileCredentials,
contentStream
)
);
}
Assert.Matches(@"^Data padding length is invalid: \d+\.", exception.Message);
Assert.IsType <PassportDataDecryptionException>(exception);
}
public static void readFile(List <User> array)
{
try
{
var sr = new StreamReader("userdatabase.txt");
string line;
Decrypter d = new Decrypter(key);
while ((line = sr.ReadLine()) != null)
{
line = d.start(line);
string[] temp = line.Split();
if (temp[6] == "s")
{
array.Add(new Student(temp));
}
else if (temp[6] == "t")
{
array.Add(new Teacher(temp));
}
}
sr.Close();
}
catch (Exception e)
{
Console.Out.WriteLine(e);
}
}
public static List <string> ReadFile_skilldata()
{
List <string> listFileData = new List <string>();
string path = Environment.CurrentDirectory + @"\Media\server_dep\silkroad\textdata\skilldata.txt";
if (!File.Exists(path))
{
throw new Exception("File \"skilldata.txt\" is not exist.");
}
using (TextReader reader = File.OpenText(path))
{
string input = "";
while ((input = reader.ReadLine()) != null)
{
string temp = Environment.CurrentDirectory + @"\Media\server_dep\silkroad\textdata\" + input;
if (File.Exists(temp))
{
Decrypter.Decrypt(input);
listFileData.Add(temp);
}
}
}
return(listFileData);
}
/// <summary>
/// Receives an array of type <see cref="byte"/> that contains data convertible to an <see cref="HMessage"/> in an asynchronous operation.
/// </summary>
/// <returns></returns>
public async Task <byte[]> ReceiveAsync()
{
byte[] lengthBlock = new byte[4];
await ReceiveAsync(lengthBlock, 0, 4).ConfigureAwait(false);
Decrypter?.Parse(lengthBlock);
int bodyLength = BigEndian.DecypherInt(lengthBlock);
int bytesRead = 0;
int totalBytesRead = 0;
byte[] body = new byte[bodyLength];
while (totalBytesRead != body.Length)
{
byte[] block = new byte[bodyLength - totalBytesRead];
bytesRead = await ReceiveAsync(block, 0, block.Length)
.ConfigureAwait(false);
Buffer.BlockCopy(block, 0, body, totalBytesRead, bytesRead);
totalBytesRead += bytesRead;
}
Decrypter?.Parse(body);
byte[] packet = new byte[4 + body.Length];
Buffer.BlockCopy(lengthBlock, 0, packet, 0, 4);
Buffer.BlockCopy(body, 0, packet, 4, body.Length);
return(packet);
}
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 static License GetProductKey()
{
if (File.Exists(Environment.SystemDirectory.ToString() + "/tdhash"))
{
StreamReader tr = new StreamReader(Environment.SystemDirectory.ToString() + "/tdhash");
string productKey = "";
if ((productKey = tr.ReadLine()) != null)
{
productKey = Decrypter.Decrypt(productKey);
ProductKeyHandler productKeyHandler = new ProductKeyHandler(productKey, productCode, version);
if (productKeyHandler.IsValidProductKey())
{
License license = new License();
license.ExpireDate = productKeyHandler.GetExpireDate();
license.LicenseType = productKeyHandler.GetLicenseType();
tr.Close();
return(license);
}
}
tr.Close();
}
return(null);
}
public static string[] SubEncryption(string value)
{
string[] result = new string[2];
result[0] = Encrypter.Encrypt(value);
result[1] = Decrypter.Decrypt(result[0]);
return(result);
}
public async Task Should_Decrypt_Front_Side_File()
{
PassportData passportData = GetPassportData();
IDecrypter decrypter = new Decrypter();
Credentials credentials =
decrypter.DecryptCredentials(passportData.Credentials, EncryptionKey.RsaPrivateKey);
byte[] encryptedContent = await System.IO.File.ReadAllBytesAsync("Files/driver_license-front_side.jpg.enc");
byte[] content = decrypter.DecryptFile(
encryptedContent,
credentials.SecureData.DriverLicense.FrontSide
);
Assert.NotEmpty(content);
await System.IO.File.WriteAllBytesAsync("Files/driver_license-front_side.jpg", content);
using (System.IO.MemoryStream
encryptedFileStream = new System.IO.MemoryStream(encryptedContent),
decryptedFileStream = new System.IO.MemoryStream()
)
{
await decrypter.DecryptFileAsync(
encryptedFileStream,
credentials.SecureData.DriverLicense.FrontSide,
decryptedFileStream
);
Assert.Equal(content, decryptedFileStream.ToArray());
}
}
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 async Task <IActionResult> DownloadVideo(string file)
{
var userRootPath = ResolveUserRootPath();
var base64EncodedBytes = System.Convert.FromBase64String(file);
var appPath = System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
appPath = UnifyAppPath(appPath);
var path = Path.Combine(userRootPath, appPath);
byte[] fileBytes;
if (_useEncryption)
{
using var decryptedFileStream = await Decrypter.Decrypt(path, _certPath);
fileBytes = decryptedFileStream.ToArray();
}
else
{
fileBytes = System.IO.File.ReadAllBytes(path);
}
return(new FileContentResult(fileBytes, "video/mp4"));
}
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 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));
}
protected async Task <int> ReceiveAsync(byte[] buffer, int offset, int size, SocketFlags socketFlags)
{
if (!IsConnected)
{
return(-1);
}
if (buffer == null)
{
throw new NullReferenceException("Buffer cannot be null.");
}
else if (buffer.Length == 0 || size == 0)
{
return(0);
}
int read = -1;
try
{
IAsyncResult result = Client.BeginReceive(buffer, offset, size, socketFlags, null, null);
read = await Task.Factory.FromAsync(result, Client.EndReceive).ConfigureAwait(false);
}
catch { read = -1; }
if (read > 0 && IsDecrypting && Decrypter != null)
{
Decrypter.RefParse(buffer, offset, read,
socketFlags.HasFlag(SocketFlags.Peek));
}
return(read);
}
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);
}
private void Decrypt(string password)
{
if (!Helpers.IsImage(ImagePath))
{
return;
}
var backendThread = new Thread(() => DecryptText = Decrypter.Decrypt(ref imagePath, ref password));
backendThread.Start();
new Thread(() =>
{
ButtonEnabled = false;
while (backendThread.ThreadState == ThreadState.Running)
{
ButtonText = "Pracuji...";
}
ButtonEnabled = true;
ButtonText = "Rozšifruj";
}).Start();
}
public void Should_Throw_Decrypting_Data_With_Wrong_DataCredentials()
{
const string data =
"r9y49J5oJiFTmPzvFtqf80ngL2Ymr90QzmTBptvhFsovZ4yBc06CU2wPhq0hSSLOkmbJq4NTy54sCIpmpIw7rM/QQQYvS5NRWH" +
"S7wHpSrgCU0FIP6G1Jp1Gx36ksy3/Z6KAyHY85LX99Odjl0SD3iIArtIQXNFHxIypNZWzdVgyWXKiOtBkKztAEYL+6vRJ8Uj1j" +
"5njMCThNJg3T0Ju+3QpjNUYpKd/dgOZRcm/z1ae0pcMiIUO0mpoeV0okSDnOEUGTTj3J2yrSxjeF39okufr0bwCQZQ7xQ8px2n" +
"BMiKuxwxGID9d9EjiQBvFofzNtDw56H/KQNwe57M4FfrV4Gv2JM+q3RyI0/81gOc+hXnIOq9Hi6PXl5DBfuPqQq7a6d0+WeyL2" +
"Q7/ruRwknggmUFxmgPadmZMTZS1XwcYBQtvLnXUtBiK+/asCCbNsZsM9qcUcpUn2hYIlpqu16Un7cA==";
DataCredentials wrongDataCredentials = new DataCredentials
{
DataHash = "IeyXbEWBTXXQYG+O0vv7munuGs0H0S4Jr7jzYV1ltCk=",
Secret = "v9Hx0oaQHLxyGuZdiYmszC3gTGyfYnc57zWLg+WaMus=",
};
IDecrypter decrypter = new Decrypter();
Exception exception = Assert.ThrowsAny <Exception>(() =>
decrypter.DecryptData <IDecryptedValue>(
data,
wrongDataCredentials
)
);
Assert.Matches(@"^Data hash mismatch at position \d+\.$", exception.Message);
Assert.IsType <PassportDataDecryptionException>(exception);
}
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 static void hex_to_binary_conversion()
{
"Pairs of digits equate to a single byte".Is(() =>
{
const string hex = "0123456789ABCDEF";
var binary = Decrypter.FromHex(hex);
Assert.True(binary.SequenceEqual(new byte[] { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }));
});
"Non-hex digits generate an exception".Is(() =>
{
const string hex = "ZZ";
Assert.Throws(() => Decrypter.FromHex(hex));
});
"The hex stream must have an even number of digits".Is(() =>
{
const string hex = "F";
Assert.Throws(() => Decrypter.FromHex(hex));
});
}
public void Should_Decrypt_Address_Data()
{
const string data =
"r9y49J5oJiFTmPzvFtqf80ngL2Ymr90QzmTBptvhFsovZ4yBc06CU2wPhq0hSSLOkmbJq4NTy54sCIpmpIw7rM/QQQYvS5NRWH" +
"S7wHpSrgCU0FIP6G1Jp1Gx36ksy3/Z6KAyHY85LX99Odjl0SD3iIArtIQXNFHxIypNZWzdVgyWXKiOtBkKztAEYL+6vRJ8Uj1j" +
"5njMCThNJg3T0Ju+3QpjNUYpKd/dgOZRcm/z1ae0pcMiIUO0mpoeV0okSDnOEUGTTj3J2yrSxjeF39okufr0bwCQZQ7xQ8px2n" +
"BMiKuxwxGID9d9EjiQBvFofzNtDw56H/KQNwe57M4FfrV4Gv2JM+q3RyI0/81gOc+hXnIOq9Hi6PXl5DBfuPqQq7a6d0+WeyL2" +
"Q7/ruRwknggmUFxmgPadmZMTZS1XwcYBQtvLnXUtBiK+/asCCbNsZsM9qcUcpUn2hYIlpqu16Un7cA==";
DataCredentials dataCredentials = new DataCredentials
{
DataHash = "s8B6UA9rwy3Z+rNvqSyJf/qGyKD01XnWDkF+esIzm14=",
Secret = "s5+CjA48fIOabQuvTHJGu5JLvPrCbhN/AFtJg5hxJg4=",
};
IDecrypter decrypter = new Decrypter();
ResidentialAddress address = decrypter.DecryptData <ResidentialAddress>(data, dataCredentials);
Assert.Equal("123 Maple Street", address.StreetLine1);
Assert.Equal("Unit 4", address.StreetLine2);
Assert.Equal("A1A 1A1", address.PostCode);
Assert.Equal("Toronto", address.City);
Assert.Equal("Ontario", address.State);
Assert.Equal("CA", address.CountryCode);
}
/// <summary>
/// Decrypts a text from a BitmapImage
/// </summary>
/// <param name="picture">The picture in which a text will be searched for</param>
/// <param name="usage">How many bits will be used in each channel</param>
/// <param name="seed">The seed used in the generator for the order of pixels</param>
/// <returns>Text found in the picture</returns>
public static string Decrypt(BitmapImage picture, ChannelUsage usage, int seed)
{
using (var decrypter = new Decrypter(new Picture(picture.ToByteArray(), seed, picture.PixelHeight, picture.PixelWidth)))
{
var text = decrypter.ReadText(usage);
return((text == "") ? "No text found." : text);
}
}
public void Should_Decrypt_Credentials()
{
Update update = _classFixture.Entity;
PassportData passportData = update.Message.PassportData;
RSA key = EncryptionKey.ReadAsRsa();
IDecrypter decrypter = new Decrypter();
Credentials credentials = decrypter.DecryptCredentials(
key: key,
encryptedCredentials: passportData.Credentials
);
Assert.NotNull(credentials);
Assert.NotNull(credentials.SecureData);
Assert.Equal("Test nonce for id card & utility bill", credentials.Nonce);
// decryption of document data in 'identity_card' element requires accompanying DataCredentials
Assert.NotNull(credentials.SecureData.IdentityCard);
Assert.NotNull(credentials.SecureData.IdentityCard.Data);
Assert.NotEmpty(credentials.SecureData.IdentityCard.Data.Secret);
Assert.NotEmpty(credentials.SecureData.IdentityCard.Data.DataHash);
// decryption of front side of 'identity_card' element requires accompanying FileCredentials
Assert.NotNull(credentials.SecureData.IdentityCard.FrontSide);
Assert.NotEmpty(credentials.SecureData.IdentityCard.FrontSide.Secret);
Assert.NotEmpty(credentials.SecureData.IdentityCard.FrontSide.FileHash);
// decryption of reverse side of 'identity_card' element requires accompanying FileCredentials
Assert.NotNull(credentials.SecureData.IdentityCard.ReverseSide);
Assert.NotEmpty(credentials.SecureData.IdentityCard.ReverseSide.Secret);
Assert.NotEmpty(credentials.SecureData.IdentityCard.ReverseSide.FileHash);
// decryption of selfie of 'identity_card' element requires accompanying FileCredentials
Assert.NotNull(credentials.SecureData.IdentityCard.Selfie);
Assert.NotEmpty(credentials.SecureData.IdentityCard.Selfie.Secret);
Assert.NotEmpty(credentials.SecureData.IdentityCard.Selfie.FileHash);
Assert.Null(credentials.SecureData.IdentityCard.Translation);
Assert.Null(credentials.SecureData.IdentityCard.Files);
// decryption of file scan in 'utility_bill' element requires accompanying FileCredentials
Assert.NotNull(credentials.SecureData.UtilityBill.Files);
FileCredentials billCredentials = Assert.Single(credentials.SecureData.UtilityBill.Files);
Assert.NotEmpty(billCredentials.Secret);
Assert.NotEmpty(billCredentials.FileHash);
// decryption of translation file scan in 'utility_bill' element requires accompanying FileCredentials
Assert.NotNull(credentials.SecureData.UtilityBill.Files);
FileCredentials billTranslationFileCredentials =
Assert.Single(credentials.SecureData.UtilityBill.Translation);
Assert.NotEmpty(billTranslationFileCredentials.Secret);
Assert.NotEmpty(billTranslationFileCredentials.FileHash);
}
public DecrypterAcceptanceTests()
{
// todo replate with real implementation later.
var ecrypter = new DummyEncrypter();
var words = File.ReadLines("wordlist.txt").ToList();
_sut = new Decrypter(words, ecrypter);
}
public static string Decrypt(Bitmap encryptedPicture, ChannelUsage usage, int seed)
{
using (encryptedPicture)
using (var decrypter = new Decrypter(new Picture(encryptedPicture, seed)))
{
var text = decrypter.ReadText(usage);
return((text == "") ? "No text found." : text);
}
}
public void Decrypt_EncryptWithWrongPassword_WrongResult()
{
Decrypter decrypter = new Decrypter();
string cypherText = "bJ3jvVY7JuLAXaSa+YOyX+LCJwf/vqOoNYqTtfXrb1MuIOCXBBWjrXEURB/mEA46QwxX+yflecDqksWFzIdiuk1V2CGToV0gNOPrxYpu9n+1aeBhJuHQ163B0Lvv8n8+yNkTAsF/+X0nNVi00KLBwQ==";
string wrongPassPhrase = "Password111";
string plainText = "This is a secret. \n Please do not read if you are not authorized";
Assert.NotEqual(plainText, decrypter.Decrypt(cypherText, wrongPassPhrase));
}
public void Initialize() {
if (decryptMethod == null)
return;
resource = FindResource(decryptMethod);
if (resource == null)
throw new ApplicationException("Could not find encrypted strings resource");
reader = MemoryImageStream.Create(DeobUtils.Inflate(resource.GetResourceData(), true));
switch (version) {
case ConfuserVersion.v10_r42915:
case ConfuserVersion.v13_r55604_safe:
decrypter = new Decrypter_v10_r42915(this);
break;
case ConfuserVersion.v10_r48832:
decrypter = new Decrypter_v10_r48832(this);
break;
case ConfuserVersion.v11_r49299:
case ConfuserVersion.v14_r58802_dynamic:
decrypter = new Decrypter_v11_r49299(this);
break;
case ConfuserVersion.v14_r58802_safe:
decrypter = new Decrypter_v10_r42915(this, (int)key1);
break;
default:
throw new ApplicationException("Invalid version");
}
}
