public static string ExtractDwm(IEmbeder embeder, ICryptor cryptor, Key key, Container container)
{
byte[] byteMessage = embeder.Extract(container, key);
Stream message = cryptor.Decrypt(StreamHelper.BytesToStream(byteMessage), key);
return StreamHelper.StreamToString(message);
}
public async Task Decrypt(MessageModel messageModel)
{
ICryptor cryptor = CryptorFactory.CreateInstance(messageModel.CryptorType);
messageModel.Message = await cryptor.Decrypt(messageModel);
await Clients.Caller.SendAsync("GetDecryptNewMessage", messageModel);
}
public override void Load(Stream stream)
{
base.Load(stream);
var encryptedItems = Data.Where(x => x.Key.EndsWith(".Encrypted",
StringComparison.CurrentCultureIgnoreCase));
foreach (var item in encryptedItems)
{
decrypted.Add(item.Key.Replace(".Encrypted", ""), cryptor.Decrypt(item.Value));
}
}
/// <summary>
/// Decrypts the note, if the belonging safe is open.
/// </summary>
/// <returns>Decrypted note content, or null if the safe is closed.</returns>
private string UnlockIfSafeOpen(string lockedContent)
{
SafeModel safe = _safes.FindById(Model.SafeId);
if ((safe != null) && safe.IsOpen)
{
byte[] binaryContent = CryptoUtils.Base64StringToBytes(lockedContent);
byte[] unlockedContent = _cryptor.Decrypt(binaryContent, safe.Key);
return(CryptoUtils.BytesToString(unlockedContent));
}
return(null);
}
public Memory <byte> Decrypt(byte[] data, uint len)
{
// await decLock.WaitAsync();
try
{
var outLen = cryptor.Decrypt(data, len, decryptBuf);
return(decryptBuf.AsMemory(0, (int)outLen));
}
finally
{
// decLock.Release();
}
}
public unsafe virtual uint Decrypt(ReadOnlySpan <byte> data, Span <byte> outData, ICryptor cryptor = null)
{
if (cryptor == null)
{
cryptor = this.cryptor;
}
fixed(byte *dataPtr = &data.GetPinnableReference(), outDataPtr = &outData.GetPinnableReference())
{
var outLen = cryptor.Decrypt((ulong)dataPtr, (uint)data.Length, (ulong)outDataPtr, (uint)outData.Length);
#pragma warning disable IDE0004
return((uint)outLen);
#pragma warning restore IDE0004
}
}
public int Dec(
[Argument] string value,
[Option('k')] string key,
[Option('v')] string iv,
[Option('a')][Algorithms] string algorithms = DefaultAlgorithms
)
{
ICryptor cryptor = algorithms switch
{
nameof(SupportAlgorithms.TripleDES) => new TripleDESCryptor(key, iv),
nameof(SupportAlgorithms.DES) => new DESCryptor(key, iv),
_ => throw new ArgumentException()
};
Console.WriteLine(cryptor.Decrypt(value));
return(0);
}
/// <summary>
/// Authenticates the user login. This gets the user from the repository, decrypts
/// the stored password and determines if the un-encrypted password in passwordGuess
/// is the same as the un-encrypted password from the user retrieved in the
/// repository.
/// </summary>
public static async Task <U> Authenticate <U>(string username, string passwordGuess,
IGateKeeperUserRepository <U> userRepository, ICryptor cryptor,
GateKeeperConfig gateKeeperConfig) where U : IUser
{
U user = await userRepository.GetByUsername(username);
if (user == null)
{
throw new AuthenticationException(AuthenticationException.REASON_USER_NOT_FOUND);
}
string realPassword = cryptor.Decrypt(user.Password, gateKeeperConfig.EncryptionKey, gateKeeperConfig.Salt);
if (passwordGuess != realPassword)
{
throw new AuthenticationException(AuthenticationException.REASON_WRONG_PASSWORD);
}
return(user);
}
private bool TryDecryptRepositoryWithTransfercode(ICryptor decryptor, byte[] binaryCloudRepository, string transferCode, out byte[] decryptedRepository)
{
try
{
decryptedRepository = decryptor.Decrypt(binaryCloudRepository, CryptoUtils.StringToSecureString(transferCode));
return(true);
}
catch (CryptoExceptionInvalidCipherFormat)
{
// If the downloaded repository is invalid, this is serious and we should not continue
throw;
}
catch (CryptoUnsupportedRevisionException)
{
throw;
}
catch (Exception)
{
// Could not decrypt with this transfercode
decryptedRepository = null;
return(false);
}
}
public async Task <PaymentResponseModel> GetByIdAsync(Guid paymentId, MerchantModel merchant)
{
Guard.IsNotNull(paymentId, nameof(paymentId));
_merchantModelValidator.ValidateAndThrow(merchant);
var payment = await _paymentRepository.GetByIdAsync(paymentId);
if (payment == null)
{
throw new ObjectNotFoundException($"No payment with id '{ paymentId } was found.'");
}
// This check should normally return a Not Found exception for security purposes. Unauthorized used for testing purposes only.
if (payment.MerchantId != merchant.Id)
{
throw new UnauthorizedException($"Merchant is not authorised to retrieve this payment.");
}
var response = _mapper.Map <PaymentResponseModel>(payment);
response.Card.Number = MaskHelper.MaskCardNumber(_cryptor.Decrypt(response.Card.Number));
return(response);
}
public static string Decrypt(this string str, ICryptor cryptor)
{
return(cryptor.Decrypt(str));
}
public Packet(byte[] data, ICryptor cryptor, byte[] cryptKey)
: base()
{
buffer = cryptor.Decrypt(data, cryptKey);
bufferLength = (uint)buffer.Length;
}
public StreamReader TakeRemainDecrypedBytes(out byte[] value, ICryptor cryptor, byte[] key)
{
TakeRemainBytes(out var data);
value = cryptor.Decrypt(data, key);
return(this);
}
