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));
}
