public void RecoverSanity()
{
H256 messageHash = "0xce7df6b1b2852c5c156b683a9f8d4a8daeda2f35f025cb0cf34943dcac70d6a3";
PrivateKey key = "0x97ddae0f3a25b92268175400149d65d6887b9cefaf28ea2c078e05cdc15a3c0a";
string sPublicKey = "0x7b83ad6afb1209f3c82ebeb08c0c5fa9bf6724548506f2fb4f991e2287a77090177316ca82b0bdf70cd9dee145c3002c0da1d92626449875972a27807b73b42e";
string compressedKey = "0x027b83ad6afb1209f3c82ebeb08c0c5fa9bf6724548506f2fb4f991e2287a77090";
string expectedR = "0x6f0156091cbe912f2d5d1215cc3cd81c0963c8839b93af60e0921b61a19c5430";
string expectedS = "0x0c71006dd93f3508c432daca21db0095f4b16542782b7986f48a5d0ae3c583d4";
byte expectedV = 1;
Assert.Equal(sPublicKey, Hex.ToString(key.PublicKey.Key));
Assert.Equal(compressedKey, Hex.ToString(key.PublicKey.CompressedKey));
Signature sig = key.Sign(messageHash);
Assert.Equal(expectedR, Hex.ToString(sig.R));
Assert.Equal(expectedS, Hex.ToString(sig.S));
Assert.Equal(expectedV, sig.V);
PublicKey recovered = sig.GetPublicKey(messageHash);
Assert.Equal(sPublicKey, Hex.ToString(recovered.Key));
Assert.True(recovered.Verify(sig, messageHash));
}
public void TrieShouldUpdatable(int repeats)
{
const string path = "data1";
// leveldb
FileDB.Destroy(path);
FileDB db = new FileDB(path, true);
// 랜덤 키 생성 : 키의 길이는 1 - 64
List <byte[]> keys = new List <byte[]>();
for (int i = 0; i < repeats; i++)
{
keys.Add(SecureRandom.GetBytes(SecureRandom.Next(1, 65)));
}
ITrie trie = new Trie(db);
// put
foreach (var key in keys)
{
trie.Put(key, key.Hash256());
}
// update
foreach (var key in keys)
{
trie.Put(key, key.Hash512());
}
H256 root = trie.Commit();
trie.Dispose();
// update된 내용이 맞는지 확인
trie = new Trie(db, root);
foreach (var key in keys)
{
Assert.Equal(key.Hash512(), trie.Get(key));
}
// 모든 키 삭제
foreach (var key in keys)
{
trie.Del(key);
}
root = trie.Commit();
trie.Dispose();
// 키에 해당하는 내용이 있는지 확인
trie = new Trie(db, root);
foreach (var key in keys)
{
Assert.Null(trie.Get(key));
}
}
public void TrieShouldWorksWithLevelDB(int repeats)
{
const string path = "data";
// leveldb
FileDB.Destroy(path);
FileDB db = new FileDB(path, true);
// 랜덤 키 생성 : 키의 길이는 1 - 64
List <byte[]> keys = new List <byte[]>();
for (int i = 0; i < repeats; i++)
{
keys.Add(SecureRandom.GetBytes(SecureRandom.Next(1, 65)));
}
// for BaseTrie
{
ITrie trie = new Trie(db);
foreach (var key in keys)
{
trie.Put(key, key.Hash256());
}
H256 root = trie.Commit();
trie.Dispose();
ITrie trie2 = new Trie(db, root);
foreach (var key in keys)
{
Assert.Equal(key.Hash256(), trie2.Get(key));
}
}
// for SecureTrie
{
ITrie trie = new SecureTrie(db);
foreach (var key in keys)
{
trie.Put(key, key.Hash256());
}
H256 root = trie.Commit();
trie.Dispose();
ITrie trie2 = new SecureTrie(db, root);
foreach (var key in keys)
{
Assert.Equal(key.Hash256(), trie2.Get(key));
}
}
}
public void SignerShouldBeDeterministic()
{
for (int i = 0; i < repeats; i++)
{
H256 messageHash = SecureRandom.GetBytes(H256.BYTE_LENGTH);
PrivateKey privateKey = PrivateKey.CreateKey();
Signature sig1 = privateKey.Sign(messageHash);
Signature sig2 = privateKey.Sign(messageHash);
Assert.Equal(sig1, sig2);
}
}
public void SignerShouldRecoverableWithValidRecoverId()
{
for (int i = 0; i < repeats; i++)
{
H256 messageHash = SecureRandom.GetBytes(H256.BYTE_LENGTH);
PrivateKey privateKey = PrivateKey.CreateKey();
Signature sig = privateKey.Sign(messageHash);
Assert.True(sig.V < 4);
Assert.Equal(privateKey.PublicKey, sig.GetPublicKey(messageHash));
byte[] bytes = sig;
bytes[64] = 99;
Signature wrong = Signature.Parse(bytes);
Assert.NotEqual(privateKey.PublicKey, wrong.GetPublicKey(messageHash));
}
}
public void SignerShouldGenerateValidKey()
{
for (int i = 0; i < repeats; i++)
{
H256 messageHash = SecureRandom.GetBytes(H256.BYTE_LENGTH);
PrivateKey secKey = PrivateKey.CreateKey();
PublicKey pubKey = secKey.PublicKey;
Signature sig = secKey.Sign(messageHash);
// private key verify
Assert.True(Secp256k1Helper.SecretKeyVerify(secKey.Key));
// private key, public key, signature length verify
Assert.Equal(PrivateKey.KEY_LENGTH, secKey.Key.Length);
Assert.Equal(PublicKey.KEY_LENGTH, pubKey.Length);
Assert.Equal(Signature.LENGTH, sig.Length);
// verify signature
Assert.True(pubKey.Verify(sig, messageHash));
Assert.Equal(pubKey, sig.GetPublicKey(messageHash));
}
}
public static PrivateKey CreateKey(byte[] seed)
{
H256 key = seed.IsNullOrEmpty() ? SecureRandom.GetBytes(KEY_LENGTH) : seed.Hash256();
return(CheckPrivateKey(key) ? new PrivateKey(key) : CreateKey(key));
}
public static bool CheckPrivateKey(H256 key)
{
return(Secp256k1Helper.SecretKeyVerify(key));
}
public SecureTrie(ITrieDB db, H256 rootHash) : base(db, rootHash)
{
}
public byte[] Read(H256 hash)
{
return(!ReferenceEquals(hash, null) ? db.Get(hash) : null);
}
public Trie(ITrieDB db, H256 rootHash) : this(db)
{
this.rootHash = rootHash;
RootNode = GetNodeByHash(rootHash);
}
protected TrieNode GetNodeByHash(H256 hash)
{
byte[] rlp = Read(hash);
return(rlp.IsNullOrEmpty() ? null : new TrieNode(this, rlp));
}
public bool Remove(H256 txid)
{
lock (txs)
return(txs.Remove(txid));
}
public Tx Get(H256 txid)
{
lock (txs)
return(txs.TryGetValue(txid, out Tx tx) ? tx : null);
}
