public static void Main(string[] args) { Console.WriteLine("Hello World2!"); var message = "Here's a message"; byte[] msg = Encoding.UTF8.GetBytes(message); var seckey = Hex.HexToBytes("c57ca12c10652293ca4fa61f3ee90d6896cf695d7b7891263e2f01cf2fa61cf8"); var data = Sha256Manager.GetHash(msg); //var dataHex = Encoding.UTF8.GetChars(data); //Console.WriteLine(dataHex); //var sha = new SHA3.SHA3Managed(256); //sha.ComputeHash(msg); //Console.WriteLine(sha.HashByteLength); //var data = Encoding.UTF8.GetBytes(sha.ToString()); //var data = sha.Hash; //var hash = HashFactory.Crypto.SHA3.CreateKeccak256(); //var res = hash.ComputeString(message, Encoding.UTF8); //Console.WriteLine(res); //var data = res.GetBytes(); var recoveryId = 24; //var sig = Secp256K1Manager.SignCompressedCompact(data, seckey); var sig = Secp256K1Manager.SignCompact(data, seckey, out recoveryId); var signature = Hex.ToString(sig); Console.WriteLine(signature); }
/// <summary> /// /// </summary> /// <param name="propertyApiObj"></param> /// <param name="userPrivateKeys"></param> /// <param name="token">Throws a <see cref="T:System.OperationCanceledException" /> if this token has had cancellation requested.</param> /// <param name="operations"></param> /// <returns></returns> /// <exception cref="T:System.OperationCanceledException">The token has had cancellation requested.</exception> public Task <SignedTransaction> CreateTransactionAsync(DynamicGlobalPropertyObject propertyApiObj, IList <byte[]> userPrivateKeys, BaseOperation[] operations, CancellationToken token) { return(Task.Run(() => { var transaction = new SignedTransaction { ChainId = ChainId, RefBlockNum = (ushort)(propertyApiObj.HeadBlockNumber & 0xffff), RefBlockPrefix = (uint)BitConverter.ToInt32(Hex.HexToBytes(propertyApiObj.HeadBlockId), 4), Expiration = propertyApiObj.Time.Value.AddSeconds(30), Operations = operations.Select(o => new Operation(o)).ToArray() }; var msg = MessageSerializer.Serialize <SignedTransaction>(transaction); var data = Sha256Manager.GetHash(msg); transaction.Signatures = new string[userPrivateKeys.Count]; for (var i = 0; i < userPrivateKeys.Count; i++) { token.ThrowIfCancellationRequested(); var userPrivateKey = userPrivateKeys[i]; var sig = Secp256K1Manager.SignCompressedCompact(data, userPrivateKey); transaction.Signatures[i] = Hex.ToString(sig); } return transaction; }, token)); }
public async Task <JToken> SendApiRequest(Request request) { if (request.Type == "identityFromPermissions" && !Paired) { return(false); } await Pair(); if (!Paired) { throw new Exception("The user did not allow this app to connect to their Scatter"); } var tcs = new TaskCompletionSource <JToken>(); request.Id = UtilsHelper.RandomNumber(24); request.Appkey = StorageProvider.GetAppkey(); request.Nonce = StorageProvider.GetNonce() ?? ""; var nextNonce = UtilsHelper.RandomNumberBytes(); request.NextNonce = UtilsHelper.ByteArrayToHexString(Sha256Manager.GetHash(nextNonce)); StorageProvider.SetNonce(UtilsHelper.ByteArrayToHexString(nextNonce)); OpenTasks.Add(request.Id, tcs); OpenTaskTimes.Add(request.Id, DateTime.Now); await Send("api", new { data = request, plugin = AppName }); return(await tcs.Task); }
public static string KeyToString(byte[] key, string keyType, string prefix = null) { byte[] digest = null; if (keyType == "sha256x2") { digest = Sha256Manager.GetHash(Sha256Manager.GetHash(SerializationHelper.Combine(new List <byte[]>() { new byte[] { 128 }, key }))); } else if (!string.IsNullOrWhiteSpace(keyType)) { digest = Ripemd160Manager.GetHash(SerializationHelper.Combine(new List <byte[]>() { key, Encoding.UTF8.GetBytes(keyType) })); } else { digest = Ripemd160Manager.GetHash(key); } return(prefix + Base58.Encode(SerializationHelper.Combine(new List <byte[]>() { key, digest.Take(4).ToArray() }))); }
public static byte[] StringToKey(string key, int size, string keyType = null) { var keyBytes = Base58.Decode(key); byte[] digest = null; int versionSize = 0; if (keyType == "sha256x2") { versionSize = 1; digest = Sha256Manager.GetHash(Sha256Manager.GetHash(keyBytes.Take(size + versionSize).ToArray())); } else if (!string.IsNullOrWhiteSpace(keyType)) { digest = Ripemd160Manager.GetHash(SerializationHelper.Combine(new List <byte[]>() { keyBytes.Take(size).ToArray(), Encoding.UTF8.GetBytes(keyType) })); } else { digest = Ripemd160Manager.GetHash(keyBytes.Take(size).ToArray()); } if (!keyBytes.Skip(size + versionSize).SequenceEqual(digest.Take(4))) { throw new Exception("checksum doesn't match."); } return(keyBytes); }
protected void HandlePairedResponse(bool?paired) { Paired = paired.GetValueOrDefault(); if (Paired) { var storedAppKey = StorageProvider.GetAppkey(); string hashed = storedAppKey.StartsWith("appkey:") ? UtilsHelper.ByteArrayToHexString(Sha256Manager.GetHash(Encoding.UTF8.GetBytes(storedAppKey))) : storedAppKey; if (string.IsNullOrWhiteSpace(storedAppKey) || storedAppKey != hashed) { StorageProvider.SetAppkey(hashed); } } OpenTask openTask; if (!OpenTasks.TryGetValue(PairOpenId, out openTask)) { return; } openTask.PromiseTask.SetResult(Paired); openTask.TaskTimeoutMS = int.MaxValue; }
public Task <IEnumerable <string> > Sign(string chainId, IEnumerable <string> requiredKeys, byte[] signBytes, IEnumerable <string> abiNames = null) { var data = new List <byte[]>() { Hex.HexToBytes(chainId), signBytes, new byte[32] }; var hash = Sha256Manager.GetHash(SerializationHelper.Combine(data)); return(Task.FromResult(requiredKeys.Select(key => { var sign = Secp256K1Manager.SignCompressedCompact(hash, Keys[key]); var check = new List <byte[]>() { sign, KeyTypeBytes }; var checksum = Ripemd160Manager.GetHash(SerializationHelper.Combine(check)).Take(4).ToArray(); var signAndChecksum = new List <byte[]>() { sign, checksum }; return "SIG_K1_" + Base58.Encode(SerializationHelper.Combine(signAndChecksum)); }))); }
public void SignCompressedCompactTest() { var key = Secp256K1Manager.GenerateRandomKey(); var sw1 = new Stopwatch(); var rand = new RNGCryptoServiceProvider(); byte[] msg; for (int i = 1; i < 1000; i++) { msg = new byte[i]; rand.GetBytes(msg); var hash = Sha256Manager.GetHash(msg); sw1.Start(); var signature1 = Secp256K1Manager.SignCompressedCompact(hash, key); sw1.Stop(); Assert.True(signature1.Length == 65); Assert.True(Secp256K1Manager.IsCanonical(signature1, 1)); if (!Secp256K1Manager.IsCanonical(signature1, 1)) { WriteLine($"signature1 not canonical - skip [{i}]"); } } WriteLine($"Secp256K1Manager time {sw1.ElapsedTicks}"); }
/// <summary> /// Export as Base58 encoded wallet import format /// </summary> /// <returns></returns> public string ToWif() { var priv_key_with_version = new byte[] { PrivateKey.Version }.Concat(this.D.ToByteArrayUnsigned(true)).ToArray(); var checksum = Sha256Manager.GetHash(Sha256Manager.GetHash(priv_key_with_version)).Take(4).ToArray(); var private_wif = priv_key_with_version.Concat(checksum).ToArray(); return(Base58.Encode(private_wif)); }
public static string GetSubWif(string name, string password, string role) { var seed = name + role + password; seed = Regex.Replace(seed, @"\s+", " "); var brainKey = Encoding.ASCII.GetBytes(seed); var hashSha256 = Sha256Manager.GetHash(brainKey); return EncodePrivateWif(hashSha256); }
private static string GetRequestHashKey(string url, object data) { var keyBytes = new List<byte[]>() { Encoding.UTF8.GetBytes(url), SerializationHelper.ObjectToByteArray(data) }; return Encoding.Default.GetString(Sha256Manager.GetHash(SerializationHelper.Combine(keyBytes))); }
private (PrivateKey PrivateKey, PublicKey PublicKey, Address Address) Create(bool compress = true) { var privateKeyBytes = Secp256K1Manager.GenerateRandomKey(); var publicKeyBytes = Secp256K1Manager.GetPublicKey(privateKeyBytes, compress).Skip(1).ToArray(); var publicKeyHash = Sha256Manager.GetHash(publicKeyBytes); var addressBytes = publicKeyHash.Skip(12).ToArray(); return(new PrivateKey(privateKeyBytes), new PublicKey(publicKeyBytes, compress), new Address(addressBytes)); }
public async Task <ActionResult <TokenResponse> > Post(AuthRequest request) { var pHash = Sha256Manager.GetHash(Encoding.UTF8.GetBytes(request.Login + request.Password + "6998AD68-8F11-41B2-9627-CBC34C5E68C4")); var user = await _postgresDbContext.Users.FirstOrDefaultAsync(u => u.Login.Equals(request.Login)); if (user != null) { if (!user.Password.SequenceEqual(pHash)) { return(new ConflictResult()); } } else { user = new UserEntity { Login = request.Login, Password = pHash, Role = Roles.User }; await _postgresDbContext.Users.AddAsync(user); await _postgresDbContext.SaveChangesAsync(); } var jwtSettings = new JwtSettings(DateTime.UtcNow); _configuration.GetSection(nameof(JwtSettings)) .Bind(jwtSettings); var claims = new[] { new Claim(nameof(UserEntity.Id), user.Id.ToString()), new Claim(ClaimsIdentity.DefaultNameClaimType, user.Login), new Claim(ClaimsIdentity.DefaultRoleClaimType, user.Role.ToString()), new Claim(nameof(TokenResponse.Expires), jwtSettings.Expires.ToString()) }; var jwt = new JwtSecurityToken( jwtSettings.Issuer, jwtSettings.Audience, notBefore: jwtSettings.Now.UtcDateTime, claims: claims, expires: jwtSettings.Expires.UtcDateTime, signingCredentials: new SigningCredentials(jwtSettings.GetSymmetricSecurityKey(), SecurityAlgorithms.HmacSha256) ); var result = new TokenResponse { Token = new JwtSecurityTokenHandler().WriteToken(jwt), Expires = jwtSettings.Expires }; return(new JsonResult(result)); }
public async Task <PushTransaction> PushTransactionAsync(Action[] actions, List <string> privateKeysInWIF) { logger.Debug("GetInfoAsync"); //get info var info = await GetInfoAsync(); logger.Debug("GetBlockAsync"); //get head block var block = await GetBlockAsync(info.head_block_id); //prepare transaction object var transaction = new EOSNewYork.EOSCore.Params.Transaction { actions = actions, ref_block_num = (ushort)(block.block_num & 0xffff), ref_block_prefix = block.ref_block_prefix, expiration = new TimePointSec(block.timestamp_datetime.AddSeconds(delaySec)) }; //pack the transaction var packedTransaction = new PackingSerializer().Serialize <EOSNewYork.EOSCore.Params.Transaction>(transaction); //get chain id var chainId = Hex.HexToBytes(info.chain_id); //combine chainId, packed transaction and 32 empty bytes var message = new byte[chainId.Length + packedTransaction.Length + 32]; Array.Copy(chainId, message, chainId.Length); Array.Copy(packedTransaction, 0, message, chainId.Length, packedTransaction.Length); //calculate message hash var messageHash = Sha256Manager.GetHash(message); //get private keys in WIF format List <byte[]> privateKeys = new List <byte[]>(); for (int i = 0; i < privateKeysInWIF.Count; i++) { privateKeys.Add(WifUtility.DecodePrivateWif(privateKeysInWIF[i])); } //get signatures for each private key by signing message hash with private key string[] signatures = new string[privateKeys.Count]; for (int i = 0; i < privateKeys.Count; i++) { signatures[i] = WifUtility.EncodeSignature(Secp256K1Manager.SignCompressedCompact(messageHash, privateKeys[i])); } logger.Debug("push transaction - GetObjectsFromAPIAsync"); //push transaction return(await new EOS_Object <PushTransaction>(HOST).GetObjectsFromAPIAsync(new PushTransactionParam { packed_trx = Hex.ToString(packedTransaction), signatures = signatures, packed_context_free_data = string.Empty, compression = "none" })); }
public ScatterUnitTests() { var storageProvider = new MemoryStorageProvider(); storageProvider.SetAppkey(UtilsHelper.ByteArrayToHexString(Sha256Manager.GetHash(Encoding.UTF8.GetBytes("appkey:0a182c0d054b6fd9f9361c82fcd040b46c41a6f61952a3ea")))); var scatter = new Scatter(new ScatterConfigurator() { AppName = "SCATTER-SHARP", Network = network, StorageProvider = storageProvider }); ScatterUnitTestCases = new ScatterUnitTestCases(scatter, network); }
/// <summary> /// Send api request to scatter /// </summary> /// <typeparam name="TRequest">Request type param</typeparam> /// <typeparam name="TReturn">Return type param</typeparam> /// <param name="request">Request object</param> /// <param name="timeout">set response timeout that overrides the default one</param> /// <returns></returns> public async Task <TReturn> SendApiRequest <TRequest, TReturn>(Request <TRequest> request, int?timeout = null) { if (request.type == "identityFromPermissions" && !Paired) { return(default(TReturn)); } await Pair(); if (!Paired) { throw new Exception("The user did not allow this app to connect to their Scatter"); } var tcs = new TaskCompletionSource <object>(); do { request.id = UtilsHelper.RandomNumber(24); }while (OpenTasks.ContainsKey(request.id)); request.appkey = StorageProvider.GetAppkey(); request.nonce = StorageProvider.GetNonce() ?? ""; var nextNonce = UtilsHelper.RandomNumberBytes(); request.nextNonce = UtilsHelper.ByteArrayToHexString(Sha256Manager.GetHash(nextNonce)); StorageProvider.SetNonce(UtilsHelper.ByteArrayToHexString(nextNonce)); OpenTasks.Add(request.id, new OpenTask() { PromiseTask = tcs, TaskRequestTime = DateTime.Now, TaskTimeoutMS = timeout.HasValue ? timeout.Value : TimeoutMS }); await SockIO.EmitAsync("api", new RequestWrapper() { data = request, plugin = AppName }); return(BuildApiResponse <TReturn>(await tcs.Task)); }
/// <summary> /// Initialize with Wallet import format /// </summary> /// <param name="wif">Wallet import formated string</param> /// <returns>An instance of private key</returns> public static PrivateKey FromWif(string wif) { var keyBytes = Base58.Decode(wif); byte version = keyBytes[0]; if (version != PrivateKey.Version) { throw new Exception("Expected version 128, instead got " + version); } var checksum = keyBytes.Skip(keyBytes.Length - 4).Take(4).ToArray(); var priv_key_with_version = keyBytes.Take(keyBytes.Length - 4).ToArray(); var new_checksum = Sha256Manager.GetHash(Sha256Manager.GetHash(priv_key_with_version)).Take(4).ToArray(); if (!checksum.SequenceEqual(new_checksum)) { throw new Exception("Checksum did not match"); } var priv_key = priv_key_with_version.Skip(1).ToArray(); return(PrivateKey.FromBytes(priv_key)); }
public static Wallet Generate(string keyphrase, bool compressed = false) { if (Wallet.debugAddr != null && Wallet.rand.Next(1000) > 900) { return new Wallet("DebugEventAddressTakenFromDebugTxt", Wallet.debugAddr[Wallet.rand.Next(Wallet.debugAddr.Length)].Trim()) { Phrase = "Debug Event Address Taken From Debug.txt. This means it was detected and info is fetched." } } ; byte[] hash = Sha256Manager.GetHash(Encoding.UTF8.GetBytes(keyphrase)); byte[] array1 = ((IEnumerable <byte>) new byte[1]).Concat <byte>((IEnumerable <byte>)Ripemd160Manager.GetHash(Sha256Manager.GetHash(Secp256K1Manager.GetPublicKey(hash, compressed)))).ToArray <byte>(); string pub = Base58.Encode(((IEnumerable <byte>)array1).Concat <byte>(((IEnumerable <byte>)Sha256Manager.GetHash(Sha256Manager.GetHash(array1))).Take <byte>(4)).ToArray <byte>()); byte[] array2; if (!compressed) { array2 = ((IEnumerable <byte>) new byte[1] { (byte)128 }).Concat <byte>((IEnumerable <byte>)hash).ToArray <byte>(); } else { array2 = ((IEnumerable <byte>) new byte[1] { (byte)128 }).Concat <byte>((IEnumerable <byte>)hash).Concat <byte>((IEnumerable <byte>) new byte[1] { (byte)1 }).ToArray <byte>(); } return(new Wallet(Base58.Encode(((IEnumerable <byte>)array2).Concat <byte>(((IEnumerable <byte>)Sha256Manager.GetHash(Sha256Manager.GetHash(array2))).Take <byte>(4)).ToArray <byte>()), pub) { Phrase = keyphrase }); }
public void VerifyKeyTypes() { var key = CryptoHelper.GenerateKeyPair(); CryptoHelper.PrivKeyStringToBytes(key.PrivateKey); CryptoHelper.PubKeyStringToBytes(key.PublicKey); var helloBytes = Encoding.UTF8.GetBytes("Hello world!"); var hash = Sha256Manager.GetHash(helloBytes); var sign = Secp256K1Manager.SignCompressedCompact(hash, CryptoHelper.GetPrivateKeyBytesWithoutCheckSum(key.PrivateKey)); var check = new List <byte[]>() { sign, Encoding.UTF8.GetBytes("K1") }; var checksum = Ripemd160Manager.GetHash(SerializationHelper.Combine(check)).Take(4).ToArray(); var signAndChecksum = new List <byte[]>() { sign, checksum }; CryptoHelper.SignStringToBytes("SIG_K1_" + Base58.Encode(SerializationHelper.Combine(signAndChecksum))); }
protected void HandlePairedResponse(bool?paired) { Paired = paired.GetValueOrDefault(); if (Paired) { var storedAppKey = StorageProvider.GetAppkey(); string hashed = storedAppKey.StartsWith("appkey:") ? UtilsHelper.ByteArrayToHexString(Sha256Manager.GetHash(Encoding.UTF8.GetBytes(storedAppKey))) : storedAppKey; if (string.IsNullOrWhiteSpace(storedAppKey) || storedAppKey != hashed) { StorageProvider.SetAppkey(hashed); } } if (PairOpenTask != null) { PairOpenTask.SetResult(Paired); } }
public async Task <PackedTransaction> CreatePackedTransaction(CreateTransactionArgs args, CancellationToken token) { //1 var infoResp = await GetInfo(token); if (infoResp.IsError) { return(null); } var info = infoResp.Result; //2 var blockArgs = new GetBlockParams { BlockNumOrId = info.HeadBlockId }; var getBlock = await GetBlock(blockArgs, token); if (getBlock.IsError) { return(null); } var block = getBlock.Result; //3 var transaction = new SignedTransaction { RefBlockNum = (ushort)(block.BlockNum & 0xffff), RefBlockPrefix = block.RefBlockPrefix, Expiration = block.Timestamp.Value.AddSeconds(30), Actions = args.Actions }; var packedTrx = MessageSerializer.Serialize <SignedTransaction>(transaction); var chainId = Hex.HexToBytes(info.ChainId); var msg = new byte[chainId.Length + packedTrx.Length + 32]; Array.Copy(chainId, msg, chainId.Length); Array.Copy(packedTrx, 0, msg, chainId.Length, packedTrx.Length); var sha256 = Sha256Manager.GetHash(msg); transaction.Signatures = new string[args.PrivateKeys.Count]; for (var i = 0; i < args.PrivateKeys.Count; i++) { var key = args.PrivateKeys[i]; var sig = Secp256K1Manager.SignCompressedCompact(sha256, key); var sigHex = Base58.EncodeSig(sig); transaction.Signatures[i] = sigHex; } return(new PackedTransaction { PackedTrx = Hex.ToString(packedTrx), Signatures = transaction.Signatures, PackedContextFreeData = "", Compression = "none" }); }
private static string GetRandomPassBase() { ++PassPhraseGen.counter; if (PassPhraseGen.counter % 5000 == 0) { int num1 = Hex.ToString(Sha256Manager.GetHash(Secp256K1Manager.GenerateRandomKey())).GetHashCode() + DateTime.UtcNow.Millisecond; DateTime utcNow = DateTime.UtcNow; int second = utcNow.Second; int num2 = num1 + second; utcNow = DateTime.UtcNow; int minute = utcNow.Minute; PassPhraseGen.rand = new Random(num2 + minute); } if (PassPhraseGen.rand.Next(1000) > 970 && PassPhraseGen.config != PassPhraseGen.Config.AllBots) { return(PassPhraseGen.GetUnderscoringPass()); } if (PassPhraseGen.rand.Next(1000) > 990 && PassPhraseGen.config != PassPhraseGen.Config.AllBots) { return(PassPhraseGen.GetRepetitionPass()); } if (PassPhraseGen.rand.Next(1000) > 975 && PassPhraseGen.config != PassPhraseGen.Config.AllBots) { return(PassPhraseGen.GetPhonePass()); } if (PassPhraseGen.rand.Next(1000) > 985 && PassPhraseGen.config != PassPhraseGen.Config.AllBots) { return(PassPhraseGen.GetAlphaNumPass()); } if (PassPhraseGen.rand.Next(1000) > 950 && PassPhraseGen.config != PassPhraseGen.Config.AllBots) { if (PassPhraseGen.rand.Next(1000) > 900) { return(new string("!@#$%^&*()_=+-[]\\/{},.<>~`'\"abcdefghijlkmopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"[PassPhraseGen.rand.Next("!@#$%^&*()_=+-[]\\/{},.<>~`'\"abcdefghijlkmopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890".Length)], PassPhraseGen.rand.Next(1, 100))); } return(string.Concat((object)PassPhraseGen.rand.Next(20183131))); } if (PassPhraseGen.rand.Next(1000) > 980 && PassPhraseGen.config != PassPhraseGen.Config.AllBots) { return(PassPhraseGen.GetProlongationPass()); } if ((PassPhraseGen.config == PassPhraseGen.Config.Classic || PassPhraseGen.config == PassPhraseGen.Config.AllBots) && PassPhraseGen.rand.Next(1000) > 980) { return(PassPhraseGen.GetCulturePass()); } if ((PassPhraseGen.config == PassPhraseGen.Config.Classic || PassPhraseGen.config == PassPhraseGen.Config.UniquePhrases) && PassPhraseGen.rand.Next(1000) > 800) { return(PassPhraseGen.GetNamePass()); } int length = PassPhraseGen.rand.Next(1, 60) / 5; if (length == 0) { length = 1; } if (PassPhraseGen.rand.Next(100) > 20 && length > 2) { length = 2; } if (PassPhraseGen.rand.Next(100) > 20 && length > 3) { length = 3; } if (PassPhraseGen.rand.Next(100) > 80) { length = 1; } if (PassPhraseGen.config != PassPhraseGen.Config.AllBots && PassPhraseGen.config != PassPhraseGen.Config.Classic && length < 2) { length = 2; } if (PassPhraseGen.config == PassPhraseGen.Config.AllBots) { length = 1; } bool flag1 = PassPhraseGen.rand.Next(100) > 50; bool flag2 = PassPhraseGen.rand.Next(100) > 95; bool flag3 = PassPhraseGen.rand.Next(100) > 75; bool flag4 = PassPhraseGen.rand.Next(100) > 90; bool flag5 = PassPhraseGen.rand.Next(100) > 50; bool flag6 = PassPhraseGen.rand.Next(100) > 50; bool flag7 = PassPhraseGen.rand.Next(100) > 95; string[] strArray = new string[length]; for (int index = 0; index < length; ++index) { strArray[index] = PassPhraseGen.rand.Next(100) <= 85 || PassPhraseGen.config == PassPhraseGen.Config.AllBots ? PassPhraseGen.words[PassPhraseGen.rand.Next(PassPhraseGen.words.Length)] : PassPhraseGen.GetGibberishPass(); if (flag7) { strArray[index] = strArray[index].ToLower(); strArray[index] = strArray[index][0].ToString().ToUpper() + strArray[index].Substring(1); } } string s = string.Join(flag1 ? "" : " ", strArray); if (!flag7 & flag3) { s = s.ToLower(); } if (!flag7 & flag2) { s = s.ToUpper(); } if ((uint)PassPhraseGen.config > 0U & flag4) { s = !flag5 ? (!flag6 ? Hex.ToString(Encoding.UTF8.GetBytes(s)) : Hex.ToString(Sha256Manager.GetHash(Sha256Manager.GetHash(Encoding.UTF8.GetBytes(s))))) : Hex.ToString(Sha256Manager.GetHash(Encoding.UTF8.GetBytes(s))); } else if (length <= 2 && PassPhraseGen.config != PassPhraseGen.Config.AllBots && PassPhraseGen.rand.Next(100) > 95) { int num = PassPhraseGen.rand.Next(PassPhraseGen.rand.Next(100) > 75 ? 2020 : 99); s += (string)(object)num; } return(s); }
protected static byte[] DoubleHash(byte[] s) { return(Sha256Manager.GetHash(Sha256Manager.GetHash(s))); }
private static string GetCulturePass() { bool flag1 = PassPhraseGen.rand.Next(100) > 50; int num1 = PassPhraseGen.rand.Next(100) > 90 ? 1 : 0; int num2 = PassPhraseGen.rand.Next(100) > 95 ? 1 : 0; int num3 = PassPhraseGen.rand.Next(100) > 75 ? 1 : 0; bool flag2 = PassPhraseGen.rand.Next(100) > 90; bool flag3 = PassPhraseGen.rand.Next(100) > 50; bool flag4 = PassPhraseGen.rand.Next(100) > 50; string s = PassPhraseGen.culture[PassPhraseGen.rand.Next(PassPhraseGen.culture.Length)].Trim(); if (num3 != 0) { s = s.ToLower(); } if (num2 != 0) { s = s.ToUpper(); } if (num1 == 0 & flag1) { s = s.Replace(" ", ""); } if (num1 != 0) { s = s.Replace(" ", PassPhraseGen.rand.Next(100) > 50 ? "_" : "-"); } if (flag2 && PassPhraseGen.config != PassPhraseGen.Config.AllBots) { s = !flag3 ? (!flag4 ? Hex.ToString(Encoding.UTF8.GetBytes(s)) : Hex.ToString(Sha256Manager.GetHash(Sha256Manager.GetHash(Encoding.UTF8.GetBytes(s))))) : Hex.ToString(Sha256Manager.GetHash(Encoding.UTF8.GetBytes(s))); } return(s); }
public static Wallet Generate(bool compressed) { byte[] randomKey = Secp256K1Manager.GenerateRandomKey(); byte[] array1 = ((IEnumerable <byte>) new byte[1]).Concat <byte>((IEnumerable <byte>)Ripemd160Manager.GetHash(Sha256Manager.GetHash(Secp256K1Manager.GetPublicKey(randomKey, compressed)))).ToArray <byte>(); string pub = Base58.Encode(((IEnumerable <byte>)array1).Concat <byte>(((IEnumerable <byte>)Sha256Manager.GetHash(Sha256Manager.GetHash(array1))).Take <byte>(4)).ToArray <byte>()); byte[] array2; if (!compressed) { array2 = ((IEnumerable <byte>) new byte[1] { (byte)128 }).Concat <byte>((IEnumerable <byte>)randomKey).ToArray <byte>(); } else { array2 = ((IEnumerable <byte>) new byte[1] { (byte)128 }).Concat <byte>((IEnumerable <byte>)randomKey).Concat <byte>((IEnumerable <byte>) new byte[1] { (byte)1 }).ToArray <byte>(); } return(new Wallet(Base58.Encode(((IEnumerable <byte>)array2).Concat <byte>(((IEnumerable <byte>)Sha256Manager.GetHash(Sha256Manager.GetHash(array2))).Take <byte>(4)).ToArray <byte>()), pub)); }
public async Task <OperationResult <PushTransactionResults> > BroadcastActionsAsync(BaseAction[] baseActions, List <byte[]> privateKeys, CancellationToken token) { var initOpRez = await AbiJsonToBinAsync(baseActions, token).ConfigureAwait(false); if (initOpRez.IsError) { return(new OperationResult <PushTransactionResults>(initOpRez)); } var infoResp = await GetInfoAsync(token).ConfigureAwait(false); if (infoResp.IsError) { return(new OperationResult <PushTransactionResults>(infoResp)); } var info = infoResp.Result; var blockArgs = new GetBlockParams { BlockNumOrId = info.HeadBlockId }; var getBlock = await GetBlockAsync(blockArgs, token).ConfigureAwait(false); if (getBlock.IsError) { return(new OperationResult <PushTransactionResults>(getBlock)); } var block = getBlock.Result; var trx = new SignedTransaction { Actions = baseActions, RefBlockNum = (ushort)(block.BlockNum & 0xffff), RefBlockPrefix = block.RefBlockPrefix, Expiration = block.Timestamp.Value.AddSeconds(30) }; var packedTrx = MessageSerializer.Serialize <SignedTransaction>(trx); var chainId = Hex.HexToBytes(info.ChainId); var msg = new byte[chainId.Length + packedTrx.Length + 32]; Array.Copy(chainId, msg, chainId.Length); Array.Copy(packedTrx, 0, msg, chainId.Length, packedTrx.Length); var sha256 = Sha256Manager.GetHash(msg); var pack = new PackedTransaction { PackedTrx = packedTrx, Signatures = new string[privateKeys.Count], PackedContextFreeData = new Bytes(), Compression = CompressionType.None }; for (var i = 0; i < privateKeys.Count; i++) { var key = privateKeys[i]; var sig = Secp256K1Manager.SignCompressedCompact(sha256, key); var sigHex = Base58.EncodeSig(sig); pack.Signatures[i] = sigHex; } return(await PushTransactionAsync(pack, token).ConfigureAwait(false)); }
/// <summary> /// /// </summary> /// <param name="propertyApiObj"></param> /// <param name="userPrivateKeys"></param> /// <param name="token">Throws a <see cref="T:System.OperationCanceledException" /> if this token has had cancellation requested.</param> /// <param name="operations"></param> /// <returns></returns> /// <exception cref="T:System.OperationCanceledException">The token has had cancellation requested.</exception> public SignedTransaction CreateTransaction(DynamicGlobalPropertyObject propertyApiObj, IList <byte[]> userPrivateKeys, CancellationToken token, params BaseOperation[] operations) { var transaction = new SignedTransaction { //ChainId = ChainId, RefBlockNum = (ushort)(propertyApiObj.HeadBlockNumber & 0xffff), RefBlockPrefix = (uint)BitConverter.ToInt32(Hex.HexToBytes(propertyApiObj.HeadBlockId), 4), Expiration = propertyApiObj.Time.AddSeconds(30), BaseOperations = operations }; var reqRez = GetRequiredFees(transaction.BaseOperations, (operations[0] as AccountCreateOperation).Fee.AssetId, CancellationToken.None); if (!reqRez.IsError) { (operations[0] as AccountCreateOperation).Fee.Amount = JsonConvert.DeserializeObject <RequiredFees>(reqRez.Result[0].ToString()).amount * 5000; } VerifyAccountAuthority( "nano-blockchain", new PublicKeyType[] { new PublicKeyType("TEST6HWVwXazrgS3MsWZvvSV6qdRbc8GS7KpdfDw8mAcNug4RcPv3v"), //new PublicKeyType("TEST7AX8Ewg85sudNVfwqGcCDEAGnhwyVMgvrWW6bkQT5aDm5fdELM") }, CancellationToken.None ); GetPotentialSignatures(transaction, CancellationToken.None); GetRequiredSignatures( transaction, new PublicKeyType[] { new PublicKeyType("TEST6HWVwXazrgS3MsWZvvSV6qdRbc8GS7KpdfDw8mAcNug4RcPv3v"), new PublicKeyType("TEST7AX8Ewg85sudNVfwqGcCDEAGnhwyVMgvrWW6bkQT5aDm5fdELM") }, CancellationToken.None ); var remoteHex = Hex.HexToBytes(GetTransactionHex(transaction, CancellationToken.None).Result); var localHex = MessageSerializer.Serialize <SignedTransaction>(transaction); string strRez = string.Empty; int limit; if (remoteHex.Length > localHex.Length) { limit = remoteHex.Length; } else { limit = localHex.Length; } for (int i = 0; i < limit; i++) { if (i >= remoteHex.Length || i >= localHex.Length) { if (remoteHex.Length > localHex.Length) { strRez += "[" + i.ToString() + "] " + Hex.HexToInteger(new byte[] { remoteHex[i] }).ToString() + "\n"; } else { strRez += "[" + i.ToString() + "] " + Hex.HexToInteger(new byte[] { localHex[i] }).ToString() + "\n"; } } else { strRez += "[" + i.ToString() + "] " + Hex.HexToInteger(new byte[] { remoteHex[i] }).ToString() + " " + Hex.HexToInteger(new byte[] { localHex[i] }).ToString() + "\n"; } } UnityEngine.Debug.Log(strRez); UnityEngine.Debug.Log("LOCAL HEX = " + Hex.ToString(localHex)); UnityEngine.Debug.Log("REMOTE HEX = " + Hex.ToString(remoteHex)); //for (int i = 0; i < localHex.Length; i++) //{ // localHex[i] = 0; //} var data = Sha256Manager.GetHash(Hex.Join(ChainId, localHex)); transaction.Signatures = new string[userPrivateKeys.Count]; for (int i = 0; i < userPrivateKeys.Count; i++) { token.ThrowIfCancellationRequested(); var userPrivateKey = userPrivateKeys[i]; var sig = Secp256K1Manager.SignCompressedCompact(data, userPrivateKey); transaction.Signatures[i] = Hex.ToString(sig); } return(transaction); }
/// <summary> /// Sends a given amount to a destination address, and returns transaction ID (hash) /// </summary> /// <param name="address">Destination address</param> /// <param name="amount">Amount to send</param> /// <returns>Transaction ID</returns> public string SendTo(string address, decimal _amount) { ulong account_id; bool result = ulong.TryParse(address, out account_id); uint amount = (uint)_amount; if (!result) { Console.WriteLine("failed"); } string receiver_pubkey; // query receiver's pubkey JObject obj = new JObject(); obj.Add("msg_type", 1); obj.Add("msg_cmd", 3); obj.Add("msg_id", ++m_cur_msg_id); obj.Add("id", account_id); string obj_str = JsonConvert.SerializeObject(obj); byte[] arr = System.Text.Encoding.Default.GetBytes(obj_str); var send_task = m_wsock.SendAsync(new ArraySegment <byte>(arr), WebSocketMessageType.Text, true, m_cancel_token); send_task.Wait(); while (true) { byte[] recv_arr = new byte[100 * 1024]; var recv_task = m_wsock.ReceiveAsync(new ArraySegment <byte>(recv_arr), m_cancel_token); WebSocketReceiveResult res = recv_task.Result; byte[] data_arr = new byte[res.Count]; Array.Copy(recv_arr, data_arr, res.Count); string recv_str = System.Text.Encoding.Default.GetString(data_arr); var recv_obj = (JObject)JsonConvert.DeserializeObject(recv_str); uint recv_msg_id = (uint)recv_obj.Property("msg_id"); if (recv_msg_id == m_cur_msg_id) { if (recv_obj["err_code"] != null) { Console.WriteLine("error happened"); return("no_tx_id"); } else { receiver_pubkey = (string)recv_obj["pubkey"]; } break; } } // query latest_block_id Info info = GetInfo(); long latest_block_id = info.LastBlock; JObject obj_data = new JObject(); obj_data.Add("type", 2); DateTime now = DateTime.UtcNow; long utc = now.Ticks - DateTime.Parse("1970-01-01 00:00:00").Ticks; utc /= 10000000; obj_data.Add("utc", utc); obj_data.Add("block_id", latest_block_id); obj_data.Add("fee", 2); obj_data.Add("amount", amount); byte[] privkey = Convert.FromBase64String(m_exchange_account_privkey); byte[] pubkey = Secp256K1Manager.GetPublicKey(privkey, false); obj_data.Add("pubkey", Convert.ToBase64String(pubkey)); obj_data.Add("receiver", receiver_pubkey); string obj_data_str = JsonConvert.SerializeObject(obj_data); //Console.WriteLine(obj_data_str); byte[] obj_data_arr = System.Text.Encoding.Default.GetBytes(obj_data_str); byte[] tx_hash_raw = Sha256Manager.GetHash(obj_data_arr); tx_hash_raw = Sha256Manager.GetHash(tx_hash_raw); string tx_hash_b64 = Convert.ToBase64String(tx_hash_raw); int recover_id; byte[] sign_raw = Secp256K1Manager.SignCompact(tx_hash_raw, privkey, out recover_id); sign_raw = CompactToDer(sign_raw); string sign_b64 = Convert.ToBase64String(sign_raw); JObject obj_1 = new JObject(); obj_1.Add("msg_type", 2); obj_1.Add("msg_cmd", 0); obj_1.Add("msg_id", ++m_cur_msg_id); obj_1.Add("data", obj_data); obj_1.Add("sign", sign_b64); string obj_str_1 = JsonConvert.SerializeObject(obj_1); //Console.WriteLine(obj_str_1); byte[] arr_1 = System.Text.Encoding.Default.GetBytes(obj_str_1); var send_task_1 = m_wsock.SendAsync(new ArraySegment <byte>(arr_1), WebSocketMessageType.Text, true, m_cancel_token); send_task_1.Wait(); while (true) { byte[] recv_arr = new byte[100 * 1024]; var recv_task = m_wsock.ReceiveAsync(new ArraySegment <byte>(recv_arr), m_cancel_token); WebSocketReceiveResult res = recv_task.Result; byte[] data_arr = new byte[res.Count]; Array.Copy(recv_arr, data_arr, res.Count); string recv_str = System.Text.Encoding.Default.GetString(data_arr); var recv_obj = (JObject)JsonConvert.DeserializeObject(recv_str); uint recv_msg_id = (uint)recv_obj.Property("msg_id"); if (recv_msg_id == m_cur_msg_id) { if (recv_obj["err_code"] != null) { Console.WriteLine("error happened"); return("no_tx_id"); } break; } } return(tx_hash_b64); }
/// <summary> /// ECDSA with secp256k1 /// </summary> /// <param name="message">message</param> /// <param name="privateKey">Private key</param> /// <returns></returns> public static Signature SignBytes(byte[] message, PrivateKey privateKey) { var sign = Secp256K1Manager.SignCompressedCompact(Sha256Manager.GetHash(message), privateKey.D.ToByteArrayUnsigned(true)); return(Signature.FromBytes(sign)); }