public static CompareResult Compare(Bitmap bmp1, Bitmap bmp2)
{
CompareResult cr = CompareResult.ciCompareOk;
//Test to see if we have the same size of image
if (bmp1.Size != bmp2.Size)
{
cr = CompareResult.ciSizeMismatch;
}
else
{
//Convert each image to a byte array
System.Drawing.ImageConverter ic = new System.Drawing.ImageConverter();
byte[] btImage1 = new byte[1];
btImage1 = (byte[])ic.ConvertTo(bmp1, btImage1.GetType());
byte[] btImage2 = new byte[1];
btImage2 = (byte[])ic.ConvertTo(bmp2, btImage2.GetType());
//Compute a hash for each image
SHA256Managed shaM = new SHA256Managed();
byte[] hash1 = shaM.ComputeHash(btImage1);
byte[] hash2 = shaM.ComputeHash(btImage2);
//Compare the hash values
for (int i = 0; i < hash1.Length && i < hash2.Length && cr == CompareResult.ciCompareOk; i++)
{
if (hash1[i] != hash2[i])
cr = CompareResult.ciPixelMismatch;
}
shaM.Clear();
}
return cr;
}
private static SqlDataRecord FillRecord(Int32 pk, SqlDataRecord record)
{
Int32 age = SlowRandom(16, 99);
string sourceString = "Age: " + age.ToString();
DateTime sourceDate = DateTime.UtcNow;
var data = /*salt + */sourceString;
string key = "Top Secret Key";
var encData = AES.EncryptBytes(data, key);
//var encDataBytes = Encoding.Unicode.GetBytes(encData);
var decData = AES.DecryptBytes(encData, key);
var sha = new SHA256Managed();
byte[] dataSHA256 = sha.ComputeHash(encData/*Bytes*/);
sha.Dispose();
// конвертирую хеш из byte[16] в строку шестнадцатиричного формата
// (вида «3C842B246BC74D28E59CCD92AF46F5DA»)
// это опциональный этап, если вам хеш нужен в строковом виде
// string sha512hex = BitConverter.ToString(dataSHA512).Replace("-", string.Empty);
record.SetInt32(0, pk);
record.SetDateTime(1, sourceDate);
record.SetString(2, sourceString);
record.SetString(3, Convert.ToBase64String(dataSHA256)); // sha256
record.SetString(4, Convert.ToBase64String(encData)); // Encrypted
record.SetString(5, decData); // Decrypted
return record;
}
static Boolean Test()
{
Console.WriteLine("Testing SHA256 hash...");
SimpleHash sh = new SimpleHash();
SHA256 sha = new SHA256Managed();
return sh.TestAlgorithm(sha);
}
public HMACSHA256 (byte[] key) {
m_hashName = "SHA256";
m_hash1 = new SHA256Managed();
m_hash2 = new SHA256Managed();
HashSizeValue = 256;
base.InitializeKey(key);
}
//hashes the string
public static byte[] sha256(string password)
{
var crypt = new SHA256Managed();
string hash = String.Empty;
byte[] crypto = crypt.ComputeHash(Encoding.UTF8.GetBytes(password), 0, Encoding.UTF8.GetByteCount(password));
return crypto;
}
/// <summary>
/// Initialize the cipher.
/// </summary>
/// <param name="key"></param>
public Cipher(String key)
{
using (SHA256Managed SHA = new SHA256Managed())
{
AES = new RijndaelManaged();
AES.Key = SHA.ComputeHash(Encoding.ASCII.GetBytes(key));
AES.IV = new Byte[16];
}
}
// original, samo copy-paste
public static string SHA256(string input)
{
SHA256 sha256 = new SHA256Managed();
byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(input);
byte[] hash = sha256.ComputeHash(inputBytes);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
sb.Append(hash[i].ToString("X2"));
return sb.ToString();
}
public static string EncryptText(string input)
{
// Get the bytes of the string
SHA256 sha256 = new SHA256Managed();
byte[] b = sha256.ComputeHash(Encoding.UTF8.GetBytes(input));
string result = BitConverter.ToString(b);
return result;
}
public static string Encrypt(string input)
{
SHA256Managed cypher = new SHA256Managed();
string hash = "";
byte[] crypto = cypher.ComputeHash(System.Text.Encoding.UTF8.GetBytes(input), 0, System.Text.Encoding.UTF8.GetByteCount(input));
foreach (byte a in crypto)
{
hash += a.ToString("x2");
}
return hash;
}
public static string KriptirajMe(string txt)
{
//Ugrađena .NET biblioteka za kriptiranje
SHA256Managed sha = new SHA256Managed();
//Pretvorimo text u niz bajtova da bi kriptirali
byte[] poljeBajtova = Encoding.UTF8.GetBytes(txt);
//Idemoooo
byte[] poljeRezultata = sha.ComputeHash(poljeBajtova);
// Vrati rez kao string
return Convert.ToBase64String(poljeRezultata);
}
protected string hashMe(string ulazni)
{
//kreiraj objekt koji će hashitrat sa SHA256
SHA256Managed algoritam = new SHA256Managed();
//prebaci string u polje bajtova
byte[] poljeBajtova = System.Text.Encoding.ASCII.GetBytes(ulazni);
//hashiraj polje bajtova
byte[] rezultatHashiranja = algoritam.ComputeHash(poljeBajtova);
//vrati nazad u base64 string(samo slova i brojevi...)
return Convert.ToBase64String(rezultatHashiranja);
}
public static string hash(string tekst)
{
//SHA hashing algorithm
SHA256Managed algoritam = new SHA256Managed();
//Get bytes from string
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(tekst);
//Execute hashing
byte[] resultBytes = algoritam.ComputeHash(bytes);
//return as string
return Convert.ToBase64String(resultBytes);
}
SHA256Managed (SHA256Managed other)
{
count = other.count;
_H = new uint [other._H.Length];
Array.Copy (other._H, _H, _H.Length);
_ProcessingBufferCount = other._ProcessingBufferCount;
_ProcessingBuffer = new byte [other._ProcessingBuffer.Length];
Array.Copy (other._ProcessingBuffer, _ProcessingBuffer, _ProcessingBuffer.Length);
buff = new uint [other.buff.Length];
Array.Copy (other.buff, buff, buff.Length);
}
/**
* This function calculates the Sha 256 of the text
* passed to it.
**/
public static string getHashSha256(string text)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
SHA256Managed hashstring = new SHA256Managed();
byte[] hash = hashstring.ComputeHash(bytes);
string hashString = string.Empty;
foreach (byte x in hash)
{
hashString += String.Format("{0:x2}", x);
}
return hashString;
}
static void _Main(string[] args)
{
// Get path+filename of this executable (i.e. argv[0])
string argv0 = Path.GetFileName(Process.GetCurrentProcess().MainModule.FileName);
// Check args
if (args.Length < 2) {
Console.WriteLine("Usage: pin label [count [wait-in-milliseconds]]\r\nSign this executable ({0}).", argv0);
return;
}
// Parse optional args
int count, wait;
if (args.Length < 3 || !int.TryParse(args[2], out count))
count = 1;
if (args.Length < 4 || !int.TryParse(args[3], out wait))
wait = 10000;
// Create a SHA-256 hash of this executable
byte[] buf = File.ReadAllBytes(argv0);
#if MANAGED
SHA256Managed sha256 = new SHA256Managed();
byte[] hash = sha256.ComputeHash(buf, 0, buf.Length);
#else
byte[] ctx = new byte[104]; // 104 => sizeof(sha256_ctx)
byte[] hash = new byte[ 32]; // 32 => 256-bit sha256
sha256_starts(ctx);
sha256_update(ctx, buf, (uint)buf.Length);
sha256_finish(ctx, hash);
#endif
// Sign the hash of this executable n times, where n = count
try {
for (int i = 0; i < count; i++) {
if (i > 0 && count > 1) {
Console.WriteLine("wait {0} milliseconds for next signature", wait);
Thread.Sleep(wait);
}
IntPtr pCms;
long start = Environment.TickCount;
int len = sign_hash(args[0], args[1], hash, hash.Length, out pCms);
long end = Environment.TickCount;
Console.WriteLine("sign_hash returned: {0}, time used: {1} ms", len, end - start);
if (len > 0) {
byte[] cms = new byte[len];
Marshal.Copy(pCms, cms, 0, cms.Length);
File.WriteAllBytes(argv0 + ".p7s", cms);
}
}
} finally {
release_template();
}
}
public static string hashHash(string pojam)
{
//Racunam dajte mi string da ga hashiram
SHA256Managed sha = new SHA256Managed();
//Treba mi polje bajtova za hashiranje
byte[] poljeBajtova = Encoding.UTF8.GetBytes(pojam);
//sad možemo hashirati
byte[] rezultat = sha.ComputeHash(poljeBajtova);
//vrati nazad kao string
return Convert.ToBase64String(rezultat);
}
/// <summary>
/// Generate the SHA256 hash from a passed string value
/// </summary>
public static string ComputeHash(string stringValue)
{
SHA256Managed shaM = new SHA256Managed();
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
string correctPasswordHash = BitConverter.ToString(shaM.ComputeHash(enc.GetBytes(stringValue)));
// hash value cleanup
correctPasswordHash = correctPasswordHash.Replace("-", string.Empty).ToLower();
return correctPasswordHash;
}
private static byte[] GetBytes(byte[] password, byte[] salt, int iterations, int howManyBytes)
{
// round up
uint cBlocks = (uint)((howManyBytes + HASH_SIZE_IN_BYTES - 1) / HASH_SIZE_IN_BYTES);
// seed for the pseudo-random fcn: salt + block index
byte[] saltAndIndex = new byte[salt.Length + 4];
Array.Copy(salt, 0, saltAndIndex, 0, salt.Length);
byte[] output = new byte[cBlocks * HASH_SIZE_IN_BYTES];
int outputOffset = 0;
SHA256Managed innerHash = new SHA256Managed();
SHA256Managed outerHash = new SHA256Managed();
// HMAC says the key must be hashed or padded with zeros
// so it fits into a single block of the hash in use
if (password.Length > BLOCK_SIZE_IN_BYTES)
{
password = innerHash.ComputeHash(password);
}
byte[] key = new byte[BLOCK_SIZE_IN_BYTES];
Array.Copy(password, 0, key, 0, password.Length);
byte[] InnerKey = new byte[BLOCK_SIZE_IN_BYTES];
byte[] OuterKey = new byte[BLOCK_SIZE_IN_BYTES];
for (int i = 0; i < BLOCK_SIZE_IN_BYTES; ++i)
{
InnerKey[i] = (byte)(key[i] ^ IPAD);
OuterKey[i] = (byte)(key[i] ^ OPAD);
}
// for each block of desired output
for (int iBlock = 0; iBlock < cBlocks; ++iBlock)
{
// seed HMAC with salt & block index
_incrementBigEndianIndex(saltAndIndex, salt.Length);
byte[] U = saltAndIndex;
for (int i = 0; i < iterations; ++i)
{
// simple implementation of HMAC-SHA-256
innerHash.Initialize();
innerHash.TransformBlock(InnerKey, 0, BLOCK_SIZE_IN_BYTES, InnerKey, 0);
innerHash.TransformFinalBlock(U, 0, U.Length);
byte[] temp = innerHash.Hash; outerHash.Initialize();
outerHash.TransformBlock(OuterKey, 0, BLOCK_SIZE_IN_BYTES, OuterKey, 0);
outerHash.TransformFinalBlock(temp, 0, temp.Length);
U = outerHash.Hash;
// U = result of HMAC
// xor result into output buffer
_xorByteArray(U, 0, HASH_SIZE_IN_BYTES, output, outputOffset);
}
outputOffset += HASH_SIZE_IN_BYTES;
}
byte[] result = new byte[howManyBytes];
Array.Copy(output, 0, result, 0, howManyBytes);
return result;
}
protected void Button_Login_Click(object sender, EventArgs e)
{
var salt = "";
string kode = "";
SqlConnection conn = new SqlConnection(MyConnectionString.ConnectionString); // MyConnectionString.ConnectionString er fra en class som gør det lettere og skrive sin connectionstring.
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn; // Standard connection til din database.
cmd.CommandText = @"
SELECT bruger_id, bruger_navn, bruger_email, bruger_password, bruger_salt, rolle_adgang
FROM bruger INNER JOIN rolle ON rolle_id = fk_rolle_id
WHERE
bruger_email = @bruger_email"; // Din CommandText hvor du fortæller hvad den skal loade fra db.
cmd.Parameters.AddWithValue("@bruger_email", TextBox_Email.Text);
conn.Open();
SqlDataReader reader = cmd.ExecuteReader();
if (reader.Read())
{
salt = reader["bruger_salt"].ToString(); // Henter salt fra db. Salt bruges til når man skal krypterer koden så sætter man salt bag ved koden og så kryptere man koden.
// Så hvis der er 2 der har koden 123, så er deres kode ikke ens efter den er krypteret.
kode = reader["bruger_password"].ToString(); // Henter password fra db så vi kan se om koden er ens.
var password = TextBox_Password.Text; // Tager koden som er indtastet i texboxen.
UTF8Encoding encoder = new UTF8Encoding(); // Gør klar så vi encoder koden om til UTF8.
SHA256Managed sha256hasher = new SHA256Managed(); // Gør klar til at lave kryptering.
byte[] hashedDataBytes = sha256hasher.ComputeHash(encoder.GetBytes(password + salt)); // Her sætter vi koden (textboxen) og salted (fra db) og laver det til bytes efter, da ComputeHash kun kan bruge bytes.
StringBuilder hash = new StringBuilder(""); // Laver en string builder så vi kan samle alle bytes til en string.
for (int i = 0; i < hashedDataBytes.Length; i++) // For hver bytes
hash.Append(hashedDataBytes[i].ToString("X2")); // Her laver vi bytesne om til Hexadecimal.
if (hash.ToString() == kode) // Nu tjekker vi om de koder er ens. Vi blev nød til at kryptere koden (fra texboxen) da koden fra db er kryptere og vi ikke kan dekryptere koden.
{
Session["bruger_id"] = reader["bruger_id"]; // Hvis koden er ens laver vi en masse sessions, så vi kan bruge dem hvis vi får brug for dem.
Session["bruger_navn"] = reader["bruger_navn"];
Session["bruger_email"] = reader["bruger_email"];
Session["rolle_adgang"] = reader["rolle_adgang"];
Session.Remove("besked");
Response.Redirect(ResolveClientUrl("~/Admin/Default.aspx"));
}
else // Hvis koden ikke er ens.
{
Label_Errors.Text = "Forkert Email eller Password";
Label_Errors.Visible = true;
}
}
else // Hvis emailen ikke er findes. Af sikkerheds mæssige grunde fortæller vi ikke at det er emailen som er forkert.
{
Label_Errors.Text = "Forkert Email eller Password";
Label_Errors.Visible = true;
}
conn.Close();
}
public static string hashSHA256(string unhashedValue)
{
SHA256Managed shaM = new SHA256Managed();
byte[] hash =
shaM.ComputeHash(Encoding.ASCII.GetBytes(unhashedValue));
StringBuilder stringBuilder = new StringBuilder();
foreach (byte b in hash)
{
stringBuilder.AppendFormat("{0:x1}", b);
}
return stringBuilder.ToString();
}
//Function to convert password string into a SHA256 Hexadecimal Hash
public static string GetSha256FromString(string strData)
{
var message = Encoding.ASCII.GetBytes(strData);
SHA256Managed hashString = new SHA256Managed();
string hex = "";
var hashValue = hashString.ComputeHash(message);
foreach (byte x in hashValue)
{
hex += String.Format("{0:x2}", x);
}
return hex;
}
public string hashiraj(string ulaz)
{
//Dohvati algoritam za hashiranje, neka bude SHA256
SHA256 algoritam = new SHA256Managed();
// pretvori ulazni string u niz byte-ova koji će se kodirati
byte[] ulazBajtovi = System.Text.Encoding.ASCII.GetBytes(ulaz);
//kodiraj i preimi novi niz byte-ova koji sadrže hashiran niz
byte[] izlazBajtovi = algoritam.ComputeHash(ulazBajtovi);
//pretvori ponovo u string i vrati rezultat
return Convert.ToBase64String(izlazBajtovi);
}
public static void Main(String[] args)
{
//calculate caninicalized xml
var t = new XmlDsigEnvelopedSignatureTransform(false);
XmlDocument doc = new XmlDocument();
//doc.PreserveWhitespace = true;
doc.Load(@"c:\temp\x.xml");
t.LoadInput(doc);
FieldInfo field = t.GetType().GetField("_signaturePosition",
BindingFlags.NonPublic |
BindingFlags.Instance);
field.SetValue(t, 1);
var res = (XmlDocument)t.GetOutput();
var s = res.OuterXml;
var c14 = new XmlDsigC14NTransform();
c14.LoadInput(res);
var mem = (MemoryStream)c14.GetOutput();
var sha = new SHA256Managed();
var byte1 = c14.GetDigestedOutput(new SHA256Managed());
var digest1 = Convert.ToBase64String(byte1);
var byte2 = sha.ComputeHash(mem.ToArray());
var digest2 = Convert.ToBase64String(byte2);
var s1 = System.Text.Encoding.UTF8.GetString(mem.ToArray());
var byte3 = sha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(s1));
var digest3 = Convert.ToBase64String(byte3);
//return;
//validate signature
CryptoConfig.AddAlgorithm(typeof(RSAPKCS1SHA256SignatureDescription), "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(@"c:\temp\x.xml");
XmlNode node = xmlDoc.DocumentElement;
X509Certificate2 cert = new X509Certificate2(File.ReadAllBytes(@"c:\temp\x.cer"));
bool isValid = ValidateXml(xmlDoc, cert);
//return;
//calc hash
var sha1 = new SHA256Managed();
var b1 = sha1.ComputeHash(System.Text.Encoding.UTF8.GetBytes(File.ReadAllText(@"c:\temp\x_no_sig.xml")));
var b64 = Convert.ToBase64String(b1);
}
public HMACSHA256 (byte[] key) {
m_hashName = "SHA256";
#if FEATURE_CRYPTO
m_hash1 = GetHashAlgorithmWithFipsFallback(() => new SHA256Managed(), () => HashAlgorithm.Create("System.Security.Cryptography.SHA256CryptoServiceProvider"));
m_hash2 = GetHashAlgorithmWithFipsFallback(() => new SHA256Managed(), () => HashAlgorithm.Create("System.Security.Cryptography.SHA256CryptoServiceProvider"));
#else
m_hash1 = new SHA256Managed();
m_hash2 = new SHA256Managed();
#endif // FEATURE_CRYPTO
HashSizeValue = 256;
base.InitializeKey(key);
}
public static string hashFile(string filePath)
{
using (var c = new SHA256Managed()) {
using (var f = new FileStream(filePath, FileMode.Open))
{
byte[] hash = c.ComputeHash(f);
StringBuilder sb = new StringBuilder();
foreach (byte b in hash) {
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
}
/*
*pHash - is the Hash Returned from the Credit Service. You need to URLDecode the value before passing it in.
*pSecretValue - the secret key issued when you registered at the Credit Gateway
*pAppId - the appid issued to you when you registered at the credit gateway
*pTransId - the transaction id your system issues to identify the purchase
*pTransAmount - the value you are charging for this transaction
*pAppStatus - The status of the credit transaction. Values : A = Accepted, D = Denied
*/
public static bool VerifyServerResponseHash(String pHash, String pSecretValue, String pAppId, String pTransId, String pTransAmount, String pAppStatus)
{
String secretPartA = pSecretValue.Substring(0, 5);
String secretPartB = pSecretValue.Substring(5, 5);
String val = secretPartA + "-" + pAppId + "-" + pTransId + "-" + pTransAmount + "-" + pAppStatus + "-" + secretPartB;
var pwdBytes = Encoding.UTF8.GetBytes(val);
SHA256 hashAlg = new SHA256Managed();
hashAlg.Initialize();
var hashedBytes = hashAlg.ComputeHash(pwdBytes);
var hash = Convert.ToBase64String(hashedBytes);
if (hash == pHash)
return true;
else
return false;
}
static Boolean Test()
{
Boolean bRes = true;
Byte[] abData1 = { (Byte)'a', (Byte)'b', (Byte)'c' };
Byte[] abDigest1 = {0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad};
String sData2 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
Byte[] abData2 = new Byte[sData2.Length];
for (int i=0; i<sData2.Length; i++) abData2[i] = (Byte)sData2[i];
Byte[] abDigest2 = {0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8,
0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39,
0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1};
Console.WriteLine("Testing SHA1 hash...");
SHA256Managed sha1 = new SHA256Managed();
SHA256Managed sha2 = new SHA256Managed();
sha1.ComputeHash(abData1);
sha2.ComputeHash(abData2);
Console.WriteLine("The computed hash #1 is : ");
PrintByteArray(sha1.Hash);
Console.WriteLine("The correct hash #1 is : ");
PrintByteArray(abDigest1);
if(Compare(sha1.Hash, abDigest1)) {
Console.WriteLine("CORRECT");
} else {
Console.WriteLine("INCORRECT");
bRes = false;
}
Console.WriteLine("The computed hash #2 is : ");
PrintByteArray(sha2.Hash);
Console.WriteLine("The correct hash #2 is : ");
PrintByteArray(abDigest2);
if(Compare(sha2.Hash, abDigest2)) {
Console.WriteLine("CORRECT");
} else {
Console.WriteLine("INCORRECT");
bRes = false;
}
return bRes;
}
string Decrypt(string coded, string key)
{
RijndaelManaged cryptProvider = new RijndaelManaged();
cryptProvider.KeySize = 256;
cryptProvider.BlockSize = 256;
cryptProvider.Mode = CipherMode.CBC;
SHA256Managed hashSHA256 = new SHA256Managed();
cryptProvider.Key = hashSHA256.ComputeHash(ASCIIEncoding.ASCII.GetBytes(key));
string iv = "user";
cryptProvider.IV = hashSHA256.ComputeHash(ASCIIEncoding.ASCII.GetBytes(iv));
byte[] cipherTextByteArray = Convert.FromBase64String(coded);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, cryptProvider.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(cipherTextByteArray, 0, cipherTextByteArray.Length);
cs.FlushFinalBlock();
cs.Close();
byte[] byt = ms.ToArray();
return Encoding.ASCII.GetString(byt);
}
/// <summary>
/// Tjekker om man har indtastet al infomation og tilføjer en bruger.
/// </summary>
protected void Button_Save_Click(object sender, EventArgs e)
{
var fejl = false;
if (TextBox_Name.Text == "") // Hvis TexBoxen er tom.
{
fejl = true; // Fortæller en der er sket en fejl så den ikke prøve og tilføje brugeren.
eName.Attributes.Add("class", "form-group has-error"); // Gør TexBoxen rød så man kan se at det er den der er problemet.
}
if (TextBox_Email.Text == "") // Hvis TexBoxen er tom.
{
fejl = true; // Fortæller en der er sket en fejl så den ikke prøve og tilføje brugeren.
eEmail.Attributes.Add("class", "form-group has-error");// Gør TexBoxen rød så man kan se at det er den der er problemet.
}
if (!fejl) // Hvis der ikke sker en fejl så skal den udfører dette.
{
var salt = Guid.NewGuid().ToString(); // Opretter et salt som er unique som bruges til at tilføje efter koden.
var password = TextBox_Password.Text; // Tager koden som er indtastet i texboxen.
UTF8Encoding encoder = new UTF8Encoding(); // Gør klar så vi encoder koden om til UTF8.
SHA256Managed sha256hasher = new SHA256Managed(); // Gør klar til at lave kryptering.
byte[] hashedDataBytes = sha256hasher.ComputeHash(encoder.GetBytes(password + salt)); // Her sætter vi koden (textboxen) og salted (fra db) og laver det til bytes efter, da ComputeHash kun kan bruge bytes.
StringBuilder hash = new StringBuilder(""); // Laver en string builder så vi kan samle alle bytes til en string.
for (int i = 0; i < hashedDataBytes.Length; i++) // For hver bytes
hash.Append(hashedDataBytes[i].ToString("X2")); // Her laver vi bytesne om til Hexadecimal.
var cmd = new SqlCommand();
var conn = new SqlConnection(MyConnectionString.ConnectionString); // MyConnectionString.ConnectionString er fra en class som gør det lettere og skrive sin connectionstring.
cmd.Connection = conn; // Standard connection til din database.
cmd.CommandText = cmd.CommandText = "INSERT INTO bruger (bruger_navn, bruger_email, bruger_password, bruger_salt, fk_rolle_id, bruger_dato) VALUES (@1, @2, @3, @4, @5, @6)"; // Din CommandText hvor du fortæller hvad den skal loade fra db.
cmd.Parameters.AddWithValue("@1", TextBox_Name.Text); // Dit parameter som laver sikkerhed for sql injection.
cmd.Parameters.AddWithValue("@2", TextBox_Email.Text);
cmd.Parameters.AddWithValue("@3", hash.ToString());
cmd.Parameters.AddWithValue("@4", salt);
cmd.Parameters.AddWithValue("@5", DropDownList_Role.SelectedValue);
cmd.Parameters.AddWithValue("@6", DateTime.Now);
conn.Open(); // Åbner din connection så så du kan Execute og få din data ud.
cmd.ExecuteNonQuery(); // Gør hvad du fortæller den skal gøre som står i din CommandText.
conn.Close(); // Lukker din connection så den ved at du ikke skal bruge mere data.
Response.Redirect("OprerBruger.aspx"); // Sender personen til siden igen så der ikke er daten som lige er blevet sendt.
}
}
/*
*pSecretValue - the secret key issued when you registered at the Credit Gateway
*pAppId - the appid issued to you when you registered at the credit gateway
*pTransId - the transaction id your system issues to identify the purchase
*pTransAmount - the value you are charging for this transaction
*/
public static String GenerateClientRequestHash(String pSecretValue, String pAppId, String pTransId, String pTransAmount)
{
try
{
String secretPartA = pSecretValue.Substring(0, 5);
String secretPartB = pSecretValue.Substring(5, 5);
String val = secretPartA + "-" + pAppId + "-" + pTransId + "-" + pTransAmount + "-" + secretPartB;
var pwdBytes = Encoding.UTF8.GetBytes(val);
SHA256 hashAlg = new SHA256Managed();
hashAlg.Initialize();
var hashedBytes = hashAlg.ComputeHash(pwdBytes);
var hash = Convert.ToBase64String(hashedBytes);
return hash;
}
catch (Exception)
{
return null;
}
}
public static unsafe void Save(string path)
{
string idx = Path.Combine(path, "texidx.mul");
string mul = Path.Combine(path, "texmaps.mul");
_checkSums = new List <Checksums>();
using (var fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write))
using (var fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
{
var memidx = new MemoryStream();
var memmul = new MemoryStream();
using (BinaryWriter binidx = new BinaryWriter(memidx), binmul = new BinaryWriter(memmul))
{
var sha = new SHA256Managed();
//StreamWriter Tex = new StreamWriter(new FileStream("d:/texlog.txt", FileMode.Create, FileAccess.ReadWrite));
for (int index = 0; index < GetIdxLength(); ++index)
{
if (_cache[index] == null)
{
_cache[index] = GetTexture(index);
}
Bitmap bmp = _cache[index];
if ((bmp == null) || (_removed[index]))
{
binidx.Write(-1); // lookup
binidx.Write(0); // length
binidx.Write(-1); // extra
}
else
{
var ms = new MemoryStream();
bmp.Save(ms, ImageFormat.Bmp);
byte[] checksum = sha.ComputeHash(ms.ToArray());
if (compareSaveImages(checksum, out Checksums sum))
{
binidx.Write(sum.pos); //lookup
binidx.Write(sum.length);
binidx.Write(0);
//Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, (int)sum.pos, (int)sum.length));
//Tex.WriteLine(System.String.Format("0x{0:X4} -> 0x{1:X4}", sum.index, index));
continue;
}
BitmapData bd = bmp.LockBits(
new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly,
PixelFormat.Format16bppArgb1555);
var line = (ushort *)bd.Scan0;
int delta = bd.Stride >> 1;
binidx.Write((int)binmul.BaseStream.Position); //lookup
var length = (int)binmul.BaseStream.Position;
for (int y = 0; y < bmp.Height; ++y, line += delta)
{
ushort *cur = line;
for (int x = 0; x < bmp.Width; ++x)
{
binmul.Write((ushort)(cur[x] ^ 0x8000));
}
}
int start = length;
length = (int)binmul.BaseStream.Position - length;
binidx.Write(length);
binidx.Write((bmp.Width == 64 ? 0 : 1));
bmp.UnlockBits(bd);
var s = new Checksums {
pos = start, length = length, checksum = checksum, index = index
};
//Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, start, length));
_checkSums.Add(s);
}
}
memidx.WriteTo(fsidx);
memmul.WriteTo(fsmul);
}
}
}
public static string cashAddrToOldAddr(string cashAddr, out bool isP2PKH, out bool mainnet)
{
cashAddr = cashAddr.ToLower();
if (cashAddr.Length != 54 && cashAddr.Length != 42 && cashAddr.Length != 50)
{
if (cashAddr.StartsWith("bchreg:"))
{
throw new CashAddrConversionException("Decoding RegTest addresses is not implemented.");
}
throw new CashAddrConversionException("Address to be decoded is longer or shorter than expected.");
}
int afterPrefix;
if (cashAddr.StartsWith("bitcoincash:"))
{
mainnet = true;
afterPrefix = 12;
}
else if (cashAddr.StartsWith("bchtest:"))
{
mainnet = false;
afterPrefix = 8;
}
else if (cashAddr.StartsWith("bchreg:"))
{
throw new CashAddrConversionException("Decoding RegTest addresses is not implemented.");
}
else
{
if (cashAddr.IndexOf(":") == -1)
{
mainnet = true;
afterPrefix = 0;
}
else
{
throw new CashAddrConversionException("Unexpected colon character.");
}
}
int max = afterPrefix + 42;
if (max != cashAddr.Length)
{
throw new CashAddrConversionException("Address to be decoded is longer or shorter than expected.");
}
byte[] decodedBytes = new byte[42];
for (int i = afterPrefix; i < max; i++)
{
int value = DICT_CASHADDR[cashAddr[i]];
if (value != -1)
{
decodedBytes[i - afterPrefix] = (byte)value;
}
else
{
throw new CashAddrConversionException("Address contains unexpected character.");
}
}
if (PolyMod(decodedBytes, (ulong)(mainnet ? 1058337025301 : 584719417569)) != 0)
{
throw new CashAddrConversionException("Address checksum doesn't match. Have you made a mistake while typing it?");
}
decodedBytes = convertBitsFiveToEight(decodedBytes);
switch (decodedBytes[0])
{
case 0x00:
isP2PKH = true;
break;
case 0x08:
isP2PKH = false;
break;
default:
throw new CashAddrConversionException("Unexpected address byte.");
}
if (mainnet && isP2PKH)
{
decodedBytes[0] = 0x00;
}
else if (mainnet && !isP2PKH)
{
decodedBytes[0] = 0x05;
}
else if (!mainnet && isP2PKH)
{
decodedBytes[0] = 0x6f;
}
else
{
// Warning! Bigger than 0x80.
decodedBytes[0] = 0xc4;
}
SHA256 hasher = SHA256Managed.Create();
byte[] checksum = hasher.ComputeHash(hasher.ComputeHash(decodedBytes, 0, 21));
decodedBytes[21] = checksum[0];
decodedBytes[22] = checksum[1];
decodedBytes[23] = checksum[2];
decodedBytes[24] = checksum[3];
System.Text.StringBuilder ret = new System.Text.StringBuilder(40);
for (int numZeros = 0; numZeros < 25 && decodedBytes[numZeros] == 0; numZeros++)
{
ret.Append("1");
}
{
var temp = new List <byte>(decodedBytes);
// for 0xc4
temp.Insert(0, 0);
temp.Reverse();
decodedBytes = temp.ToArray();
}
byte[] retArr = new byte[40];
int retIdx = 0;
BigInteger baseChanger = BigInteger.Abs(new BigInteger(decodedBytes));
BigInteger baseFiftyEight = new BigInteger(58);
BigInteger modulo = new BigInteger();
while (!baseChanger.IsZero)
{
baseChanger = BigInteger.DivRem(baseChanger, baseFiftyEight, out modulo);
retArr[retIdx++] = (byte)modulo;
}
for (retIdx--; retIdx >= 0; retIdx--)
{
ret.Append(CHARSET_BASE58[retArr[retIdx]]);
}
return(ret.ToString());
}
public void WriteXMLDataToFile(string string_XMLFilePath)
{
FileStream fileStream_ServerDB = File.Create(string_XMLFilePath);
MemoryStream memoryStream_XMLData = new MemoryStream(),
memoryStream_EncryptedXMLData = new MemoryStream();
SHA256Managed sHA256Managed_obj = new SHA256Managed();
RijndaelManaged rijndaelManaged_obj = new RijndaelManaged();
CryptoStream cryptoStream_obj = null;
byte[] byteArray_ComputedXMLDataHash = new byte[32], byteArray_PasswordHash = new byte[32],
byteArray_EncryptedData = null, byteArray_CompressedXMLData,
byteArray_HashOfPasswordHash = new byte[32];
byte byte_ToEncryptServerDataBase = 0, byte_ToCompressSettingsDataBase = 0;
ConnectingServiceDB.WriteXml(memoryStream_XMLData);
if (CommonEnvironment.EncryptSettingsDataBase == true)
{
byte_ToEncryptServerDataBase = 1;
}
if (CommonEnvironment.CompressSettingsDataBase == true)
{
byte_ToCompressSettingsDataBase = 1;
}
if (CommonEnvironment.CompressSettingsDataBase == true)
{
YakSys.Compression.LZSS lZSS_obj = new YakSys.Compression.LZSS(16, true, true, false, 65536);
byteArray_CompressedXMLData = lZSS_obj.Compress(memoryStream_XMLData.ToArray(), false);
memoryStream_XMLData = new MemoryStream(byteArray_CompressedXMLData);
}
byteArray_ComputedXMLDataHash = sHA256Managed_obj.ComputeHash(memoryStream_XMLData);
if (CommonEnvironment.LocalSecurityPassword.Length > 5 && CommonEnvironment.EncryptSettingsDataBase == true)
{
byteArray_PasswordHash = sHA256Managed_obj.ComputeHash(System.Text.Encoding.Default.GetBytes(CommonEnvironment.LocalSecurityPassword));
byteArray_HashOfPasswordHash = sHA256Managed_obj.ComputeHash(byteArray_PasswordHash);
rijndaelManaged_obj.KeySize = 256;
rijndaelManaged_obj.Key = byteArray_PasswordHash;
rijndaelManaged_obj.IV = new byte[rijndaelManaged_obj.BlockSize / 8];
cryptoStream_obj = new CryptoStream(memoryStream_EncryptedXMLData, rijndaelManaged_obj.CreateEncryptor(), CryptoStreamMode.Write);
cryptoStream_obj.Write(memoryStream_XMLData.ToArray(), 0, memoryStream_XMLData.ToArray().Length);
memoryStream_XMLData.SetLength(0);
cryptoStream_obj.FlushFinalBlock();
byteArray_EncryptedData = memoryStream_EncryptedXMLData.ToArray();
cryptoStream_obj.Close();
memoryStream_XMLData = new MemoryStream(byteArray_EncryptedData);
}
fileStream_ServerDB.Write(System.Text.Encoding.Default.GetBytes("ConnectingServiceDB010"), 0, 22);
fileStream_ServerDB.WriteByte(byte_ToEncryptServerDataBase);
fileStream_ServerDB.WriteByte(byte_ToCompressSettingsDataBase);
fileStream_ServerDB.Write(byteArray_ComputedXMLDataHash, 0, byteArray_ComputedXMLDataHash.Length);
fileStream_ServerDB.Write(byteArray_HashOfPasswordHash, 0, byteArray_HashOfPasswordHash.Length);
fileStream_ServerDB.Write(memoryStream_XMLData.ToArray(), 0, memoryStream_XMLData.ToArray().Length);
fileStream_ServerDB.Close();
}
public ShaRandom()
{
sha = new SHA256Managed();
}
public static String ToSha256(this String input)
{
var sha = new SHA256Managed();
return(BitConverter.ToString(sha.ComputeHash(Encoding.UTF8.GetBytes(input))).Replace("-", ""));
}
/// <summary>
///
/// </summary>
/// <param name="TimeStampQuery"></param>
/// <returns></returns>
public OutputResponseMarca getTimeStamp(InputMarca TimeStampQuery)
{
OutputResponseMarca outputMarca = new OutputResponseMarca();
byte[] dati = String_To_Bytes(TimeStampQuery.file_p7m);
//SHA1 sha1 = SHA1CryptoServiceProvider.Create();
//byte[] hash = sha1.ComputeHash(dati);
SHA256Managed sha256 = new SHA256Managed();
byte[] hash = sha256.ComputeHash(dati);
TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
reqGen.SetCertReq(true);
//Funzione randomica per il Nonce.
//RandomNumberGenerator nRand = new RNGCryptoServiceProvider();
long casuale = (long)nRandom.Next();
//TimeStampRequest tsReq = reqGen.Generate(TspAlgorithms.Sha1, hash, BigInteger.ValueOf(casuale));
TimeStampRequest tsReq = reqGen.Generate(TspAlgorithms.Sha256, hash, BigInteger.ValueOf(casuale));
byte[] tsData = tsReq.GetEncoded();
string urlTSA = string.Empty;
if (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["URL_TSA"]))
{
urlTSA = ConfigurationManager.AppSettings["URL_TSA"].ToString();
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(urlTSA);
req.Method = "POST";
req.ContentType = "application/timestamp-query";
//Username e password per accedere alla Time Stamping Authority
string pwd = string.Empty;
if (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["PASSWORD_UTENTE_TSA"]))
{
pwd = ConfigurationManager.AppSettings["PASSWORD_UTENTE_TSA"].ToString();
req.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.ASCII.GetBytes(pwd)));
}
req.ContentLength = tsData.Length;
Stream reqStream = req.GetRequestStream();
reqStream.Write(tsData, 0, tsData.Length);
reqStream.Close();
HttpWebResponse res = (HttpWebResponse)req.GetResponse();
if (res == null)
{
outputMarca.esito = "KO";
outputMarca.descrizioneErrore = "Impossibile contattare la TSA o autorizzazione negata";
return(outputMarca);
}
else
{
Stream resStream = new BufferedStream(res.GetResponseStream());
TimeStampResponse tsRes = new TimeStampResponse(resStream);
resStream.Close();
BusinessLogic.Documenti.DigitalSignature.VerifyTimeStamp checkMarca = new BusinessLogic.Documenti.DigitalSignature.VerifyTimeStamp();
outputMarca = checkMarca.Verify(tsReq, tsRes);
}
}
else
{
outputMarca.esito = "KO";
outputMarca.descrizioneErrore = "Impossibile contattare la TSA o url configurata errata!";
return(outputMarca);
}
return(outputMarca);
}
/// <summary>
/// 计算SHA256哈希值
/// </summary>
/// <param name="buffer">要计算其哈希代码的数组。</param>
/// <returns>返回SHA256哈希值</returns>
public static string SHA256(byte[] buffer)
{
SHA256Managed sha256 = new SHA256Managed();
return(ConvertToString(sha256.ComputeHash(buffer)));
}
/// <summary>
/// Saves mul
/// </summary>
/// <param name="path"></param>
public static unsafe void Save(string path)
{
checksumsLand = new List <CheckSums>();
checksumsStatic = new List <CheckSums>();
string idx = Path.Combine(path, "artidx.mul");
string mul = Path.Combine(path, "art.mul");
using (
FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
{
MemoryStream memidx = new MemoryStream();
MemoryStream memmul = new MemoryStream();
SHA256Managed sha = new SHA256Managed();
//StreamWriter Tex = new StreamWriter(new FileStream("d:/artlog.txt", FileMode.Create, FileAccess.ReadWrite));
using (BinaryWriter binidx = new BinaryWriter(memidx), binmul = new BinaryWriter(memmul))
{
for (int index = 0; index < GetIdxLength(); index++)
{
Files.FireFileSaveEvent();
if (m_Cache[index] == null)
{
if (index < 0x4000)
{
m_Cache[index] = GetLand(index);
}
else
{
m_Cache[index] = GetStatic(index - 0x4000, false);
}
}
Bitmap bmp = m_Cache[index];
if ((bmp == null) || (m_Removed[index]))
{
binidx.Write(-1); // lookup
binidx.Write(0); // length
binidx.Write(-1); // extra
//Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, (int)-1, (int)-1));
}
else if (index < 0x4000)
{
MemoryStream ms = new MemoryStream();
bmp.Save(ms, ImageFormat.Bmp);
byte[] checksum = sha.ComputeHash(ms.ToArray());
CheckSums sum;
if (compareSaveImagesLand(checksum, out sum))
{
binidx.Write(sum.pos); //lookup
binidx.Write(sum.length);
binidx.Write(0);
//Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, (int)sum.pos, (int)sum.length));
//Tex.WriteLine(System.String.Format("0x{0:X4} -> 0x{1:X4}", sum.index, index));
continue;
}
//land
BitmapData bd = bmp.LockBits(
new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, Settings.PixelFormat);
ushort *line = (ushort *)bd.Scan0;
int delta = bd.Stride >> 1;
binidx.Write((int)binmul.BaseStream.Position); //lookup
int length = (int)binmul.BaseStream.Position;
int x = 22;
int y = 0;
int linewidth = 2;
for (int m = 0; m < 22; ++m, ++y, line += delta, linewidth += 2)
{
--x;
ushort *cur = line;
for (int n = 0; n < linewidth; ++n)
{
binmul.Write((ushort)(cur[x + n] ^ 0x8000));
}
}
x = 0;
linewidth = 44;
y = 22;
line = (ushort *)bd.Scan0;
line += delta * 22;
for (int m = 0; m < 22; m++, y++, line += delta, ++x, linewidth -= 2)
{
ushort *cur = line;
for (int n = 0; n < linewidth; n++)
{
binmul.Write((ushort)(cur[x + n] ^ 0x8000));
}
}
int start = length;
length = (int)binmul.BaseStream.Position - length;
binidx.Write(length);
binidx.Write(0);
bmp.UnlockBits(bd);
CheckSums s = new CheckSums
{
pos = start,
length = length,
checksum = checksum,
index = index
};
//Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, start, length));
checksumsLand.Add(s);
}
else
{
MemoryStream ms = new MemoryStream();
bmp.Save(ms, ImageFormat.Bmp);
byte[] checksum = sha.ComputeHash(ms.ToArray());
CheckSums sum;
if (compareSaveImagesStatic(checksum, out sum))
{
binidx.Write(sum.pos); //lookup
binidx.Write(sum.length);
binidx.Write(0);
//Tex.WriteLine(System.String.Format("0x{0:X4} -> 0x{1:X4}", sum.index, index));
//Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, sum.pos, sum.length));
continue;
}
// art
BitmapData bd = bmp.LockBits(
new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, Settings.PixelFormat);
ushort *line = (ushort *)bd.Scan0;
int delta = bd.Stride >> 1;
binidx.Write((int)binmul.BaseStream.Position); //lookup
int length = (int)binmul.BaseStream.Position;
binmul.Write(1234); // header
binmul.Write((short)bmp.Width);
binmul.Write((short)bmp.Height);
int lookup = (int)binmul.BaseStream.Position;
int streamloc = lookup + bmp.Height * 2;
int width = 0;
for (int i = 0; i < bmp.Height; ++i) // fill lookup
{
binmul.Write(width);
}
int X = 0;
for (int Y = 0; Y < bmp.Height; ++Y, line += delta)
{
ushort *cur = line;
width = (int)(binmul.BaseStream.Position - streamloc) / 2;
binmul.BaseStream.Seek(lookup + Y * 2, SeekOrigin.Begin);
binmul.Write(width);
binmul.BaseStream.Seek(streamloc + width * 2, SeekOrigin.Begin);
int i = 0;
int j = 0;
X = 0;
while (i < bmp.Width)
{
i = X;
for (i = X; i <= bmp.Width; ++i)
{
//first pixel set
if (i < bmp.Width)
{
if (cur[i] != 0)
{
break;
}
}
}
if (i < bmp.Width)
{
for (j = (i + 1); j < bmp.Width; ++j)
{
//next non set pixel
if (cur[j] == 0)
{
break;
}
}
binmul.Write((short)(i - X)); //xoffset
binmul.Write((short)(j - i)); //run
for (int p = i; p < j; ++p)
{
binmul.Write((ushort)(cur[p] ^ 0x8000));
}
X = j;
}
}
binmul.Write((short)0); //xOffset
binmul.Write((short)0); //Run
}
int start = length;
length = (int)binmul.BaseStream.Position - length;
binidx.Write(length);
binidx.Write(0);
bmp.UnlockBits(bd);
CheckSums s = new CheckSums
{
pos = start,
length = length,
checksum = checksum,
index = index
};
//Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, start, length));
checksumsStatic.Add(s);
}
}
memidx.WriteTo(fsidx);
memmul.WriteTo(fsmul);
}
}
}
public static Fingerprint EvaluateKeyToFingerprint(
AgentTaskPluginExecutionContext context,
string filePathRoot,
IEnumerable <string> keySegments)
{
var sha256 = new SHA256Managed();
string defaultWorkingDirectory = context.Variables.GetValueOrDefault(
"system.defaultworkingdirectory" // Constants.Variables.System.DefaultWorkingDirectory
)?.Value;
var resolvedSegments = new List <string>();
foreach (string keySegment in keySegments)
{
CheckKeySegment(keySegment);
}
foreach (string keySegment in keySegments)
{
if (IsPathyKeySegment(keySegment))
{
context.Verbose($"Interpretting `{keySegment}` as a path.");
string[] pathRules = keySegment.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray();
string[] includeRules = pathRules.Where(p => !p.StartsWith('!')).ToArray();
if (!includeRules.Any())
{
throw new ArgumentException("No include rules specified.");
}
var enumerations = new Dictionary <Enumeration, List <string> >();
foreach (string includeRule in includeRules)
{
string absoluteRootRule = MakePathCanonical(defaultWorkingDirectory, includeRule);
context.Verbose($"Expanded include rule is `{absoluteRootRule}`.");
Enumeration enumeration = DetermineFileEnumerationFromGlob(absoluteRootRule);
List <string> globs;
if (!enumerations.TryGetValue(enumeration, out globs))
{
enumerations[enumeration] = globs = new List <string>();
}
globs.Add(absoluteRootRule);
}
string[] excludeRules = pathRules.Where(p => p.StartsWith('!')).ToArray();
string[] absoluteExcludeRules = excludeRules.Select(excludeRule => {
excludeRule = excludeRule.Substring(1);
return(MakePathCanonical(defaultWorkingDirectory, excludeRule));
}).ToArray();
var fileHashes = new SortedDictionary <string, string>(StringComparer.Ordinal);
foreach (var kvp in enumerations)
{
Enumeration enumerate = kvp.Key;
List <string> absoluteIncludeGlobs = kvp.Value;
context.Verbose($"Enumerating starting at root `{enumerate.RootPath}` with pattern `{enumerate.Pattern}` and depth `{enumerate.Depth}`.");
IEnumerable <string> files = Directory.EnumerateFiles(enumerate.RootPath, enumerate.Pattern, enumerate.Depth);
Func <string, bool> filter = CreateFilter(context, absoluteIncludeGlobs, absoluteExcludeRules);
files = files.Where(f => filter(f)).Distinct();
foreach (string path in files)
{
using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
byte[] hash = sha256.ComputeHash(fs);
// Path.GetRelativePath returns 'The relative path, or path if the paths don't share the same root.'
string displayPath = filePathRoot == null ? path : Path.GetRelativePath(filePathRoot, path);
fileHashes.Add(path, $"\nSHA256({displayPath})=[{fs.Length}]{hash.ToHex()}");
}
}
}
if (!fileHashes.Any())
{
throw new FileNotFoundException("No files found.");
}
var fileHashesBuilder = new StringBuilder();
foreach (string fileHashString in fileHashes.Values)
{
fileHashesBuilder.Append(fileHashString);
}
string wholeFileHashString = fileHashesBuilder.ToString();
string summary = SummarizeString(wholeFileHashString);
context.Output($"File hashes summarized as `{summary}` from BASE64(SHA256(`{wholeFileHashString}`))");
resolvedSegments.Add(summary);
}
else
{
context.Verbose($"Interpretting `{keySegment}` as a string.");
resolvedSegments.Add($"{keySegment}");
}
}
return(new Fingerprint()
{
Segments = resolvedSegments.ToArray()
});
}
/// <summary>
/// Generates a hash for the given plain text value and returns a
/// base64-encoded result. Before the hash is computed, a random salt
/// is generated and appended to the plain text. This salt is stored at
/// the end of the hash value, so it can be used later for hash
/// verification.
/// </summary>
/// <param name="plainText">
/// Plaintext value to be hashed. The function does not check whether
/// this parameter is null.
/// </param>
/// <param name="hashAlgorithm">
/// Name of the hash algorithm. Allowed values are: "MD5", "SHA1",
/// "SHA256", "SHA384", and "SHA512" (if any other value is specified
/// MD5 hashing algorithm will be used). This value is case-insensitive.
/// </param>
/// <param name="saltBytes">
/// Salt bytes. This parameter can be null, in which case a random salt
/// value will be generated.
/// </param>
/// <returns>
/// Hash value formatted as a base64-encoded string.
/// </returns>
public static string ComputeHash(string plainText,
string hashAlgorithm,
byte[] saltBytes)
{
// If salt is not specified, generate it on the fly.
if (saltBytes == null)
{
// Define min and max salt sizes.
int minSaltSize = 4;
int maxSaltSize = 8;
// Generate a random number for the size of the salt.
Random random = new Random();
int saltSize = random.Next(minSaltSize, maxSaltSize);
// Allocate a byte array, which will hold the salt.
saltBytes = new byte[saltSize];
// Initialize a random number generator.
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
// Fill the salt with cryptographically strong byte values.
rng.GetNonZeroBytes(saltBytes);
}
// Convert plain text into a byte array.
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
// Allocate array, which will hold plain text and salt.
byte[] plainTextWithSaltBytes =
new byte[plainTextBytes.Length + saltBytes.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < plainTextBytes.Length; i++)
{
plainTextWithSaltBytes[i] = plainTextBytes[i];
}
// Append salt bytes to the resulting array.
for (int i = 0; i < saltBytes.Length; i++)
{
plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];
}
// Because we support multiple hashing algorithms, we must define
// hash object as a common (abstract) base class. We will specify the
// actual hashing algorithm class later during object creation.
HashAlgorithm hash;
// Make sure hashing algorithm name is specified.
if (hashAlgorithm == null)
{
hashAlgorithm = "";
}
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
// Compute hash value of our plain text with appended salt.
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
// Create array which will hold hash and original salt bytes.
byte[] hashWithSaltBytes = new byte[hashBytes.Length +
saltBytes.Length];
// Copy hash bytes into resulting array.
for (int i = 0; i < hashBytes.Length; i++)
{
hashWithSaltBytes[i] = hashBytes[i];
}
// Append salt bytes to the result.
for (int i = 0; i < saltBytes.Length; i++)
{
hashWithSaltBytes[hashBytes.Length + i] = saltBytes[i];
}
// Convert result into a base64-encoded string.
string hashValue = Convert.ToBase64String(hashWithSaltBytes);
// Return the result.
return(hashValue);
}
public static Byte[] SHA256(IEnumerable <Byte> Bytes)
{
SHA256 sha = new SHA256Managed();
return(sha.ComputeHash(Bytes.ToArray()));
}
public DriverSignatureCheckup(String SHA25632, String SHA25664, String NewSHA25632, String NewSHA25664, Boolean Is64Bit)
{
InitializeComponent();
var sha32 = new SHA256Managed();
var DLL32bit = new FileStream(Environment.GetFolderPath(Environment.SpecialFolder.SystemX86) + "\\keppysynth\\keppysynth.dll", FileMode.OpenOrCreate, FileAccess.Read);
byte[] checksum32 = sha32.ComputeHash(DLL32bit);
String Driver32SHA256 = BitConverter.ToString(checksum32).Replace("-", String.Empty);
String Driver64SHA256 = null;
Driver32Current.Text = Driver32SHA256;
Driver32Expected.Text = SHA25632;
if (Driver32SHA256 != SHA25632)
{
if (!object.Equals(SHA25664, NewSHA25664))
{
Driver32Status.Image = KeppySynthConfigurator.Properties.Resources.erroriconupd;
}
else
{
Driver32Status.Image = KeppySynthConfigurator.Properties.Resources.erroricon;
}
Is32BitMatch = false;
}
else
{
if (!object.Equals(SHA25664, NewSHA25664))
{
Driver32Status.Image = KeppySynthConfigurator.Properties.Resources.successiconupd;
}
else
{
Driver32Status.Image = KeppySynthConfigurator.Properties.Resources.successicon;
}
Is32BitMatch = true;
}
if (Environment.Is64BitOperatingSystem)
{
Functions.Wow64DisableWow64FsRedirection(ref WOW64Value);
var sha64 = new SHA256Managed();
var DLL64bit = new FileStream(Environment.GetFolderPath(Environment.SpecialFolder.System) + "\\keppysynth\\keppysynth.dll", FileMode.OpenOrCreate, FileAccess.Read);
byte[] checksum64 = sha64.ComputeHash(DLL64bit);
Driver64SHA256 = BitConverter.ToString(checksum64).Replace("-", String.Empty);
Functions.Wow64RevertWow64FsRedirection(WOW64Value);
Driver64Current.Text = Driver64SHA256;
Driver64Expected.Text = SHA25664;
if (Driver64SHA256 != SHA25664)
{
if (!object.Equals(SHA25664, NewSHA25664))
{
Driver64Status.Image = KeppySynthConfigurator.Properties.Resources.erroriconupd;
}
else
{
Driver64Status.Image = KeppySynthConfigurator.Properties.Resources.erroricon;
}
Is64BitMatch = false;
}
else
{
if (!object.Equals(SHA25664, NewSHA25664))
{
Driver64Status.Image = KeppySynthConfigurator.Properties.Resources.successiconupd;
}
else
{
Driver64Status.Image = KeppySynthConfigurator.Properties.Resources.successicon;
}
Is64BitMatch = true;
}
}
String OriginalRelease = "{0} not the original from GitHub. Click here to download the original release.";
String LatestRelease = "{0} not the original from GitHub.\nThere's also an update, click here to download the latest release.";
String EverythingFine = "Both drivers are the originals from GitHub. Everything's good, click OK to close the dialog.";
String EverythingFineUpd = "Both drivers are the originals from GitHub, but newer versions are available.\nClick here to download the latest release.";
if (!Is32BitMatch && !Is64BitMatch)
{
if (!object.Equals(SHA25632, NewSHA25632) || !object.Equals(SHA25664, NewSHA25664))
{
BothDriverStatus.Text = String.Format(LatestRelease, "Both drivers are");
BothDriverStatus.ForeColor = Color.DarkRed;
BothDriverStatus.Cursor = Cursors.Hand;
BothDriverStatus.Font = new Font(BothDriverStatus.Font.FontFamily, BothDriverStatus.Font.Size, System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
IsNewVerAvailable = true;
}
else
{
BothDriverStatus.Text = String.Format(OriginalRelease, "Both drivers are");
BothDriverStatus.ForeColor = Color.DarkRed;
BothDriverStatus.Cursor = Cursors.Hand;
BothDriverStatus.Font = new Font(BothDriverStatus.Font.FontFamily, BothDriverStatus.Font.Size, System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
}
}
else if (!Is32BitMatch)
{
if (!object.Equals(SHA25632, NewSHA25632) || !object.Equals(SHA25664, NewSHA25664))
{
BothDriverStatus.Text = String.Format(LatestRelease, "The 32-bit driver is");
BothDriverStatus.ForeColor = Color.Peru;
BothDriverStatus.Cursor = Cursors.Hand;
BothDriverStatus.Font = new Font(BothDriverStatus.Font.FontFamily, BothDriverStatus.Font.Size, System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
IsNewVerAvailable = true;
}
else
{
BothDriverStatus.Text = String.Format(OriginalRelease, "The 32-bit driver is");
BothDriverStatus.ForeColor = Color.Peru;
BothDriverStatus.Cursor = Cursors.Hand;
BothDriverStatus.Font = new Font(BothDriverStatus.Font.FontFamily, BothDriverStatus.Font.Size, System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
}
}
else if (!Is64BitMatch)
{
if (!object.Equals(SHA25632, NewSHA25632) || !object.Equals(SHA25664, NewSHA25664))
{
BothDriverStatus.Text = String.Format(LatestRelease, "The 64-bit driver is");
BothDriverStatus.ForeColor = Color.Peru;
BothDriverStatus.Cursor = Cursors.Hand;
BothDriverStatus.Font = new Font(BothDriverStatus.Font.FontFamily, BothDriverStatus.Font.Size, System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
IsNewVerAvailable = true;
}
else
{
BothDriverStatus.Text = String.Format(OriginalRelease, "The 64-bit driver is");
BothDriverStatus.ForeColor = Color.Peru;
BothDriverStatus.Cursor = Cursors.Hand;
BothDriverStatus.Font = new Font(BothDriverStatus.Font.FontFamily, BothDriverStatus.Font.Size, System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
}
}
else
{
if (!object.Equals(Driver32SHA256, NewSHA25632) || !object.Equals(Driver64SHA256, NewSHA25664))
{
BothDriverStatus.Text = EverythingFineUpd;
BothDriverStatus.ForeColor = Color.Blue;
BothDriverStatus.Cursor = Cursors.Hand;
BothDriverStatus.Font = new Font(BothDriverStatus.Font.FontFamily, BothDriverStatus.Font.Size, System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
IsNewVerAvailable = true;
}
else
{
BothDriverStatus.Text = EverythingFine;
BothDriverStatus.ForeColor = Color.Green;
BothDriverStatus.Cursor = Cursors.Arrow;
BothDriverStatus.Font = new Font(BothDriverStatus.Font.FontFamily, BothDriverStatus.Font.Size, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
}
}
}
void TryRegister()
{
if (Globals.WaitingOnServer)
{
return;
}
if (Networking.Network.Connected)
{
if (FieldChecking.IsValidUsername(mUsernameTextbox.Text, Strings.Regex.username))
{
if (mPasswordTextbox.Text == mPasswordTextbox2.Text)
{
if (FieldChecking.IsValidPassword(mPasswordTextbox.Text, Strings.Regex.password))
{
if (FieldChecking.IsWellformedEmailAddress(mEmailTextbox.Text, Strings.Regex.email))
{
Hide();
//Hash Password
using (var sha = new SHA256Managed())
{
var hashedPass = BitConverter.ToString(
sha.ComputeHash(Encoding.UTF8.GetBytes(mPasswordTextbox.Text.Trim()))
)
.Replace("-", "");
PacketSender.SendCreateAccount(
mUsernameTextbox.Text, hashedPass, mEmailTextbox.Text
);
}
Globals.WaitingOnServer = true;
mRegisterBtn.Disable();
ChatboxMsg.ClearMessages();
}
else
{
Interface.MsgboxErrors.Add(
new KeyValuePair <string, string>("", Strings.Registration.emailinvalid)
);
}
}
else
{
Interface.MsgboxErrors.Add(
new KeyValuePair <string, string>("", Strings.Errors.passwordinvalid)
);
}
}
else
{
Interface.MsgboxErrors.Add(
new KeyValuePair <string, string>("", Strings.Registration.passwordmatch)
);
}
}
else
{
Interface.MsgboxErrors.Add(new KeyValuePair <string, string>("", Strings.Errors.usernameinvalid));
}
}
else
{
Interface.MsgboxErrors.Add(new KeyValuePair <string, string>("", Strings.Errors.notconnected));
}
}
public void SaveAttachmentsToDisk(bool rewriteExisting = false)
{
//string root = AppDomain.CurrentDomain.BaseDirectory + "\\Prilohy\\";
//if (!System.IO.Directory.Exists(root))
// System.IO.Directory.CreateDirectory(root);
//string dir = root + item.Id;
//if (!System.IO.Directory.Exists(dir))
//{
// System.IO.Directory.CreateDirectory(dir);
//}
var io = Lib.Init.PrilohaLocalCopy;
int count = 0;
string listing = "";
if (this.Prilohy != null)
{
if (!System.IO.Directory.Exists(io.GetFullDir(this)))
{
System.IO.Directory.CreateDirectory(io.GetFullDir(this));
}
foreach (var p in this.Prilohy)
{
string attUrl = p.odkaz;
if (string.IsNullOrEmpty(attUrl))
{
continue;
}
count++;
string fullPath = io.GetFullPath(this, p);
listing = listing + string.Format("{0} : {1} \n", count, System.Net.WebUtility.UrlDecode(attUrl));
if (!System.IO.File.Exists(fullPath) || rewriteExisting)
{
try
{
using (Devmasters.Net.Web.URLContent url = new Devmasters.Net.Web.URLContent(attUrl))
{
url.Timeout = url.Timeout * 10;
byte[] data = url.GetBinary().Binary;
System.IO.File.WriteAllBytes(fullPath, data);
//p.LocalCopy = System.Text.UTF8Encoding.UTF8.GetBytes(io.GetRelativePath(item, p));
}
}
catch (Exception e)
{
HlidacStatu.Util.Consts.Logger.Error(attUrl, e);
}
}
if (p.hash == null)
{
using (FileStream filestream = new FileStream(fullPath, FileMode.Open))
{
using (SHA256 mySHA256 = SHA256Managed.Create())
{
filestream.Position = 0;
byte[] hashValue = mySHA256.ComputeHash(filestream);
p.hash = new Lib.XSD.tHash()
{
algoritmus = "sha256",
Value = BitConverter.ToString(hashValue).Replace("-", String.Empty)
};
}
}
}
//System.IO.File.WriteAllText(dir + "\\" + "content.nfo", listing);
}
}
}
/// <summary>
/// 计算SHA256哈希值
/// </summary>
/// <param name="buffer">要计算其哈希代码的数组。</param>
/// <param name="offset">字节数组中的偏移量，从该位置开始使用数据。</param>
/// <param name="count">数组中用作数据的字节数。</param>
/// <returns>返回SHA256哈希值</returns>
public static string SHA256(byte[] buffer, int offset, int count)
{
SHA256Managed sha256 = new SHA256Managed();
return(ConvertToString(sha256.ComputeHash(buffer, offset, count)));
}
public static string GetSHA256(this Stream stream)
{
return(stream.GetHashString(SHA256Managed.Create()));
}
public ActionResult Agregar(encuesta_usuariosCLS Oencuesta_usuariosCLS)
{
using (var db = new csstdura_encuestaEntities())
{
using (var transaction = new TransactionScope())
{
if (!ModelState.IsValid)
{
llenarEmpresa();
llenarSexo();
llenarEdad();
llenarEdoCivil();
llenarOpciones();
llenarProcesoEdu();
llenarTipoPuesto();
llenarTipoContratacion();
llenarTipoPersonal();
llenarTipoJornada();
llenarRotacionTurno();
llenarTiempoEmp();
llenarExpLab();
//llenarDepto();
// llenarCentro();
ViewBag.listaSexo = listaSexo;
ViewBag.listaEdad = listaEdad;
ViewBag.listaEdoCivil = listaEdoCivil;
ViewBag.listaOpciones = listaOpciones;
ViewBag.listaProceso = listaProceso;
ViewBag.listaPuesto = listaPuesto;
ViewBag.listaContrata = listaContrata;
ViewBag.listaPersonal = listaPersonal;
ViewBag.listaJornada = listaJornada;
ViewBag.listaRotacion = listaRotacion;
ViewBag.listaTiempo = listaTiempo;
ViewBag.listaExpLab = listaExpLab;
// ViewBag.listaDepto = listaDepto;
// ViewBag.listaCentro = listaCentro;
return(View(Oencuesta_usuariosCLS));
}
//Usando clase de entity framework
encuesta_usuarios usuarios = new encuesta_usuarios();
usuarios.usua_nombre = Oencuesta_usuariosCLS.usua_nombre;
usuarios.usua_empresa = Oencuesta_usuariosCLS.usua_empresa;
usuarios.usua_f_aplica = DateTime.Now;
usuarios.usua_tipo = "U";
usuarios.usua_estatus = "ACTIVO";
usuarios.usua_n_usuario = Oencuesta_usuariosCLS.usua_n_usuario;
//Cifrando el password
SHA256Managed sha = new SHA256Managed();
byte[] byteContra = Encoding.Default.GetBytes(Oencuesta_usuariosCLS.usua_p_usuario);
byte[] byteContraCifrado = sha.ComputeHash(byteContra);
string contraCifrada = BitConverter.ToString(byteContraCifrado).Replace("-", "");
usuarios.usua_p_usuario = contraCifrada;
int periodo = db.Database.SqlQuery <int>("Select periodo_id from encuaesta_periodo where periodo_estatus='A'")
.FirstOrDefault();
//usuarios.usua_p_usuario = Oencuesta_usuariosCLS.usua_p_usuario;
usuarios.usua_u_alta = "";
usuarios.usua_f_alta = DateTime.Now;
usuarios.usua_u_cancela = "";
usuarios.usua_f_cancela = null;
usuarios.usua_genero = Oencuesta_usuariosCLS.usua_genero;
usuarios.usua_edad = Oencuesta_usuariosCLS.usua_edad;
usuarios.usua_edo_civil = Oencuesta_usuariosCLS.usua_edo_civil;
usuarios.usua_sin_forma = Oencuesta_usuariosCLS.usua_sin_forma;
usuarios.usua_primaria = Oencuesta_usuariosCLS.usua_primaria;
usuarios.usua_secundaria = Oencuesta_usuariosCLS.usua_secundaria;
usuarios.usua_preparatoria = Oencuesta_usuariosCLS.usua_preparatoria;
usuarios.usua_tecnico = Oencuesta_usuariosCLS.usua_tecnico;
usuarios.usua_licenciatura = Oencuesta_usuariosCLS.usua_licenciatura;
usuarios.usua_maestria = Oencuesta_usuariosCLS.usua_maestria;
usuarios.usua_doctorado = Oencuesta_usuariosCLS.usua_doctorado;
usuarios.usua_tipo_puesto = Oencuesta_usuariosCLS.usua_tipo_puesto;
usuarios.usua_tipo_contratacion = Oencuesta_usuariosCLS.usua_tipo_contratacion;
usuarios.usua_tipo_personal = Oencuesta_usuariosCLS.usua_tipo_personal;
usuarios.usua_tipo_jornada = Oencuesta_usuariosCLS.usua_tipo_jornada;
usuarios.usua_rotacion_turno = Oencuesta_usuariosCLS.usua_rotacion_turno;
usuarios.usua_tiempo_puesto = Oencuesta_usuariosCLS.usua_tiempo_puesto;
usuarios.usua_exp_laboral = Oencuesta_usuariosCLS.usua_exp_laboral;
usuarios.usua_presento = "N";
usuarios.usua_departamento = Oencuesta_usuariosCLS.usua_departamento;
usuarios.usua_centro_trabajo = Oencuesta_usuariosCLS.usua_centro_trabajo;
usuarios.usua_periodo = periodo;
db.encuesta_usuarios.Add(usuarios);
int res = db.SaveChanges();
transaction.Complete();
if (res == 1)
{
return(Content("<script language='javascript' type='text/javascript'>alert('Registro exitoso!');window.location = '/Login/Index';</script>"));
}
else
{
return(Content("<script language='javascript' type='text/javascript'>alert('Ocurrio un error!');window.location = '/Usuarios/Agregar';</script>"));
}
}
}
}
public static Task <string> GetSHA256Async(this Stream stream, CancellationToken token = default)
{
return(stream.GetHashStringAsync(SHA256Managed.Create(), token: token));
}
protected static byte[] Hash256(byte[] orig)
{
HashAlgorithm sha = new SHA256Managed();
return(sha.ComputeHash(orig));
}
private void btn_ingresar_Click(object sender, EventArgs e)
{
if (!ValidarCampos())
{
return;
}
Usuario usuario = new Usuario(textBox_user.Text);
if (!usuario.existeUsuario())
{
Interfaz.Interfaz.mostrarMensaje("El usuario no existe!!");
return;
}
if (!usuario.estaHabilitado())
{
Interfaz.Interfaz.mostrarMensaje("El usuario no esta habilitado!! contactese con un administrador");
return;
}
//Si es el primer login tomo como password lo que inserta el usuario ya que nunca se guardo la pass encriptada, si no lo paso al SHA256
if (usuario.primerLogin)
{
usuario.Password = textBox_password.Text;
}
else
{
UTF8Encoding encoderHash = new UTF8Encoding();
SHA256Managed hasher = new SHA256Managed();
byte[] bytesDeHasheo = hasher.ComputeHash(encoderHash.GetBytes(textBox_password.Text));
string password = Interfaz.Interfaz.bytesDeHasheoToString(bytesDeHasheo);
usuario.Password = password;
}
if (usuario.checkPassword())
{
Interfaz.Interfaz.mostrarMensaje("Usuario logueado exitosamente!");
usuario.resetearIntentos();
if (usuario.primerLogin)
{
Interfaz.Interfaz.mostrarMensaje("Debido a que es la primera vez que se loguea luego de la migracion, es necesario que modifique su contrasena");
InputDialog formDialog = new InputDialog();
formDialog.ShowDialog();
usuario.cambiarPassword(formDialog.newPass);
Interfaz.Interfaz.mostrarMensaje("La contraseña ha sido modificada");
usuario.setPrimeraVez(false);
}
Interfaz.Interfaz.usuario = usuario;
//hace falta este?
Repositorio.currentUser(usuario);
SelectRolFuncionalidad rolDialog = new SelectRolFuncionalidad();
rolDialog.ShowDialog();
}
else // LA PASSWORD ES INVALIDA
{
Interfaz.Interfaz.mostrarMensaje("La password es invalida");
usuario.sumarIntentoFallido();
if (usuario.getIntentosFallidos() == 3)
{
usuario.deshabilitar();
Interfaz.Interfaz.mostrarMensaje("Su usuario ha sido deshabilitado por reiterados ingresos invalidos");
}
}
}
/// <summary>
/// Computes the SHA-256 checksum for the bytes.
/// </summary>
public static Byte[] Compute(Byte[] bytes)
{
SHA256Managed sha256 = new SHA256Managed();
return sha256.ComputeHash(bytes);
}
public byte[] GetSuperBlockHash()
{
SHA256Managed sha = new SHA256Managed();
return(sha.ComputeHash(Data, 0, 0x400));
}
public static string oldAddrToCashAddr(string oldAddress, out bool isP2PKH, out bool mainnet)
{
// BigInteger wouldn't be needed, but that would result in the use a MIT License
BigInteger address = new BigInteger(0);
BigInteger baseFiftyEight = new BigInteger(58);
for (int x = 0; x < oldAddress.Length; x++)
{
int value = DICT_BASE58[oldAddress[x]];
if (value != -1)
{
address = BigInteger.Multiply(address, baseFiftyEight);
address = BigInteger.Add(address, new BigInteger(value));
}
else
{
throw new CashAddrConversionException("Address contains unexpected character.");
}
}
int numZeros = 0;
for (; (numZeros < oldAddress.Length) && (oldAddress[numZeros] == Convert.ToChar("1")); numZeros++)
{
}
byte[] addrBytes = address.ToByteArray();
Array.Reverse(addrBytes);
// Reminder, addrBytes was converted from BigInteger. So the first byte,
// the sign byte should be skipped, **if exists**
if (addrBytes[0] == 0)
{
// because of 0xc4
var temp = new List <byte>(addrBytes);
temp.RemoveAt(0);
addrBytes = temp.ToArray();
}
if (numZeros > 0)
{
var temp = new List <byte>(addrBytes);
for (; numZeros != 0; numZeros--)
{
temp.Insert(0, 0);
}
addrBytes = temp.ToArray();
}
if (addrBytes.Length != 25)
{
throw new CashAddrConversionException("Address to be decoded is shorter or longer than expected!");
}
switch (addrBytes[0])
{
case 0x00:
isP2PKH = true;
mainnet = true;
break;
case 0x05:
isP2PKH = false;
mainnet = true;
break;
case 0x6f:
isP2PKH = true;
mainnet = false;
break;
case 0xc4:
isP2PKH = false;
mainnet = false;
break;
case 0x1c:
// BitPay P2PKH, obsolete!
case 0x28:
// BitPay P2SH, obsolete!
default:
throw new CashAddrConversionException("Unexpected address byte.");
}
if (addrBytes.Length != 25)
{
throw new CashAddrConversionException("Old address is longer or shorter than expected.");
}
SHA256 hasher = SHA256Managed.Create();
byte[] checksum = hasher.ComputeHash(hasher.ComputeHash(addrBytes, 0, 21));
if (addrBytes[21] != checksum[0] || addrBytes[22] != checksum[1] || addrBytes[23] != checksum[2] || addrBytes[24] != checksum[3])
{
throw new CashAddrConversionException("Address checksum doesn't match. Have you made a mistake while typing it?");
}
addrBytes[0] = (byte)(isP2PKH ? 0x00 : 0x08);
byte[] cashAddr = convertBitsEightToFive(addrBytes);
var ret = new System.Text.StringBuilder(mainnet ? "bitcoincash:" : "bchtest:");
// https://play.golang.org/p/sM_CE4AQ7Vp
ulong mod = PolyMod(cashAddr, (ulong)(mainnet ? 1058337025301 : 584719417569));
for (int i = 0; i < 8; ++i)
{
cashAddr[i + 34] = (byte)((mod >> (5 * (7 - i))) & 0x1f);
}
for (int i = 0; i < cashAddr.Length; i++)
{
ret.Append(CHARSET_CASHADDR[cashAddr[i]]);
}
return(ret.ToString());
}
/// <summary>
/// Attempts to find the correct hash for the current block.
/// </summary>
/// <param name="miningWindow">Shows the mining window if set to true.</param>
/// <returns>Returns true if this user successfully mined the block.</returns>
public async void MineBlock()
{
// Asks for address to collect mining rewards. Defaults to my address if cancelled.
if (miner_id == "")
{
miner_id = Microsoft.VisualBasic.Interaction.InputBox("Enter the public key that you would like your mining rewards sent to.", "Mining Rewards",
"BgIAAACkAABSU0ExAAQAAAEAAQA/KlTgRpoq4gx6RQFiPz+1FAEq5VOUZrfOWJ593nwm7gjsV6x+uxEJRScSLOmBda2PEmVTlFim2Y/Aund29KDXryz16sl6719hR3qZVUkEohAbvPayDJ7r70EAM+oGAU8KiPnyoQqF6bLexEE9yXtA39q94KTPMC4wT7jIhi1E9Q==");
}
int count = 0;
int count2 = 0;
string hashString = "1234567890";
DateTime start = DateTime.Now;
DateTime previous = DateTime.Now;
mw.ConsoleOutput.Document.Blocks.Clear();
mw.speedWindow.Clear();
await Task.Run(() =>
{
while (hashString.Substring(0, 5) != "00000")
{
if (mining == false)
{
break;
}
byte[] hash;
string temp;
SHA256Managed hasher = new SHA256Managed();
temp = count.ToString() + previousBlock.index.ToString() + previousBlock.getTimeString() + previousBlock.data.ToString() + previousBlock.previousHash;
Byte[] byteArray = Encoding.UTF8.GetBytes(temp);
hash = hasher.ComputeHash(byteArray);
hashString = string.Empty;
foreach (byte x in hash)
{
hashString += String.Format("{0:x2}", x);
}
if (count % 1000 == 0)
{
mw.Dispatcher.Invoke(DispatcherPriority.Render, new Action(() =>
{
mw.ConsoleOutput.AppendText(Environment.NewLine + count.ToString() + " - " + hashString);
mw.ConsoleOutput.ScrollToEnd();
}));
}
DateTime elapsed = DateTime.Now;
if (elapsed.Subtract(previous).TotalMilliseconds >= 1000)
{
mw.Dispatcher.Invoke(DispatcherPriority.Render, new Action(() =>
{
mw.speedWindow.Text = (count2 / 1000).ToString() + " KH/sec";
}));
count2 = 0;
previous = DateTime.Now;
}
count++;
count2++;
}
});
if (mining == true)
{
mw.Dispatcher.Invoke(DispatcherPriority.Render, new Action(() =>
{
mw.ConsoleOutput.AppendText(Environment.NewLine + count.ToString() + " - " + hashString);
mw.ConsoleOutput.ScrollToEnd();
}));
DateTime finish = DateTime.Now;
Double duration = finish.Subtract(start).TotalSeconds;
mw.ConsoleOutput.AppendText(Environment.NewLine + "Block time: " + duration.ToString() + " Seconds. Average speed: " + ((count / duration) / 1000).ToString("N2") + " KH/sec.");
// Include mining reward in block
Transaction reward = new Transaction("miningReward", miner_id, MiningReward(), HashCount(count));
currentBlock.AddTransaction(reward, chain);
// Add block to chain
Serialize.WriteBlock(currentBlock);
chain.Add(currentBlock);
blockHeight++;
network.blockheight = blockHeight;
previousBlock = chain.ElementAt(blockHeight - 1);
// Broadcast Block
SendBlock(currentBlock);
// Create new block
currentBlock = new Block();
currentBlock.NewBlock(blockHeight, previousBlock.HashBlock());
// Start mining again
MineBlock();
}
}
public static byte[] GetBytes(byte[] payload, byte[] salt, int iterations, int howManyBytes)
{
// round up
uint cBlocks = (uint)((howManyBytes + HASH_SIZE_IN_BYTES - 1) / HASH_SIZE_IN_BYTES);
// seed for the pseudo-random fcn: salt + block index
byte[] saltAndIndex = new byte[salt.Length + 4];
Array.Copy(salt, 0, saltAndIndex, 0, salt.Length);
byte[] output = new byte[cBlocks * HASH_SIZE_IN_BYTES];
int outputOffset = 0;
SHA256Managed innerHash = new SHA256Managed();
SHA256Managed outerHash = new SHA256Managed();
// HMAC says the key must be hashed or padded with zeros
// so it fits into a single block of the hash in use
if (payload.Length > BLOCK_SIZE_IN_BYTES)
{
payload = innerHash.ComputeHash(payload);
}
byte[] key = new byte[BLOCK_SIZE_IN_BYTES];
Array.Copy(payload, 0, key, 0, payload.Length);
byte[] innerKey = new byte[BLOCK_SIZE_IN_BYTES];
byte[] outerKey = new byte[BLOCK_SIZE_IN_BYTES];
for (int i = 0; i < BLOCK_SIZE_IN_BYTES; ++i)
{
innerKey[i] = (byte)(key[i] ^ IPAD);
outerKey[i] = (byte)(key[i] ^ OPAD);
}
// for each block of desired output
for (int iBlock = 0; iBlock < cBlocks; ++iBlock)
{
// seed HMAC with salt & block index
IncrementBigEndianIndex(saltAndIndex, salt.Length);
byte[] u = saltAndIndex;
for (int i = 0; i < iterations; ++i)
{
// simple implementation of HMAC-SHA-256
innerHash.Initialize();
innerHash.TransformBlock(innerKey, 0,
BLOCK_SIZE_IN_BYTES, innerKey, 0);
innerHash.TransformFinalBlock(u, 0, u.Length);
byte[] temp = innerHash.Hash;
outerHash.Initialize();
outerHash.TransformBlock(outerKey, 0,
BLOCK_SIZE_IN_BYTES, outerKey, 0);
outerHash.TransformFinalBlock(temp, 0, temp.Length);
u = outerHash.Hash; // U = result of HMAC
// xor result into output buffer
XorByteArray(u, 0, HASH_SIZE_IN_BYTES,
output, outputOffset);
}
outputOffset += HASH_SIZE_IN_BYTES;
}
byte[] result = new byte[howManyBytes];
Array.Copy(output, 0, result, 0, howManyBytes);
return(result);
}
private static void LerDados()
{
Console.WriteLine("Listening the server in a new thread");
while (true)
{
try
{
//Recebe os dados
byte[] lengthBytes = ler.ReadBytes(4);
int length = System.BitConverter.ToInt32(lengthBytes, 0);
byte[] rcvBytes = ler.ReadBytes(length);
//Tira da base64
string text = Encoding.UTF8.GetString(rcvBytes);
//Tira do JSON
Model.Message msg = JsonConvert.DeserializeObject <Model.Message>(text);
string mensagemText = Encoding.UTF8.GetString(msg.text);
Console.WriteLine("DEBUG: Test: " + mensagemText);
string chaveString = Encoding.ASCII.GetString(msg.chave);
RSA = DecodeX509PublicKey(Convert.FromBase64String(chaveString));
string mensagemHash = Encoding.ASCII.GetString(msg.hash);
string mensagemAssinada = Encoding.ASCII.GetString(msg.sign);
bool verify = verifySignature(mensagemAssinada, mensagemHash);
if (verify)
{
//Verifica o Hash SHA-256
SHA256Managed crypt = new SHA256Managed();
StringBuilder hash = new StringBuilder(); //StringBuilder para maior desempenho devido as constantes mudanças na string
string hashStr = Encoding.ASCII.GetString(msg.hash);
byte[] hashByte = Convert.FromBase64String(hashStr);
byte[] hashBytes = crypt.ComputeHash(msg.text);
foreach (byte theByte in hashBytes)
{
hash.Append(theByte.ToString("x2"));
}
StringBuilder messageHash = new StringBuilder();
foreach (byte theByte in hashByte)
{
messageHash.Append(theByte.ToString("x2"));
}
if (messageHash.Equals(hash))
{
Console.WriteLine("Server response: " + Encoding.UTF8.GetString(msg.text));
}
else
{
Console.WriteLine("Invalid message hash!");
}
}
Console.WriteLine("Result: " + verify);
}
catch (Exception e)
{
Console.WriteLine("Connection with the server was lost, shutting down client...");
Environment.Exit(0);
}
}
}
private void MakeRomFSData(RomfsFile[] RomFiles, MemoryStream metadata)
{
TempFile = Path.GetRandomFileName();
TB_Progress.Invoke((Action)(() => UpdateTB_Progress("Computing IVFC Header Data...")));
IVFCInfo ivfc = new IVFCInfo();
ivfc.Levels = new IVFCLevel[3];
for (int i = 0; i < ivfc.Levels.Length; i++)
{
ivfc.Levels[i] = new IVFCLevel();
ivfc.Levels[i].BlockSize = 0x1000;
}
ivfc.Levels[2].DataLength = RomfsFile.GetDataBlockLength(RomFiles, (ulong)metadata.Length);
ivfc.Levels[1].DataLength = (Align(ivfc.Levels[2].DataLength, ivfc.Levels[2].BlockSize) / ivfc.Levels[2].BlockSize) * 0x20; //0x20 per SHA256 hash
ivfc.Levels[0].DataLength = (Align(ivfc.Levels[1].DataLength, ivfc.Levels[1].BlockSize) / ivfc.Levels[1].BlockSize) * 0x20; //0x20 per SHA256 hash
ulong MasterHashLen = (Align(ivfc.Levels[0].DataLength, ivfc.Levels[0].BlockSize) / ivfc.Levels[0].BlockSize) * 0x20;
ulong lofs = 0;
for (int i = 0; i < ivfc.Levels.Length; i++)
{
ivfc.Levels[i].HashOffset = lofs;
lofs += Align(ivfc.Levels[i].DataLength, ivfc.Levels[i].BlockSize);
}
uint IVFC_MAGIC = 0x43465649; //IVFC
uint RESERVED = 0x0;
uint HeaderLen = 0x5C;
uint MEDIA_UNIT_SIZE = 0x200;
byte[] SuperBlockHash = new byte[0x20];
FileStream OutFileStream = new FileStream(TempFile, FileMode.Create, FileAccess.ReadWrite);
try
{
OutFileStream.Seek(0, SeekOrigin.Begin);
OutFileStream.Write(BitConverter.GetBytes(IVFC_MAGIC), 0, 0x4);
OutFileStream.Write(BitConverter.GetBytes(0x10000), 0, 0x4);
OutFileStream.Write(BitConverter.GetBytes(MasterHashLen), 0, 0x4);
for (int i = 0; i < ivfc.Levels.Length; i++)
{
OutFileStream.Write(BitConverter.GetBytes(ivfc.Levels[i].HashOffset), 0, 0x8);
OutFileStream.Write(BitConverter.GetBytes(ivfc.Levels[i].DataLength), 0, 0x8);
OutFileStream.Write(BitConverter.GetBytes((int)(Math.Log(ivfc.Levels[i].BlockSize, 2))), 0, 0x4);
OutFileStream.Write(BitConverter.GetBytes(RESERVED), 0, 0x4);
}
OutFileStream.Write(BitConverter.GetBytes(HeaderLen), 0, 0x4);
//IVFC Header is Written.
OutFileStream.Seek((long)Align(MasterHashLen + 0x60, ivfc.Levels[0].BlockSize), SeekOrigin.Begin);
byte[] metadataArray = metadata.ToArray();
OutFileStream.Write(metadataArray, 0, metadataArray.Length);
long baseOfs = OutFileStream.Position;
TB_Progress.Invoke((Action)(() => UpdateTB_Progress("Writing Level 2 Data...")));
PB_Show.Invoke((Action)(() =>
{
PB_Show.Minimum = 0;
PB_Show.Maximum = RomFiles.Length;
PB_Show.Value = 0;
PB_Show.Step = 1;
}));
for (int i = 0; i < RomFiles.Length; i++)
{
OutFileStream.Seek((long)(baseOfs + (long)RomFiles[i].Offset), SeekOrigin.Begin);
using (FileStream inStream = new FileStream(RomFiles[i].FullName, FileMode.Open, FileAccess.Read))
{
while (inStream.Position < inStream.Length)
{
byte[] buffer = new byte[inStream.Length - inStream.Position > 0x100000 ? 0x100000 : inStream.Length - inStream.Position];
inStream.Read(buffer, 0, buffer.Length);
OutFileStream.Write(buffer, 0, buffer.Length);
}
}
PB_Show.Invoke((Action)(() => PB_Show.PerformStep()));
}
long hashBaseOfs = (long)Align((ulong)OutFileStream.Position, ivfc.Levels[2].BlockSize);
long hOfs = (long)Align(MasterHashLen, ivfc.Levels[0].BlockSize);
long cOfs = hashBaseOfs + (long)ivfc.Levels[1].HashOffset;
SHA256Managed sha = new SHA256Managed();
for (int i = ivfc.Levels.Length - 1; i >= 0; i--)
{
TB_Progress.Invoke((Action)(() => UpdateTB_Progress("Computing Level " + i + " Hashes...")));
byte[] buffer = new byte[(int)ivfc.Levels[i].BlockSize];
PB_Show.Invoke((Action)(() =>
{
PB_Show.Minimum = 0;
PB_Show.Maximum = (int)(ivfc.Levels[i].DataLength / ivfc.Levels[i].BlockSize);
PB_Show.Value = 0;
PB_Show.Step = 1;
}));
for (long ofs = 0; ofs < (long)ivfc.Levels[i].DataLength; ofs += ivfc.Levels[i].BlockSize)
{
OutFileStream.Seek(hOfs, SeekOrigin.Begin);
OutFileStream.Read(buffer, 0, (int)ivfc.Levels[i].BlockSize);
hOfs = OutFileStream.Position;
byte[] hash = sha.ComputeHash(buffer);
OutFileStream.Seek(cOfs, SeekOrigin.Begin);
OutFileStream.Write(hash, 0, hash.Length);
cOfs = OutFileStream.Position;
PB_Show.Invoke((Action)(() => PB_Show.PerformStep()));
}
if (i == 2)
{
long len = OutFileStream.Position;
if (len % 0x1000 != 0)
{
len = (long)Align((ulong)len, 0x1000);
byte[] buf = new byte[len - OutFileStream.Position];
OutFileStream.Write(buf, 0, buf.Length);
}
}
if (i > 0)
{
hOfs = hashBaseOfs + (long)ivfc.Levels[i - 1].HashOffset;
if (i > 1)
{
cOfs = hashBaseOfs + (long)ivfc.Levels[i - 2].HashOffset;
}
else
{
cOfs = (long)Align(HeaderLen, PADDING_ALIGN);
}
}
}
OutFileStream.Seek(0, SeekOrigin.Begin);
uint SuperBlockLen = (uint)Align(MasterHashLen + 0x60, MEDIA_UNIT_SIZE);
byte[] MasterHashes = new byte[SuperBlockLen];
OutFileStream.Read(MasterHashes, 0, (int)SuperBlockLen);
SuperBlockHash = sha.ComputeHash(MasterHashes);
}
finally
{
if (OutFileStream != null)
{
OutFileStream.Dispose();
}
}
TB_Progress.Invoke((Action)(() => UpdateTB_Progress("RomFS Super Block Hash: " + ByteArrayToString(SuperBlockHash))));
TB_Progress.Invoke((Action)(() => UpdateTB_Progress("Prompting to Save...")));
SaveFileDialog sfd = new SaveFileDialog();
Invoke((Action)(() =>
{
if (sfd.ShowDialog() == DialogResult.OK)
{
TB_Progress.Invoke((Action)(() => UpdateTB_Progress("Writing Binary to " + sfd.FileName + "...")));
Thread thread = new Thread(() => WriteBinary(TempFile, sfd.FileName));
thread.IsBackground = true;
thread.Start();
}
}));
}
public static Byte[] SHA256(Byte[] Bytes)
{
SHA256 sha = new SHA256Managed();
return(sha.ComputeHash(Bytes));
}
public static string HashCode(this string password)
{
byte[] getByte = new ASCIIEncoding().GetBytes(password);
byte[] hashByte = new SHA256Managed().ComputeHash(getByte);
return(new ASCIIEncoding().GetString(hashByte));
}
/// <summary>
/// Generates a hash for the given plain text value and returns a
/// base64-encoded result. Before the hash is computed, a random salt
/// is generated and appended to the plain text. This salt is stored at
/// the end of the hash value, so it can be used later for hash
/// verification.
/// </summary>
/// <param name="byteData">
/// Plaintext value to be hashed.
/// </param>
/// <param name="hashAlgorithm">
/// Name of the hash algorithm. Allowed values are: "MD5", "SHA1",
/// "SHA256", "SHA384", "SHA512", "HMACMD5", "HMACSHA1", "HMACSHA256",
/// "HMACSHA512" (if any other value is specified MD5 will be used).
///
/// HMAC algorithms uses Hash-based Message Authentication Code.
/// The HMAC process mixes a secret key with the message data, hashes
/// the result with the hash function, mixes that hash value with
/// the secret key again, and then applies the hash function
/// a second time. HMAC hashes are fixed lenght and generally
/// much longer than non-HMAC hashes of the same type.
///
/// https://msdn.microsoft.com/en-us/library/system.security.cryptography.hmacsha256(v=vs.110).aspx
///
/// This value is case-insensitive.
/// </param>
/// <param name="saltBytes">
/// Optional but recommended salt bytes to apply to the hash. If not passed the
/// raw encoding is used. If salt is nullthe raw algorithm is used (useful for
/// file hashes etc.) HMAC versions REQUIRE that salt is passed.
/// </param>
/// <param name="useBinHex">if true returns the data as BinHex byte pair string. Otherwise Base64 is returned.</param>
/// <returns>
/// Hash value formatted as a base64-encoded or BinHex stringstring.
/// </returns>
public static string ComputeHash(byte[] byteData,
string hashAlgorithm,
byte[] saltBytes,
bool useBinHex = false)
{
if (byteData == null)
{
return(null);
}
// Convert plain text into a byte array.
byte[] plainTextWithSaltBytes;
if (saltBytes != null && !hashAlgorithm.StartsWith("HMAC"))
{
// Allocate array, which will hold plain text and salt.
plainTextWithSaltBytes =
new byte[byteData.Length + saltBytes.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < byteData.Length; i++)
{
plainTextWithSaltBytes[i] = byteData[i];
}
// Append salt bytes to the resulting array.
for (int i = 0; i < saltBytes.Length; i++)
{
plainTextWithSaltBytes[byteData.Length + i] = saltBytes[i];
}
}
else
{
plainTextWithSaltBytes = byteData;
}
HashAlgorithm hash;
// Make sure hashing algorithm name is specified.
if (hashAlgorithm == null)
{
hashAlgorithm = "";
}
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
case "HMACMD5":
hash = new HMACMD5(saltBytes);
break;
case "HMACSHA1":
hash = new HMACSHA1(saltBytes);
break;
case "HMACSHA256":
hash = new HMACSHA256(saltBytes);
break;
case "HMACSHA512":
hash = new HMACSHA512(saltBytes);
break;
default:
// default to MD5
hash = new MD5CryptoServiceProvider();
break;
}
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
hash.Dispose();
if (useBinHex)
{
return(BinaryToBinHex(hashBytes));
}
return(Convert.ToBase64String(hashBytes));
}
