156 lines
3.9 KiB
Go
156 lines
3.9 KiB
Go
package store
|
|
|
|
import (
|
|
"crypto/aes"
|
|
"crypto/cipher"
|
|
"crypto/ecdh"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
|
|
"golang.org/x/crypto/argon2"
|
|
"golang.org/x/crypto/hkdf"
|
|
)
|
|
|
|
// Key derivation parameters. The version string is stored with every user key
|
|
// so the parameters can be changed later without breaking existing data.
|
|
const (
|
|
kdfVersion = "argon2id-v1"
|
|
kdfSaltBytes = 16
|
|
keyBytes = 32
|
|
)
|
|
|
|
var (
|
|
errKeyLocked = errors.New("Verschlüsselung ist gesperrt")
|
|
errNoKeyAccess = errors.New("kein Zugriff auf diesen Datenschlüssel")
|
|
)
|
|
|
|
func deriveUserKEK(password string, salt []byte) []byte {
|
|
return argon2.IDKey([]byte(password), salt, 3, 64*1024, 2, keyBytes)
|
|
}
|
|
|
|
func newSalt() ([]byte, error) {
|
|
salt := make([]byte, kdfSaltBytes)
|
|
if _, err := io.ReadFull(rand.Reader, salt); err != nil {
|
|
return nil, err
|
|
}
|
|
return salt, nil
|
|
}
|
|
|
|
func newDEK() ([]byte, error) {
|
|
key := make([]byte, keyBytes)
|
|
if _, err := io.ReadFull(rand.Reader, key); err != nil {
|
|
return nil, err
|
|
}
|
|
return key, nil
|
|
}
|
|
|
|
func sealAESGCM(key, plaintext, additionalData []byte) ([]byte, error) {
|
|
block, err := aes.NewCipher(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
gcm, err := cipher.NewGCM(block)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nonce := make([]byte, gcm.NonceSize())
|
|
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
|
|
return nil, err
|
|
}
|
|
return gcm.Seal(nonce, nonce, plaintext, additionalData), nil
|
|
}
|
|
|
|
func openAESGCM(key, sealed, additionalData []byte) ([]byte, error) {
|
|
block, err := aes.NewCipher(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
gcm, err := cipher.NewGCM(block)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(sealed) < gcm.NonceSize() {
|
|
return nil, errors.New("verschlüsselter Wert ist unvollständig")
|
|
}
|
|
nonce, ciphertext := sealed[:gcm.NonceSize()], sealed[gcm.NonceSize():]
|
|
return gcm.Open(nil, nonce, ciphertext, additionalData)
|
|
}
|
|
|
|
// wrapDEK encrypts a data key for the recipient's X25519 public key using an
|
|
// ephemeral key and HKDF. The scope is bound as additional data so a wrapper
|
|
// cannot be moved to a different tenant or person.
|
|
func wrapDEK(recipientPublic, dek []byte, scope string) (ephemeralPublic, wrapped []byte, err error) {
|
|
curve := ecdh.X25519()
|
|
publicKey, err := curve.NewPublicKey(recipientPublic)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
ephemeral, err := curve.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
shared, err := ephemeral.ECDH(publicKey)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
salt := append(append([]byte{}, ephemeral.PublicKey().Bytes()...), recipientPublic...)
|
|
wrappingKey, err := hkdfKey(shared, salt, "lektorenplan-dek-wrap-v1")
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
wrapped, err = sealAESGCM(wrappingKey, dek, []byte(scope))
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return ephemeral.PublicKey().Bytes(), wrapped, nil
|
|
}
|
|
|
|
func unwrapDEK(privateKey, ephemeralPublic, wrapped []byte, scope string) ([]byte, error) {
|
|
curve := ecdh.X25519()
|
|
private, err := curve.NewPrivateKey(privateKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ephemeral, err := curve.NewPublicKey(ephemeralPublic)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
shared, err := private.ECDH(ephemeral)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
salt := append(append([]byte{}, ephemeralPublic...), private.PublicKey().Bytes()...)
|
|
wrappingKey, err := hkdfKey(shared, salt, "lektorenplan-dek-wrap-v1")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return openAESGCM(wrappingKey, wrapped, []byte(scope))
|
|
}
|
|
|
|
func hkdfKey(secret, salt []byte, info string) ([]byte, error) {
|
|
reader := hkdf.New(sha256.New, secret, salt, []byte(info))
|
|
key := make([]byte, keyBytes)
|
|
if _, err := io.ReadFull(reader, key); err != nil {
|
|
return nil, err
|
|
}
|
|
return key, nil
|
|
}
|
|
|
|
func keyAAD(parts ...string) []byte {
|
|
return []byte(fmt.Sprintf("lektorenplan-secret-v1|%s", joinKeyParts(parts)))
|
|
}
|
|
|
|
func joinKeyParts(parts []string) string {
|
|
out := ""
|
|
for index, part := range parts {
|
|
if index > 0 {
|
|
out += "\x00"
|
|
}
|
|
out += part
|
|
}
|
|
return out
|
|
}
|