public string ComputeHash(byte[] buffer)
{
var sha = Sha3.Sha3256();
var result = sha.ComputeHash(buffer);
return(result.ToHex());
}
public string Encrypt(string message)
{
byte[] result = null;
StringBuilder hash = new StringBuilder();
switch (HashSize)
{
case HashFunctionSize.Bits224:
result = Sha3.Sha3224().ComputeHash(Encoding.UTF8.GetBytes(message));
break;
case HashFunctionSize.Bits256:
result = Sha3.Sha3256().ComputeHash(Encoding.UTF8.GetBytes(message));
break;
case HashFunctionSize.Bits384:
result = Sha3.Sha3384().ComputeHash(Encoding.UTF8.GetBytes(message));
break;
case HashFunctionSize.Bits512:
result = Sha3.Sha3512().ComputeHash(Encoding.UTF8.GetBytes(message));
break;
}
for (int i = 0; i < result.Length; i++)
{
hash.Append(result[i].ToString("x2"));
}
return(hash.ToString());
}
public string ComputeHash(string str)
{
var buffer = Encoding.ASCII.GetBytes(str);
var sha = Sha3.Sha3256();
var result = sha.ComputeHash(buffer);
return(result.ToHex());
}
public async Task <string> ComputeSha3OfObject(string path)
{
await using var dataStream = await GetObjectContent(path);
var sha3 = Sha3.Sha3256();
var hash = await sha3.ComputeHashAsync(dataStream);
return(Convert.ToHexString(hash).ToLowerInvariant());
}
static string GenerateId(string[] row)
{
var id = row[1] + row[2] + row[3];
using (var shaAlg = Sha3.Sha3256())
{
return(Encoding.UTF8.GetString(shaAlg.ComputeHash(Encoding.UTF8.GetBytes(id))));
}
}
/// <summary>
/// Faz o HASH SHA-3 da senha
/// </summary>
/// <param name="Password"></param>
/// <returns></returns>
internal string HashPassword(string Password)
{
StringBuilder x = new StringBuilder();
foreach (var item in Sha3.Sha3256().ComputeHash(Encoding.UTF8.GetBytes(Password)))
{
x.Append(item.ToString("x2"));
}
return(x.ToString());
}
public void ATest()
{
ECSigner ecSigner = new ECSigner("F43EBCC94E6C257EDBE559183D1A8778B2D5A08040902C0F0A77A3343A1D0EA5");
byte[] encoded = ecSigner._keyPair.ECPublicKey.Q.GetEncoded();
byte[] computeHash = Sha3.Sha3256().ComputeHash(encoded, 1, 64);
string string2 = computeHash.ToHexString2();
String pubkey04 = "04e6a49d098ee94871252622b8a8b727e5cdf81b7138e5ac16591887f6e8c10e881e4b4250fa8c87f5b29ad020216a9ffd0acf5995a627d6c70e4dd274c54c20bd";
string hexString04 = Sha3.Sha3256().ComputeHash(pubkey04.FromHexToByteArray2(), 1, 64).ToHexString2();
}
/// <summary>
/// Making SHA3-256 hash for password.
/// </summary>
/// <param name="input"> password in string </param>
/// <returns> hash SHA3-256 </returns>
public static byte[] ComputeHash(string input)
{
byte[] byteArray = Encoding.UTF32.GetBytes(input);
MemoryStream stream = new MemoryStream(byteArray);
var hash = Sha3.Sha3256().ComputeHash(stream);
stream = new MemoryStream(hash);
StreamReader rdr = new StreamReader(stream);
string tst = rdr.ReadToEnd();
return(hash);
}
public override string ToString()
{
var sha3Hash = Sha3.Sha3256().ComputeHash(Value);
var sha3HashBytes = new byte[20];
Array.Copy(sha3Hash, sha3Hash.Length - 20, sha3HashBytes, 0, 20);
var address = _addressPrefix + sha3HashBytes.ToHexString();
var hexToByteArray = address.FromHexToByteArray();
var hash = Sha256.HashTwice(hexToByteArray);
var bytes = new byte[4];
Array.Copy(hash, bytes, 4);
var checksum = bytes.ToHexString();
var addChecksum = (address + checksum).FromHexToByteArray();
Array.Copy(hexToByteArray, addChecksum, hexToByteArray.Length);
return(Base58.Encode(addChecksum));
}
public void Sha3256ComputeHash_WithControlledInput_ResultMatchesExpected(string input, string expected)
{
var hash = Sha3.Sha3256().ComputeHash(Encoding.ASCII.GetBytes(input));
hash.ToHexString().Should().Be(expected);
}
static void Main(string[] args)
{
Channel channel = new Channel("ac.testnet.libra.org:8000", ChannelCredentials.Insecure);
var client = new AdmissionControl.AdmissionControl.AdmissionControlClient(channel);
HexEncoder hex = new HexEncoder();
SharedSecret sharedSecret = SharedSecret.Import(Encoding.UTF8.GetBytes("newdummy"));
HkdfSha512 kdf = new HkdfSha512();
var key = kdf.DeriveKey(sharedSecret, null, null, Ed25519.Ed25519);
var sender = key.PublicKey.Export(KeyBlobFormat.RawPublicKey);
UInt64 seqNum = 11;
string senderHex = hex.EncodeData(Sha3.Sha3256().ComputeHash(sender));
uint amount = 10000000;
string reciver = "4ba2555fd146e79e37fda7a2f30dc1b4f3d9228aa48b230dbab0a18d407f2f9b";
RawTransactionLCS rawTr = new RawTransactionLCS()
{
ExpirationTime = (ulong)DateTimeOffset.UtcNow.AddSeconds(60)
.ToUnixTimeSeconds(),
GasUnitPrice = 0,
MaxGasAmount = 100000,
SequenceNumber = seqNum
};
rawTr.TransactionPayload = new TransactionPayloadLCS();
rawTr.TransactionPayload.PayloadType = (uint)TransactionPayloadLCSEnum.Script;
rawTr.TransactionPayload.Script = new ScriptLCS()
{
Code = Utilities.PtPTrxBytecode,
TransactionArguments = new List <TransactionArgumentLCS>()
{
new TransactionArgumentLCS()
{
ArgType = (uint)TransactionArgumentLCSEnum.Address,
Address = new AddressLCS(reciver)
},
new TransactionArgumentLCS()
{
ArgType = (uint)TransactionArgumentLCSEnum.U64,
U64 = amount
}
}
};
rawTr.Sender = new AddressLCS(senderHex);
var bytesTrx = LCSCore.LCSSerialization(rawTr);
Types.SignedTransaction signedTx = new Types.SignedTransaction();
var bytesTrxHash = Google.Protobuf.ByteString.CopyFrom(bytesTrx);
var seed = Encoding.ASCII.GetBytes(RAWTX_HASH_SALT + LIBRA_HASH_SUFFIX);
var seedHash = Sha3.Sha3256().ComputeHash(seed);
List <byte> hashInput = new List <byte>();
hashInput.AddRange(seedHash);
hashInput.AddRange(bytesTrxHash);
var hash = Sha3.Sha3256().ComputeHash(hashInput.ToArray());
SubmitTransactionRequest req = new SubmitTransactionRequest();
req.SignedTxn = new SignedTransaction();
List <byte> retArr = new List <byte>();
retArr = retArr.Concat(bytesTrx).ToList();
retArr = retArr.Concat(
LCSCore.LCSSerialization(key.Export(KeyBlobFormat.RawPublicKey))).ToList();
var sig = SignatureAlgorithm.Ed25519.Sign(key, hash);
retArr = retArr.Concat(LCSCore.LCSSerialization(sig)).ToList();
req.SignedTxn.SignedTxn = ByteString.CopyFrom(retArr.ToArray());
var result = client.SubmitTransaction(
req, new Metadata());
Task.Delay(5000).Wait();
GetTransaction(client, senderHex, seqNum);
}
