Files

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
}