add crypto package tests

pkg/crypto/crypto.go

@@ -26,8 +26,8 @@ func GenerateSecp256k1Key() (*ecdsa.PrivateKey, error) {
 
 // NewAddress constructs a Swarm Address from ECDSA private key.
 func NewAddress(p ecdsa.PublicKey) swarm.Address {
-	d := elliptic.Marshal(btcec.S256(), p.X, p.Y)
-	return swarm.NewAddress(keccak256(d))
+	h := sha3.Sum256(elliptic.Marshal(btcec.S256(), p.X, p.Y))
+	return swarm.NewAddress(h[:])
 }
 
 // privateKey holds information about Swarm private key for marshaling.
@@ -67,15 +67,3 @@ func decodeSecp256k1PrivateKey(data []byte) (*ecdsa.PrivateKey, error) {
 	privk, _ := btcec.PrivKeyFromBytes(btcec.S256(), data)
 	return (*ecdsa.PrivateKey)(privk), nil
 }
-
-// keccak256 calculates a hash sum from provided data.
-func keccak256(data ...[]byte) []byte {
-	d := sha3.New256()
-	for _, b := range data {
-		_, err := d.Write(b)
-		if err != nil {
-			panic(err)
-		}
-	}
-	return d.Sum(nil)
-}

pkg/crypto/crypto_test.go

+// Copyright 2020 The Swarm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package crypto_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/ethersphere/bee/pkg/crypto"
+)
+
+func TestGenerateSecp256k1Key(t *testing.T) {
+	k1, err := crypto.GenerateSecp256k1Key()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if k1 == nil {
+		t.Fatal("nil key")
+	}
+	k2, err := crypto.GenerateSecp256k1Key()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if k2 == nil {
+		t.Fatal("nil key")
+	}
+
+	if bytes.Equal(k1.D.Bytes(), k2.D.Bytes()) {
+		t.Fatal("two generated keys are equal")
+	}
+}
+
+func TestNewAddress(t *testing.T) {
+	k, err := crypto.GenerateSecp256k1Key()
+	if err != nil {
+		t.Fatal(err)
+	}
+	a := crypto.NewAddress(k.PublicKey)
+	if l := len(a.Bytes()); l != 32 {
+		t.Errorf("got address length %v, want %v", l, 32)
+	}
+}
+
+func TestMarshalSecp256k1PrivateKey(t *testing.T) {
+	k1, err := crypto.GenerateSecp256k1Key()
+	if err != nil {
+		t.Fatal(err)
+	}
+	d, err := crypto.MarshalSecp256k1PrivateKey(k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	k2, err := crypto.UnmarshalPrivateKey(d)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(k1.D.Bytes(), k2.D.Bytes()) {
+		t.Fatal("marshaled and unmarshaled keys are not equal")
+	}
+}