private static byte[] GetSignatureBytesWithoutCheckSum(string signature) { Regex regex = new Regex(@"\bSIG_K1_\S*"); Match match = regex.Match(signature); if (!match.Success) { throw new FormatException("Invalid Signature prefix."); } signature = signature.Substring(SIG_PREFIX.Length); var signatureBytesWithChecksum = Base58.Decode(signature); var receivedChecksum = signatureBytesWithChecksum.TakeLast(CHECKSUM_LENGHT).ToArray(); var signatureWithoutChecksum = signatureBytesWithChecksum.Take(signatureBytesWithChecksum.Length - CHECKSUM_LENGHT).ToArray(); var check = new List <byte[]>() { signatureWithoutChecksum, KEY_TYPE_BYTES }; var checksum = Ripemd160Manager.GetHash(SerializationHelper.Combine(check)).Take(CHECKSUM_LENGHT).ToArray(); if (!receivedChecksum.SequenceEqual(checksum)) { throw new FormatException("Invalid Signature checksum."); } return(signatureWithoutChecksum); }
public byte[] GetAddress() { if (m_address != null) { return(m_address); } var pubKey = GetPublicKey(); if (pubKey.Length != 64) { pubKey = CryptoUtil.GetPublicKey(pubKey, false); } pubKey = ByteUtil.Contact(new byte[] { 0x04 }, pubKey); var content = Sha3Util.Get256Hash(pubKey); content = Ripemd160Manager.GetHash(content); content = ByteUtil.Contact(new[] { ADDRESS_PREFIX, (byte)AddressType.Normal }, content); var checksum = new byte[4]; Buffer.BlockCopy(Sha3Util.Get256Hash(content), 0, checksum, 0, 4); m_address = ByteUtil.Contact(content, checksum.ToArray()); return(m_address); }
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 void CompareHashTest(string key, string expected) { var buf = Encoding.ASCII.GetBytes(key); var t = Ripemd160Manager.GetHash(buf); Assert.IsTrue(expected.Equals(Hex.ToString(t))); }
public static string SignHash(string privateKeyString, byte[] hash) { try { ECPrivateKeyParameters privateKeyParameters = EosKeyHelper.GetECPrivateKeyParametersFromString(privateKeyString); ISigner signer = SignerUtilities.GetSigner("NONEwithECDSA"); signer.Init(true, privateKeyParameters); signer.BlockUpdate(hash, 0, hash.Length); byte[] sigBytes = signer.GenerateSignature(); var check = new List <byte[]>() { sigBytes, KEY_TYPE_BYTES }; var checksum = Ripemd160Manager.GetHash(SerializationHelper.Combine(check)).Take(CHECKSUM_LENGHT).ToArray(); var signAndChecksum = new List <byte[]>() { sigBytes, checksum }; var finalSig = SIG_PREFIX + Base58.Encode(SerializationHelper.Combine(signAndChecksum)); return(finalSig); } catch (Exception exc) { Console.WriteLine("Signing Failed: " + exc.ToString()); return(null); } }
public override string ToString() { var checksum = Ripemd160Manager.GetHash(this.Data).Take(4).ToArray(); var public_key_with_checksum = this.Data.Concat(checksum).ToArray(); return(PREFIX + Base58.Encode(public_key_with_checksum)); }
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 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); }
public static string EncodePublicWif(byte[] publicKey, string prefix) { var checksum = Ripemd160Manager.GetHash(publicKey); var s = AddLastBytes(publicKey, CheckSumSizeInBytes); Array.Copy(checksum, 0, s, s.Length - CheckSumSizeInBytes, CheckSumSizeInBytes); var pubdata = Encode(s); return prefix + pubdata; }
public static string GetPublicWif(byte[] publicKey, string prefix) { var hash = Ripemd160Manager.GetHash(publicKey); var updatedPublicKey = AddLastBytes(publicKey, CheckSumSizeInBytes); Array.Copy(hash, 0, updatedPublicKey, updatedPublicKey.Length - CheckSumSizeInBytes, CheckSumSizeInBytes); var encodedHash = Encode(updatedPublicKey); return(prefix + encodedHash); }
public static string EncodeSignature(byte[] source) { var buf = AddLastBytes(source, 2); buf[source.Length] = 0x4b; //K buf[source.Length + 1] = 0x31; //1 var checksum = Ripemd160Manager.GetHash(buf); buf = AddLastBytes(source, CheckSumSizeInBytes); Array.Copy(checksum, 0, buf, source.Length, CheckSumSizeInBytes); return("SIG_K1_" + Encode(buf)); }
public string GetPublicAddress() { byte[] content = Tool.Sha3Util.Get256Hash(GetPubKey()); content = Ripemd160Manager.GetHash(content); content = ByteUtil.Merge(new byte[] { ADDRESS_PREFIX }, new byte[] { (int)AddressType.NormalType }, content); byte[] checksum = ByteUtil.Slice(Tool.Sha3Util.Get256Hash(content), 0, 4); return(ByteUtil.Merge(content, checksum).ToHex()); }
public static byte[] DecodePublicWif(string publicKey, string prefix) { if (!publicKey.StartsWith(prefix)) return new byte[0]; var buf = publicKey.Remove(0, prefix.Length); var s = Decode(buf); var checksum = BitConverter.ToInt32(s, s.Length - CheckSumSizeInBytes); var dec = RemoveCheckSum(s); var hash = Ripemd160Manager.GetHash(dec); var newChecksum = BitConverter.ToInt32(hash, 0); if (checksum != newChecksum) throw new ArithmeticException(nameof(checksum)); return dec; }
public static PublicKey FromString(string publicKeyString) { var prefix = publicKeyString.Substring(0, 3); if (prefix != PREFIX) { throw new Exception("Prefix should be " + PREFIX + " but get " + prefix); } var public_key_with_checksum = Base58.Decode(publicKeyString.Substring(3)); var checksum = public_key_with_checksum.Skip(public_key_with_checksum.Length - 4).Take(4).ToArray(); var d = public_key_with_checksum.Take(public_key_with_checksum.Length - 4).ToArray(); var new_checksum = Ripemd160Manager.GetHash(d).Take(4).ToArray(); if (!checksum.SequenceEqual(new_checksum)) { throw new Exception("Checksum did not match"); } return(new PublicKey() { Data = d }); }
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))); }
internal static byte[] GetPublicKeyBytesWithoutCheckSum(string publicKeyString) { Regex regex = new Regex(@"\bEOS\S*"); Match match = regex.Match(publicKeyString); if (!match.Success) { throw new FormatException("Invalid public key prefix."); } publicKeyString = publicKeyString.Substring(EOS_PREFIX.Length); var publicKeyBytesWithChecksum = Base58.Decode(publicKeyString); var publicKeyBytesWithoutChecksum = publicKeyBytesWithChecksum.Take(PUBLIC_KEY_LENGHT).ToArray(); var receivedChecksum = publicKeyBytesWithChecksum.TakeLast(CHECKSUM_LENGHT).ToArray(); var checksum = Ripemd160Manager.GetHash(publicKeyBytesWithoutChecksum).Take(CHECKSUM_LENGHT).ToArray(); if (!receivedChecksum.SequenceEqual(checksum)) { throw new FormatException("Invalid public key checksum."); } return(publicKeyBytesWithoutChecksum); }
static byte[] GetChecksum(byte[] data) { var hash = Ripemd160Manager.GetHash(data); return(hash.Take(4).ToArray()); }
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 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 }); }