restic/repo/key.go

229 lines
4.6 KiB
Go
Raw Normal View History

2015-05-09 11:21:28 +00:00
package repo
2014-09-23 20:39:12 +00:00
import (
"crypto/rand"
2015-03-28 10:50:23 +00:00
"crypto/sha256"
2014-09-23 20:39:12 +00:00
"encoding/json"
"errors"
"fmt"
"os"
"os/user"
"time"
2014-12-05 20:45:49 +00:00
"github.com/restic/restic/backend"
"github.com/restic/restic/crypto"
2014-09-23 20:39:12 +00:00
)
var (
2014-11-15 16:17:24 +00:00
// ErrNoKeyFound is returned when no key for the repository could be decrypted.
ErrNoKeyFound = errors.New("no key could be found")
2014-09-23 20:39:12 +00:00
)
// TODO: figure out scrypt values on the fly depending on the current
// hardware.
const (
2014-11-15 16:17:24 +00:00
scryptN = 65536
scryptR = 8
scryptP = 1
scryptSaltsize = 64
2014-09-23 20:39:12 +00:00
)
2014-11-15 16:17:24 +00:00
// Key represents an encrypted master key for a repository.
2014-09-23 20:39:12 +00:00
type Key struct {
Created time.Time `json:"created"`
Username string `json:"username"`
Hostname string `json:"hostname"`
KDF string `json:"kdf"`
N int `json:"N"`
R int `json:"r"`
P int `json:"p"`
Salt []byte `json:"salt"`
Data []byte `json:"data"`
2015-04-12 07:41:47 +00:00
user *crypto.Key
master *crypto.Key
2014-11-25 22:18:02 +00:00
2015-03-28 10:50:23 +00:00
name string
2014-09-23 20:39:12 +00:00
}
2015-05-03 15:37:12 +00:00
// createMasterKey creates a new master key in the given backend and encrypts
// it with the password.
2015-05-09 11:25:52 +00:00
func createMasterKey(s *Repository, password string) (*Key, error) {
return AddKey(s, password, nil)
2014-09-23 20:39:12 +00:00
}
2015-03-28 10:50:23 +00:00
// OpenKey tries do decrypt the key specified by name with the given password.
2015-05-09 11:25:52 +00:00
func OpenKey(s *Repository, name string, password string) (*Key, error) {
2015-03-28 10:50:23 +00:00
k, err := LoadKey(s, name)
2014-09-23 20:39:12 +00:00
if err != nil {
return nil, err
}
// check KDF
if k.KDF != "scrypt" {
return nil, errors.New("only supported KDF is scrypt()")
}
// derive user key
k.user, err = crypto.KDF(k.N, k.R, k.P, k.Salt, password)
2014-09-23 20:39:12 +00:00
if err != nil {
return nil, err
}
// decrypt master keys
buf, err := crypto.Decrypt(k.user, []byte{}, k.Data)
2014-09-23 20:39:12 +00:00
if err != nil {
return nil, err
}
// restore json
2015-04-12 07:41:47 +00:00
k.master = &crypto.Key{}
2014-09-23 20:39:12 +00:00
err = json.Unmarshal(buf, k.master)
if err != nil {
return nil, err
}
2015-03-28 10:50:23 +00:00
k.name = name
2014-09-23 20:39:12 +00:00
if !k.Valid() {
return nil, errors.New("Invalid key for repository")
}
2014-09-23 20:39:12 +00:00
return k, nil
}
2014-11-15 16:17:24 +00:00
// SearchKey tries to decrypt all keys in the backend with the given password.
// If none could be found, ErrNoKeyFound is returned.
2015-05-09 11:25:52 +00:00
func SearchKey(s *Repository, password string) (*Key, error) {
2014-09-23 20:39:12 +00:00
// try all keys in repo
2015-03-28 10:50:23 +00:00
done := make(chan struct{})
defer close(done)
for name := range s.List(backend.Key, done) {
key, err := OpenKey(s, name, password)
2014-09-23 20:39:12 +00:00
if err != nil {
continue
}
return key, nil
}
return nil, ErrNoKeyFound
}
2015-02-17 22:05:23 +00:00
// LoadKey loads a key from the backend.
2015-05-09 11:25:52 +00:00
func LoadKey(s *Repository, name string) (*Key, error) {
2015-02-17 22:05:23 +00:00
// extract data from repo
rd, err := s.be.Get(backend.Key, name)
2015-02-17 22:05:23 +00:00
if err != nil {
return nil, err
}
2015-03-28 10:50:23 +00:00
defer rd.Close()
2015-02-17 22:05:23 +00:00
// restore json
2015-03-28 10:50:23 +00:00
dec := json.NewDecoder(rd)
k := Key{}
err = dec.Decode(&k)
2015-02-17 22:05:23 +00:00
if err != nil {
return nil, err
}
2015-03-28 10:50:23 +00:00
return &k, nil
2015-02-17 22:05:23 +00:00
}
2014-11-25 22:07:00 +00:00
// AddKey adds a new key to an already existing repository.
2015-05-09 11:25:52 +00:00
func AddKey(s *Repository, password string, template *crypto.Key) (*Key, error) {
2014-11-25 22:07:00 +00:00
// fill meta data about key
newkey := &Key{
Created: time.Now(),
KDF: "scrypt",
N: scryptN,
R: scryptR,
P: scryptP,
}
hn, err := os.Hostname()
if err == nil {
newkey.Hostname = hn
}
usr, err := user.Current()
if err == nil {
newkey.Username = usr.Username
}
// generate random salt
newkey.Salt = make([]byte, scryptSaltsize)
n, err := rand.Read(newkey.Salt)
if n != scryptSaltsize || err != nil {
panic("unable to read enough random bytes for salt")
}
Refactor crypto layer, switch HMAC for Poyl1305-AES HMAC-SHA256 calls SHA256() twice which is very expensive. Therefore, this commit uses Poly1305-AES instead of HMAC-SHA256. benchcmp: benchmark old ns/op new ns/op delta BenchmarkChunkEncrypt 261033772 195114818 -25.25% BenchmarkChunkEncryptParallel 260973195 195787368 -24.98% BenchmarkArchiveDirectory 1050500651 1002615884 -4.56% BenchmarkPreload 23544286 24994508 +6.16% BenchmarkLoadTree 350065 427665 +22.17% BenchmarkEncryptWriter 87789753 31069126 -64.61% BenchmarkEncrypt 88283197 38259043 -56.66% BenchmarkDecryptReader 90478843 40714818 -55.00% BenchmarkEncryptDecryptReader 179917626 81231730 -54.85% BenchmarkDecrypt 87871591 37784207 -57.00% BenchmarkSaveJSON 52481 56861 +8.35% BenchmarkSaveFrom 75404085 51108596 -32.22% BenchmarkLoadJSONID 90545437 82696805 -8.67% benchmark old MB/s new MB/s speedup BenchmarkChunkEncrypt 40.17 53.74 1.34x BenchmarkChunkEncryptParallel 40.18 53.56 1.33x BenchmarkEncryptWriter 95.55 270.00 2.83x BenchmarkEncrypt 95.02 219.26 2.31x BenchmarkDecryptReader 92.71 206.03 2.22x BenchmarkEncryptDecryptReader 46.62 103.27 2.22x BenchmarkDecrypt 95.46 222.01 2.33x BenchmarkSaveFrom 55.62 82.07 1.48x benchmark old allocs new allocs delta BenchmarkChunkEncrypt 112 110 -1.79% BenchmarkChunkEncryptParallel 103 100 -2.91% BenchmarkArchiveDirectory 383704 392083 +2.18% BenchmarkPreload 21765 21874 +0.50% BenchmarkLoadTree 341 436 +27.86% BenchmarkEncryptWriter 20 17 -15.00% BenchmarkEncrypt 14 13 -7.14% BenchmarkDecryptReader 18 15 -16.67% BenchmarkEncryptDecryptReader 46 39 -15.22% BenchmarkDecrypt 16 12 -25.00% BenchmarkSaveJSON 81 86 +6.17% BenchmarkSaveFrom 117 121 +3.42% BenchmarkLoadJSONID 80525 80264 -0.32% benchmark old bytes new bytes delta BenchmarkChunkEncrypt 118956 64697 -45.61% BenchmarkChunkEncryptParallel 118972 64681 -45.63% BenchmarkArchiveDirectory 160236600 177498232 +10.77% BenchmarkPreload 2772488 3302992 +19.13% BenchmarkLoadTree 49102 46484 -5.33% BenchmarkEncryptWriter 28927 8388146 +28897.64% BenchmarkEncrypt 2473 1950 -21.15% BenchmarkDecryptReader 527827 2774 -99.47% BenchmarkEncryptDecryptReader 4100875 1528036 -62.74% BenchmarkDecrypt 2509 2154 -14.15% BenchmarkSaveJSON 4971 5892 +18.53% BenchmarkSaveFrom 40117 31742 -20.88% BenchmarkLoadJSONID 9444217 9442106 -0.02% This closes #102.
2015-03-14 18:53:51 +00:00
// call KDF to derive user key
newkey.user, err = crypto.KDF(newkey.N, newkey.R, newkey.P, newkey.Salt, password)
2014-11-25 22:07:00 +00:00
if err != nil {
return nil, err
}
if template == nil {
// generate new random master keys
2015-04-30 02:28:34 +00:00
newkey.master = crypto.NewRandomKey()
} else {
// copy master keys from old key
newkey.master = template
}
2014-11-25 22:07:00 +00:00
// encrypt master keys (as json) with user key
buf, err := json.Marshal(newkey.master)
if err != nil {
return nil, err
}
2015-04-26 12:46:15 +00:00
newkey.Data, err = crypto.Encrypt(newkey.user, nil, buf)
2014-11-25 22:07:00 +00:00
// dump as json
buf, err = json.Marshal(newkey)
if err != nil {
return nil, err
}
// store in repository and return
blob, err := s.be.Create()
2014-11-25 22:07:00 +00:00
if err != nil {
return nil, err
}
2015-03-28 10:50:23 +00:00
plainhw := backend.NewHashingWriter(blob, sha256.New())
2015-03-28 10:50:23 +00:00
_, err = plainhw.Write(buf)
if err != nil {
return nil, err
}
2015-03-28 10:50:23 +00:00
name := backend.ID(plainhw.Sum(nil)).String()
err = blob.Finalize(backend.Key, name)
if err != nil {
return nil, err
}
2015-03-28 10:50:23 +00:00
newkey.name = name
2014-11-25 22:07:00 +00:00
return newkey, nil
2014-11-25 22:07:00 +00:00
}
2014-09-23 20:39:12 +00:00
func (k *Key) String() string {
if k == nil {
return "<Key nil>"
}
return fmt.Sprintf("<Key of %s@%s, created on %s>", k.Username, k.Hostname, k.Created)
}
2014-11-25 22:18:02 +00:00
2015-03-28 10:50:23 +00:00
func (k Key) Name() string {
return k.name
2014-11-25 22:18:02 +00:00
}
// Valid tests whether the mac and encryption keys are valid (i.e. not zero)
func (k *Key) Valid() bool {
return k.user.Valid() && k.master.Valid()
}