crypto: delete old key management stuff

4 files changed, 0 insertions, 492 deletions

diff --git a/crypto/key_manager.go b/crypto/key_manager.go
deleted file mode 100644
index 326e559e0..000000000
--- a/crypto/key_manager.go
+++ /dev/null
@@ -1,134 +0,0 @@
-package crypto
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/logger"
-)
-
-var keylogger = logger.NewLogger("KEY")
-
-type KeyManager struct {
-	keyRing  *KeyRing
-	session  string
-	keyStore KeyStore            // interface
-	keyRings map[string]*KeyRing // cache
-	keyPair  *KeyPair
-}
-
-func NewDBKeyManager(db ethutil.Database) *KeyManager {
-	return &KeyManager{keyStore: &DBKeyStore{db: db}, keyRings: make(map[string]*KeyRing)}
-}
-
-func NewFileKeyManager(basedir string) *KeyManager {
-	return &KeyManager{keyStore: &FileKeyStore{basedir: basedir}, keyRings: make(map[string]*KeyRing)}
-}
-
-func (k *KeyManager) KeyPair() *KeyPair {
-	return k.keyPair
-}
-
-func (k *KeyManager) KeyRing() *KeyPair {
-	return k.keyPair
-}
-
-func (k *KeyManager) PrivateKey() []byte {
-	return k.keyPair.PrivateKey
-}
-
-func (k *KeyManager) PublicKey() []byte {
-	return k.keyPair.PublicKey
-}
-
-func (k *KeyManager) Address() []byte {
-	return k.keyPair.Address()
-}
-
-func (k *KeyManager) save(session string, keyRing *KeyRing) error {
-	err := k.keyStore.Save(session, keyRing)
-	if err != nil {
-		return err
-	}
-	k.keyRings[session] = keyRing
-	return nil
-}
-
-func (k *KeyManager) load(session string) (*KeyRing, error) {
-	keyRing, found := k.keyRings[session]
-	if !found {
-		var err error
-		keyRing, err = k.keyStore.Load(session)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return keyRing, nil
-}
-
-func cursorError(cursor int, len int) error {
-	return fmt.Errorf("cursor %d out of range (0..%d)", cursor, len)
-}
-
-func (k *KeyManager) reset(session string, cursor int, keyRing *KeyRing) error {
-	if cursor >= keyRing.Len() {
-		return cursorError(cursor, keyRing.Len())
-	}
-	lock := &sync.Mutex{}
-	lock.Lock()
-	defer lock.Unlock()
-	err := k.save(session, keyRing)
-	if err != nil {
-		return err
-	}
-	k.session = session
-	k.keyRing = keyRing
-	k.keyPair = keyRing.GetKeyPair(cursor)
-	return nil
-}
-
-func (k *KeyManager) SetCursor(cursor int) error {
-	if cursor >= k.keyRing.Len() {
-		return cursorError(cursor, k.keyRing.Len())
-	}
-	k.keyPair = k.keyRing.GetKeyPair(cursor)
-	return nil
-}
-
-func (k *KeyManager) Init(session string, cursor int, force bool) error {
-	var keyRing *KeyRing
-	if !force {
-		var err error
-		keyRing, err = k.load(session)
-		if err != nil {
-			return err
-		}
-	}
-	if keyRing == nil {
-		keyRing = NewGeneratedKeyRing(1)
-		keylogger.Infof("Created keypair. Private key: %x\n", keyRing.keys[0].PrivateKey)
-	}
-	return k.reset(session, cursor, keyRing)
-}
-
-func (k *KeyManager) InitFromSecretsFile(session string, cursor int, secretsfile string) error {
-	keyRing, err := NewKeyRingFromFile(secretsfile)
-	if err != nil {
-		return err
-	}
-	return k.reset(session, cursor, keyRing)
-}
-
-func (k *KeyManager) InitFromString(session string, cursor int, secrets string) error {
-	keyRing, err := NewKeyRingFromString(secrets)
-	if err != nil {
-		return err
-	}
-	return k.reset(session, cursor, keyRing)
-}
-
-func (k *KeyManager) Export(dir string) error {
-	fileKeyStore := FileKeyStore{dir}
-	return fileKeyStore.Save(k.session, k.keyRing)
-}
diff --git a/crypto/key_store.go b/crypto/key_store.go
deleted file mode 100644
index 04560a04e..000000000
--- a/crypto/key_store.go
+++ /dev/null
@@ -1,113 +0,0 @@
-package crypto
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/ethutil"
-)
-
-type KeyStore interface {
-	Load(string) (*KeyRing, error)
-	Save(string, *KeyRing) error
-}
-
-type DBKeyStore struct {
-	db ethutil.Database
-}
-
-const dbKeyPrefix = "KeyRing"
-
-func (k *DBKeyStore) dbKey(session string) []byte {
-	return []byte(fmt.Sprintf("%s%s", dbKeyPrefix, session))
-}
-
-func (k *DBKeyStore) Save(session string, keyRing *KeyRing) error {
-	k.db.Put(k.dbKey(session), keyRing.RlpEncode())
-	return nil
-}
-
-func (k *DBKeyStore) Load(session string) (*KeyRing, error) {
-	data, err := k.db.Get(k.dbKey(session))
-	if err != nil {
-		return nil, nil
-	}
-	var keyRing *KeyRing
-	keyRing, err = NewKeyRingFromBytes(data)
-	if err != nil {
-		return nil, err
-	}
-	// if empty keyRing is found we return nil, no error
-	if keyRing.Len() == 0 {
-		return nil, nil
-	}
-	return keyRing, nil
-}
-
-type FileKeyStore struct {
-	basedir string
-}
-
-func (k *FileKeyStore) Save(session string, keyRing *KeyRing) error {
-	var content []byte
-	var err error
-	var privateKeys []string
-	var publicKeys []string
-	var mnemonics []string
-	var addresses []string
-	keyRing.Each(func(keyPair *KeyPair) {
-		privateKeys = append(privateKeys, ethutil.Bytes2Hex(keyPair.PrivateKey))
-		publicKeys = append(publicKeys, ethutil.Bytes2Hex(keyPair.PublicKey))
-		addresses = append(addresses, ethutil.Bytes2Hex(keyPair.Address()))
-		mnemonics = append(mnemonics, keyPair.Mnemonic())
-	})
-
-	basename := session
-	if session == "" {
-		basename = "default"
-	}
-
-	path := path.Join(k.basedir, basename)
-	content = []byte(strings.Join(privateKeys, "\n"))
-	err = ioutil.WriteFile(path+".prv", content, 0600)
-	if err != nil {
-		return err
-	}
-
-	content = []byte(strings.Join(publicKeys, "\n"))
-	err = ioutil.WriteFile(path+".pub", content, 0644)
-	if err != nil {
-		return err
-	}
-
-	content = []byte(strings.Join(addresses, "\n"))
-	err = ioutil.WriteFile(path+".addr", content, 0644)
-	if err != nil {
-		return err
-	}
-
-	content = []byte(strings.Join(mnemonics, "\n"))
-	err = ioutil.WriteFile(path+".mne", content, 0600)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (k *FileKeyStore) Load(session string) (*KeyRing, error) {
-	basename := session
-	if session == "" {
-		basename = "default"
-	}
-	secfile := path.Join(k.basedir, basename+".prv")
-	_, err := os.Stat(secfile)
-	// if file is not found then we return nil, no error
-	if err != nil {
-		return nil, nil
-	}
-	return NewKeyRingFromFile(secfile)
-}
diff --git a/crypto/keyring.go b/crypto/keyring.go
deleted file mode 100644
index eab13dbc4..000000000
--- a/crypto/keyring.go
+++ /dev/null
@@ -1,123 +0,0 @@
-package crypto
-
-import (
-	"fmt"
-	"io/ioutil"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/ethutil"
-)
-
-type KeyRing struct {
-	keys []*KeyPair
-}
-
-func NewKeyRing() *KeyRing {
-	return &KeyRing{}
-}
-
-func (k *KeyRing) AddKeyPair(keyPair *KeyPair) {
-	k.keys = append(k.keys, keyPair)
-}
-
-func (k *KeyRing) GetKeyPair(i int) *KeyPair {
-	if len(k.keys) > i {
-		return k.keys[i]
-	}
-
-	return nil
-}
-
-func (k *KeyRing) Empty() bool {
-	return k.Len() == 0
-}
-
-func (k *KeyRing) Len() int {
-	return len(k.keys)
-}
-
-func (k *KeyRing) Each(f func(*KeyPair)) {
-	for _, keyPair := range k.keys {
-		f(keyPair)
-	}
-}
-
-func NewGeneratedKeyRing(len int) *KeyRing {
-	keyRing := NewKeyRing()
-	for i := 0; i < len; i++ {
-		keyRing.AddKeyPair(GenerateNewKeyPair())
-	}
-	return keyRing
-}
-
-func NewKeyRingFromFile(secfile string) (*KeyRing, error) {
-	var content []byte
-	var err error
-	content, err = ioutil.ReadFile(secfile)
-	if err != nil {
-		return nil, err
-	}
-	keyRing, err := NewKeyRingFromString(string(content))
-	if err != nil {
-		return nil, err
-	}
-	return keyRing, nil
-}
-
-func NewKeyRingFromString(content string) (*KeyRing, error) {
-	secretStrings := strings.Split(content, "\n")
-	var secrets [][]byte
-	for _, secretString := range secretStrings {
-		secret := secretString
-		words := strings.Split(secretString, " ")
-		if len(words) == 24 {
-			secret = MnemonicDecode(words)
-		} else if len(words) != 1 {
-			return nil, fmt.Errorf("Unrecognised key format")
-		}
-
-		if len(secret) != 0 {
-			secrets = append(secrets, ethutil.Hex2Bytes(secret))
-		}
-	}
-
-	return NewKeyRingFromSecrets(secrets)
-}
-
-func NewKeyRingFromSecrets(secs [][]byte) (*KeyRing, error) {
-	keyRing := NewKeyRing()
-	for _, sec := range secs {
-		keyPair, err := NewKeyPairFromSec(sec)
-		if err != nil {
-			return nil, err
-		}
-		keyRing.AddKeyPair(keyPair)
-	}
-	return keyRing, nil
-}
-
-func NewKeyRingFromBytes(data []byte) (*KeyRing, error) {
-	var secrets [][]byte
-	it := ethutil.NewValueFromBytes(data).NewIterator()
-	for it.Next() {
-		secret := it.Value().Bytes()
-		secrets = append(secrets, secret)
-	}
-	keyRing, err := NewKeyRingFromSecrets(secrets)
-	if err != nil {
-		return nil, err
-	}
-	return keyRing, nil
-}
-
-func (k *KeyRing) RlpEncode() []byte {
-	return k.RlpValue().Encode()
-}
-
-func (k *KeyRing) RlpValue() *ethutil.Value {
-	v := ethutil.EmptyValue()
-	k.Each(func(keyPair *KeyPair) {
-		v.Append(keyPair.RlpValue())
-	})
-	return v
-}
diff --git a/crypto/keys_test.go b/crypto/keys_test.go
deleted file mode 100644
index 56e851969..000000000
--- a/crypto/keys_test.go
+++ /dev/null
@@ -1,122 +0,0 @@
-package crypto
-
-// import (
-// 	"github.com/ethereum/go-ethereum/ethdb"
-// 	// "io/ioutil"
-// 	"fmt"
-// 	"os"
-// 	"path"
-// 	"testing"
-// )
-
-// // test if persistence layer works
-// func TestDBKeyManager(t *testing.T) {
-// 	memdb, _ := ethdb.NewMemDatabase()
-// 	keyManager0 := NewDBKeyManager(memdb)
-// 	err := keyManager0.Init("", 0, false)
-// 	if err != nil {
-// 		t.Error("Unexpected error: ", err)
-// 	}
-// 	keyManager1 := NewDBKeyManager(memdb)
-// 	err = keyManager1.Init("", 0, false)
-// 	if err != nil {
-// 		t.Error("Unexpected error: ", err)
-// 	}
-// 	if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
-// 		t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
-// 	}
-// 	err = keyManager1.Init("", 0, true)
-// 	if err != nil {
-// 		t.Error("Unexpected error: ", err)
-// 	}
-// 	if string(keyManager0.PrivateKey()) == string(keyManager1.PrivateKey()) {
-// 		t.Error("Expected private keys %x, %x, to be be different despite db persistence if force generate", keyManager0.PrivateKey(), keyManager1.PrivateKey())
-// 	}
-// }
-
-// func TestFileKeyManager(t *testing.T) {
-// 	basedir0 := "/tmp/ethtest0"
-// 	os.RemoveAll(basedir0)
-// 	os.Mkdir(basedir0, 0777)
-
-// 	keyManager0 := NewFileKeyManager(basedir0)
-// 	err := keyManager0.Init("", 0, false)
-// 	if err != nil {
-// 		t.Error("Unexpected error: ", err)
-// 	}
-
-// 	keyManager1 := NewFileKeyManager(basedir0)
-
-// 	err = keyManager1.Init("", 0, false)
-// 	if err != nil {
-// 		t.Error("Unexpected error: ", err)
-// 	}
-// 	if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
-// 		t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
-// 	}
-
-// 	err = keyManager1.Init("", 0, true)
-// 	if err != nil {
-// 		t.Error("Unexpected error: ", err)
-// 	}
-// 	if string(keyManager0.PrivateKey()) == string(keyManager1.PrivateKey()) {
-// 		t.Error("Expected private keys %x, %x, to be be different despite db persistence if force generate", keyManager0.PrivateKey(), keyManager1.PrivateKey())
-// 	}
-// }
-
-// // cursor errors
-// func TestCursorErrors(t *testing.T) {
-// 	memdb, _ := ethdb.NewMemDatabase()
-// 	keyManager0 := NewDBKeyManager(memdb)
-// 	err := keyManager0.Init("", 0, false)
-// 	err = keyManager0.Init("", 1, false)
-// 	if err == nil {
-// 		t.Error("Expected cursor error")
-// 	}
-// 	err = keyManager0.SetCursor(1)
-// 	if err == nil {
-// 		t.Error("Expected cursor error")
-// 	}
-// }
-
-// func TestExportImport(t *testing.T) {
-// 	memdb, _ := ethdb.NewMemDatabase()
-// 	keyManager0 := NewDBKeyManager(memdb)
-// 	err := keyManager0.Init("", 0, false)
-// 	basedir0 := "/tmp/ethtest0"
-// 	os.RemoveAll(basedir0)
-// 	os.Mkdir(basedir0, 0777)
-// 	keyManager0.Export(basedir0)
-
-// 	keyManager1 := NewFileKeyManager(basedir0)
-// 	err = keyManager1.Init("", 0, false)
-// 	if err != nil {
-// 		t.Error("Unexpected error: ", err)
-// 	}
-// 	fmt.Printf("keyRing: %v\n", keyManager0.KeyPair())
-// 	fmt.Printf("keyRing: %v\n", keyManager1.KeyPair())
-// 	if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
-// 		t.Error("Expected private keys %x, %x, to be identical via export to filestore basedir", keyManager0.PrivateKey(), keyManager1.PrivateKey())
-// 	}
-// 	path.Join("")
-
-// 	// memdb, _ = ethdb.NewMemDatabase()
-// 	// keyManager2 := NewDBKeyManager(memdb)
-// 	// err = keyManager2.InitFromSecretsFile("", 0, path.Join(basedir0, "default.prv"))
-// 	// if err != nil {
-// 	// 	t.Error("Unexpected error: ", err)
-// 	// }
-// 	// if string(keyManager0.PrivateKey()) != string(keyManager2.PrivateKey()) {
-// 	// 	t.Error("Expected private keys %s, %s, to be identical via export/import prv", keyManager0.PrivateKey(), keyManager1.PrivateKey())
-// 	// }
-
-// 	// memdb, _ = ethdb.NewMemDatabase()
-// 	// keyManager3 := NewDBKeyManager(memdb)
-// 	// err = keyManager3.InitFromSecretsFile("", 0, path.Join(basedir0, "default.mne"))
-// 	// if err != nil {
-// 	// 	t.Error("Unexpected error: ", err)
-// 	// }
-// 	// if string(keyManager0.PrivateKey()) != string(keyManager3.PrivateKey()) {
-// 	// 	t.Error("Expected private keys %s, %s, to be identical via export/import mnemonic file", keyManager0.PrivateKey(), keyManager1.PrivateKey())
-// 	// }
-// }