11680548502

Committed 05 Nov 2024 08:46AM UTC coverage: 55.845% (+0.004%) from 55.841%

Build # 11680548502

Build Type

Pull #3559

github

Committed by

web-flow

Commit Message

Merge b557a851e into 08ecb7edb

Pull Request Pull Request #3559: use `Xxhash3` for StorageKey.GetHashCode

Run Details

5794 of 8956 branches covered (64.69%)

Branch coverage included in aggregate %.

13 of 24 new or added lines in 5 files covered. (54.17%)

5 existing lines in 2 files now uncovered.

21747 of 40361 relevant lines covered (53.88%)

86055.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/tests/Neo.UnitTests/Cryptography/UT_Cryptography_Helper.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// UT_Cryptography_Helper.cs file belongs to the neo project and is free
// software distributed under the MIT software license, see the
// accompanying file LICENSE in the main directory of the
// repository or http://www.opensource.org/licenses/mit-license.php
// for more details.
//
// Redistribution and use in source and binary forms with or without
// modifications are permitted.

using FluentAssertions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Neo.Cryptography;
using Neo.Extensions;
using Neo.IO;
using Neo.Network.P2P.Payloads;
using Neo.SmartContract;
using Neo.Wallets;
using Neo.Wallets.NEP6;
using System;
using System.Collections.Generic;
using System.IO.Hashing;
using System.Linq;
using System.Text;

namespace Neo.UnitTests.Cryptography
{
    [TestClass]
    public class UT_Cryptography_Helper
    {
        [TestMethod]
        public void TestBase58CheckDecode()
        {
            string input = "3vQB7B6MrGQZaxCuFg4oh";
            byte[] result = input.Base58CheckDecode();
            byte[] helloWorld = { 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100 };
            result.Should().Equal(helloWorld);

            input = "3v";
            Action action = () => input.Base58CheckDecode();
            action.Should().Throw<FormatException>();

            input = "3vQB7B6MrGQZaxCuFg4og";
            action = () => input.Base58CheckDecode();
            action.Should().Throw<FormatException>();

            Assert.ThrowsException<FormatException>(() => string.Empty.Base58CheckDecode());
        }

        [TestMethod]
        public void TestMurmurReadOnlySpan()
        {
            ReadOnlySpan<byte> input = "Hello, world!"u8;
            byte[] input2 = input.ToArray();
            input.Murmur32(0).Should().Be(input2.Murmur32(0));
            input.Murmur128(0).Should().Equal(input2.Murmur128(0));
        }

        [TestMethod]
        public void TestXxHash3()
        {
            byte[] data = Encoding.ASCII.GetBytes(string.Concat(Enumerable.Repeat("Hello, World!^_^", 16 * 1024)));
            data.XxHash3_32().Should().Be(HashCode.Combine(XxHash3.HashToUInt64(data)));
            XxHash32.HashToUInt32(data).Should().Be(682967318u);
            data.Murmur32(0).Should().Be(3731881930u);
        }

        [TestMethod]
        public void TestSha256()
        {
            byte[] value = Encoding.ASCII.GetBytes("hello world");
            byte[] result = value.Sha256(0, value.Length);
            result.ToHexString().Should().Be("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9");
            value.Sha256().Should().Equal(result);
            ((Span<byte>)value).Sha256().Should().Equal(result);
            ((ReadOnlySpan<byte>)value).Sha256().Should().Equal(result);
        }

        [TestMethod]
        public void TestKeccak256()
        {
            var input = "Hello, world!"u8.ToArray();
            var result = input.Keccak256();
            result.ToHexString().Should().Be("b6e16d27ac5ab427a7f68900ac5559ce272dc6c37c82b3e052246c82244c50e4");
            ((Span<byte>)input).Keccak256().Should().Equal(result);
            ((ReadOnlySpan<byte>)input).Keccak256().Should().Equal(result);
        }

        [TestMethod]
        public void TestRIPEMD160()
        {
            ReadOnlySpan<byte> value = Encoding.ASCII.GetBytes("hello world");
            byte[] result = value.RIPEMD160();
            result.ToHexString().Should().Be("98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f");
        }

        [TestMethod]
        public void TestAESEncryptAndDecrypt()
        {
            NEP6Wallet wallet = new NEP6Wallet("", "1", TestProtocolSettings.Default);
            wallet.CreateAccount();
            WalletAccount account = wallet.GetAccounts().ToArray()[0];
            KeyPair key = account.GetKey();
            Random random = new Random();
            byte[] nonce = new byte[12];
            random.NextBytes(nonce);
            var cypher = Neo.Cryptography.Helper.AES256Encrypt(Encoding.UTF8.GetBytes("hello world"), key.PrivateKey, nonce);
            var m = Neo.Cryptography.Helper.AES256Decrypt(cypher, key.PrivateKey);
            var message2 = Encoding.UTF8.GetString(m);
            Assert.AreEqual("hello world", message2);
        }

        [TestMethod]
        public void TestEcdhEncryptAndDecrypt()
        {
            NEP6Wallet wallet = new NEP6Wallet("", "1", ProtocolSettings.Default);
            wallet.CreateAccount();
            wallet.CreateAccount();
            WalletAccount account1 = wallet.GetAccounts().ToArray()[0];
            KeyPair key1 = account1.GetKey();
            WalletAccount account2 = wallet.GetAccounts().ToArray()[1];
            KeyPair key2 = account2.GetKey();
            Console.WriteLine($"Account:{1},privatekey:{key1.PrivateKey.ToHexString()},publicKey:{key1.PublicKey.ToArray().ToHexString()}");
            Console.WriteLine($"Account:{2},privatekey:{key2.PrivateKey.ToHexString()},publicKey:{key2.PublicKey.ToArray().ToHexString()}");
            var secret1 = Neo.Cryptography.Helper.ECDHDeriveKey(key1, key2.PublicKey);
            var secret2 = Neo.Cryptography.Helper.ECDHDeriveKey(key2, key1.PublicKey);
            Assert.AreEqual(secret1.ToHexString(), secret2.ToHexString());
            var message = Encoding.ASCII.GetBytes("hello world");
            Random random = new Random();
            byte[] nonce = new byte[12];
            random.NextBytes(nonce);
            var cypher = message.AES256Encrypt(secret1, nonce);
            cypher.AES256Decrypt(secret2);
            Assert.AreEqual("hello world", Encoding.ASCII.GetString(cypher.AES256Decrypt(secret2)));
        }

        [TestMethod]
        public void TestTest()
        {
            int m = 7, n = 10;
            uint nTweak = 123456;
            BloomFilter filter = new(m, n, nTweak);

            Transaction tx = new()
            {
                Script = TestUtils.GetByteArray(32, 0x42),
                SystemFee = 4200000000,
                Signers = new Signer[] { new Signer() { Account = (Array.Empty<byte>()).ToScriptHash() } },
                Attributes = Array.Empty<TransactionAttribute>(),
                Witnesses = new[]
                {
                    new Witness
                    {
                        InvocationScript = Array.Empty<byte>(),
                        VerificationScript = Array.Empty<byte>()
                    }
                }
            };
            filter.Test(tx).Should().BeFalse();
            filter.Add(tx.Witnesses[0].ScriptHash.ToArray());
            filter.Test(tx).Should().BeTrue();
            filter.Add(tx.Hash.ToArray());
            filter.Test(tx).Should().BeTrue();
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// UT_Cryptography_Helper.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12	using FluentAssertions;
13	using Microsoft.VisualStudio.TestTools.UnitTesting;
14	using Neo.Cryptography;
15	using Neo.Extensions;
16	using Neo.IO;
17	using Neo.Network.P2P.Payloads;
18	using Neo.SmartContract;
19	using Neo.Wallets;
20	using Neo.Wallets.NEP6;
21	using System;
22	using System.Collections.Generic;
23	using System.IO.Hashing;
24	using System.Linq;
25	using System.Text;
26
27	namespace Neo.UnitTests.Cryptography
28	{
29	[TestClass]
30	public class UT_Cryptography_Helper
31	{
32	[TestMethod]
33	public void TestBase58CheckDecode()
34	{	×
35	string input = "3vQB7B6MrGQZaxCuFg4oh";	×
36	byte[] result = input.Base58CheckDecode();	×
37	byte[] helloWorld = { 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100 };	×
38	result.Should().Equal(helloWorld);	×
39
40	input = "3v";	×
41	Action action = () => input.Base58CheckDecode();	×
42	action.Should().Throw<FormatException>();	×
43
44	input = "3vQB7B6MrGQZaxCuFg4og";	×
45	action = () => input.Base58CheckDecode();	×
46	action.Should().Throw<FormatException>();	×
47
48	Assert.ThrowsException<FormatException>(() => string.Empty.Base58CheckDecode());	×
49	}	×
50
51	[TestMethod]
52	public void TestMurmurReadOnlySpan()
53	{	×
54	ReadOnlySpan<byte> input = "Hello, world!"u8;	×
55	byte[] input2 = input.ToArray();	×
56	input.Murmur32(0).Should().Be(input2.Murmur32(0));	×
57	input.Murmur128(0).Should().Equal(input2.Murmur128(0));	×
58	}	×
59
60	[TestMethod]
61	public void TestXxHash3()
NEW 62	{	×
NEW 63	byte[] data = Encoding.ASCII.GetBytes(string.Concat(Enumerable.Repeat("Hello, World!^_^", 16 * 1024)));	×
NEW 64	data.XxHash3_32().Should().Be(HashCode.Combine(XxHash3.HashToUInt64(data)));	×
NEW 65	XxHash32.HashToUInt32(data).Should().Be(682967318u);	×
NEW 66	data.Murmur32(0).Should().Be(3731881930u);	×
NEW 67	}	×
68
69	[TestMethod]
70	public void TestSha256()
71	{	×
72	byte[] value = Encoding.ASCII.GetBytes("hello world");	×
73	byte[] result = value.Sha256(0, value.Length);	×
NEW 74	result.ToHexString().Should().Be("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9");	×
75	value.Sha256().Should().Equal(result);	×
76	((Span<byte>)value).Sha256().Should().Equal(result);	×
77	((ReadOnlySpan<byte>)value).Sha256().Should().Equal(result);	×
78	}	×
79
80	[TestMethod]
81	public void TestKeccak256()
82	{	×
83	var input = "Hello, world!"u8.ToArray();	×
84	var result = input.Keccak256();	×
85	result.ToHexString().Should().Be("b6e16d27ac5ab427a7f68900ac5559ce272dc6c37c82b3e052246c82244c50e4");	×
86	((Span<byte>)input).Keccak256().Should().Equal(result);	×
87	((ReadOnlySpan<byte>)input).Keccak256().Should().Equal(result);	×
88	}	×
89
90	[TestMethod]
91	public void TestRIPEMD160()
92	{	×
93	ReadOnlySpan<byte> value = Encoding.ASCII.GetBytes("hello world");	×
94	byte[] result = value.RIPEMD160();	×
NEW 95	result.ToHexString().Should().Be("98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f");	×
96	}	×
97
98	[TestMethod]
99	public void TestAESEncryptAndDecrypt()
100	{	×
101	NEP6Wallet wallet = new NEP6Wallet("", "1", TestProtocolSettings.Default);	×
102	wallet.CreateAccount();	×
103	WalletAccount account = wallet.GetAccounts().ToArray()[0];	×
104	KeyPair key = account.GetKey();	×
105	Random random = new Random();	×
106	byte[] nonce = new byte[12];	×
107	random.NextBytes(nonce);	×
108	var cypher = Neo.Cryptography.Helper.AES256Encrypt(Encoding.UTF8.GetBytes("hello world"), key.PrivateKey, nonce);	×
109	var m = Neo.Cryptography.Helper.AES256Decrypt(cypher, key.PrivateKey);	×
110	var message2 = Encoding.UTF8.GetString(m);	×
111	Assert.AreEqual("hello world", message2);	×
112	}	×
113
114	[TestMethod]
115	public void TestEcdhEncryptAndDecrypt()
116	{	×
117	NEP6Wallet wallet = new NEP6Wallet("", "1", ProtocolSettings.Default);	×
118	wallet.CreateAccount();	×
119	wallet.CreateAccount();	×
120	WalletAccount account1 = wallet.GetAccounts().ToArray()[0];	×
121	KeyPair key1 = account1.GetKey();	×
122	WalletAccount account2 = wallet.GetAccounts().ToArray()[1];	×
123	KeyPair key2 = account2.GetKey();	×
124	Console.WriteLine($"Account:{1},privatekey:{key1.PrivateKey.ToHexString()},publicKey:{key1.PublicKey.ToArray().ToHexString()}");	×
125	Console.WriteLine($"Account:{2},privatekey:{key2.PrivateKey.ToHexString()},publicKey:{key2.PublicKey.ToArray().ToHexString()}");	×
126	var secret1 = Neo.Cryptography.Helper.ECDHDeriveKey(key1, key2.PublicKey);	×
127	var secret2 = Neo.Cryptography.Helper.ECDHDeriveKey(key2, key1.PublicKey);	×
128	Assert.AreEqual(secret1.ToHexString(), secret2.ToHexString());	×
129	var message = Encoding.ASCII.GetBytes("hello world");	×
130	Random random = new Random();	×
131	byte[] nonce = new byte[12];	×
132	random.NextBytes(nonce);	×
133	var cypher = message.AES256Encrypt(secret1, nonce);	×
134	cypher.AES256Decrypt(secret2);	×
135	Assert.AreEqual("hello world", Encoding.ASCII.GetString(cypher.AES256Decrypt(secret2)));	×
136	}	×
137
138	[TestMethod]
139	public void TestTest()
140	{	×
141	int m = 7, n = 10;	×
142	uint nTweak = 123456;	×
143	BloomFilter filter = new(m, n, nTweak);	×
144
145	Transaction tx = new()	×
146	{	×
147	Script = TestUtils.GetByteArray(32, 0x42),	×
148	SystemFee = 4200000000,	×
149	Signers = new Signer[] { new Signer() { Account = (Array.Empty<byte>()).ToScriptHash() } },	×
150	Attributes = Array.Empty<TransactionAttribute>(),	×
151	Witnesses = new[]	×
152	{	×
153	new Witness	×
154	{	×
155	InvocationScript = Array.Empty<byte>(),	×
156	VerificationScript = Array.Empty<byte>()	×
157	}	×
158	}	×
159	};	×
160	filter.Test(tx).Should().BeFalse();	×
161	filter.Add(tx.Witnesses[0].ScriptHash.ToArray());	×
162	filter.Test(tx).Should().BeTrue();	×
163	filter.Add(tx.Hash.ToArray());	×
164	filter.Test(tx).Should().BeTrue();	×
165	}	×
166	}
167	}

neo-project / neo / 11680548502

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous