11720062867

Committed 07 Nov 2024 09:20AM UTC coverage: 55.859% (-0.04%) from 55.894%

Build # 11720062867

Build Type

Pull #3562

github

Committed by

web-flow

Commit Message

Merge 1100aea4b into 42f0efdd0

Pull Request Pull Request #3562: A simpler impl for `ByteArrayEqualityComparer` and remove redundant impl

Run Details

5756 of 8900 branches covered (64.67%)

Branch coverage included in aggregate %.

21 of 21 new or added lines in 2 files covered. (100.0%)

46 existing lines in 3 files now uncovered.

21701 of 40254 relevant lines covered (53.91%)

86088.97 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, 40343)));
        }

        [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()
62	{	×
63	byte[] data = Encoding.ASCII.GetBytes(string.Concat(Enumerable.Repeat("Hello, World!^_^", 16 * 1024)));	×
64	data.XxHash3_32().Should().Be(HashCode.Combine(XxHash3.HashToUInt64(data, 40343)));	×
65	}	×
66
67	[TestMethod]
68	public void TestSha256()
69	{	×
UNCOV 70	byte[] value = Encoding.ASCII.GetBytes("hello world");	×
UNCOV 71	byte[] result = value.Sha256(0, value.Length);	×
UNCOV 72	result.ToHexString().Should().Be("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9");	×
73	value.Sha256().Should().Equal(result);	×
74	((Span<byte>)value).Sha256().Should().Equal(result);	×
75	((ReadOnlySpan<byte>)value).Sha256().Should().Equal(result);	×
76	}	×
77
78	[TestMethod]
79	public void TestKeccak256()
UNCOV 80	{	×
UNCOV 81	var input = "Hello, world!"u8.ToArray();	×
UNCOV 82	var result = input.Keccak256();	×
83	result.ToHexString().Should().Be("b6e16d27ac5ab427a7f68900ac5559ce272dc6c37c82b3e052246c82244c50e4");	×
84	((Span<byte>)input).Keccak256().Should().Equal(result);	×
85	((ReadOnlySpan<byte>)input).Keccak256().Should().Equal(result);	×
86	}	×
87
88	[TestMethod]
89	public void TestRIPEMD160()
UNCOV 90	{	×
91	ReadOnlySpan<byte> value = Encoding.ASCII.GetBytes("hello world");	×
92	byte[] result = value.RIPEMD160();	×
93	result.ToHexString().Should().Be("98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f");	×
94	}	×
95
96	[TestMethod]
97	public void TestAESEncryptAndDecrypt()
98	{	×
99	NEP6Wallet wallet = new NEP6Wallet("", "1", TestProtocolSettings.Default);	×
100	wallet.CreateAccount();	×
101	WalletAccount account = wallet.GetAccounts().ToArray()[0];	×
102	KeyPair key = account.GetKey();	×
103	Random random = new Random();	×
UNCOV 104	byte[] nonce = new byte[12];	×
UNCOV 105	random.NextBytes(nonce);	×
UNCOV 106	var cypher = Neo.Cryptography.Helper.AES256Encrypt(Encoding.UTF8.GetBytes("hello world"), key.PrivateKey, nonce);	×
107	var m = Neo.Cryptography.Helper.AES256Decrypt(cypher, key.PrivateKey);	×
108	var message2 = Encoding.UTF8.GetString(m);	×
109	Assert.AreEqual("hello world", message2);	×
110	}	×
111
112	[TestMethod]
113	public void TestEcdhEncryptAndDecrypt()
114	{	×
115	NEP6Wallet wallet = new NEP6Wallet("", "1", ProtocolSettings.Default);	×
116	wallet.CreateAccount();	×
117	wallet.CreateAccount();	×
118	WalletAccount account1 = wallet.GetAccounts().ToArray()[0];	×
119	KeyPair key1 = account1.GetKey();	×
120	WalletAccount account2 = wallet.GetAccounts().ToArray()[1];	×
121	KeyPair key2 = account2.GetKey();	×
122	Console.WriteLine($"Account:{1},privatekey:{key1.PrivateKey.ToHexString()},publicKey:{key1.PublicKey.ToArray().ToHexString()}");	×
123	Console.WriteLine($"Account:{2},privatekey:{key2.PrivateKey.ToHexString()},publicKey:{key2.PublicKey.ToArray().ToHexString()}");	×
124	var secret1 = Neo.Cryptography.Helper.ECDHDeriveKey(key1, key2.PublicKey);	×
125	var secret2 = Neo.Cryptography.Helper.ECDHDeriveKey(key2, key1.PublicKey);	×
126	Assert.AreEqual(secret1.ToHexString(), secret2.ToHexString());	×
127	var message = Encoding.ASCII.GetBytes("hello world");	×
UNCOV 128	Random random = new Random();	×
UNCOV 129	byte[] nonce = new byte[12];	×
UNCOV 130	random.NextBytes(nonce);	×
131	var cypher = message.AES256Encrypt(secret1, nonce);	×
132	cypher.AES256Decrypt(secret2);	×
133	Assert.AreEqual("hello world", Encoding.ASCII.GetString(cypher.AES256Decrypt(secret2)));	×
134	}	×
135
136	[TestMethod]
137	public void TestTest()
138	{	×
139	int m = 7, n = 10;	×
140	uint nTweak = 123456;	×
141	BloomFilter filter = new(m, n, nTweak);	×
142
143	Transaction tx = new()	×
144	{	×
145	Script = TestUtils.GetByteArray(32, 0x42),	×
146	SystemFee = 4200000000,	×
147	Signers = new Signer[] { new Signer() { Account = (Array.Empty<byte>()).ToScriptHash() } },	×
148	Attributes = Array.Empty<TransactionAttribute>(),	×
149	Witnesses = new[]	×
150	{	×
151	new Witness	×
152	{	×
153	InvocationScript = Array.Empty<byte>(),	×
154	VerificationScript = Array.Empty<byte>()	×
155	}	×
156	}	×
UNCOV 157	};	×
UNCOV 158	filter.Test(tx).Should().BeFalse();	×
UNCOV 159	filter.Add(tx.Witnesses[0].ScriptHash.ToArray());	×
UNCOV 160	filter.Test(tx).Should().BeTrue();	×
UNCOV 161	filter.Add(tx.Hash.ToArray());	×
UNCOV 162	filter.Test(tx).Should().BeTrue();	×
UNCOV 163	}	×
164	}
165	}

neo-project / neo / 11720062867

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