Esempio n. 1
0
        public static string Sha1(byte[] data)
        {
            var hash   = SHA1.Create().ComputeHash(data);
            var result = Base58CheckEncoding.Encode(hash);

            return(result);
        }
 override public string ToString()
 {
     byte[] keyBody = new byte[PublicIdentityKey.PREFIX.Length + Bytes.Length];
     System.Buffer.BlockCopy(PublicIdentityKey.PREFIX, 0, keyBody, 0, PublicIdentityKey.PREFIX.Length);
     System.Buffer.BlockCopy(Bytes, 0, keyBody, PublicIdentityKey.PREFIX.Length, Bytes.Length);
     return(Base58CheckEncoding.Encode(keyBody));
 }
 override public string ToString()
 {
     byte[] withPrefix = new byte[PrivateIdentityKey.PREFIX.Length + Seed.Length];
     System.Buffer.BlockCopy(PrivateIdentityKey.PREFIX, 0, withPrefix, 0, PrivateIdentityKey.PREFIX.Length);
     System.Buffer.BlockCopy(Seed, 0, withPrefix, PrivateIdentityKey.PREFIX.Length, Seed.Length);
     return(Base58CheckEncoding.Encode(withPrefix));
 }
Esempio n. 4
0
        /// <summary>
        /// Calculates Bitcoin P2PKH address given public key hash and network version bytes
        /// </summary>
        /// <param name="hash">public key hash</param>
        /// <param name="versionBytes">version bytes of network</param>
        /// <returns>base58check address</returns>
        public static string ToP2PKHAddress(this Hash160 hash, Span <byte> versionBytes)
        {
            Span <byte> data = new byte[versionBytes.Length + hash.Bytes.Length];

            versionBytes.CopyTo(data);
            hash.Bytes.CopyTo(data.Slice(versionBytes.Length, hash.Bytes.Length));
            return(Base58CheckEncoding.Encode(data));
        }
Esempio n. 5
0
        public void TestEncoding()
        {
            // Example address from https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses
            var          addressBytes   = "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31".HexToBytes();
            const string base58Expected = "1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs";

            var base58Actual = Base58CheckEncoding.Encode(addressBytes);

            base58Actual.Should().BeEquivalentTo(base58Expected);
        }
        public void TestDecode()
        {
            byte[]     expected_result = UTF8Encoding.UTF8.GetBytes("hello world");
            string     header          = "header-part ";
            string     footer          = " footer part.";
            string     encoded         = header + Base58CheckEncoding.Encode(expected_result) + footer;
            SimplePack packer          = new SimplePack(header, footer);

            Assert.AreEqual(packer.decode(encoded),
                            expected_result);
        }
        private static String GetAddressFromHash160(byte[] scriptBytes, int publicKeyHashIndex, byte[] type)
        {
            // build up an address

            byte[] pubKeyHashWithVersion = new byte[2 + 20];
            pubKeyHashWithVersion[0] = type[0];
            pubKeyHashWithVersion[1] = type[1];
            Array.Copy(scriptBytes, publicKeyHashIndex, pubKeyHashWithVersion, 2, 20);

            return(Base58CheckEncoding.Encode(pubKeyHashWithVersion));
        }
        public void TestEncode()
        {
            byte[]     message         = UTF8Encoding.UTF8.GetBytes("hello world");
            string     expected_header = "header-part ";
            string     expected_footer = " footer part.";
            string     expected_result = expected_header + Base58CheckEncoding.Encode(message) + expected_footer;
            SimplePack packer          = new SimplePack(expected_header, expected_footer);
            string     actual_result   = packer.encode(message);

            Assert.AreEqual(actual_result, expected_result);
        }
Esempio n. 9
0
        public string GetFormatted(string addressPrefix, int chainId)
        {
            if (_formatted != null)
            {
                return(_formatted);
            }
            var addressSuffix = Base58CheckEncoding.Encode(chainId.ToBytes(false));

            _formatted = $"{addressPrefix}_{Address.ToBase58()}_{addressSuffix}";
            return(_formatted);
        }
Esempio n. 10
0
        /// <summary>
        ///     Encode a publicKey into CurveLock format.
        /// </summary>
        /// <param name="publicKey">A 32 byte publicKey.</param>
        /// <exception cref="KeyOutOfRangeException"></exception>
        /// <returns>A Base58 encoded publicKey.</returns>
        public static string EncodeCurveLockPublicKey(byte[] publicKey)
        {
            if (publicKey == null || publicKey.Length != PublicKeyBytes)
            {
                throw new KeyOutOfRangeException("publicKey", (publicKey == null) ? 0 : publicKey.Length,
                                                 string.Format("key must be {0} bytes in length.", PublicKeyBytes));
            }

            var final = ArrayHelper.ConcatArrays(new[] { CurveLockVersionPrefix }, publicKey);

            return(Base58CheckEncoding.Encode(final));
        }
Esempio n. 11
0
        public void Encode_And_Decode_Hash()
        {
            var hash = Hash.Generate();
            var data = hash.DumpByteArray();

            var enCode = Base58CheckEncoding.Encode(data);

            enCode.ShouldNotBe(string.Empty);
            var deCode = Base58CheckEncoding.Decode(enCode);

            deCode.ShouldBe(data);
        }
Esempio n. 12
0
        public void Encode_And_Decode_Hash()
        {
            var hash = HashHelper.ComputeFrom("hash");
            var data = hash.ToByteArray();

            var enCode = Base58CheckEncoding.Encode(data);

            enCode.ShouldNotBe(string.Empty);
            var deCode = Base58CheckEncoding.Decode(enCode);

            deCode.ShouldBe(data);
        }
Esempio n. 13
0
        /// <summary>
        /// Base58Check encoding.
        /// </summary>
        /// <param name="payload">The message to encode.</param>
        /// <param name="prefix">The optional prefix to prepend.</param>
        /// <returns>Base58 encoded prefix + payload.</returns>
        public static string Encode(byte[] payload, byte[] prefix = null)
        {
            int prefixLen = prefix?.Length ?? 0;

            byte[] msg = new byte[prefixLen + payload.Length];

            if (prefix != null)
            {
                Array.Copy(prefix, 0, msg, 0, prefix.Length);
            }

            Array.Copy(payload, 0, msg, prefixLen, payload.Length);

            return(Base58CheckEncoding.Encode(msg));
        }
Esempio n. 14
0
        public void Encode_And_Decode_Address()
        {
            var address = Address.Generate();
            var data    = address.DumpByteArray();

            var enCode = Base58CheckEncoding.Encode(data);

            enCode.ShouldNotBe(string.Empty);
            var deCode = Base58CheckEncoding.Decode(enCode);

            deCode.ShouldBe(data);

            var deCode1 = Base58CheckEncoding.DecodePlain(enCode);

            deCode1.ShouldNotBe(data);
        }
Esempio n. 15
0
        /// <summary>
        /// Converts address into base58 representation.
        /// </summary>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        public string ToBase58()
        {
            if (_formattedAddress != null)
            {
                return(_formattedAddress);
            }

            if (Value.Length != AElfConstants.AddressHashLength)
            {
                throw new ArgumentException("Invalid address", nameof(Value));
            }

            var pubKeyHash = Base58CheckEncoding.Encode(Value.ToByteArray());

            return(_formattedAddress = pubKeyHash);
        }
        public void TestRequireFooter()
        {
            string header = "test-header";
            string footer = "";

            byte[] expected_result = UTF8Encoding.UTF8.GetBytes("hello world");
            string encoded         = header + Base58CheckEncoding.Encode(expected_result) + footer;

            try{
                SimplePack packer = new SimplePack(header, footer);
            }
            catch (InvalidSimplePackHeader) {
                return;
            }
            Assert.Fail();
        }
Esempio n. 17
0
        public void Encode_And_Decode_Address()
        {
            var address = Address.FromBase58("xFqJD9R33mQBQPr1hCFUZMayXFQ577j34MPyUdXzbPpAYufG2");
            var data    = address.ToByteArray();

            var enCode = Base58CheckEncoding.Encode(data);

            enCode.ShouldNotBe(string.Empty);
            var deCode = Base58CheckEncoding.Decode(enCode);

            deCode.ShouldBe(data);

            var deCode1 = Base58CheckEncoding.DecodePlain(enCode);

            deCode1.ShouldNotBe(data);
        }
Esempio n. 18
0
        string GenerateAddress(PubKey pubKey)
        {
            var         pk      = pubKey.ToBytes();
            HMACBlake2B blake2b = new HMACBlake2B(PKHASH_BIT_SIZE);

            blake2b.Initialize();

            var pkNew = blake2b.ComputeHash(pk);

            int prefixLen = tz2.Length;

            byte[] msg = new byte[prefixLen + pkNew.Length];

            Array.Copy(tz2, 0, msg, 0, tz2.Length);
            Array.Copy(pkNew, 0, msg, prefixLen, pkNew.Length);

            return(Base58CheckEncoding.Encode(msg));
        }
        public void Encode_Success()
        {
            string data = Base58CheckEncoding.Encode(ByteString.Parse("6f" + "d5188210339b2012cd8f3c5ce3773d49dd7baa4b").Value.ToArray());

            Assert.Equal("mzwhamFUz1oFz2noTGDK9dxq3PAEhNkpuL", data);

            data = Base58CheckEncoding.Encode(ByteString.Parse("6f" + "4641508da141383ce2d1e035c58fad31480bcaac").Value.ToArray());
            Assert.Equal("mmvRqdAcJrSv6M8GozQE4tR3DhfF56c5M1", data);

            data = Base58CheckEncoding.Encode(ByteString.Parse("6f" + "eeab6b6757f135e9ec2f47157c412f80493f1eca").Value.ToArray());
            Assert.Equal("n3GvU9Zo74UZLYgHQcYiLgTFcWfErXFdwe", data);

            data = Base58CheckEncoding.Encode(ByteString.Parse("00" + "691290451961ad74e177bf44f32d9e2fe7454ee6").Value.ToArray());
            Assert.Equal("1AaaBxiLVzo1xZSFpAw3Zm9YBYAYQgQuuU", data);

            data = Base58CheckEncoding.Encode(ByteString.Parse("05" + "36e0ea8e93eaa0285d641305f4c81e563aa570a2").Value.ToArray());
            Assert.Equal("36hBrMeUfevFPZdY2iYSHVaP9jdLd9Np4R", data);
        }
Esempio n. 20
0
        public string ToPublicKeyString(string addressPrefix = null)
        {
            if (addressPrefix.IsNull())
            {
                addressPrefix = ChainConfig.AddressPrefix;
            }
            var buffer   = ToBuffer(true);
            var hash     = RIPEMD160.Create().HashAndDispose(buffer);
            var checksum = hash.Slice(0, 4);

            hash.Clear();
            var key = buffer.Concat(checksum);

            buffer.Clear();
            checksum.Clear();
            var result = addressPrefix + Base58CheckEncoding.Encode(key);

            key.Clear();
            return(result);
        }
Esempio n. 21
0
        public string ToWif()
        {
            var priv = this.BN.ToByteArray();

            byte[] res;

            if (this.Compressed)
            {
                res = new byte[34];
                res[res.Length - 1] = 0x01;
            }
            else
            {
                res = new byte[33];
            }

            Array.Copy(priv, 0, res, 1, priv.Length);

            res[0] = this.Network.PrivKeyPrefix;

            return(Base58CheckEncoding.Encode(res));
        }
Esempio n. 22
0
        private async Task <Dictionary <string, string> > GetAndCreateAccountKey(DeployArg arg)
        {
            if (string.IsNullOrWhiteSpace(arg.ChainAccount))
            {
                var keyStore = new AElfKeyStore(ApplicationHelper.AppDataPath);

                var chainPrefixBase58 = Base58CheckEncoding.Encode(ByteArrayHelpers.FromHexString(arg.SideChainId));
                var chainPrefix       = chainPrefixBase58.Substring(0, 4);

                var key = await keyStore.CreateAsync(arg.AccountPassword, chainPrefix);

                // todo clean
                //arg.ChainAccount = "ELF_" + chainPrefix + "_" + key.GetEncodedPublicKey();
            }

            var fileName   = arg.ChainAccount + ".ak";
            var filePath   = Path.Combine(ApplicationHelper.AppDataPath, "keys", fileName);
            var keyContent = File.ReadAllText(filePath);

            return(new Dictionary <string, string> {
                { fileName, keyContent }
            });
        }
Esempio n. 23
0
        private void btnCrypt_Click(object sender, EventArgs e)
        {
            txtEncriptado.Text = "";
            this.Refresh();

            int blocklen = (n.GetBitsize() / 8) - 4;

            if (blocklen < 5)
            {
                MessageBox.Show("Chave Pequena", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            byte[] plaintextArr = Encoding.UTF8.GetBytes(txtMensagem.Text);
            UInt16 blockCnt     = 0;
            String finalString  = "";

            foreach (byte[] plainBlock in plaintextArr.Slices(blocklen))
            {
                byte[] withPadArr = new byte[plainBlock.Length + 4];
                byte[] padArr     = new byte[4];
                rng.GetBytes(padArr);
                padArr[0] &= (Byte)0x7F;
                Array.Copy(padArr, withPadArr, 4);
                Array.Copy(plainBlock, 0, withPadArr, 4, plainBlock.Length);
                Array.Reverse(withPadArr);
                BigInteger toCrypt  = new BigInteger(withPadArr);
                BigInteger crypt    = BigInteger.ModPow(toCrypt, publicExp, n);
                byte[]     cryptArr = crypt.ToByteArray();
                String     b58Enc   = Base58CheckEncoding.Encode(cryptArr).ToString();
                finalString += b58Enc + "_";

                blockCnt++;
            }

            txtEncriptado.Text = finalString.TrimEnd('_');
        }
Esempio n. 24
0
 public string encode(byte[] data)
 {
     // OutOfMemoryException may be thrown for large payloads
     return(head + Base58CheckEncoding.Encode(data) + foot);
 }
Esempio n. 25
0
        public void EncodeBitcoinAddress()
        {
            var actualText = Base58CheckEncoding.Encode(AddressBytes);

            Assert.AreEqual(ADDRESS_TEXT, actualText);
        }
Esempio n. 26
0
 public override string ToString()
 {
     return(Base58CheckEncoding.Encode(this.ToByteArray()));
 }
Esempio n. 27
0
        static void Main(string[] args)
        {
            // Bitcoin
            var privateKeyBitcoin             = "L4Y1cGSsNv1Nf9dZpTkEyQjLU24zRyRQeRyE5i4MoVvrjrr15Koy"; // Example https://komodoplatform.com/en/academy/bitcoin-private-key/
            var privateKeyBillText            = new BitcoinSecret(privateKeyBitcoin, Network.Main);
            var uncompressed                  = privateKeyBillText.Copy(false);
            var privateKeyBill                = uncompressed.ToBytes();
            var publicKeyBillText             = privateKeyBillText.PubKey.GetAddress(ScriptPubKeyType.Legacy, Network.Main).ToString();
            var publicKeyBillTextUncompressed = uncompressed.PubKey.GetAddress(ScriptPubKeyType.Legacy, Network.Main).ToString(); // TODO Remove
            var publicKeyBillHex              = Convert.ToHexString(uncompressed.PubKey.ToBytes().Skip(1).ToArray());

            // Data
            var data = new byte[] { 1, 2, 3 };
            // var hash = SHA256.Create().ComputeHash(data); // Calculate hash of data. See also ECDsa.SignHash();

            // PrivateKey
            var privateKey = privateKeyBill; // new byte[32] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
            // RNGCryptoServiceProvider.Create().GetBytes(privateKey); // Fill random

            // PublicKey calculate
            var ecdsaCurve = ECCurve.CreateFromFriendlyName("secp256k1");
            var ecdsa      = ECDsa.Create(new ECParameters
            {
                Curve = ecdsaCurve,
                D     = privateKey
            });
            var publicAndPrivateKey = ecdsa.ExportParameters(true);

            // Sign
            var ecdsaSign = ECDsa.Create(new ECParameters
            {
                Curve = ecdsaCurve,
                D     = publicAndPrivateKey.D,
                Q     = publicAndPrivateKey.Q
            });
            var signature = ecdsaSign.SignData(data, HashAlgorithmName.SHA256); // Needs private and public key

            // Verify
            var ecdsaVerify = ECDsa.Create(new ECParameters
            {
                Curve = ecdsaCurve,
                Q     = publicAndPrivateKey.Q
            });
            bool isValid = ecdsaVerify.VerifyData(data, signature, HashAlgorithmName.SHA256); // No private key needed!

            // Output
            var publicKey = Enumerable.Concat(publicAndPrivateKey.Q.X, publicAndPrivateKey.Q.Y).ToArray();

            Console.WriteLine("PrivateKey=" + Convert.ToHexString(publicAndPrivateKey.D));
            Console.WriteLine("PublicKey=" + Convert.ToHexString(publicKey));
            Console.WriteLine("Data=" + Convert.ToHexString(data));
            Console.WriteLine("IsValid=" + isValid);

            Debug.Assert(publicKeyBillHex == Convert.ToHexString(publicKey));

            // P2PKH Address
            var x = new byte[65];

            x[0] = 0x04;
            publicAndPrivateKey.Q.X.CopyTo(x, 1);
            publicAndPrivateKey.Q.Y.CopyTo(x, 33);

            var sha256    = System.Security.Cryptography.SHA256.Create().ComputeHash(x);
            var ripemd160 = RIPEMD160Managed.Create().ComputeHash(sha256);

            Debug.Assert(ripemd160.Length == 20);
            var publicKeyText = Base58CheckEncoding.Encode(Enumerable.Concat(new byte[] { 0 }, ripemd160).ToArray());

            // Debug.Assert(publicKeyBillText == publicKeyText); // TODO
            Debug.Assert(publicKeyBillTextUncompressed == publicKeyText); // TODO Remove. Use compressed

            Console.WriteLine("Hello World!");
        }