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"); } }