protondrive: refuse files whose content key signature is missing

A server could replace a file's content key with one it made, without a
signature: updates were then encrypted with a key the server knows, and
ranged reads returned whatever it encrypted under that key. A missing or
invalid content key signature now makes the file unverified, like an
unverified node key: reads and updates are refused unless
ignore_signature_errors is set, when an ERROR is logged once per file and
operation. The fake gains corruptions for this and for the hash key,
name and extended attribute checks that follow.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Lucas WintherandClaude Opus 5.5 committed 2026-11-12 14:21:14 +01:00
1 parent ea8d09ce43
commit e95317b52a
10 files changed
+215 -26

No files matched your search

+7 -10
View File
@@ -594,9 +594,9 @@ func generateContentKey(nodeKR *crypto.KeyRing, now time.Time) (contentKeyPacket
// decryptContentKey returns the content session key from the base64
// key packet (v3 or v6 PKESK), decrypted with the node key nodeKR.
//
// If contentKeyPacketSig is not empty, it is checked against nodeKR and
// extraVerifyKR (which may be nil): some clients signed with the
// address key. A signature which doesn't verify is returned as
// contentKeyPacketSig is checked against nodeKR and extraVerifyKR
// (which may be nil): some clients signed with the address key. A
// signature which doesn't verify, or is missing, is returned as
// verifyErr with the session key.
func decryptContentKey(contentKeyPacketB64, contentKeyPacketSig string, nodeKR, extraVerifyKR *crypto.KeyRing, now time.Time) (sk *crypto.SessionKey, verifyErr, err error) {
keyPacket, err := base64.StdEncoding.DecodeString(contentKeyPacketB64)
@@ -611,14 +611,11 @@ func decryptContentKey(contentKeyPacketB64, contentKeyPacketSig string, nodeKR,
if err != nil {
return nil, nil, fmt.Errorf("decrypt content key: %w", err)
}
if contentKeyPacketSig != "" {
verifyKR, err := joinKeyRings(nodeKR, extraVerifyKR)
if err != nil {
return nil, nil, fmt.Errorf("decrypt content key: %w", err)
}
verifyErr = verifyDetached(sk.Key, contentKeyPacketSig, verifyKR, now)
verifyKR, err := joinKeyRings(nodeKR, extraVerifyKR)
if err != nil {
return nil, nil, fmt.Errorf("decrypt content key: %w", err)
}
return sk, verifyErr, nil
return sk, verifyDetached(sk.Key, contentKeyPacketSig, verifyKR, now), nil
}
// encryptBlock returns the block plain encrypted with the content
+1 -1
View File
@@ -518,7 +518,7 @@ func TestContentKeyRoundTrip(t *testing.T) {
t.Run("NoSignature", func(t *testing.T) {
got, verifyErr, err := decryptContentKey(b64, "", keys.keyRing, nil, now)
require.NoError(t, err)
assert.NoError(t, verifyErr)
assert.ErrorIs(t, verifyErr, errSignatureMissing)
assert.Equal(t, sk.Key, got.Key)
})
t.Run("SignedByAddressKey", func(t *testing.T) {
+20 -12
View File
@@ -105,7 +105,7 @@ func (c *client) openRead(ctx context.Context, n *node, offset, limit int64, ful
if offset < 0 {
return nil, fmt.Errorf("open %q: negative offset %d", n.Name, offset)
}
sk, err := c.contentKey(n)
sk, err := c.contentKey(n, "reading")
if err != nil {
return nil, fmt.Errorf("open %q: %w", n.Name, err)
}
@@ -183,17 +183,25 @@ func blockAt(sizes []int64, pos int64) (index int, offset int64) {
return len(sizes) + 1, pos
}
// contentKey returns the content session key of file n, checking its
// signature as the SDK's decryptContentKeyPacket does.
// contentKey returns the content session key of file n for op,
// "reading" or "updating", checking its signature as the SDK's
// decryptContentKeyPacket does, except that a missing signature fails
// too: anyone with the node's public key can make a content key packet.
//
// An unverified node key is errIntegrity too: a key someone else made
// could decrypt any content they chose.
func (c *client) contentKey(n *node) (*crypto.SessionKey, error) {
// An unverified node key or content key is errIntegrity unless
// IgnoreSignatureErrors is set, when it is logged once per node and op:
// whoever made the key could read what is written with it and make up
// the content read.
func (c *client) contentKey(n *node, op string) (*crypto.SessionKey, error) {
hint := signatureHint
if op != "reading" {
hint = "set ignore_signature_errors to update the file anyway"
}
if n.keys.unverified != nil {
if !c.opt.IgnoreSignatureErrors {
return nil, fmt.Errorf("node key: %w: %w: %s", errIntegrity, n.keys.unverified, signatureHint)
return nil, fmt.Errorf("node key: %w: %w: %s", errIntegrity, n.keys.unverified, hint)
}
c.reportUnverified("reading", n, "")
c.reportUnverified(op, n, "")
}
f := n.link.File
now := c.s.serverTime()
@@ -201,7 +209,7 @@ func (c *client) contentKey(n *node) (*crypto.SessionKey, error) {
if err != nil {
return nil, err
}
if verifyErr != nil && n.CreateTime.Unix() <= contentKeyFallbackUntil {
if verifyErr != nil && !isNotSigned(verifyErr) && n.CreateTime.Unix() <= contentKeyFallbackUntil {
// Old clients signed with an address key, and a rename or
// move could change the node's signer without signing the
// content key packet again.
@@ -217,10 +225,10 @@ func (c *client) contentKey(n *node) (*crypto.SessionKey, error) {
if verifyErr != nil {
verifyErr = fmt.Errorf("content key: %w: %w", errIntegrity, verifyErr)
if !c.opt.IgnoreSignatureErrors {
return nil, fmt.Errorf("%w: %s", verifyErr, signatureHint)
return nil, fmt.Errorf("%w: %s", verifyErr, hint)
}
c.reportOnce("content key", n.ID, func() {
fs.Errorf(nil, "protondrive: %q (ID %s): %v", n.Name, n.ID, verifyErr)
c.reportOnce("content key "+op, n.ID, func() {
fs.Errorf(nil, "protondrive: %s %q (ID %s): %v", op, n.Name, n.ID, verifyErr)
})
}
return sk, nil
@@ -259,7 +259,8 @@ func TestDownloadContentKey(t *testing.T) {
created time.Time
ok bool
}{
{"unsigned", "", time.Now(), true},
{"unsigned", "", time.Now(), false},
{"unsigned before 2023", "", before2023, false},
{"signer address", u.Email(), time.Now(), true},
{"other address before 2023", second, before2023, true},
{"other address after 2023", second, time.Now(), false},
+1 -1
View File
@@ -782,7 +782,7 @@ func (gc *goldenCapture) file(ctx context.Context, n *node, gn goldenNode, store
rk.note("XAttr: claims SHA-1 %s, the content has %s", n.X.SHA1, gn.Want.SHA1)
}
sk, err := c.contentKey(n)
sk, err := c.contentKey(n, "reading")
if err != nil {
return fmt.Errorf("%q: %w", n.Name, err)
}
+92
View File
@@ -59,6 +59,12 @@ const (
// DefaultMaxSpace is the MaxSpace of every user, 5 GiB.
const DefaultMaxSpace int64 = 5 << 30
// The claims of the "xattrs-unsigned" corruption.
const (
ForgedModTime = "2099-01-01T00:00:00.000Z"
ForgedSHA1 = "0123456789abcdef0123456789abcdef01234567"
)
// drive is a user's volume with its main share and links.
//
// Stored values are never modified in place once a snapshot may have
@@ -923,6 +929,18 @@ func (u *User) insertLink(parentID string, l *link) string {
// - "foreign-block": the first block is the same plaintext encrypted
// with another content key, with its hash and block signature to
// match
// - "content-key-unsigned": the file's content key is one the server
// made, without a signature, and the blocks are encrypted under it
// with the blocks and manifest validly signed
// - "content-key-signature": as "content-key-unsigned", with the
// content key signed by an unrelated key
// - "hash-key-unsigned": the folder's hash key is one the server
// made, without a signature
// - "name-unsigned": the name is encrypted anew under a session key
// the server made, without a signature
// - "xattrs-unsigned": the extended attributes are encrypted anew
// without a signature, claiming ForgedModTime, and for a file a
// size of 1 TiB and ForgedSHA1
func (u *User) Corrupt(id string, what string) {
impostor := generateKey("impostor", "impostor@proton.test")
v := u.view()
@@ -997,6 +1015,80 @@ func (u *User) Corrupt(id string, what string) {
b.data, b.hash, b.encSignature = data, sum[:], encSig
r.blocks[0] = &b
})
case "content-key-unsigned", "content-key-signature":
// A content key the server made, with the blocks encrypted
// under it, and the blocks and manifest signed anew by the
// user: more than a server can do, so that only the content
// key's signature can catch it.
key, oldSK := v.contentKey(l)
ck := newContentKey(key, oldSK.IsV6())
sig := ""
if what == "content-key-signature" {
sig = signArmored(ck.sk.Key, impostor)
}
rev := l.activeRevision()
blocks := make([]*block, len(rev.blocks))
var manifest []byte
for i, old := range rev.blocks {
plain, err := decryptBlock(old.data, old.encSignature, oldSK, key, v.verifier(old.signatureEmail, key), v.now)
if plain == nil {
mustCrypto("decrypt block", err)
}
b := *old
b.data, b.encSignature = ck.encryptBlock(plain, key, v.addrKey)
sum := sha256.Sum256(b.data)
b.hash = sum[:]
blocks[i] = &b
manifest = append(manifest, b.hash...)
}
manifestSig := signArmored(manifest, v.addrKey)
reblock := changeActiveRevision(func(r *revision) { r.blocks, r.manifestSignature = blocks, manifestSig })
change = func(l *link) {
l.contentKeyPacket, l.contentKeyPacketSignature = ck.packet, sig
reblock(l)
}
case "hash-key-unsigned":
if l.typ != linkTypeFolder {
panic("protontest: hash-key-unsigned needs a folder")
}
key, _ := v.folderKeys(id)
bad := encryptArmored(newPassphrase(), key, nil, false)
change = func(l *link) { l.hashKey = bad }
case "name-unsigned":
parent, _ := v.parentKey(l)
name, err := decryptArmored(l.name, parent, nil, v.now)
mustCrypto("decrypt name", err)
bad := encryptArmored(name, parent, nil, false)
change = func(l *link) { l.name = bad }
case "xattrs-unsigned":
key, err := v.unlock(id)
if key == nil {
panic(fmt.Sprintf("protontest: unlock %s: %v", id, err))
}
armored := l.xattr
if l.typ == linkTypeFile {
armored = l.activeRevision().xattr
}
var x fileXAttr
if armored != "" {
plain, err := decryptArmored(armored, key, nil, v.now)
mustCrypto("decrypt extended attributes", err)
mustCrypto("parse extended attributes", json.Unmarshal(plain, &x))
}
x.Common.ModificationTime = ForgedModTime
if l.typ == linkTypeFile {
size := int64(1) << 40
x.Common.Size = &size
x.Common.Digests = &struct{ SHA1 string }{SHA1: ForgedSHA1}
}
plain, err := json.Marshal(&x)
mustCrypto("marshal extended attributes", err)
bad := encryptArmored(plain, key, nil, true)
if l.typ == linkTypeFile {
change = changeActiveRevision(func(r *revision) { r.xattr = bad })
} else {
change = func(l *link) { l.xattr = bad }
}
default:
panic("protontest: unknown corruption " + what)
}
+62
View File
@@ -167,6 +167,16 @@ var hostileContents = []hostileContent{{
return u.SeedAnonymousFile(nested, "victim.bin", content, time.Now())
},
signatureOnly: true,
}, {
name: "unsigned content key the server made",
content: patternedContent(blockSize+10, 15),
prepare: seedCorrupted("content-key-unsigned"),
signatureOnly: true,
}, {
name: "content key signed by another key",
content: patternedContent(blockSize+10, 16),
prepare: seedCorrupted("content-key-signature"),
signatureOnly: true,
}}
// hostileNames are names a hostile server gives nodes, each of which
@@ -538,6 +548,58 @@ func TestHostileServer(t *testing.T) {
}
})
for _, corruption := range []string{"content-key-unsigned", "content-key-signature"} {
t.Run("ranged reads and updates of a file with "+corruption, func(t *testing.T) {
ctx := context.Background()
remote, _, u := setupFakeRemote(t)
content := patternedContent(blockSize+10, 17)
id := u.SeedFile(u.RootID(), "victim.bin", content, time.Now())
u.Corrupt(id, corruption)
info := object.NewStaticObjectInfo("victim.bin", time.Now(), 6, true, nil, nil)
f := newFakeFs(t, remote, "")
o, err := f.NewObject(ctx, "victim.bin")
require.NoError(t, err)
for _, r := range []fs.RangeOption{{Start: 1, End: 100}, {Start: blockSize, End: -1}} {
rc, err := o.Open(ctx, &r)
var got []byte
if err == nil {
got, err = io.ReadAll(rc)
_ = rc.Close()
}
require.Error(t, err, "%v read", r)
assert.Empty(t, got, "%v: bytes released", r)
assert.Contains(t, err.Error(), "ignore_signature_errors")
}
err = o.Update(ctx, bytes.NewReader([]byte("secret")), info)
require.Error(t, err, "a new revision was encrypted with the server's content key")
assert.Contains(t, err.Error(), "ignore_signature_errors")
for _, n := range u.Dump() {
if n.ID == id {
assert.Equal(t, content, n.Content)
}
}
// With signature checks off it goes ahead, logged once
// per operation.
f = newFakeFs(t, strings.TrimSuffix(remote, ":")+",ignore_signature_errors=true:", "")
capture := captureLog(t, 0)
for range 2 {
o, err = f.NewObject(ctx, "victim.bin")
require.NoError(t, err)
got, err := readAll(ctx, o)
require.NoError(t, err)
assert.True(t, bytes.Equal(content, got))
}
require.NoError(t, o.Update(ctx, bytes.NewReader([]byte("secret")), info))
log := capture.String()
for _, op := range []string{"reading", "updating"} {
want := fmt.Sprintf("ERROR : protondrive: %s %q (ID %s): content key", op, "victim.bin", id)
assert.Equal(t, 1, strings.Count(log, want), "%q logged other than once in:\n%s", want, log)
}
})
}
t.Run("names", func(t *testing.T) {
// Its own stats, so the sync sees only its own errors.
ctx := accounting.WithStatsGroup(context.Background(), "hostile names")
+1 -1
View File
@@ -309,7 +309,7 @@ func (c *client) createRevision(ctx context.Context, n *node, size int64) (*draf
if n.IsFolder || n.link == nil || n.link.File == nil || n.RevisionID == "" {
return nil, fmt.Errorf("%q is not a file with content", n.Name)
}
sk, err := c.contentKey(n)
sk, err := c.contentKey(n, "updating")
if err != nil {
return nil, err
}
+26
View File
@@ -5,6 +5,32 @@ it with a new one that links back. One entry per decision a future maintainer
would otherwise have to reverse-engineer.
No index: `grep -n '^## ' docs/DECISIONS.md` lists every entry.
## 2026-11-12 - Proton Drive refuses a file whose content key is unsigned
**Status:** accepted (handoff ruling 29)
**Context:** Anyone holding a file's public node key, which the server
stores, can make a content key packet for it. Proton's SDK checks the
content key packet's signature only when one is present. A server could
then send its own content key without a signature: rclone would encrypt
every update of the file with a key the server knows, and a ranged read
(which can't check the manifest) would return whatever the server
encrypted under it.
**Decision:** A content key whose signature is missing or invalid makes
the file unverified, as an unverified node key does (rulings 18 and 22):
reads, full and ranged, and updates are refused unless
`ignore_signature_errors` is set, when rclone logs an `ERROR` once per file
and operation and goes ahead. The pre-2023 fallback to the account's other
address keys still applies to a signature which is present but fails, as
in the SDK. Integrity checks are never turned off. This is stricter than
the SDK.
**Alternatives:** Following the SDK (leaves the hole); a creation-date
exemption for unsigned keys (the date is server-supplied, so it would
exempt anything the server back-dates).
**Consequences:** A genuine file whose content key was never signed, if
any client ever wrote one, needs `ignore_signature_errors`. Every file in
the golden fixtures, written by Proton's web app, CLI and the old
library, has a signed content key.
## 2026-11-12 - Proton Drive deletes an upload's draft only on an explicit refusal
**Status:** accepted. Supersedes the read-back half of handoff ruling 11
+3
View File
@@ -222,6 +222,9 @@ By default rclone refuses to:
- read a file whose key, content key or manifest signature doesn't
verify, or which is beneath a folder whose key isn't verified;
- update a file whose key or content key signature doesn't verify, as
its new content would be encrypted with a key someone else may hold.
A content key without a signature counts as one that doesn't verify;
- create, upload, rename, move or copy anything into a folder whose key
isn't verified, because what is written there would be encrypted to a
key someone else may hold;