public async Task Run()
{
const string stringToProtect = "AccessToken";
// Note how expiration time is specified in call to Protect
string protectedPayload = protector.Protect(stringToProtect, TimeSpan.FromSeconds(1));
Console.WriteLine($"Ciphertext: {protectedPayload}");
string unprotectedPayload = protector.Unprotect(protectedPayload);
Console.WriteLine($"Plaintext: {unprotectedPayload}");
// Try unprotecting after expiration time -> has to fail
await Task.Delay(TimeSpan.FromSeconds(2));
try
{
protector.Unprotect(protectedPayload);
throw new InvalidOperationException("Expected crypto exception did not happen!");
}
catch (CryptographicException)
{
Console.WriteLine("Could not unprotect after protection expired.");
}
}
public async Task <FileStreamResult> GetDocumentContent(string encryptedData)
{
string decryptedData;
try
{
decryptedData = dataProtector.Unprotect(encryptedData);
}
catch (CryptographicException)
{
throw new ApiServiceException("Download data is not valid");
}
var index = decryptedData.LastIndexOf('_');
var documentId = decryptedData.Substring(0, index);
var userId = new Guid(decryptedData.Substring(index + 1));
var document = await documentStorage.GetDocument(
new DocumentIdentity(documentId, userId),
CancellationToken.None);
contentTypeProvider.TryGetContentType(document.FileName, out var contentType);
return(new FileStreamResult(
await document.Content.OpenReadStream(CancellationToken.None),
contentType ?? "application/octet-stream")
{
FileDownloadName = document.FileName,
EnableRangeProcessing = true
});
}
private async Task <bool> IsTokenValid(string token)
{
try
{
using (var scope = await _shellHost.GetScopeAsync(_shellSettingsManager.GetSettings(ShellHelper.DefaultShellName)))
{
var dataProtectionProvider = scope.ServiceProvider.GetService <IDataProtectionProvider>();
ITimeLimitedDataProtector dataProtector = dataProtectionProvider.CreateProtector("Tokens").ToTimeLimitedDataProtector();
var tokenValue = dataProtector.Unprotect(token, out var expiration);
if (_clock.UtcNow < expiration.ToUniversalTime())
{
if (_shellSettings.Secret == tokenValue)
{
return(true);
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in decrypting the token");
}
return(false);
}
public string Unprotect(string protectedPayload)
{
// protect the payload
string unprotectedPayload = _timeLimitedProtector.Unprotect(protectedPayload);
return(unprotectedPayload);
}
public IActionResult Read(string code)
{
DateTimeOffset dateTimeOffset;
var result = _timeLimitedDataProtector.Unprotect(code, out dateTimeOffset);
return(Content($"{result}:{dateTimeOffset.LocalDateTime}"));
}
public byte[] Unprotect(byte[] protectedData)
{
if (protectedData == null)
{
throw new ArgumentNullException(nameof(protectedData));
}
return(_innerProtector.Unprotect(protectedData, out Expiration));
}
/// <summary>
/// Veri Şifre Çözücü
/// </summary>
/// <param name="value">Şifrelenmiş veri</param>
/// <param name="isTimeLimited">Şifrelenmiş veriye bir süre verilmiş mi?</param>
/// <returns>Şifresi çözülmüş veri</returns>
public string Unprotect(string value, bool isTimeLimited)
{
if (!isTimeLimited)
{
return(_dataProtector.Unprotect(value));
}
return(_timeLimitedDataProtector.Unprotect(value));
}
public byte[] DecryptStream(MemoryStream dataStream)
{
using (var mStream = new MemoryStream())
{
// TODO: Check if we can run this with one stream only
dataStream.Position = 0;
dataStream.CopyTo(mStream);
var bytesData = mStream.ToArray();
return(_protector.Unprotect(bytesData));
}
}
public Task <(AccountLinkingState state, DateTimeOffset expiration)> GetAsync(string accountLinkingState)
{
string unprotectedStateString = _dataProtector.Unprotect(accountLinkingState, out DateTimeOffset expiration);
var stateObject = JsonSerializer.Deserialize <AccountLinkingState>(unprotectedStateString);
if (stateObject == default)
{
_logger.LogWarning("Failed to deserialize the state object");
throw new Exception("Verification failed, state object invalid");
}
return(Task.FromResult((stateObject, expiration)));
}
public ActionResult <string> Get(string endstring)
{
try
{
//return _dataProtector.Unprotect(endstring);
DateTimeOffset dateTimeOffset;
var result = _timeLimitedDataProtector.Unprotect(endstring, out dateTimeOffset);
return($"{result},{dateTimeOffset.LocalDateTime}");
}
catch (CryptographicException exc)
{
return($"{exc.Message},当前时间:{DateTime.Now}");
}
}
public void RunSample()
{
Console.Write("Enter input: ");
string input = Console.ReadLine();
// protect the payload
string protectedPayload = _timeLimitedProtector.Protect(input, lifetime: TimeSpan.FromSeconds(2));
Console.WriteLine($"Protect returned: {protectedPayload}");
Thread.Sleep(2000);
// unprotect the payload
string unprotectedPayload = _timeLimitedProtector.Unprotect(protectedPayload);
Console.WriteLine($"Unprotect returned: {unprotectedPayload}");
Console.ReadLine();
}
// GET: Products/Details/5
public async Task <IActionResult> Details(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
// int decryptedId = int.Parse(_dataProtector.Unprotect(id)); //Zaman bağımsız şifre çözme işlemi
int decryptedId = int.Parse(_timeLimitedDataProtector.Unprotect(id)); //Zaman bağımlı şifre çözme
var product = await _context.Products
.FirstOrDefaultAsync(m => m.Id == decryptedId);
if (product == null)
{
return(NotFound());
}
return(View(product));
}
public bool TryDecryptToken <T>(string token, out T payload)
{
payload = default;
try
{
var json = _dataProtector.Unprotect(token, out var expiration);
if (_clock.UtcNow < expiration.ToUniversalTime())
{
payload = JsonConvert.DeserializeObject <T>(json);
return(true);
}
}
catch
{
}
return(false);
}
public bool TryDecryptToken <T>(string token, out T payload)
{
payload = default;
try
{
var json = _dataProtector.Unprotect(token, out var expiration);
if (_dateTimeProvider.Now < expiration.ToUniversalTime())
{
payload = JsonConvert.DeserializeObject <T>(json);
return(true);
}
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
return(false);
}
public async Task <IActionResult> Login(string code)
{
try
{
//单点登录系统中的过期时间
DateTimeOffset dateTimeOffset;
var result = _timeLimitedDataProtector.Unprotect(code, out dateTimeOffset);
var userPro = Newtonsoft.Json.JsonConvert.DeserializeObject <dynamic>(result);
var identity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme);
identity.AddClaim(new Claim(ClaimTypes.Sid, userPro.UserName.ToString()));
identity.AddClaim(new Claim(ClaimTypes.Role, userPro.Role.ToString()));
identity.AddClaim(new Claim(ClaimTypes.Name, userPro.Name.ToString()));
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(identity));
return(Redirect("/"));
}
catch (CryptographicException)//过期
{
return(Redirect("/home/error"));
}
}
public IActionResult GetRawFile(string fileKey, string url)
{
try
{
/*
* 文件下载时，我会先根据 文件路径 创建一个文件key，然后设置他的过期时间
* 当前为了跟大家演示效果，为了读取 加密的url，所有 将url进行传入，
* 真实业务场景，会传入一个 订单编号 或者业务编号去动态查询 上传地址
*/
//通过订单编号-orderNo 查询客户上传的文件路径
var rawFileInfo = _protector.Unprotect(fileKey);
string cdipath = Directory.GetCurrentDirectory() + url;
var stream = System.IO.File.OpenRead(cdipath);
stream.Position = 0;
return(File(stream, "application/oct-stream", rawFileInfo));
}
catch
{
return(StatusCode(401));
}
}
public (bool result, string message) VerifyAccessSecret(AccessSecret secret, string accessKey, string accessSecret)
{
try
{
if (secret.ExpiresTime < DateTime.Now.Date)
return (false, "服务时间已到期");
var deserializeSecret = Encoding.UTF8.GetString(_timeLimitedProtector.Unprotect(Convert.FromBase64String(accessSecret))).JsonDeserialize<AccessSecret>();
if (deserializeSecret.Key != accessKey)
return (false, "AccessKey、AccessSecret异常");
if (deserializeSecret.Version != secret.Version)
return (false, "AccessKey、AccessSecret版本错误");
return (true, "");
}
catch (CryptographicException ex)
{
return (false, ex.Message);
}
}
public IActionResult GetByToken(string token)
{
var id = _context.SecretItems
.FirstOrDefault(b => b.Token == token);
try
{
var item = _context.SecretItems.Find(id.Id);
var secretValue = item.Value;
_context.SecretItems.Remove(item);
_context.SaveChanges();
return(Ok(_protector.Unprotect(secretValue)));
}
catch (NullReferenceException)
{
return(NotFound());
}
catch (CryptographicException)
{
return(Ok("This secret has expired"));
}
}
private string DecryptUserId(string encryptUserId)
{
var deCryptId = dataProtector.Unprotect(encryptUserId);
return(deCryptId);
}
public ActionResult <object> GetDesencriptadoTiempo(string textoEncriptado)
{
return(Ok(_dataProtectorTiempoLimitado.Unprotect(textoEncriptado)));
}
public string Decrypt(Credentials credentials)
{
return(dataProtector.Unprotect(credentials.Password));
}