Ejemplo n.º 1
0
        public void pbkdf2_hmac_sha512()
        {
            // Test cases produced by calls like:
            // hashlib.pbkdf2_hmac('sha512', 'foo'.encode('utf-8'), b'electrum', 2048).hex()

            var password   = "******".UTF8ToBytes();
            var salt       = "electrum".UTF8ToBytes();
            var iterations = 1;
            var hash       = KzHashes.pbkdf2_hmac_sha512(password, salt, iterations);

            Assert.Equal("03a9f1065daccbd328c4a7b8b5b123f11fac370c5503dd95ed42274d1d177c8b513f089afd4e9cfc56cda62d2849318e07a5737ada481f6e5b78e4d9b30e8d60", hash.ToHex());

            iterations = 2;
            hash       = KzHashes.pbkdf2_hmac_sha512(password, salt, iterations);
            Assert.Equal("2c55fe7d6b439a9fde70667d571963eccfe2fcf399457498e0def61598fff5ae8934eafd335b4b290bff5430224e77238c005a07c58f9c3fe5d3b356699b2e65", hash.ToHex());

            iterations = 3;
            hash       = KzHashes.pbkdf2_hmac_sha512(password, salt, iterations);
            Assert.Equal("759c446ff5496297a45bd949efc33343811fb23b6a752d04a5f242265aa0dcb91a32fbad3e714c77a27d8e9217fffc5ddcae0f6df4c6e674a22284bbf566eecc", hash.ToHex());

            iterations = 2048;
            hash       = KzHashes.pbkdf2_hmac_sha512(password, salt, iterations);

            Assert.Equal("3406c404303c1d8e279dd4e56b8428bf3c1154c6991a458aa7934030b0abb1aa493a7a436322a8a5419d32ef06962d58449db57c4782c3db89c75c003bc6b338", hash.ToHex());
        }
Ejemplo n.º 2
0
        public void electrumsv_PubKey_without_custom_words()
        {
            var seed        = "police off kit fee village rather kind when turn crowd fun that";
            var customWords = (string)null;
            var pub         = "xpub661MyMwAqRbcGAH5Lmmp6Tq7qtwnDfkJnMjz96AsLZTJZbHyGZe4CL792x3Eu1cNVt7BVXTAQWeQb2HBgrbcd3QZKc8M2UcX2tXy7RkLGXx";
            var seedHash    = "df4ec2782c76449989f780483b57775fc6ac66c2c274abc27566b5427875529881faf0aac27aea4b294ea27e5213a44f28f8ef4fae66cd070e76bd6a6adeb08f";
            var iterations  = 2048;

            var hash = KzHashes.pbkdf2_hmac_sha512(seed.UTF8ToBytes(), $"electrum{customWords}".UTF8ToBytes(), iterations);
            var key  = KzExtPrivKey.MasterBip32(hash.Span);

            Assert.Equal(seedHash, hash.ToHex());
            Assert.Equal(pub, key.GetExtPubKey().ToString());
            Assert.Equal(key, KzElectrumSv.GetMasterPrivKey(seed));
        }
Ejemplo n.º 3
0
        public void electrumsv_PubKey_with_custom_words()
        {
            var seed        = "bachelor nominee surprise visa oak negative anxiety observe catch sibling act hawk";
            var customWords = "fred fruitbat";
            var pub         = "xpub661MyMwAqRbcH576xNa2EBv7NKLFqeGhwxqMVjLe7oKpQhdMEUjitTZzhEJRX2vAz8xn9x7V8vDhAJ87EoSgBoqNi5jCrdSrdwad6tb2trR";
            var seedHash    = "f53fcf294737ded129179824d437b9f393d00afddaabc58918e15cef9246bbdcbae20af66ae15420a66c2e7115b3066296dc3d9e893d3a41bff9fe47ca702f1d";
            var iterations  = 2048;

            var hash = KzHashes.pbkdf2_hmac_sha512(seed.UTF8ToBytes(), $"electrum{customWords}".UTF8ToBytes(), iterations);
            var key  = KzExtPrivKey.MasterBip32(hash.Span);

            Assert.Equal(seedHash, hash.ToHex());
            Assert.Equal(pub, key.GetExtPubKey().ToString());
            Assert.Equal(key, KzElectrumSv.GetMasterPrivKey(seed, customWords));
        }
Ejemplo n.º 4
0
        public void KzB58PrivKeyTests()
        {
            var bsecret1  = new KzB58PrivKey();
            var bsecret2  = new KzB58PrivKey();
            var bsecret1C = new KzB58PrivKey();
            var bsecret2C = new KzB58PrivKey();
            var baddress1 = new KzB58PrivKey();

            Assert.True(bsecret1.SetString(strSecret1));
            Assert.True(bsecret2.SetString(strSecret2));
            Assert.True(bsecret1C.SetString(strSecret1C));
            Assert.True(bsecret2C.SetString(strSecret2C));
            Assert.False(baddress1.SetString(strAddressBad));

            var key1 = bsecret1.GetKey();

            Assert.False(key1.IsCompressed);
            var key2 = bsecret2.GetKey();

            Assert.False(key2.IsCompressed);
            var key1C = bsecret1C.GetKey();

            Assert.True(key1C.IsCompressed);
            var key2C = bsecret2C.GetKey();

            Assert.True(key2C.IsCompressed);

            var pubkey1  = key1.GetPubKey();
            var pubkey2  = key2.GetPubKey();
            var pubkey1C = key1C.GetPubKey();
            var pubkey2C = key2C.GetPubKey();

            var a = pubkey1.ToAddress();

            Assert.True(key1.VerifyPubKey(pubkey1));
            Assert.False(key1.VerifyPubKey(pubkey1C));
            Assert.False(key1.VerifyPubKey(pubkey2));
            Assert.False(key1.VerifyPubKey(pubkey2C));

            Assert.False(key1C.VerifyPubKey(pubkey1));
            Assert.True(key1C.VerifyPubKey(pubkey1C));
            Assert.False(key1C.VerifyPubKey(pubkey2));
            Assert.False(key1C.VerifyPubKey(pubkey2C));

            Assert.False(key2.VerifyPubKey(pubkey1));
            Assert.False(key2.VerifyPubKey(pubkey1C));
            Assert.True(key2.VerifyPubKey(pubkey2));
            Assert.False(key2.VerifyPubKey(pubkey2C));

            Assert.False(key2C.VerifyPubKey(pubkey1));
            Assert.False(key2C.VerifyPubKey(pubkey1C));
            Assert.False(key2C.VerifyPubKey(pubkey2));
            Assert.True(key2C.VerifyPubKey(pubkey2C));

            for (var n = 0; n < 16; n++)
            {
                var strMsg  = $"Very secret message {n}: 11";
                var hashMsg = KzHashes.HASH256(Encoding.ASCII.GetBytes(strMsg));

                // normal signatures

                var(ok1, sign1)   = key1.Sign(hashMsg);
                var(ok1C, sign1C) = key1C.Sign(hashMsg);
                var(ok2, sign2)   = key2.Sign(hashMsg);
                var(ok2C, sign2C) = key2C.Sign(hashMsg);
                Assert.True(ok1 && ok1C && ok2 && ok2C);

                Assert.True(pubkey1.Verify(hashMsg, sign1));
                Assert.True(pubkey1.Verify(hashMsg, sign1C));
                Assert.False(pubkey1.Verify(hashMsg, sign2));
                Assert.False(pubkey1.Verify(hashMsg, sign2C));

                Assert.True(pubkey1C.Verify(hashMsg, sign1));
                Assert.True(pubkey1C.Verify(hashMsg, sign1C));
                Assert.False(pubkey1C.Verify(hashMsg, sign2));
                Assert.False(pubkey1C.Verify(hashMsg, sign2C));

                Assert.False(pubkey2.Verify(hashMsg, sign1));
                Assert.False(pubkey2.Verify(hashMsg, sign1C));
                Assert.True(pubkey2.Verify(hashMsg, sign2));
                Assert.True(pubkey2.Verify(hashMsg, sign2C));

                Assert.False(pubkey2C.Verify(hashMsg, sign1));
                Assert.False(pubkey2C.Verify(hashMsg, sign1C));
                Assert.True(pubkey2C.Verify(hashMsg, sign2));
                Assert.True(pubkey2C.Verify(hashMsg, sign2C));

                // compact signatures (with key recovery)

                var(cok1, csign1)   = key1.SignCompact(hashMsg);
                var(cok1C, csign1C) = key1C.SignCompact(hashMsg);
                var(cok2, csign2)   = key2.SignCompact(hashMsg);
                var(cok2C, csign2C) = key2C.SignCompact(hashMsg);
                Assert.True(cok1 && cok1C && cok2 && cok2C);

                var(rok1, rkey1)   = KzPubKey.FromRecoverCompact(hashMsg, csign1);
                var(rok2, rkey2)   = KzPubKey.FromRecoverCompact(hashMsg, csign2);
                var(rok1C, rkey1C) = KzPubKey.FromRecoverCompact(hashMsg, csign1C);
                var(rok2C, rkey2C) = KzPubKey.FromRecoverCompact(hashMsg, csign2C);
                Assert.True(rok1 && rok2 && rok1C && rok2C);

                Assert.True(rkey1 == pubkey1);
                Assert.True(rkey2 == pubkey2);
                Assert.True(rkey1C == pubkey1C);
                Assert.True(rkey2C == pubkey2C);
            }
        }
Ejemplo n.º 5
0
 public void ElectrumStandardMnemonic()
 {
     var words = "sword victory much blossom cradle sense boy float soda render arrive arrive";
     var h     = KzHashes.HMACSHA512("Seed version".UTF8ToBytes(), words.UTF8NFKDToBytes());
     var hb    = h.ToBytes();
 }