private void DecryptLogin(LoginViewModel model)
{
model.UserName = string.Empty;
model.Password = string.Empty;
var key = Request.Cookies["tokenBP1"].Value;
var iv = Request.Cookies["tokenBP2"].Value;
if (key != null && iv != null)
{
try
{
var crypto = new SimpleAes();
key = crypto.DecryptString(key);
iv = crypto.DecryptString(iv);
model.UserName = AesForLogin.DecryptStringAES(key, iv, model.Log1);
model.Password = AesForLogin.DecryptStringAES(key, iv, model.Log2);
}
catch (Exception)
{
model.Password = string.Empty;
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
else
{
model.Password = string.Empty;
ModelState.AddModelError("", "Your Session is expire please try login again");
}
}
protected override object GetInternal(string key)
{
object value = null;
try
{
if (_directoryValid)
{
//check for a non-expiring cache:
var cachePath = GetFilePath(key);
if (!File.Exists(cachePath))
{
cachePath = null;
//check for expired caches:
var fileName = GetFileNameSearchPattern(key);
var existingCaches = Directory.EnumerateFiles(_directory, fileName).OrderByDescending(x => x);
if (existingCaches.Count() > 0)
{
var mostRecentCache = existingCaches.ElementAt(0);
//if the most recent cache is live, return it -
//format is {key}.cache.{expiresAt}.expiry
if (mostRecentCache.EndsWith(".expiry"))
{
var expiresAt = mostRecentCache.Substring(mostRecentCache.IndexOf(".expiry") - 19, 19);
var expiresAtDate = expiresAt.Replace('-', '/').Replace('_', ':');
var expiryDate = DateTime.Parse(expiresAtDate);
if (expiryDate > DateTime.UtcNow)
{
cachePath = Path.Combine(_directory, mostRecentCache);
}
else
{
var deleteKey = key;
Task.Factory.StartNew(() => DeleteFile(deleteKey));
}
}
}
}
if (cachePath != null)
{
if (CacheConfiguration.Current.DiskCache.EncryptItems)
{
var encryptedBytes = File.ReadAllBytes(cachePath);
value = SimpleAes.Decrypt(encryptedBytes);
}
else
{
value = File.ReadAllText(cachePath);
}
}
}
}
catch (Exception ex)
{
Log.Warn("DiskCache.GetInternal - failed, item not returned. Message: {0}", ex.Message);
}
return(value);
}
public async Task EncryptFileTest()
{
// Arrange
var aes = new SimpleAes(key);
// Act
await aes.EncryptAsync(testFile, cryptFile);
// Assert
Assert.IsTrue(File.Exists(cryptFile));
}
public async Task DecryptTest()
{
// Arrange
var aes = new SimpleAes(key);
// Act
string decrypted = await aes.DecryptAsync(result);
// Assert
Assert.AreEqual(sample, decrypted);
}
public async Task EncryptTest()
{
// Arrange
var aes = new SimpleAes(key);
// Act
string encrypted = await aes.EncryptAsync(sample);
// Assert
Assert.AreEqual(result, encrypted);
}
public async Task DecryptEncryptFileTest()
{
// Arrange
var aes = new SimpleAes(key);
// Act
await aes.DecryptAsync(testCryptFile, outFile);
await aes.EncryptAsync(outFile, cryptFile);
// Assert
Assert.AreEqual(File.ReadAllText(testCryptFile), File.ReadAllText(cryptFile));
}
private static void DemoEncrypt()
{
var generateEncryptionKey = SimpleAes.GenerateEncryptionKey();
foreach (var b in generateEncryptionKey)
{
Console.Write(b);
Console.Write(",");
}
Console.WriteLine();
var generateEncryptionVector = SimpleAes.GenerateEncryptionVector();
foreach (var b in generateEncryptionVector)
{
Console.Write(b);
Console.Write(",");
}
Console.WriteLine();
Console.WriteLine("------SimpleAes-----");
var simpleAes = new SimpleAes();
var @join = string.Join(",", Enumerable.Repeat("b2f28db601599e3c1271117acfd9caed1d4abfb3", 1000).ToArray());
//var @join = simpleAes.EncryptToString("b2f28db601599e3c1271117acfd9caed1d4abfb3");
var encrypt = simpleAes.EncryptToString(@join);
Console.WriteLine(encrypt.Length);
var decryptString = simpleAes.DecryptString(encrypt);
Console.WriteLine(decryptString.Length);
Console.WriteLine("----StringCompressor----");
var stringCompressor = StringCompressor.Instance;
var compressString = stringCompressor.CompressString(encrypt);
Console.WriteLine(compressString.Length);
var decompressString = stringCompressor.DecompressString(compressString);
Console.WriteLine(decompressString.Length);
Console.WriteLine("----ZipHelper----");
var bytes = ZipHelper.Zip(encrypt);
Console.WriteLine(bytes.Length);
var unzip = ZipHelper.Unzip(bytes);
Console.WriteLine(unzip.Length);
}
public async Task EncryptStreamTest()
{
// Arrange
var aes = new SimpleAes(key);
using var ms = new MemoryStream(Encoding.UTF8.GetBytes(sample));
// Act
byte[] encrypted = await aes.EncryptAsync(ms);
string encStr = Convert.ToBase64String(encrypted);
// Assert
Assert.AreEqual(result, encStr);
}
public void TestSymetrical()
{
const string original = "this is a test string";
using (var aes = new SimpleAes())
{
var enc = aes.Encrypt(original);
Debug.WriteLine("encrypted = " + enc);
string decrypted = aes.Decrypt(enc);
Assert.AreEqual(original, decrypted);
var secondEnc = aes.Encrypt(original);
Assert.AreNotEqual(secondEnc, enc);
}
}
public async Task DecryptStreamTest()
{
// Arrange
var aes = new SimpleAes(key);
var bytes = Convert.FromBase64String(result);
using var ms = new MemoryStream(bytes);
// Act
byte[] decrypted = await aes.DecryptAsync(ms);
var decStr = Encoding.UTF8.GetString(decrypted);
// Assert
Assert.AreEqual(sample, decStr);
}
public async Task EncryptDecryptStreamTest()
{
// Arrange
var aes = new SimpleAes(key);
using var inStream = new MemoryStream(Encoding.UTF8.GetBytes(sample));
// Act
byte[] encrypted = await aes.EncryptAsync(inStream);
using var outStream = new MemoryStream(encrypted);
byte[] decrypted = await aes.DecryptAsync(outStream);
string decStr = Encoding.UTF8.GetString(decrypted);
// Assert
Assert.AreEqual(sample, decStr);
}
public async Task DecryptEncryptStreamTest()
{
// Arrange
var aes = new SimpleAes(key);
using var inStream = new MemoryStream(Convert.FromBase64String(result));
// Act
byte[] decrypted = await aes.DecryptAsync(inStream);
using var outStream = new MemoryStream(decrypted);
byte[] encrypted = await aes.EncryptAsync(outStream);
string encStr = Convert.ToBase64String(encrypted);
// Assert
Assert.AreEqual(result, encStr);
}
private void SetInternal(string key, object value, DateTime?expiresAt)
{
try
{
if (_directoryValid && !HasExceededQuota())
{
//check for a non-expiring cache:
var cachePath = GetFilePath(key);
if (File.Exists(cachePath))
{
File.Delete(cachePath);
}
//check for other caches:
var fileName = GetFileNameSearchPattern(key);
var existingCaches = Directory.EnumerateFiles(_directory, fileName);
foreach (var existingCache in existingCaches)
{
File.Delete(Path.Combine(_directory, existingCache));
}
var newCachePath = GetFilePath(key, expiresAt);
var item = value as string;
if (item != null)
{
if (CacheConfiguration.Current.DiskCache.EncryptItems)
{
var encryptedBytes = SimpleAes.Encrypt(item);
File.WriteAllBytes(newCachePath, encryptedBytes);
}
else
{
File.WriteAllText(newCachePath, item);
}
}
}
}
catch (Exception ex)
{
Log.Warn("DiskCache.SetInternal - failed, item not cached. Message: {0}", ex.Message);
}
}
public ActionResult Login(string ReturnUrl = "")
{
ViewBag.ReturnUrl = ReturnUrl;
var crypto = new SimpleAes();
Session["BPKey"] = AesForLogin.Create16DigitString();
Session["BPKeyIV"] = AesForLogin.Create16DigitString();
var cookie1 = new HttpCookie("tokenBP1");
var cookie2 = new HttpCookie("tokenBP2");
cookie1.Value = crypto.EncryptToString(Session["BPKey"].ToString());
cookie2.Value = crypto.EncryptToString(Session["BPKeyIV"].ToString());
Response.Cookies.Remove("tokenBP1");
Response.Cookies.Remove("tokenBP2");
Response.Cookies.Add(cookie1);
Response.Cookies.Add(cookie2);
return(View());
}
public string DecryptAESFromBase64String(string cipher)
{
string htmlUnsafeCipher = cipher.Replace('_', '/').Replace('-', '+');
switch (cipher.Length % 4)
{
case 2:
{
htmlUnsafeCipher += "==";
break;
}
case 3:
{
htmlUnsafeCipher += "=";
break;
}
}
var cipherBytes = Convert.FromBase64String(htmlUnsafeCipher);
return(SimpleAes.Decrypt(cipherBytes));
}
public byte[] EncryptAES(string inputString)
{
return(SimpleAes.Encrypt(inputString));
}
private static HttpResponseMessage Post(object data, RequestClaim claim, string base64Secret, TextWriter message, TextWriter error)
{
var type = data.GetType();
var ie = type.GetInterfaces().FirstOrDefault(i => i.IsGenericType &&
i.GetGenericTypeDefinition() == typeof(IEnumerable <>));
if (ie == null)
{
if (!ValidateAttributes.IsValid(data, error))
{
return(null);
}
}
else
{
type = ie.GetGenericArguments()[0];
foreach (object o in (IEnumerable)data)
{
if (!ValidateAttributes.IsValid(o, error))
{
return(null);
}
}
}
var baseAddress = new Uri(_domain);
using (var handler = new HttpClientHandler())
{
using (var client = new HttpClient(handler)
{
BaseAddress = baseAddress
})
{
client.DefaultRequestHeaders.Date = new DateTimeOffset(DateTime.Now);
using (var aes = new SimpleAes())
{
claim.Token = Hash(client.DefaultRequestHeaders.GetValues("Date").First(), claim.ResourceId, base64Secret);
var jsonClaim = JsonConvert.SerializeObject(claim);
var encryptedString = aes.Encrypt(jsonClaim);
var cookieContainer = new CookieContainer();
cookieContainer.Add(baseAddress, new Cookie("token", encryptedString));
handler.CookieContainer = cookieContainer;
}
client.DefaultRequestHeaders.Accept
.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Accept
.Add(new MediaTypeWithQualityHeaderValue("text/html"));
var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, _jsonContentType);
string requestUri = $"api/{type.Name}/{claim.ResourceId}";
message.WriteLine($"Posting to {baseAddress.AbsoluteUri}{requestUri}");
HttpResponseMessage response;
try
{
//response = client.GetAsync(requestUri).Result;
response = client.PostAsync(requestUri, content).Result;
}
catch (Exception e)
{
while (e.InnerException != null)
{
e = e.InnerException;
}
error.WriteLine(e.Message);
return(null);
}
TextWriter m = response.IsSuccessStatusCode ? message : error;
m.WriteLine($"server returned {(int)response.StatusCode} ({response.ReasonPhrase})");
#if DEBUG
bool debug = true;
#else
bool debug = false;
#endif
if (!response.IsSuccessStatusCode && response.Content.Headers.ContentLength > 0)
{
var tempFile = Path.GetTempFileName() + ".html";
using (var fileStream = File.Create(tempFile))
{
using (var responseStream = response.Content.ReadAsStreamAsync().Result)
{
responseStream.CopyTo(fileStream);
}
}
System.Diagnostics.Process.Start(tempFile);
}
else if (debug)
{
var msg = response.Content.ReadAsStringAsync().Result;
if (msg != string.Empty)
{
m.WriteLine(msg);
}
}
return(response);
}
}
}
public void SetUp()
{
_simpleAes = new SimpleAes();
}
public CryptoSimpleAES(string key)
{
this.mSimpleAES = new SimpleAes(key);
}
public string DecryptAES(byte[] cipherBytes)
{
return(SimpleAes.Decrypt(cipherBytes));
}
public string EncryptAESToBase64String(string inputString)
{
return(Convert.ToBase64String(SimpleAes.Encrypt(inputString)).TrimEnd(Padding).Replace('+', '-').Replace('/', '_'));
}