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 }