private static byte[] Decode58Check(string input) { var decodeCheck = Base58.Decode(input); if (decodeCheck.Length <= 4) { return(null); } var decodeData = new byte[decodeCheck.Length - 4]; Array.Copy(decodeCheck, 0, decodeData, 0, decodeData.Length); var hash0 = Sha256.Hash(decodeData); var hash1 = Sha256.Hash(hash0); if (hash1[0] == decodeCheck[decodeData.Length] && hash1[1] == decodeCheck[decodeData.Length + 1] && hash1[2] == decodeCheck[decodeData.Length + 2] && hash1[3] == decodeCheck[decodeData.Length + 3]) { return(decodeData); } return(null); }
public void Main4Test() { Wallet.WalletClient wallet = GetMainNetWalletClient; var keyTriple = new KeyTriple("B7E85CA5910922C49DCCB92EE48DFEC13A60674845CB7152C86B88F31DA6DC67"); byte[] hashTransaction1 = StringHelper.HexStringToByteArray("a7e974c6e69fb7741bf5e08de8a2d8f6617826c59422b440de22e0612b03c393"); BytesMessage bytesMessage1 = new BytesMessage(); bytesMessage1.Value = ByteString.CopyFrom(hashTransaction1); Transaction transactionLoad1 = wallet.GetTransactionByIdAsync(bytesMessage1).GetAwaiter().GetResult(); Transaction.Types.Contract contract = transactionLoad1.RawData.Contract[0]; TransferContract transferContract = TransferContract.Parser.ParseFrom(contract.Parameter.Value.ToByteArray()); byte[] publicKeyOwner = transferContract.OwnerAddress.ToByteArray(); string encode = Base58.Encode(publicKeyOwner); byte[] transactionRaw = transactionLoad1.RawData.ToByteArray(); byte[] hash = Sha256.Hash(transactionRaw); string signBase64 = transactionLoad1.Signature[0].ToBase64(); byte[] byteArray = transactionLoad1.Signature[0].ToByteArray(); bool isSignatureValidFromBytes = new ECSigner().IsSignatureValidFromBytes(hash, byteArray, publicKeyOwner); }
private string getTransactionHash(Transaction transaction) { byte[] transactionHash = Sha256.Hash(transaction.RawData.ToByteArray()); string txid = transactionHash.ToHexString2(); return(txid); }
public ActionResult Login(UsersModel user) { using (augblogsEntities db = new augblogsEntities()) { if (user != null && !String.IsNullOrEmpty(user.Username) && !String.IsNullOrEmpty(user.Password)) { var username = user.Username; var password = Sha256.Hash(user.Password); var userLogin = (from u in db.Users where u.Username == username && u.Password == password select u).FirstOrDefault(); if (userLogin != null) { Session["UserLogin"] = userLogin; return(RedirectToAction("Index", "Home")); } } ModelState.AddModelError("", "Tên đăng nhập hoặc mật khẩu không đúng!"); } return(View()); }
public ActionResult ChangePassword(UsersModel um) { if (Session["UserLogin"] == null) { return(RedirectToAction("Login", "Home")); } User user = (User)Session["UserLogin"]; string username = user.Username; string currentPassowrd = user.Password; string password = Sha256.Hash(um.Password); string newPassword = Sha256.Hash(um.NewPassword); string confirmNewPassword = Sha256.Hash(um.ConfirmPassword); using (var db = new augblogsEntities()) { if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password) || string.IsNullOrEmpty(newPassword) || string.IsNullOrEmpty(confirmNewPassword)) { ModelState.AddModelError("", "Hãy điền đầy đủ các trường thông tin!"); } else if (!confirmNewPassword.Equals(newPassword)) { ModelState.AddModelError("ConfirmPassword", "Xác nhận mật khẩu mới không khớp!"); } else { if (!password.Equals(currentPassowrd)) { ModelState.AddModelError("Password", "Mật khẩu hiện tại không chính xác!"); } else { var userEdit = (from u in db.Users where u.Username == username select u).FirstOrDefault(); if (userEdit != null) { userEdit.Password = newPassword; int updated = db.SaveChanges(); if (updated > 0) { ViewBag.UpdateResult = "Cập nhật mật khẩu thành công."; } else { ViewBag.UpdateResult = "Cập nhật mật khẩu không thành công!"; } } } } } return(View(um)); }
public static byte[] sha3omit12(byte[] input) { byte[] hash = Sha256.Hash(input); byte[] address = hash.SubArray(11, hash.Length - 11); address[0] = TypeNode.AddressPreFixByte; return(address); }
public void Sha256_448Bits() { var(data, expected) = TestVectors["Sha256 448 Bits"]; var hash = Sha256.Hash(data); CustomAssert.MatchArrays(hash, expected); }
public void Sha256Stream_EmptyString() { var(data, expected) = TestVectorsStream["Sha256-Stream Empty String"]; var hash = Sha256.Hash(data); CustomAssert.MatchArrays(hash, expected); }
public void Hash_WithControlledInput_ResultMatchesExpected(string x, string y) { var input = x.FromHexToByteArray(); var hash = Sha256.Hash(input); var expected = y.FromHexToByteArray(); hash.Should().Equal(expected); }
public void Sha256Stream_896Bits() { var(data, expected) = TestVectorsStream["Sha256-Stream 896 Bits"]; var hash = Sha256.Hash(data); CustomAssert.MatchArrays(hash, expected); }
public void Sha256Stream_OneMillionSmallAs() { var(data, expected) = TestVectorsStream["Sha256-Stream One Million As"]; var hash = Sha256.Hash(data); CustomAssert.MatchArrays(hash, expected); }
public static bool CheckTrees(byte[] first, uint firstTreeSize, byte[] second, uint secondTreeSize, List <byte[]> consistency) { if (IsPowerOf2(firstTreeSize)) { consistency.Insert(0, first); } var fn = firstTreeSize - 1; var sn = secondTreeSize - 1; var tmp = fn >> BitOperations.TrailingZeroCount(fn); while (Lsb(fn) != 0) { fn >>= 1; sn >>= 1; } Debug.Assert(tmp == fn); if (consistency.Count == 0) { return(false); } var fr = consistency[0]; var sr = consistency[0]; for (int i = 1; i < consistency.Count; i++) { var c = consistency[i]; if (sn == 0) { return(false); } if (Lsb(fn) != 0 || fn == sn) { Sha256.Hash(fr, c, fr); Sha256.Hash(sr, c, sr); while (!(fn == 0 || Lsb(fn) != 0)) { fn >>= 1; sn >>= 1; } } else { Sha256.Hash(c, sr, sr); } fn >>= 1; sn >>= 1; } return(fr.AsSpan().SequenceEqual(first) && sr.AsSpan().SequenceEqual(second)); }
public static void HashEmptyWithSpan() { var a = new Sha256(); var expected = s_hashOfEmpty.DecodeHex(); var actual = new byte[expected.Length]; a.Hash(ReadOnlySpan <byte> .Empty, actual); Assert.Equal(expected, actual); }
private const string AddPreFixByteTestnet = "a0"; //a0 + address private static string Encode58Check(byte[] input) { var hash0 = Sha256.Hash(input); var hash1 = Sha256.Hash(hash0); var inputCheck = new byte[input.Length + 4]; Array.Copy(input, 0, inputCheck, 0, input.Length); Array.Copy(hash1, 0, inputCheck, input.Length, 4); return(Base58.Encode(inputCheck)); }
public static void HashEmptyWithSize() { var a = new Sha256(); var expected = s_hashOfEmpty.DecodeHex(); var actual = a.Hash(ReadOnlySpan <byte> .Empty, a.MaxHashSize); Assert.Equal(a.MaxHashSize, actual.Length); Assert.Equal(expected, actual); }
private static byte[] Hash(IEnumerable <byte[]> encoded) { Sha256 hash = New <Sha256>(); foreach (byte[] part in encoded) { hash.TransformBlock(part, 0, part.Length, null, 0); } hash.TransformFinalBlock(new byte[0], 0, 0); return(hash.Hash()); }
public static void Test(string msg, string digest) { var a = new Sha256(); var m = msg.DecodeHex(); var expected = digest.DecodeHex(); var actual = a.Hash(m, expected.Length); Assert.Equal(expected, actual); }
private Transaction signTransaction2Object(byte[] transaction, KeyTriple privateKey) { Transaction transaction1 = Transaction.Parser.ParseFrom(transaction); byte[] rawdata = transaction1.RawData.ToByteArray(); byte[] hash = Sha256.Hash(rawdata); byte[] sign = privateKey.GetSignature(hash); transaction1.Signature.Add(ByteString.CopyFrom(sign)); return(transaction1); }
private async Task <string> CreateAccessToken(ISessionIdentity identity) { var tokenBytes = Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(identity)); var encryptedToken = Aes.Encrypt(tokenBytes, encryptionKey); var hash = Sha256.Hash(tokenBytes); var tokenSignature = (await keyVaultClient.SignAsync(signKeyIdentifier, JsonWebKeySignatureAlgorithm.RS256, hash)).Result; return(identity.IdentityType.ToString() + "." + Convert.ToBase64String(encryptedToken) + "." + Convert.ToBase64String(tokenSignature)); }
private byte[] signTransaction2Byte(byte[] transactionBytes, KeyTriple privateKey) { Transaction transaction1 = Transaction.Parser.ParseFrom(transactionBytes); byte[] rawdata = transaction1.RawData.ToByteArray(); byte[] hash = Sha256.Hash(rawdata); byte[] sign = privateKey.GetSignature(hash); ByteString byteString = ByteString.CopyFrom(sign); Transaction transaction = transaction1.Clone(); transaction.Signature.Add(byteString); return(transaction.ToByteArray()); }
public void ValidateTransactionTest() { Wallet.WalletClient wallet = GetMainNetWalletClient; byte[] hashTransaction1 = StringHelper.HexStringToByteArray("a7e974c6e69fb7741bf5e08de8a2d8f6617826c59422b440de22e0612b03c393"); BytesMessage bytesMessage1 = new BytesMessage(); bytesMessage1.Value = ByteString.CopyFrom(hashTransaction1); Transaction signedTransaction = wallet.GetTransactionByIdAsync(bytesMessage1).GetAwaiter().GetResult(); Assert.IsTrue(signedTransaction.Signature.Count == signedTransaction.RawData.Contract.Count); RepeatedField <Transaction.Types.Contract> listContract = signedTransaction.RawData.Contract; byte[] hash = Sha256.Hash(signedTransaction.RawData.ToByteArray()); int count = signedTransaction.Signature.Count; if (count == 0) { Assert.Fail(); } for (int i = 0; i < count; ++i) { try { Transaction.Types.Contract contract = listContract[i]; TransferContract transferContract = TransferContract.Parser.ParseFrom(signedTransaction.RawData.Contract[i].Parameter.Value.ToByteArray()); byte[] owner = transferContract.OwnerAddress.ToByteArray(); signedTransaction.Signature[i].ToByteArray(); string signatureBase64 = Base64.ToBase64String(signedTransaction.Signature[i].ToByteArray()); byte[] address = signatureToAddress(hash, signatureBase64); if (!Arrays.AreEqual(owner, address)) { Assert.Fail(); } } catch (Exception e) { e.ToString(); Assert.Fail(); } } Assert.IsTrue(true); }
public Transaction Sign(Transaction transaction, KeyTriple keyTriple) { Transaction transactionBuilderSigned = transaction.Clone(); byte[] hash = Sha256.Hash(transaction.RawData.ToByteArray()); RepeatedField <Transaction.Types.Contract> listContract = transaction.RawData.Contract; for (int i = 0; i < listContract.Count; i++) { // внимание тут подпись нужно смотреть внимательное что переделалось byte[] signatureBytes = keyTriple.GetSignature(hash); ByteString bsSign = ByteString.CopyFrom(signatureBytes); transactionBuilderSigned.Signature .Add(bsSign); //Each contract may be signed with a different private key in the future. } transaction = transactionBuilderSigned.Clone(); return(transaction); }
public void TestInformalMillionA() { byte[] bytes = new byte[] { 97, 97, 97, 97, 97, 97, 97 }; Sha256 hash = New <Sha256>(); for (int i = 0; i < 1000000; i += bytes.Length) { if (1000000 - i > bytes.Length) { hash.TransformBlock(bytes, 0, bytes.Length, null, 0); } else { hash.TransformBlock(bytes, 0, 1000000 - i, null, 0); } } hash.TransformFinalBlock(new byte[0], 0, 0); byte[] actual; actual = hash.Hash(); Assert.That(actual, Is.EquivalentTo("CDC76E5C 9914FB92 81A1C7E2 84D73E67 F1809A48 A497200E 046D39CC C7112CD0".FromHex())); }
private ISessionIdentity ValidateTokenBearer(ISession session, string token) { var parts = token.Split('.'); if (parts.Length != 3) { throw new HttpStatusException($"Invalid:Token(Token={token})") { Status = StatusCode.Unauthorized } } ; var identityType = IdentityType.Unknown; switch (parts[0]) { case "App": identityType = IdentityType.App; break; case "Usr": identityType = IdentityType.User; break; case "Bot": identityType = IdentityType.Bot; break; default: throw new HttpStatusException($"Invalid:Token.IdentityType(Token={token})") { Status = StatusCode.Unauthorized }; } var encryptedToken = Convert.FromBase64String(parts[1]); var decryptedToken = default(byte[]); try { decryptedToken = Aes.Decrypt(encryptedToken, encryptionKey); } catch (Exception e) { throw new HttpStatusException($"UnableDecrypt:Token(Token={token})", e) { Status = StatusCode.Unauthorized }; } var hash = Sha256.Hash(decryptedToken); var sign = Convert.FromBase64String(parts[2]); if (!Rsa.VerifySha256Hash(hash, sign, jwk.N, jwk.E)) { throw new HttpStatusException($"ValidateFail:Signature(Token={token})") { Status = StatusCode.Unauthorized } } ; var tokenString = Encoding.UTF8.GetString(decryptedToken); ISessionIdentity identity = default(AnonymousIdentity); switch (identityType) { case IdentityType.App: identity = Newtonsoft.Json.JsonConvert.DeserializeObject <AppIdentity>(tokenString); break; case IdentityType.User: identity = Newtonsoft.Json.JsonConvert.DeserializeObject <UserIdentity>(tokenString); break; case IdentityType.Bot: //identity = Newtonsoft.Json.JsonConvert.DeserializeObject<BotI> break; default: throw new HttpStatusException($"Invalid:Token.IdentityType(Token={token})") { Status = StatusCode.Unauthorized }; } //if (identity == null) throw new HttpStatusException("Null:Identity") { Status = StatusCode.Unauthorized }; if (identity.ClientDeviceId != session.ClientDeviceId || identity.ClientSessionId != session.ClientSessionId) { throw new HttpStatusException( $"NotMatch:Session(IdentityDeviceId={identity.ClientDeviceId}, CurrentDeviceId={session.ClientDeviceId}, IdentitySessionId={identity.ClientSessionId}, CurrentSessionId={session.ClientSessionId})") { Status = StatusCode.Unauthorized } } ; if (identity.ExpireIn < DateTime.UtcNow.Ticks) { throw new HttpStatusException("Expired:Identity") { Status = StatusCode.Unauthorized } } ; return(identity); }
public byte[] GetTransactionHash(Transaction transaction) { byte[] hashTransaction = Sha256.Hash(transaction.RawData.ToByteArray()); return(hashTransaction); }
public void Sign(DateTime t, string[] includeHeaders = null, int debugLevel = 1) { if (includeHeaders == null) { includeHeaders = new string[] { "host", "content-type", "x-rai-date" }; } if (this.Creds == null) { return; } // ISO8601 date/time strings for time of request string signatureDate = String.Format("{0:yyyyMMddTHHmmssZ}", t); string scopeDate = String.Format("{0:yyyyMMdd}", t); // Authentication scope string scope = string.Join("/", new string[] { scopeDate, EnumString.GetDescription(this.Region), this.Service, "rai01_request" }); // SHA256 hash of content Sha256 shaw256HashAlgo = new Sha256(); byte[] reqContent = InnerReq.Content.ReadAsByteArrayAsync().Result; byte[] sha256Hash = shaw256HashAlgo.Hash(reqContent); string contentHash = sha256Hash.ToHex(); // HTTP headers InnerReq.Headers.Authorization = null; // Include "x-rai-date" in signed headers if (!InnerReq.Headers.Contains("x-rai-date")) { InnerReq.Headers.TryAddWithoutValidation("x-rai-date", signatureDate); } var allHeaders = InnerReq.Headers.Union(InnerReq.Content.Headers); // Sort and lowercase() Headers to produce canonical form string canonicalHeaders = string.Join( "\n", from header in allHeaders orderby header.Key.ToLower() where includeHeaders.Contains(header.Key.ToLower()) select string.Format( "{0}:{1}", header.Key.ToLower(), string.Join(",", header.Value).Trim() ) ); string signedHeaders = string.Join( ";", from header in allHeaders orderby header.Key.ToLower() where includeHeaders.Contains(header.Key.ToLower()) select header.Key.ToLower() ); // Sort Query String var parsedQuery = HttpUtility.ParseQueryString(InnerReq.RequestUri.Query); var parsedQueryDict = parsedQuery.AllKeys.SelectMany( parsedQuery.GetValues, (k, v) => new { key = k, value = v } ); string query = string.Join( "&", from qparam in parsedQueryDict orderby qparam.key, qparam.value select string.Format( "{0}={1}", HttpUtility.UrlEncode(qparam.key), HttpUtility.UrlEncode(qparam.value)) ); // Create hash of canonical request string canonicalForm = string.Format( "{0}\n{1}\n{2}\n{3}\n\n{4}\n{5}", InnerReq.Method, HttpUtility.UrlPathEncode(InnerReq.RequestUri.AbsolutePath), query, canonicalHeaders, signedHeaders, contentHash ); if (debugLevel > 2) { Console.WriteLine("reqContent:"); Console.WriteLine(System.Text.Encoding.Default.GetString(reqContent)); Console.WriteLine("canonical_form:"); Console.WriteLine(canonicalForm); Console.WriteLine(); } sha256Hash = shaw256HashAlgo.Hash(Encoding.UTF8.GetBytes(canonicalForm)); string canonicalHash = sha256Hash.ToHex(); // Create and sign "String to Sign" string stringToSign = string.Format( "RAI01-ED25519-SHA256\n{0}\n{1}\n{2}", signatureDate, scope, canonicalHash ); byte[] seed = Convert.FromBase64String(Creds.PrivateKey); // select the Ed25519 signature algorithm var algorithm = SignatureAlgorithm.Ed25519; // create a new key pair using var key = Key.Import(algorithm, seed, KeyBlobFormat.RawPrivateKey); // sign the data using the private key byte[] signature = algorithm.Sign(key, Encoding.UTF8.GetBytes(stringToSign)); string sig = signature.ToHex(); if (debugLevel > 2) { Console.WriteLine("string_to_sign:"); Console.WriteLine(stringToSign); Console.WriteLine(); Console.WriteLine("signature:"); Console.WriteLine(sig); Console.WriteLine(); } var authHeader = string.Format( "RAI01-ED25519-SHA256 Credential={0}/{1}, SignedHeaders={2}, Signature={3}", Creds.AccessKey, scope, signedHeaders, sig ); InnerReq.Headers.TryAddWithoutValidation("Authorization", authHeader); }
private byte[] getBlockHash(Block block) { return(Sha256.Hash(block.BlockHeader.RawData.ToByteArray())); }