X-Git-Url: http://git.osdn.net/view?p=bytom%2Fvapor.git;a=blobdiff_plain;f=vendor%2Fgithub.com%2Ftendermint%2Fgo-crypto%2Fkeys%2Fstorage%2Ffilestorage%2Fmain.go;fp=vendor%2Fgithub.com%2Ftendermint%2Fgo-crypto%2Fkeys%2Fstorage%2Ffilestorage%2Fmain.go;h=0000000000000000000000000000000000000000;hp=1f970299573d857fec280b2d0edd3daa6a6fcb7d;hb=54373c1a3efe0e373ec1605840a4363e4b246c46;hpb=ee01d543fdfe1fd0a4d548965c66f7923ea7b062

diff --git a/vendor/github.com/tendermint/go-crypto/keys/storage/filestorage/main.go b/vendor/github.com/tendermint/go-crypto/keys/storage/filestorage/main.go
deleted file mode 100644
index 1f970299..00000000
--- a/vendor/github.com/tendermint/go-crypto/keys/storage/filestorage/main.go
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
-package filestorage provides a secure on-disk storage of private keys and
-metadata.  Security is enforced by file and directory permissions, much
-like standard ssh key storage.
-*/
-package filestorage
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/pkg/errors"
-	crypto "github.com/tendermint/go-crypto"
-	keys "github.com/tendermint/go-crypto/keys"
-)
-
-const (
-	BlockType = "Tendermint Light Client"
-
-	// PrivExt is the extension for private keys.
-	PrivExt = "tlc"
-	// PubExt is the extensions for public keys.
-	PubExt = "pub"
-
-	keyPerm = os.FileMode(0600)
-	// pubPerm = os.FileMode(0644)
-	dirPerm = os.FileMode(0700)
-)
-
-type FileStore struct {
-	keyDir string
-}
-
-// New creates an instance of file-based key storage with tight permissions
-//
-// dir should be an absolute path of a directory owner by this user. It will
-// be created if it doesn't exist already.
-func New(dir string) FileStore {
-	err := os.MkdirAll(dir, dirPerm)
-	if err != nil {
-		panic(err)
-	}
-	return FileStore{dir}
-}
-
-// assert FileStore satisfies keys.Storage
-var _ keys.Storage = FileStore{}
-
-// Put creates two files, one with the public info as json, the other
-// with the (encoded) private key as gpg ascii-armor style
-func (s FileStore) Put(name string, key []byte, info keys.Info) error {
-	pub, priv := s.nameToPaths(name)
-
-	// write public info
-	err := writeInfo(pub, info)
-	if err != nil {
-		return err
-	}
-
-	// write private info
-	return write(priv, name, key)
-}
-
-// Get loads the info and (encoded) private key from the directory
-// It uses `name` to generate the filename, and returns an error if the
-// files don't exist or are in the incorrect format
-func (s FileStore) Get(name string) ([]byte, keys.Info, error) {
-	pub, priv := s.nameToPaths(name)
-
-	info, err := readInfo(pub)
-	if err != nil {
-		return nil, info, err
-	}
-
-	key, _, err := read(priv)
-	return key, info.Format(), err
-}
-
-// List parses the key directory for public info and returns a list of
-// Info for all keys located in this directory.
-func (s FileStore) List() (keys.Infos, error) {
-	dir, err := os.Open(s.keyDir)
-	if err != nil {
-		return nil, errors.Wrap(err, "List Keys")
-	}
-	defer dir.Close()
-
-	names, err := dir.Readdirnames(0)
-	if err != nil {
-		return nil, errors.Wrap(err, "List Keys")
-	}
-
-	// filter names for .pub ending and load them one by one
-	// half the files is a good guess for pre-allocating the slice
-	infos := make([]keys.Info, 0, len(names)/2)
-	for _, name := range names {
-		if strings.HasSuffix(name, PubExt) {
-			p := path.Join(s.keyDir, name)
-			info, err := readInfo(p)
-			if err != nil {
-				return nil, err
-			}
-			infos = append(infos, info.Format())
-		}
-	}
-
-	return infos, nil
-}
-
-// Delete permanently removes the public and private info for the named key
-// The calling function should provide some security checks first.
-func (s FileStore) Delete(name string) error {
-	pub, priv := s.nameToPaths(name)
-	err := os.Remove(priv)
-	if err != nil {
-		return errors.Wrap(err, "Deleting Private Key")
-	}
-	err = os.Remove(pub)
-	return errors.Wrap(err, "Deleting Public Key")
-}
-
-func (s FileStore) nameToPaths(name string) (pub, priv string) {
-	privName := fmt.Sprintf("%s.%s", name, PrivExt)
-	pubName := fmt.Sprintf("%s.%s", name, PubExt)
-	return path.Join(s.keyDir, pubName), path.Join(s.keyDir, privName)
-}
-
-func writeInfo(path string, info keys.Info) error {
-	return write(path, info.Name, info.PubKey.Bytes())
-}
-
-func readInfo(path string) (info keys.Info, err error) {
-	var data []byte
-	data, info.Name, err = read(path)
-	if err != nil {
-		return
-	}
-	pk, err := crypto.PubKeyFromBytes(data)
-	info.PubKey = pk
-	return
-}
-
-func read(path string) ([]byte, string, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, "", errors.Wrap(err, "Reading data")
-	}
-	defer f.Close()
-
-	d, err := ioutil.ReadAll(f)
-	if err != nil {
-		return nil, "", errors.Wrap(err, "Reading data")
-	}
-	block, headers, key, err := crypto.DecodeArmor(string(d))
-	if err != nil {
-		return nil, "", errors.Wrap(err, "Invalid Armor")
-	}
-	if block != BlockType {
-		return nil, "", errors.Errorf("Unknown key type: %s", block)
-	}
-	return key, headers["name"], nil
-}
-
-func write(path, name string, key []byte) error {
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, keyPerm)
-	if err != nil {
-		return errors.Wrap(err, "Writing data")
-	}
-	defer f.Close()
-	headers := map[string]string{"name": name}
-	text := crypto.EncodeArmor(BlockType, headers, key)
-	_, err = f.WriteString(text)
-	return errors.Wrap(err, "Writing data")
-}