public ActionResult Login(string returnUrl)
{
string auth = GetCookie("Auth");
if (!String.IsNullOrWhiteSpace(auth))
{
ApplicationDbContext dba = new ApplicationDbContext();
AbzHash abzHash = dba.AbzHashs.Find(auth);
if ((abzHash != null) & (abzHash.IP == HttpContext.Request.UserHostAddress))
{
string Email = MyCrypto.DeShifrovka(abzHash.Email);
string Password = MyCrypto.DeShifrovka(abzHash.Password);
var result = SignInManager.PasswordSignIn(Email, Password, true, shouldLockout: false);
return(RedirectToLocal(returnUrl));
}
}
//string Email = MyCrypto.DeShifrovka(GetCookie("MyAuth"));
//string Password = MyCrypto.DeShifrovka(GetCookie("MyPWD"));
//if (!String.IsNullOrWhiteSpace(Email) && !String.IsNullOrWhiteSpace(Password))
//{
// //FormsAuthentication.SetAuthCookie(cuc, true);
// var result = SignInManager.PasswordSignIn(Email, Password, true, shouldLockout: false);
// return RedirectToLocal(returnUrl);
//}
ViewBag.ReturnUrl = returnUrl;
return(View());
}
public void HammingDistance_Test()
{
//https://trustedsignal.blogspot.com/2015/06/xord-play-normalized-hamming-distance.html
string str = "fuse fuel for falling flocks";
string key = "few";
var ExpectedResults = new Dictionary <int, double> {
{ 2, 2.88461538461538 },
{ 3, 2.54166666666667 },
{ 4, 3.08333333333333 },
{ 5, 2.65 },
{ 6, 2.44444444444444 },
{ 7, 2.80952380952381 },
{ 8, 2.8125 },
{ 9, 2.22222222222222 },
{ 10, 2.6 },
{ 11, 2.18181818181818 },
{ 12, 2.16666666666667 },
{ 13, 2.61538461538462 },
{ 14, 2.71428571428571 }
};
var bytes = MyCrypto.SingleByteXOR_String(str, key);
var ScoreList = Stats.GetHammingDistances(bytes.ToList(), 2, 14);
for (int i = 2; i < 14; i++)
{ //Assert within a rounded range b/c of doubles (close enough)
Assert.That(Math.Abs(ScoreList[i] - ExpectedResults[i]), Is.LessThan(0.00001D));
}
}
public void AESinCBC_Encrypt_Decrypt_Test() //CBC = Cipher Block Chaining
{
int BLOCKSIZE = 16;
string OriginalMessage = "Now I rock a house party at the drop of a hat\nAnd I beat a body down with an aluminum bat";
var bytes = MyConvert.TextToByteArray(OriginalMessage);
var PaddedBytes = Pad.AddPkcs7(bytes, 128); //Pad the message to 128 bytes
//The Key (16 bytes)
string key = "YELLOW SUBMARINE";
string HexKey = MyConvert.HexEncodePlainText(key);
var Keybytes = MyConvert.HexToByteArray(HexKey);
//Initialization Vector (padded to BLOCKSIZE bytes)
string IVHex = Pad.PadHex(BLOCKSIZE * 2, "00");
var IVBytes = MyConvert.HexToByteArray(IVHex);
//Encrypt
var CiperBytes = MyCrypto.AES_CBC_Encrypt(PaddedBytes, Keybytes, IVBytes, BLOCKSIZE);
//Decrypt
var PlainBytes = MyCrypto.AES_CBC_Decrypt(CiperBytes, Keybytes, IVBytes, BLOCKSIZE);
var UnPaddedBytes = Pad.RemovePkcs7(PlainBytes); //Unpad the message
var hexPlain = MyConvert.BytesToHex(UnPaddedBytes);
var PlainText = MyConvert.HexToAscii(hexPlain);
Assert.IsTrue(OriginalMessage == PlainText);
}
public void Implement_CBC_mode_Test() //CBC = Cipher Block Chaining
{
var BLOCKSIZE = 16;
//https://cryptopals.com/sets/2/challenges/10
string str = Util.GetFile(10);
string Hex = MyConvert.Base64ToHex(str);
var bytes = MyConvert.HexToByteArray(Hex);
//Initialization Vector (padded to BLOCKSIZE bytes)
string IVHex = Pad.PadHex(BLOCKSIZE * 2, "00");
var IVBytes = MyConvert.HexToByteArray(IVHex);
//The Key
string key = "YELLOW SUBMARINE";
string HexKey = MyConvert.HexEncodePlainText(key);
var Keybytes = MyConvert.HexToByteArray(HexKey);
//Perform my version of CBC
var decryptedBytes = MyCrypto.AES_CBC_Decrypt(bytes, Keybytes, IVBytes, BLOCKSIZE);
var HexResult = MyConvert.BytesToHex(decryptedBytes);
var Plain = MyConvert.HexToAscii(HexResult);
Assert.IsTrue("I'm back and I'm ringin' " == Plain.Substring(0, 25)); //25 is at least two blocks (of16) so i know i have the algo correct
}
public void AES_ECB_and_CBC_Oracle_Test()
{
//https://cryptopals.com/sets/2/challenges/11
string myInput = Util.GenerateIdenticalString('A', 100);
bool FoundAtLeastOne_ECB = false;
bool FoundAtLeastOne_CBC = false;
for (int i = 0; i < 1000; i++)
{
var Result = MyCrypto.RandomlyEncrypt(myInput);
var MenthodUsed = MyCrypto.Encryption_Oracle(Result.EncryptedBytes);
Assert.AreEqual(MenthodUsed, Result.EType);
if (MenthodUsed == AESEncryptionType.ECB)
{
FoundAtLeastOne_ECB = true;
}
if (MenthodUsed == AESEncryptionType.CBC)
{
FoundAtLeastOne_CBC = true;
}
}
Assert.IsTrue(FoundAtLeastOne_ECB);
Assert.IsTrue(FoundAtLeastOne_CBC);
}
public void DeterminECBBlockSize_Test()
{
var ByteBlockSize = MyCrypto.DeterminECBBlockSize(MyCrypto.AES_ECB_Encrypt);
Assert.IsTrue(ByteBlockSize == 16); //AES.Blocksize is 128 bits - Assert is in bytes (16 * 8 = 128)
// dotnet core RijndaelManaged only works with a 128 bit blocksize, as documented here...
//https://stackoverflow.com/questions/52699604/how-to-use-rijndael-algorithm-with-256-long-block-size-in-dotnet-core-2-1
}
public void SingleByteXORCipher_Test()
{
//https://cryptopals.com/sets/1/challenges/3
string HexCipher = "1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736";
string HexOfChar = MyCrypto.SingleByteXOR(HexCipher).Hex;
string ExpectedHexOfChar = "58";
Assert.IsTrue(HexOfChar == ExpectedHexOfChar);
}
public void BreakRepeatingKeyXOR_Test()
{
//https://cryptopals.com/sets/1/challenges/6
string str = Util.GetFile(6);
var Expected = "Terminator X: Bring the noise";
var result = MyCrypto.BreakRepeatingKeyXOR(str);
Assert.IsTrue(Expected == result);
}
private void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
{
pwd[3] = (byte)82;
pwd[11] = (byte)104;
controller = new ServiceController();
controller.ServiceName = "CardRoute";
try
{
ServiceStatus = controller.Status.ToString();
}
catch
{
ServiceStatus = "не найден";
controller = null;
}
SetLanguage(Lang.Russian);
XmlDocument settings = new XmlDocument();
try
{
settings.Load($"{System.AppDomain.CurrentDomain.BaseDirectory}CardRoute.xml");
myCommon.timeout = XmlClass.GetDataXml(settings, "Common/Timeout", null);
myCommon.language = XmlClass.GetDataXml(settings, "Common/Language", null);
myCommon.protocol = XmlClass.GetDataXml(settings, "Common/Protocol", null);
myCommon.updateFinal = XmlClass.GetAttribute(settings, "Common/CardUpdates", "FinalMinutes", "0", null);
myCommon.updateArchive = XmlClass.GetAttribute(settings, "Common/CardUpdates", "ArchiveDays", "0", null);
mySqlServer.serverName = XmlClass.GetDataXml(settings, "Database/server", null);
mySqlServer.DbName = XmlClass.GetDataXml(settings, "Database/name", null);
mySqlServer.Uid = XmlClass.GetDataXml(settings, "Database/uid", null);
myCdp.CdpConsole = XmlClass.GetDataXml(settings, "Cdp/Console", null);
myCdp.CdpIniFolder = XmlClass.GetDataXml(settings, "Cdp/IniFolder", null);
myCdp.CdpDefaultIni = XmlClass.GetDataXml(settings, "Cdp/CdpIni", null);
myCdp.CdpDefaultIn = XmlClass.GetDataXml(settings, "Cdp/InFile", null);
myPerso.Ip = XmlClass.GetAttribute(settings, "HS", "Ip", "", null);
myPerso.Port = XmlClass.GetAttribute(settings, "HS", "Port", "", null);
myPerso.Log = XmlClass.GetAttribute(settings, "HS", "Log", "", null);
myPerso.Path = XmlClass.GetDataXml(settings, "HS/Application", null);
//пароль последним, на случай ошибки
mySqlServer.Pwd = Utils.AHex2String(MyCrypto.TripleDES_DecryptData(XmlClass.GetDataXml(settings, "Database/password", null), pwd, CipherMode.ECB, PaddingMode.Zeros));
}
catch
{ }
tiCommon.DataContext = myCommon;
tiSqlServer.DataContext = mySqlServer;
tiCdp.DataContext = myCdp;
tiPerso.DataContext = myPerso;
lStatus.Content = $"Статус: {ServiceStatus}";
tbPwd.Password = mySqlServer.Pwd;
}
public void DetectSingleCharacterXOR_Test()
{
//https://cryptopals.com/sets/1/challenges/4
string[] lines = File.ReadAllLines(@"./4.txt", Encoding.UTF8);
var messageIndex = MyCrypto.DetectSingleCharacterXOR(lines);
var ExpectedIndex = 170;
var ExpectedMsg = "Now that the party is jumping\n";
Assert.IsTrue(messageIndex.Index == ExpectedIndex);
Assert.IsTrue(messageIndex.Message == ExpectedMsg);
}
public void FixedXOR_Test1()
{
//https://cryptopals.com/sets/1/challenges/2
string Encrypted = "1c0111001f010100061a024b53535009181c"; //Encrypted Text
string HexEncodedKey = "686974207468652062756c6c277320657965"; //hit the bull's eye
string ResultOR = MyCrypto.FixedXOR(Encrypted, HexEncodedKey);
string Decrypted = "746865206b696420646f6e277420706c6179"; //the kid don't play
Assert.IsTrue(ResultOR == Decrypted);
}
public void RepeatingXOR_Test()
{
//https://cryptopals.com/sets/1/challenges/5
string PlainText1 = "Burning 'em, if you ain't quick and nimble";
string PlainText2 = "I go crazy when I hear a cymbal";
string key = "ICE";
string CipherText = MyCrypto.RepeatingXOR(PlainText1 + '\n' + PlainText2, key);
string ExpectedCipher = "0b3637272a2b2e63622c2e69692a23693a2a3c6324202d623d63343c2a26226324272765272a282b2f20430a652e2c652a3124333a653e2b2027630c692b20283165286326302e27282f";
Assert.IsTrue(CipherText == ExpectedCipher);
}
public void FixedXOR_Test2()
{
//https://cryptopals.com/sets/1/challenges/6
string str = Util.GetFile(6);
string HextoDecrypt = MyConvert.Base64ToHex(str);
var Key = "Terminator X: Bring the noise";
var HexKey = Pad.PadKey(MyConvert.HexEncodePlainText(Key), HextoDecrypt.Length);
var DecryptedHex = MyCrypto.FixedXOR(HextoDecrypt, HexKey);
var Plain = MyConvert.HexToAscii(DecryptedHex);
Assert.IsTrue("I'm back and I'm ringin' " == Plain.Substring(0, 25));
}
public void FixedOR_String_Long_Test()
{
//https://trustedsignal.blogspot.com/2015/06/xord-play-normalized-hamming-distance.html
string str = "fuse fuel for falling flocks";
string key = "few";
var ExpectedResult = new byte[] { 000, 016, 004, 003, 069, 017, 019, 000, 027, 070, 003, 024, 020, 069, 017, 007, 009, 027, 015, 011, 016, 070, 003, 027, 009, 006, 028, 021 };
var Result = MyCrypto.SingleByteXOR_String(str, key);
for (int i = 0; i < Result.Count(); i++)
{
Assert.AreEqual(Result[i], ExpectedResult[i]);
}
}
private void bSave_OnClick(object sender, RoutedEventArgs e)
{
int final = 0, archive = 0;
Int32.TryParse(myCommon.updateFinal, out final);
Int32.TryParse(myCommon.updateArchive, out archive);
FileStream fs = new FileStream($"{System.AppDomain.CurrentDomain.BaseDirectory}CardRoute.xml", FileMode.Create);
XmlTextWriter w = new XmlTextWriter(fs, Encoding.UTF8);
w.Formatting = Formatting.Indented;
w.WriteStartDocument();
w.WriteStartElement("Settings");
w.WriteStartElement("Common");
w.WriteElementString("Timeout", $"{myCommon.timeout}");
w.WriteElementString("Language", $"{myCommon.language}");
w.WriteElementString("Protocol", $"{myCommon.protocol}");
if (final > 0 || archive > 0)
{
w.WriteStartElement("CardUpdates");
w.WriteAttributeString("FinalMinutes", $"{final}");
w.WriteAttributeString("ArchiveDays", $"{archive}");
w.WriteEndElement();
}
w.WriteEndElement();
w.WriteStartElement("Database");
w.WriteElementString("providerName", $"System.Data.SqlClient");
w.WriteElementString("server", $"{mySqlServer.serverName}");
w.WriteElementString("name", $"{mySqlServer.DbName}");
w.WriteElementString("uid", $"{mySqlServer.Uid}");
w.WriteElementString("password", MyCrypto.TripleDES_EncryptData(Utils.String2AHex(tbPwd.Password), pwd, CipherMode.ECB, PaddingMode.Zeros));
w.WriteEndElement();
w.WriteStartElement("Cdp");
w.WriteElementString("Console", $"{myCdp.CdpConsole}");
w.WriteElementString("IniFolder", $"{myCdp.CdpIniFolder}");
w.WriteElementString("InFile", $"{myCdp.CdpDefaultIn}");
w.WriteElementString("CdpIni", $"{myCdp.CdpDefaultIni}");
w.WriteEndElement();
w.WriteStartElement("HS");
w.WriteAttributeString("Ip", $"{myPerso.Ip}");
w.WriteAttributeString("Port", $"{myPerso.Port}");
w.WriteAttributeString("Log", $"{myPerso.Log}");
if (!String.IsNullOrEmpty(myPerso.Path))
{
w.WriteElementString("Application", $"{myPerso.Path}");
}
w.WriteEndElement();
w.WriteEndElement();
w.Flush();
fs.Close();
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// Сбои при входе не приводят к блокированию учетной записи
// Чтобы ошибки при вводе пароля инициировали блокирование учетной записи, замените на shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
//string cookieValue = MyCrypto.Shifrovka(model.Email);
//SetCookie("MyAuth", cookieValue);
//cookieValue = MyCrypto.Shifrovka(model.Password);
//SetCookie("MyPWD", cookieValue);
//Создание AbzHash. Хранение по новому 03.07.2019
ApplicationDbContext db = new ApplicationDbContext();
AbzHash abzHash = new AbzHash();
abzHash.AbzHashID = Guid.NewGuid().ToString();
SetCookie("Auth", abzHash.AbzHashID);
abzHash.Email = MyCrypto.Shifrovka(model.Email);
abzHash.Password = MyCrypto.Shifrovka(model.Password);
abzHash.TerminationDate = DateTime.Now.AddDays(2);
string ip = HttpContext.Request.UserHostAddress;
abzHash.IP = ip;
db.AbzHashs.Add(abzHash);
db.SaveChanges();
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Неудачная попытка входа.");
return(View(model));
}
}
public void AESinECB_Test() //ECB = Electronic Codebook
{
//https://cryptopals.com/sets/1/challenges/7
string str = Util.GetFile(7);
string Hex = MyConvert.Base64ToHex(str);
var bytes = MyConvert.HexToByteArray(Hex);
string key = "YELLOW SUBMARINE";
string HexKey = MyConvert.HexEncodePlainText(key);
var Keybytes = MyConvert.HexToByteArray(HexKey);
var result = MyCrypto.AES_ECB_Decrypt(bytes, Keybytes);
var HexResult = MyConvert.BytesToHex(result);
var Plain = MyConvert.HexToAscii(HexResult);
Assert.IsTrue("I'm back and I'm ringin' " == Plain.Substring(0, 25));
}
public async Task <OrderView> GetNew(AbzHash abzHash, int invoice)
//public async Task<Order> GetNew(AbzHash abzHash,int invoice)
{
Order order = new Order();
order.CustId = (int)abzHash.CustID;
order.ContractId = abzHash.ContractID;
order.email = MyCrypto.DeShifrovka(abzHash.Email);
order.insDate = DateTime.Now;
order.DateExec = DateTime.Now.AddDays(1);
order.Dat = DateTime.Now.AddDays(1);
order.AdresId = 1;
order.Invoice = invoice;
db.Orders.Add(order);
await db.SaveChangesAsync();
return(await GetChange(order.OrderId));
//return order;
}
public void AESinECB_Encrypt_Decrypt_Test() //ECB = Electronic Codebook
{
string OriginalMessage = "Now is the time for all good men to come to the aid of their country";
var bytes = MyConvert.TextToByteArray(OriginalMessage);
var PaddedBytes = Pad.AddPkcs7(bytes, 128); //Pad the message to 128 bytes
//The Key (16 bytes)
string key = "YELLOW SUBMARINE";
string HexKey = MyConvert.HexEncodePlainText(key);
var Keybytes = MyConvert.HexToByteArray(HexKey);
//Encrypt
var CiperBytes = MyCrypto.AES_ECB_Encrypt(PaddedBytes, Keybytes);
//Decrypt
var PlainBytes = MyCrypto.AES_ECB_Decrypt(CiperBytes, Keybytes);
var UnPaddedBytes = Pad.RemovePkcs7(PlainBytes); //Unpad the message
var hexPlain = MyConvert.BytesToHex(UnPaddedBytes);
var PlainText = MyConvert.HexToAscii(hexPlain);
Assert.IsTrue(OriginalMessage == PlainText);
}
private void InitializeMyComponents()
{
crypto = new MyCrypto();
ioTools = new IOTools();
}
