public void Deve_retornanr_ola()
{
var esconder = _service.Encrypt("Olá");
var mostrar = _service.Decrypt(esconder);
Assert.AreEqual("Olá", mostrar);
}
public async Task <object> GetValue(ProviderInstanceProperty property)
{
object value = await encryptionService.Decrypt <object>(property.Value);
switch (property.Property.Type)
{
case PropertyType.Authentication:
((dynamic)value).SetLoadMethod((Func <int, Task <object> >)GetAuthenticatedSessionClient);
break;
}
List <ProviderPropertyAttribute> attributes = property?.Property?.Attributes ?? new List <ProviderPropertyAttribute>();
if (attributes.Any(a => a.Name == PropertyAttribute.Transform))
{
switch (property.Property.Type)
{
case PropertyType.String:
value = TransformString(value);
break;
}
}
return(value);
}
public string GetAccessToken(WorkContext workContext, string code, string returnUrl)
{
try
{
var part = workContext.CurrentSite.As <FacebookSettingsPart>();
var clientId = part.ClientId;
var clientSecret = _oauthHelper.Decrypt(part.Record.EncryptedClientSecret);
var urlHelper = new UrlHelper(workContext.HttpContext.Request.RequestContext);
var redirectUrl = new Uri(
workContext.HttpContext.Request.Url,
urlHelper.Action("FacebookAuth", "Account", new { area = "Teeyoot.Account" })
).ToString();
var url = string.Format(TokenRequestUrl, urlHelper.Encode(clientId), urlHelper.Encode(redirectUrl),
urlHelper.Encode(clientSecret), urlHelper.Encode(code));
var wr = WebRequest.Create(url);
wr.Proxy = OAuthHelper.GetProxy();
wr.Method = "GET";
var wres = wr.GetResponse();
using (var stream = wres.GetResponseStream())
using (var sr = new StreamReader(stream))
{
var result = HttpUtility.ParseQueryString(sr.ReadToEnd());
return(result["access_token"]);
}
}
catch (Exception ex)
{
string error = OAuthHelper.ReadWebExceptionMessage(ex);
Logger.Error(ex, string.IsNullOrEmpty(error) ? ex.Message : error);
}
return(null);
}
public async Task <bool> UpdateAsync(IPaymentProviderDetails model)
{
using (var context = _contextFactory.CreateDataContext())
{
var existingEntity = await context.PaymentProviderDetails.FindAsync(model.Id);
if (existingEntity == null)
{
return(false);
}
existingEntity = _encryptionService.Decrypt(existingEntity);
existingEntity.PaymentIntegrationProperties = model.PaymentIntegrationProperties;
existingEntity.PaymentIntegrationProvider = model.PaymentIntegrationProvider;
existingEntity = _encryptionService.Encrypt(existingEntity);
context.PaymentProviderDetails.Update(existingEntity);
await context.SaveChangesAsync();
return(true);
}
}
public async Task RefreshRepositoryByIdAsync(Guid repositoryId)
{
VcsRepository repository = await context.VcsRepositories.FindAsync(repositoryId);
Vcs versionControl = await context.VcsSources.FindAsync(repository.VcsId);
logger.LogInformation($"Refreshing repository: {repository.Url}");
await context.Entry(repository).Collection(r => r.Assets).LoadAsync();
context.Assets.RemoveRange(repository.Assets);
await context.SaveChangesAsync();
var versionControlDto = new VersionControlDto {
ApiKey = versionControl.ApiKey, Endpoint = versionControl.Endpoint, VcsId = versionControl.Id, Kind = versionControl.Kind, IsEnabled = versionControl.IsEnabled
};
var repositoryDto = new RepositoryDto {
VcsId = repository.VcsId, Url = repository.Url, WebUrl = repository.WebUrl
};
encryptionService.Decrypt(versionControlDto);
IEnumerable <Asset> items = await versionControlProvider.GetAssetsAsync(versionControlDto, repositoryDto);
foreach (Asset asset in items)
{
context.Assets.Add(asset);
await context.SaveChangesAsync();
await RefreshAssetByIdAsync(asset.Id);
}
}
public void Decrypt(IEncryptionService encryptionService)
{
Number = encryptionService.Decrypt(Convert.FromBase64String(Number));
ExpiryMonth = encryptionService.Decrypt(Convert.FromBase64String(ExpiryMonth));
ExpiryYear = encryptionService.Decrypt(Convert.FromBase64String(ExpiryYear));
Cvv = encryptionService.Decrypt(Convert.FromBase64String(Cvv));
}
public async Task <IEnumerable <Card> > Get()
{
var result = await _cardRep.Get();
foreach (Card card in result)
{
card.CardNumber = _encryptionService.Decrypt(card.CardNumber);
}
return(result);
}
public virtual Profile GetById(int id)
{
Profile instance = _repository.GetById(id);
if (instance.Password != null)
{
instance.Password = _encryptionService.Decrypt(instance.Password, instance.PasswordSalt);
}
return(instance);
}
public void Can_Decrypt_Encrypted_String()
{
var myString = Guid.NewGuid().ToString();
var encryptedString = _service.Encrypt(myString);
var decryptedString = _service.Decrypt <string>(encryptedString);
Assert.NotNull(decryptedString);
Assert.NotEqual(0, encryptedString.Length);
Assert.NotEqual(encryptedString, decryptedString);
Assert.Equal(myString, decryptedString);
}
public async Task <IReadOnlyList <AdminProfile> > GetAllAsync()
{
using (var context = _contextFactory.CreateDataContext())
{
var entities = await context.AdminProfiles.ToListAsync();
return(entities
.Select(entity => ToDomain(_encryptionService.Decrypt(entity)))
.ToList());
}
}
public ActionResult <IEnumerable <string> > Get()
{
// RequestServices.GetRequiredService<ILogin>()
string encryptStr = _encryptionService.Encrypt("嗯");
string decryptStr = _encryptionService.Decrypt(encryptStr);
// string str= _login.Login("小朱", "");
return(new string[] { "value2" });
}
public void EncryptionService_EncryptMessage_DecryptsToInitialMessage()
{
// arrange
var startingText = "this is a test";
// act
var encryptedText = _encryptionService.Encrypt(startingText);
var decryptedText = _encryptionService.Decrypt(encryptedText);
// assert
Assert.AreEqual(startingText, decryptedText);
}
public RequestTokenModel RequestToken(WorkContext wc)
{
var part = wc.CurrentSite.As <TwitterSettingsPart>();
var consumerKey = part.ConsumerKey;
var accessToken = part.AccessToken;
var consumerSecret = _oauthHelper.Decrypt(part.Record.EncryptedConsumerSecret);
var urlHelper = new UrlHelper(wc.HttpContext.Request.RequestContext);
var redirectUrl =
new Uri(wc.HttpContext.Request.Url,
urlHelper.Action("Auth", "TwitterOAuth", new { Area = "RM.QuickLogOn.OAuth" })).ToString();
var wr = WebRequest.Create(RequestTokenUrl);
wr.Method = "POST";
var ts = GetTimeStamp();
var nonce = GenerateNonce();
var sig = string.Format("{0}&{1}&{2}", wr.Method, Uri.EscapeDataString(RequestTokenUrl), Uri.EscapeDataString(string.Format(ParametersSignature, consumerKey, nonce, ts, accessToken)));
sig = OAuthHelper.HMACSHA1(sig, consumerSecret + "&");
var header = string.Format(AuthorizationHeaderValue, Uri.EscapeDataString(redirectUrl), consumerKey, nonce, Uri.EscapeDataString(sig), ts, accessToken);
wr.Headers[HttpRequestHeader.Authorization] = header;
try
{
var wres = wr.GetResponse();
using (var stream = wres.GetResponseStream())
using (var sr = new StreamReader(stream))
{
var result = HttpUtility.ParseQueryString(sr.ReadToEnd());
bool callbackConfirmed = bool.TryParse(result["oauth_callback_confirmed"], out callbackConfirmed) && callbackConfirmed;
if (!callbackConfirmed)
{
throw new AccessViolationException("Callback isn't confirmed");
}
return(new RequestTokenModel {
Token = result["oauth_token"],
TokenSecret = result["oauth_token_secret"]
});
}
}
catch (Exception ex)
{
var error = OAuthHelper.ReadWebExceptionMessage(ex);
Logger.Error(ex, error ?? ex.Message);
return(new RequestTokenModel {
Error = error ?? ex.Message
});
}
}
public async Task <Account> GetById(int Id)
{
var result = await _rep.GetById(Id);
if (result != null)
{
foreach (var card in result.Cards)
{
card.CardNumber = _encryptionService.Decrypt(card.CardNumber);
}
}
return(result);
}
public async Task <CustomerProfileErrorCodes> UpdateAsync(string customerId, string firstName, string lastName,
string phoneNumber, string shortPhoneNumber, int countryPhoneCodeId, int countryOfResidenceId)
{
using (var context = _contextFactory.CreateDataContext())
{
var entity = await context.CustomerProfiles.FirstOrDefaultAsync(o => o.CustomerId == customerId);
if (entity == null)
{
return(CustomerProfileErrorCodes.CustomerProfileDoesNotExist);
}
entity = _encryptionService.Decrypt(entity);
entity.FirstName = firstName;
entity.LastName = lastName;
entity.PhoneNumber = phoneNumber;
entity.ShortPhoneNumber = shortPhoneNumber;
entity.CountryPhoneCodeId = countryPhoneCodeId;
entity.CountryOfResidenceId = countryOfResidenceId;
entity = _encryptionService.Encrypt(entity);
context.CustomerProfiles.Update(entity);
await context.SaveChangesAsync();
return(CustomerProfileErrorCodes.None);
}
}
public ActionResult <EncryptMessageModel> Decrypt([FromBody] DecryptMessageModel input)
{
return(Ok(new EncryptMessageModel()
{
secret = _encryptionService.Decrypt(input.data)
}));
}
public void SendMessage(string text, string recipientEmail)
{
// it would be better to initialize this field in ctor
// but it was a trouble that EmailConfigurationSection
// cannot be initializes during app startup because of
// Ninject binging
_emailSettings = EmailConfigurationSection.Instance.Email;
var fromAddress = new MailAddress(_emailSettings.MailFromAddress, _emailSettings.MailFromName);
var toAddress = new MailAddress(recipientEmail);
var password = _encryptionSerive.Decrypt(_emailSettings.Password);
var credential = new NetworkCredential(fromAddress.Address, password);
_smtp.Host = _emailSettings.Host;
_smtp.Port = _emailSettings.Port;
_smtp.Credentials = credential;
using (var message = new MailMessage(fromAddress, toAddress)
{
Subject = _emailSettings.MailFromName,
Body = text
})
{
try
{
_smtp.Send(message);
}
catch (Exception)
{
// TODO: some exception handling
}
}
}
public ApiResponse <CryptographyResponseModel> Get()
{
Stopwatch stopwatch = null;
ApiResponse <CryptographyResponseModel> response = new ApiResponse <CryptographyResponseModel>();
try
{
stopwatch = new Stopwatch();
stopwatch.Start();
response = new ApiResponse <CryptographyResponseModel>();
var cryptoSet = _encryptionService.GenerateCryptoKeySet();
string encrypted = _encryptionService.Encrypt(cryptoSet, Guid.NewGuid().ToString());
string decrypted = _encryptionService.Decrypt(cryptoSet, encrypted);
response.Result = new CryptographyResponseModel()
{
Key = cryptoSet.Key,
IV = cryptoSet.IV,
Encrypted = encrypted,
Decrypted = decrypted
};
response.StatusCode = HttpStatusCode.OK;
response.Timestamp = DateTime.UtcNow;
stopwatch.Stop();
response.ElapsedMilliseconds = stopwatch.ElapsedMilliseconds;
}
catch (Exception ex)
{
response = ApiResponse <CryptographyResponseModel> .CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
}
return(response);
}
/// <summary>
/// Read the database from the disk and decrypt it with the given password
/// </summary>
/// <param name="path"></param>
/// <param name="password">If no password is given, use the one from the encryptionRepository if it has been set</param>
/// <returns></returns>
DatabaseModel InternalGetDatabase(string path, string password = "")
{
if (path is null || password is null || !File.Exists(path))
{
return(null);
}
try
{
var encryptedJson = File.ReadAllText(path);
if (password != "")
{
// Initialize Encryption service with the given key
encryptionService.Initialize(password);
}
var json = encryptionService.Decrypt(encryptedJson);
if (string.IsNullOrEmpty(json))
{
throw new Exception();
}
return(JsonConvert.DeserializeObject <DatabaseModel>(json));
}
catch (Exception)
{
encryptionService.Clear();
return(null);
}
}
public byte[] Output(byte[] bytes)
{
var uncompressed = _compressionService.Decompress(bytes);
var decrypted = _encryptionService.Decrypt(uncompressed);
return(decrypted.ToArray());
}
public IActionResult Get()
{
string encrypted = encryptionService.Encrypt("Text");
string decrypted = encryptionService.Decrypt(encrypted);
return(Ok());
}
public bool FetchMessages()
{
var messages = _client.FetchMessages().ToList();
var verfiedMessages = new List <MessageItem>();
foreach (var msg in messages)
{
string messageText;
if (_encryptionService.Decrypt(
new EncryptedMessage {
Body = msg.Body, DigitalSignature = msg.DigitalSignature, Iv = msg.Iv, SymmetricKey = msg.SymmetricKey
},
msg.SenderId,
out messageText))
{
verfiedMessages.Add(new MessageItem
{
Body = messageText,
Date = msg.DateSent,
ReceiverId = msg.ReceiverId,
SenderId = msg.SenderId,
IsNew = true
});
}
}
_storageService.SaveMessages(verfiedMessages);
return(messages.Any());
}
public object Output(Span <byte> bytes)
{
var tmp = _compressionService.Decompress(bytes);
tmp = _encryptionService.Decrypt(tmp);
return(_serializerService.Deserialize(tmp));
}
private async Task <List <CiCdBuildDto> > GetBuildsByRepository(RepositoryDto repository)
{
List <CiCdBuildDto> builds = new List <CiCdBuildDto>();
IPaginatedList <CiCdDto> cicds = await ciCdService.GetAsync(pageIndex : 1, pageSize : 1000);
foreach (var cicd in cicds)
{
encryption.Decrypt(cicd);
}
foreach (ICiCdProvider provider in providers)
{
foreach (CiCdDto cicd in cicds.Where(cicd => provider.Supports(cicd.Kind)))
{
try
{
List <CiCdBuildDto> results = await provider.GetBuildsAsync(repository, cicd);
builds.AddRange(results);
}
catch (Exception e)
{
logger.LogError(e, $"{nameof(GetBuildsByRepositoryIdAsync)}::[{repository.Url}]::[{cicd.Endpoint}]::ERROR");
}
}
}
logger.LogInformation($"{nameof(GetBuildsByRepositoryIdAsync)}::[{repository.WebUrl}]::CICD::SEARCH::RESULTS::[{builds.Count}]");
cache.Set(repository.RepositoryId, builds, absoluteExpiration: DateTimeOffset.Now.AddHours(2));
return(builds);
}
public async Task <IActionResult> Get(Guid id)
{
try
{
var payment = await _paymentRepository.GetPaymentAsync(id);
if (payment == null)
{
_logger.LogWarning($"GET - Requested payment Id {id} not found");
return(NotFound());
}
var response = _mapper.Map <GetPaymentResponse>(payment);
response.CardNumber = _encryptionService.Decrypt(payment.CardNumber).MaskCard();
response.PaymentStatus = Enum.GetName(typeof(PaymentStatusCode), payment.PaymentStatus);
_logger.LogInformation($"GET - Requested payment Id {id} returned OK");
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError($"GET - Failed due to exception ${ex.GetType()} with error ${ex.Message} for request on ID ${id}");
return(StatusCode(500));
}
}
/// <summary>
/// Gets an encrypted cookie from client and returns type as requested
/// </summary>
/// <param name="cookieName"></param>
/// <returns></returns>
public T ReadEncryptedCookie <T>(string cookieName)
{
try
{
var cookie = HttpContext.Current.Request.Cookies[_cookiePrefix +
cookieName];
if (cookie == null || (!string.IsNullOrEmpty(cookie.Domain) && cookie.Domain != _cookieDomain))
{
return(default(T));
}
var converter = TypeDescriptor.GetConverter(typeof(T));
if (converter.CanConvertFrom(typeof(string)))
{
string value = _encryptionService.Decrypt(cookie.Value);
return((T)converter.ConvertFromString(value));
}
else
{
return(default(T));
}
}
catch (Exception ex)
{
_logger.LogItem(ex.Message);
return(default(T));
}
}
private static async Task <TransactionSigningResult> CreateAsync(
ITransactionSignerFactory transactionSignerFactory,
string protocolCode,
IWalletRepository walletRepository,
IReadOnlyCollection <string> signingAddresses,
IEncryptionService encryptionService,
NetworkType networkType,
byte[] builtTransaction)
{
ITransactionSigner transactionSigner;
try
{
transactionSigner = transactionSignerFactory.Create(protocolCode);
}
catch (ArgumentOutOfRangeException e)
{
throw new BlockchainIsNotSupportedException(e);
}
var wallets = await walletRepository.GetByAddressesAsync(signingAddresses);
var privateKeys = wallets.Select(x => encryptionService.Decrypt(x.PrivateKey)).ToArray();
try
{
return(transactionSigner.Sign(builtTransaction, privateKeys, networkType));
}
catch (Exception exception)
{
throw new TransactionSigninFailedException("An error occured while signing transaction.", exception);
}
}
public async Task <IActionResult> Post([FromBody] LoginRequestModel loginRequestModel)
{
UserModel user = await _userService.Get(loginRequestModel.UserName);
if (user == null)
{
throw new NotFoundException($"{loginRequestModel.UserName} does not exist");
}
if (loginRequestModel.Password != _encryptionService.Decrypt(user.passwordHash))
{
throw new BadRequestException("Password is incoreect");
}
LoginResponseModel loginResponseModel = new LoginResponseModel()
{
accessToken = _jwtService.Get(user),
fullName = $"{user.lastname} {user.otherNames}",
refreshToken = Guid.NewGuid().ToString(),
accessId = user.id
};
await _authService.LogAccess(loginResponseModel);
loginResponseModel.accessId = -1;
return(Ok(loginResponseModel));
}
public OauthToken Find(string service)
{
var token = _context.AccessTokens.FirstOrDefault(x => x.Service == service);
if (token == null)
{
return(null);
}
return(new OauthToken()
{
Token = _encryptor.Decrypt(token.Token),
Secret = _encryptor.Decrypt(token.Secret),
Expires = token.Expires,
SessionHandle = _encryptor.Decrypt(token.SessionHandle)
});
}
private void btnReadBlock_Clicked(System.Object sender, System.EventArgs e)
{
byte[] cardKey = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
byte[] encryptedResult = nfcService.ReadByteBlock(16, cardKey, NfcKeyType.KeyB);
byte[] result = encryptionService.Decrypt(encryptedResult);
Device.BeginInvokeOnMainThread(() => lbState.Text = result == null ? "Error reading NFC block" : $"NFC block read {BitConverter.ToString(result)}");
}
