protondrive: add hostile-server and secret-hygiene tests
A hostile fake server tampers with block hashes, block order and count, serves an older revision's or another key's blocks, signs a node passphrase with its own key and gives nodes names such as "../x", "a/b", NUL and 10 MiB: each read fails or the node is left out, with and without ignore_signature_errors, and a copy or sync writes nothing wrong or outside its destination. The log at debug level, and with --dump headers, holds no password, key password, session or storage token, node passphrase or session key; browser sign-in leaves no password in the config and password sign-in keeps it obscured. The fake gains rollback and foreign-block corruptions and exposes the secrets it issued and a file's node secrets. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
db97ef7c8d
commit
f4105adfc1
10 files changed
+730
-19
No files matched your search
@@ -0,0 +1,25 @@
|
||||
package protondrive
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/rclone/rclone/fs"
|
||||
"github.com/rclone/rclone/fs/config/configmap"
|
||||
)
|
||||
|
||||
// ConfigBrowserSignIn runs the browser sign-in of rclone config for
|
||||
// remote name on m, handing the sign-in page to approve instead of
|
||||
// printing it.
|
||||
func ConfigBrowserSignIn(ctx context.Context, name string, m configmap.Mapper, approve func(signInURL string)) error {
|
||||
out, err := configure(ctx, name, m, fs.ConfigIn{State: "browser"}, signInOptions{
|
||||
showURL: approve,
|
||||
pollInterval: 10 * time.Millisecond,
|
||||
pollTimeout: 10 * time.Second,
|
||||
})
|
||||
if err == nil && out != nil {
|
||||
err = fmt.Errorf("config stopped in state %q", out.State)
|
||||
}
|
||||
return err
|
||||
}
|
||||
@@ -239,7 +239,7 @@ func (s *Server) NewSession(u *User) Session {
|
||||
// newSessionLocked creates a session for u. s.mu must be held.
|
||||
func (s *Server) newSessionLocked(u *User, locked bool) *session {
|
||||
sess := &session{
|
||||
Session: Session{UID: randomID(), AccessToken: randomID(), RefreshToken: randomID()},
|
||||
Session: Session{UID: randomID(), AccessToken: s.newSecretLocked(), RefreshToken: s.newSecretLocked()},
|
||||
user: u,
|
||||
locked: locked,
|
||||
}
|
||||
@@ -344,8 +344,8 @@ func (s *Server) handleRefresh(w http.ResponseWriter, r *http.Request) {
|
||||
writeError(w, http.StatusUnprocessableEntity, api.CodeRefreshTokenInvalid, "protontest: invalid refresh token")
|
||||
return
|
||||
}
|
||||
sess.AccessToken = randomID()
|
||||
sess.RefreshToken = randomID()
|
||||
sess.AccessToken = s.newSecretLocked()
|
||||
sess.RefreshToken = s.newSecretLocked()
|
||||
sess.expired = false
|
||||
writeJSON(w, http.StatusOK, &api.AuthRefreshResponse{
|
||||
Code: api.CodeOK,
|
||||
@@ -497,8 +497,8 @@ func (s *Server) handleKeySalts(w http.ResponseWriter, r *http.Request, u *User)
|
||||
// handleForkInit starts a session fork for a client to sign in with.
|
||||
func (s *Server) handleForkInit(w http.ResponseWriter, r *http.Request) {
|
||||
f := &fork{userCode: strings.ToUpper(hex.EncodeToString(randomBytes(4)))}
|
||||
selector := randomID()
|
||||
s.mu.Lock()
|
||||
selector := s.newSecretLocked()
|
||||
s.forks[selector] = f
|
||||
s.mu.Unlock()
|
||||
writeJSON(w, http.StatusOK, &api.ForkInitResponse{Code: api.CodeOK, Selector: selector, UserCode: f.userCode})
|
||||
|
||||
@@ -715,14 +715,7 @@ func (u *User) SeedRevision(id string, content []byte, modTime time.Time) (revis
|
||||
if l == nil || l.typ != linkTypeFile {
|
||||
panic("protontest: no file " + id)
|
||||
}
|
||||
key, err := v.unlock(id)
|
||||
if key == nil {
|
||||
panic(fmt.Sprintf("protontest: unlock file %s: %v", id, err))
|
||||
}
|
||||
sk, err := decryptContentKey(l.contentKeyPacket, l.contentKeyPacketSignature, key, v.verifier(l.signatureEmail, key), v.now)
|
||||
if sk == nil {
|
||||
panic(fmt.Sprintf("protontest: content key of %s: %v", id, err))
|
||||
}
|
||||
key, sk := v.contentKey(l)
|
||||
ck := contentKey{sk: sk, aead: sk.IsV6()}
|
||||
rev := ck.newRevision(content, key, v.addrKey, v.email, modTime.UTC().Format("2006-01-02T15:04:05.000Z"), false, nil)
|
||||
u.srv.mu.Lock()
|
||||
@@ -774,6 +767,12 @@ func (u *User) insertLink(parentID string, l *link) string {
|
||||
// - "swap-blocks": the first two blocks trade places, each still
|
||||
// matching its own hash
|
||||
// - "truncate-blocks": the last block is dropped from the revision
|
||||
// - "rollback": the active revision serves the blocks of the revision
|
||||
// before it, which SeedRevision makes, under its own ID, manifest
|
||||
// signature and extended attributes
|
||||
// - "foreign-block": the first block is the same plaintext encrypted
|
||||
// with another content key, with its hash and block signature to
|
||||
// match
|
||||
func (u *User) Corrupt(id string, what string) {
|
||||
impostor := generateKey("impostor", "impostor@proton.test")
|
||||
v := u.view()
|
||||
@@ -821,6 +820,33 @@ func (u *User) Corrupt(id string, what string) {
|
||||
needBlocks(r, 1)
|
||||
r.blocks = r.blocks[:len(r.blocks)-1]
|
||||
})
|
||||
case "rollback":
|
||||
var previous *revision
|
||||
for _, r := range l.revisions {
|
||||
if r.state == revisionStateObsolete {
|
||||
previous = r
|
||||
}
|
||||
}
|
||||
if previous == nil {
|
||||
panic("protontest: no earlier revision of " + id)
|
||||
}
|
||||
change = changeActiveRevision(func(r *revision) { r.blocks = slices.Clone(previous.blocks) })
|
||||
case "foreign-block":
|
||||
key, sk := v.contentKey(l)
|
||||
rev := l.activeRevision()
|
||||
needBlocks(rev, 1)
|
||||
first := rev.blocks[0]
|
||||
plain, err := decryptBlock(first.data, first.encSignature, sk, key, v.verifier(first.signatureEmail, key), v.now)
|
||||
if plain == nil {
|
||||
mustCrypto("decrypt block", err)
|
||||
}
|
||||
data, encSig := newContentKey(key, sk.IsV6()).encryptBlock(plain, key, v.addrKey)
|
||||
sum := sha256.Sum256(data)
|
||||
change = changeActiveRevision(func(r *revision) {
|
||||
b := *r.blocks[0]
|
||||
b.data, b.hash, b.encSignature = data, sum[:], encSig
|
||||
r.blocks[0] = &b
|
||||
})
|
||||
default:
|
||||
panic("protontest: unknown corruption " + what)
|
||||
}
|
||||
@@ -829,6 +855,39 @@ func (u *User) Corrupt(id string, what string) {
|
||||
change(u.mustDriveLocked().links[id])
|
||||
}
|
||||
|
||||
// contentKey returns the node key and content session key of file l,
|
||||
// ignoring signature errors. It panics if either can't be decrypted.
|
||||
func (v *driveView) contentKey(l *link) (*crypto.Key, *crypto.SessionKey) {
|
||||
key, err := v.unlock(l.id)
|
||||
if key == nil {
|
||||
panic(fmt.Sprintf("protontest: unlock file %s: %v", l.id, err))
|
||||
}
|
||||
sk, err := decryptContentKey(l.contentKeyPacket, l.contentKeyPacketSignature, key, v.verifier(l.signatureEmail, key), v.now)
|
||||
if sk == nil {
|
||||
panic(fmt.Sprintf("protontest: content key of %s: %v", l.id, err))
|
||||
}
|
||||
return key, sk
|
||||
}
|
||||
|
||||
// NodeSecrets returns the decrypted node passphrase and content session
|
||||
// key of file id, for tests to check a client never reveals them. It
|
||||
// panics if id is not a file or they can't be decrypted.
|
||||
func (u *User) NodeSecrets(id string) (passphrase, sessionKey []byte) {
|
||||
v := u.view()
|
||||
l := v.d.links[id]
|
||||
if l == nil || l.typ != linkTypeFile {
|
||||
panic("protontest: no file " + id)
|
||||
}
|
||||
_, sk := v.contentKey(l)
|
||||
parent, err := v.parentKey(l)
|
||||
if parent == nil {
|
||||
panic(fmt.Sprintf("protontest: parent key of %s: %v", id, err))
|
||||
}
|
||||
passphrase, err = decryptArmored(l.nodePass.armored, parent, nil, v.now)
|
||||
mustCrypto("decrypt passphrase", err)
|
||||
return passphrase, sk.Key
|
||||
}
|
||||
|
||||
// needBlocks panics unless r has at least n blocks.
|
||||
func needBlocks(r *revision, n int) {
|
||||
if len(r.blocks) < n {
|
||||
@@ -1590,7 +1649,7 @@ func (s *Server) handleRevision(w http.ResponseWriter, r *http.Request, u *User,
|
||||
SignatureEmail: nullable(b.signatureEmail),
|
||||
}
|
||||
if !noURLs {
|
||||
id, token := randomID(), randomID()
|
||||
id, token := randomID(), s.newSecretLocked()
|
||||
s.downloads[id] = &download{token: token, block: b}
|
||||
bareURL := s.URL() + "/storage/blocks/" + id
|
||||
bj.Token, bj.BareURL = &token, &bareURL
|
||||
|
||||
@@ -197,11 +197,14 @@ func TestSeedFormats(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestCorrupt(t *testing.T) {
|
||||
for _, what := range []string{"name", "name-signature", "passphrase-signature", "block-hash", "manifest", "swap-blocks", "truncate-blocks"} {
|
||||
for _, what := range []string{"name", "name-signature", "passphrase-signature", "block-hash", "manifest", "swap-blocks", "truncate-blocks", "rollback", "foreign-block"} {
|
||||
t.Run(what, func(t *testing.T) {
|
||||
s := New(t)
|
||||
u := s.AddUser("user", "pass")
|
||||
victim := u.SeedFile(u.RootID(), "victim", patterned(blockSize+10), time.Now())
|
||||
if what == "rollback" {
|
||||
u.SeedRevision(victim, patterned(blockSize+20), time.Now())
|
||||
}
|
||||
bystander := u.SeedFile(u.RootID(), "bystander", []byte("fine"), time.Now())
|
||||
u.Corrupt(victim, what)
|
||||
for _, n := range u.Dump() {
|
||||
@@ -588,6 +591,34 @@ func TestSeedRevision(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestNodeSecrets(t *testing.T) {
|
||||
s := New(t)
|
||||
u := s.AddUser("user", "pass")
|
||||
id := u.SeedFile(u.RootID(), "file", []byte("secret"), time.Now())
|
||||
passphrase, sessionKey := u.NodeSecrets(id)
|
||||
|
||||
v := u.view()
|
||||
l := v.d.links[id]
|
||||
key, err := crypto.NewPrivateKeyFromArmored(l.nodeKey, passphrase)
|
||||
require.NoError(t, err, "the passphrase unlocks the node key")
|
||||
sk, err := decryptContentKey(l.contentKeyPacket, l.contentKeyPacketSignature, key, keyRing(key), time.Time{})
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, sk.Key, sessionKey)
|
||||
}
|
||||
|
||||
func TestIssuedSecrets(t *testing.T) {
|
||||
s := New(t)
|
||||
u := s.AddUser("user", "pass")
|
||||
sess := s.NewSession(u)
|
||||
file := u.SeedFile(u.RootID(), "file", []byte("x"), time.Now())
|
||||
assert.Equal(t, []string{sess.AccessToken, sess.RefreshToken}, s.IssuedSecrets())
|
||||
|
||||
var rev revisionResponse
|
||||
status, body := getJSON(t, s, sess, "/drive/v2/volumes/"+u.VolumeID()+"/files/"+file+"/revisions/"+u.view().d.links[file].activeRevision().id, &rev)
|
||||
require.Equal(t, http.StatusOK, status, "body: %s", body)
|
||||
assert.Contains(t, s.IssuedSecrets(), *rev.Revision.Blocks[0].Token)
|
||||
}
|
||||
|
||||
func TestStoredFileRoundTrip(t *testing.T) {
|
||||
s := New(t)
|
||||
addrPass := newPassphrase()
|
||||
|
||||
@@ -12,6 +12,7 @@ import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"regexp"
|
||||
"slices"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
@@ -84,6 +85,7 @@ type Server struct {
|
||||
uploads map[string]*uploadURL // block upload URLs by ID
|
||||
storageUploads int // block uploads in progress
|
||||
storagePeak int // most block uploads in progress at once
|
||||
secrets []string // every secret issued, in order
|
||||
}
|
||||
|
||||
// New starts a fake server which is closed when the test ends.
|
||||
@@ -173,6 +175,23 @@ func (s *Server) ResetRequests() {
|
||||
s.storagePeak = s.storageUploads
|
||||
}
|
||||
|
||||
// newSecretLocked returns a new random secret and records it for
|
||||
// IssuedSecrets. s.mu must be held.
|
||||
func (s *Server) newSecretLocked() string {
|
||||
secret := randomID()
|
||||
s.secrets = append(s.secrets, secret)
|
||||
return secret
|
||||
}
|
||||
|
||||
// IssuedSecrets returns every secret the server has handed to a
|
||||
// client: session access and refresh tokens, fork selectors, and block
|
||||
// upload and download tokens.
|
||||
func (s *Server) IssuedSecrets() []string {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
return slices.Clone(s.secrets)
|
||||
}
|
||||
|
||||
// Inject adds a fault. Faults are checked in the order they were added
|
||||
// and the first one that fires is applied. A Gather fault needs Times.
|
||||
func (s *Server) Inject(f Fault) {
|
||||
|
||||
@@ -426,7 +426,7 @@ func (s *Server) handleRequestUpload(w http.ResponseWriter, r *http.Request, u *
|
||||
resp := &blockUploadResponse{UploadLinks: []blockURLJSON{}, ThumbnailLinks: []struct{}{}, Code: api.CodeOK}
|
||||
for _, b := range blocks {
|
||||
rev.pending[b.index] = b
|
||||
id, token := randomID(), randomID()
|
||||
id, token := randomID(), s.newSecretLocked()
|
||||
s.uploads[id] = &uploadURL{token: token, user: u, linkID: l.id, rev: rev, block: b}
|
||||
bareURL := s.URL() + "/storage/upload/" + id
|
||||
resp.UploadLinks = append(resp.UploadLinks, blockURLJSON{BareURL: bareURL, Token: token, URL: bareURL, Index: b.index})
|
||||
|
||||
@@ -0,0 +1,528 @@
|
||||
package protondrive_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/rclone/rclone/backend/protondrive"
|
||||
"github.com/rclone/rclone/backend/protondrive/protontest"
|
||||
"github.com/rclone/rclone/fs"
|
||||
"github.com/rclone/rclone/fs/accounting"
|
||||
"github.com/rclone/rclone/fs/config/configmap"
|
||||
"github.com/rclone/rclone/fs/config/obscure"
|
||||
"github.com/rclone/rclone/fs/log"
|
||||
"github.com/rclone/rclone/fs/object"
|
||||
"github.com/rclone/rclone/fs/operations"
|
||||
fssync "github.com/rclone/rclone/fs/sync"
|
||||
"github.com/rclone/rclone/lib/random"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// blockSize is the plaintext size of a full block.
|
||||
const blockSize = 4 << 20
|
||||
|
||||
// patternedContent returns n bytes, seeded by seed, which differ per
|
||||
// block.
|
||||
func patternedContent(n int, seed byte) []byte {
|
||||
b := make([]byte, n)
|
||||
for i := range b {
|
||||
b[i] = byte(i*7+i/blockSize) ^ seed
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// readAll opens o and reads it to the end, returning every byte the
|
||||
// reader released and the first error, from Open or Read.
|
||||
func readAll(ctx context.Context, o fs.Object) ([]byte, error) {
|
||||
rc, err := o.Open(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
got, err := io.ReadAll(rc)
|
||||
if closeErr := rc.Close(); err == nil {
|
||||
err = closeErr
|
||||
}
|
||||
return got, err
|
||||
}
|
||||
|
||||
// requireCopyFails copies remote from src to a new local directory and
|
||||
// checks the copy fails and leaves nothing behind.
|
||||
func requireCopyFails(ctx context.Context, t *testing.T, src fs.Fs, remote string) {
|
||||
t.Helper()
|
||||
dst := newFakeFs(t, "", t.TempDir())
|
||||
err := operations.CopyFile(ctx, dst, src, remote, remote)
|
||||
require.Error(t, err, "copied %s", remote)
|
||||
entries, err := os.ReadDir(dst.Root())
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, entries, "the failed copy left files behind")
|
||||
}
|
||||
|
||||
// hostileContent is a file whose content a hostile server tampers with.
|
||||
type hostileContent struct {
|
||||
name string
|
||||
content []byte
|
||||
// prepare seeds the file in u's root and tampers with it,
|
||||
// returning its ID.
|
||||
prepare func(u *protontest.User, content []byte) string
|
||||
// signatureOnly is set if only a signature check catches the
|
||||
// tampering, which ignore_signature_errors turns off.
|
||||
signatureOnly bool
|
||||
// released is how many bytes the reader may hand out before its
|
||||
// error: those of the blocks read before the check which fails.
|
||||
released int
|
||||
}
|
||||
|
||||
// seedCorrupted returns a prepare which seeds the file and applies the
|
||||
// fake's corruption what.
|
||||
func seedCorrupted(what string) func(u *protontest.User, content []byte) string {
|
||||
return func(u *protontest.User, content []byte) string {
|
||||
id := u.SeedFile(u.RootID(), "victim.bin", content, time.Now())
|
||||
u.Corrupt(id, what)
|
||||
return id
|
||||
}
|
||||
}
|
||||
|
||||
// seedRolledBack returns a prepare which seeds the file with old
|
||||
// content, gives it a new revision with the content, then serves the
|
||||
// old revision's blocks under the new revision.
|
||||
func seedRolledBack(old []byte) func(u *protontest.User, content []byte) string {
|
||||
return func(u *protontest.User, content []byte) string {
|
||||
id := u.SeedFile(u.RootID(), "victim.bin", old, time.Now())
|
||||
u.SeedRevision(id, content, time.Now())
|
||||
u.Corrupt(id, "rollback")
|
||||
return id
|
||||
}
|
||||
}
|
||||
|
||||
// hostileContents are the hostile content cases of spec section 9.6.
|
||||
var hostileContents = []hostileContent{{
|
||||
name: "wrong block hash",
|
||||
content: patternedContent(blockSize+10, 1),
|
||||
prepare: seedCorrupted("block-hash"),
|
||||
}, {
|
||||
name: "swapped blocks",
|
||||
content: patternedContent(2*blockSize+10, 2),
|
||||
prepare: seedCorrupted("swap-blocks"),
|
||||
signatureOnly: true,
|
||||
released: 2*blockSize + 10,
|
||||
}, {
|
||||
name: "swapped blocks of different sizes",
|
||||
content: patternedContent(blockSize+10, 3),
|
||||
prepare: seedCorrupted("swap-blocks"),
|
||||
}, {
|
||||
name: "truncated block list",
|
||||
content: patternedContent(blockSize+10, 4),
|
||||
prepare: seedCorrupted("truncate-blocks"),
|
||||
released: blockSize,
|
||||
}, {
|
||||
name: "older revision content under the current revision ID",
|
||||
content: patternedContent(blockSize+10, 5),
|
||||
prepare: seedRolledBack(patternedContent(blockSize+10, 6)),
|
||||
signatureOnly: true,
|
||||
released: blockSize + 10,
|
||||
}, {
|
||||
name: "older revision content of another size under the current revision ID",
|
||||
content: patternedContent(20, 7),
|
||||
prepare: seedRolledBack(patternedContent(10, 8)),
|
||||
}, {
|
||||
name: "block from another file",
|
||||
content: patternedContent(blockSize+10, 9),
|
||||
prepare: seedCorrupted("foreign-block"),
|
||||
}, {
|
||||
name: "attacker-signed passphrase",
|
||||
content: patternedContent(100, 10),
|
||||
prepare: seedCorrupted("passphrase-signature"),
|
||||
signatureOnly: true,
|
||||
}}
|
||||
|
||||
// hostileNames are names a hostile server gives nodes, each of which
|
||||
// must be left out of listings.
|
||||
var hostileNames = []string{"../x", "a/b", "nul\x00name", "..", ".", strings.Repeat("x", 10<<20)}
|
||||
|
||||
// TestHostileServer checks a hostile server can't get rclone to return
|
||||
// tampered content as the file's, or a path outside the listed
|
||||
// directory.
|
||||
func TestHostileServer(t *testing.T) {
|
||||
for _, tc := range hostileContents {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
remote, _, u := setupFakeRemote(t)
|
||||
tc.prepare(u, tc.content)
|
||||
|
||||
f := newFakeFs(t, remote, "")
|
||||
o, err := f.NewObject(ctx, "victim.bin")
|
||||
require.NoError(t, err, "the file is listed")
|
||||
got, err := readAll(ctx, o)
|
||||
require.Error(t, err, "read without error")
|
||||
assert.LessOrEqual(t, len(got), tc.released, "bytes released before the error")
|
||||
assert.False(t, bytes.Equal(got, tc.content), "the content was returned")
|
||||
requireCopyFails(ctx, t, f, "victim.bin")
|
||||
|
||||
// Turning signature checks off leaves the integrity
|
||||
// checks, and the hash check of a copy.
|
||||
f = newFakeFs(t, strings.TrimSuffix(remote, ":")+",ignore_signature_errors=true:", "")
|
||||
o, err = f.NewObject(ctx, "victim.bin")
|
||||
require.NoError(t, err)
|
||||
got, err = readAll(ctx, o)
|
||||
if !tc.signatureOnly {
|
||||
require.Error(t, err, "read without error with signature checks off")
|
||||
assert.LessOrEqual(t, len(got), tc.released, "bytes released before the error")
|
||||
}
|
||||
if bytes.Equal(got, tc.content) {
|
||||
// Only a signature was tampered with, and the content
|
||||
// is the file's.
|
||||
return
|
||||
}
|
||||
requireCopyFails(ctx, t, f, "victim.bin")
|
||||
})
|
||||
}
|
||||
|
||||
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")
|
||||
remote, _, u := setupFakeRemote(t)
|
||||
dir := u.SeedFolder(u.RootID(), "dir")
|
||||
for i, name := range hostileNames {
|
||||
u.SeedFile(dir, name, []byte("hostile file"), time.Now())
|
||||
// At the root, "../x" would land beside a sync's destination.
|
||||
u.SeedFile(u.RootID(), name, []byte("hostile file"), time.Now())
|
||||
sub := u.SeedFolder(u.RootID(), fmt.Sprintf("sub %d", i))
|
||||
u.SeedFolder(sub, name)
|
||||
}
|
||||
// A legitimate name rclone shows with a lookalike of /.
|
||||
u.SeedFile(dir, "a/b", []byte("fine"), time.Now())
|
||||
u.SeedFile(dir, "ok.txt", []byte("fine"), time.Now())
|
||||
f := newFakeFs(t, remote, "")
|
||||
|
||||
var before runtime.MemStats
|
||||
runtime.ReadMemStats(&before)
|
||||
start := time.Now()
|
||||
entries, err := f.List(ctx, "dir")
|
||||
elapsed := time.Since(start)
|
||||
var after runtime.MemStats
|
||||
runtime.ReadMemStats(&after)
|
||||
require.NoError(t, err)
|
||||
t.Logf("listing took %v and allocated %d MiB, the fake's encoding included", elapsed, (after.TotalAlloc-before.TotalAlloc)>>20)
|
||||
assert.Less(t, elapsed, 30*time.Second)
|
||||
|
||||
var remotes []string
|
||||
for _, entry := range entries {
|
||||
remotes = append(remotes, entry.Remote())
|
||||
leaf, ok := strings.CutPrefix(entry.Remote(), "dir/")
|
||||
assert.True(t, ok, "%q is outside dir", entry.Remote())
|
||||
assert.NotContains(t, leaf, "/")
|
||||
assert.NotContains(t, leaf, "\x00")
|
||||
assert.NotEqual(t, "..", leaf)
|
||||
assert.NotEqual(t, ".", leaf)
|
||||
}
|
||||
assert.Len(t, remotes, 2, "%q", remotes)
|
||||
assert.Contains(t, remotes, "dir/ok.txt")
|
||||
|
||||
for _, entry := range mustList(ctx, t, f, "") {
|
||||
if d, ok := entry.(fs.Directory); ok && strings.HasPrefix(d.Remote(), "sub ") {
|
||||
assert.Empty(t, mustList(ctx, t, f, d.Remote()), "hostile folder listed in %q", d.Remote())
|
||||
}
|
||||
}
|
||||
|
||||
// A sync of the whole remote writes only inside its
|
||||
// destination.
|
||||
parent := t.TempDir()
|
||||
dst := newFakeFs(t, "", filepath.Join(parent, "dst"))
|
||||
require.NoError(t, fssync.Sync(ctx, dst, newFakeFs(t, remote, ""), false))
|
||||
var written []string
|
||||
require.NoError(t, filepath.WalkDir(parent, func(path string, d os.DirEntry, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rel, err := filepath.Rel(parent, path)
|
||||
written = append(written, filepath.ToSlash(rel))
|
||||
return err
|
||||
}))
|
||||
assert.NotContains(t, written, "x")
|
||||
for _, path := range written {
|
||||
assert.True(t, path == "." || path == "dst" || strings.HasPrefix(path, "dst/"), "%q written outside the destination", path)
|
||||
}
|
||||
assert.Contains(t, written, "dst/dir/ok.txt")
|
||||
})
|
||||
}
|
||||
|
||||
// mustList lists dir of f.
|
||||
func mustList(ctx context.Context, t *testing.T, f fs.Fs, dir string) fs.DirEntries {
|
||||
t.Helper()
|
||||
entries, err := f.List(ctx, dir)
|
||||
require.NoError(t, err)
|
||||
return entries
|
||||
}
|
||||
|
||||
// logCapture holds rclone's log output while it is captured.
|
||||
type logCapture struct {
|
||||
mu sync.Mutex
|
||||
buf strings.Builder
|
||||
}
|
||||
|
||||
// String returns the log output captured so far.
|
||||
func (c *logCapture) String() string {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
return c.buf.String()
|
||||
}
|
||||
|
||||
// captureLog captures rclone's log output at debug level, with the HTTP
|
||||
// dumps of dump, until the test ends.
|
||||
func captureLog(t *testing.T, dump fs.DumpFlags) *logCapture {
|
||||
c := &logCapture{}
|
||||
log.Handler.SetOutput(func(level slog.Level, text string) {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
c.buf.WriteString(text)
|
||||
})
|
||||
oldLevel := log.Handler.SetLevel(slog.LevelDebug)
|
||||
ci := fs.GetConfig(context.Background())
|
||||
oldLogLevel, oldDump := ci.LogLevel, ci.Dump
|
||||
ci.LogLevel, ci.Dump = fs.LogLevelDebug, dump
|
||||
t.Cleanup(func() {
|
||||
ci.LogLevel, ci.Dump = oldLogLevel, oldDump
|
||||
log.Handler.SetLevel(oldLevel)
|
||||
log.Handler.ResetOutput()
|
||||
})
|
||||
return c
|
||||
}
|
||||
|
||||
// secretForms returns the forms a secret could take in a log line.
|
||||
func secretForms(secret []byte) []string {
|
||||
forms := []string{base64.StdEncoding.EncodeToString(secret), base64.RawURLEncoding.EncodeToString(secret), hex.EncodeToString(secret)}
|
||||
if len(secret) >= 8 {
|
||||
forms = append(forms, string(secret))
|
||||
}
|
||||
return forms
|
||||
}
|
||||
|
||||
// assertNoSecrets checks log contains no form of any of secrets,
|
||||
// described by what.
|
||||
func assertNoSecrets(t *testing.T, log, what string, secrets ...[]byte) {
|
||||
t.Helper()
|
||||
for i, secret := range secrets {
|
||||
require.NotEmpty(t, secret, "%s %d is empty", what, i)
|
||||
for _, form := range secretForms(secret) {
|
||||
assert.False(t, strings.Contains(log, form), "the log holds %s %d as %q", what, i, form)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// secretRun is what a run of signing in, uploading, downloading and
|
||||
// disconnecting revealed to the test.
|
||||
type secretRun struct {
|
||||
log string
|
||||
passwords [][]byte // the password and mailbox password
|
||||
keyPassword []byte
|
||||
sessionTokens [][]byte // every access and refresh token saved
|
||||
storageTokens [][]byte // every block upload and download token
|
||||
nodeSecrets [][]byte // node passphrases and content session keys
|
||||
}
|
||||
|
||||
// runSignedInSession signs in with a password, uploads a 5 MiB file,
|
||||
// refreshes the session, downloads files and disconnects, with rclone's
|
||||
// log captured with dump.
|
||||
func runSignedInSession(t *testing.T, dump fs.DumpFlags) secretRun {
|
||||
ctx := context.Background()
|
||||
const password, mailboxPassword = "password-Hunter2-3f9c1a", "mailbox-Hunter2-7b2d4e"
|
||||
srv := protontest.New(t)
|
||||
u := srv.AddTwoPasswordUser("user", password, mailboxPassword)
|
||||
stored := u.SeedFile(u.RootID(), "stored.bin", patternedContent(blockSize+10, 11), time.Now())
|
||||
damaged := u.SeedFile(u.RootID(), "damaged.bin", patternedContent(100, 12), time.Now())
|
||||
u.Corrupt(damaged, "block-hash")
|
||||
m := newLockedMap(configmap.Simple{
|
||||
"endpoint": srv.URL(),
|
||||
"username": "user",
|
||||
"password": obscure.MustObscure(password),
|
||||
"mailbox_password": obscure.MustObscure(mailboxPassword),
|
||||
"original_file_size": "true",
|
||||
})
|
||||
|
||||
capture := captureLog(t, dump)
|
||||
f, err := protondrive.NewFs(ctx, "secrets", "", m)
|
||||
require.NoError(t, err)
|
||||
content := []byte(random.String(5 << 20))
|
||||
uploaded, err := operations.Copy(ctx, f, nil, "upload.bin", object.NewMemoryObject("upload.bin", time.Now(), content))
|
||||
require.NoError(t, err)
|
||||
|
||||
uid, _ := m.Get("client_uid")
|
||||
srv.ExpireAccessToken(uid)
|
||||
f.(fs.DirCacheFlusher).DirCacheFlush()
|
||||
for _, name := range []string{"upload.bin", "stored.bin"} {
|
||||
o, err := f.NewObject(ctx, name)
|
||||
require.NoError(t, err)
|
||||
_, err = readAll(ctx, o)
|
||||
require.NoError(t, err, name)
|
||||
}
|
||||
o, err := f.NewObject(ctx, "damaged.bin")
|
||||
require.NoError(t, err)
|
||||
_, err = readAll(ctx, o)
|
||||
require.Error(t, err)
|
||||
require.NoError(t, f.Features().Disconnect(ctx))
|
||||
|
||||
run := secretRun{
|
||||
log: capture.String(),
|
||||
passwords: [][]byte{[]byte(password), []byte(mailboxPassword)},
|
||||
keyPassword: []byte(u.KeyPassword()),
|
||||
}
|
||||
saved := map[string]bool{}
|
||||
for _, key := range []string{"client_access_token", "client_refresh_token"} {
|
||||
for _, token := range m.values(key) {
|
||||
if token != "" {
|
||||
saved[token] = true
|
||||
run.sessionTokens = append(run.sessionTokens, []byte(token))
|
||||
}
|
||||
}
|
||||
}
|
||||
require.NotEmpty(t, run.sessionTokens)
|
||||
for _, secret := range srv.IssuedSecrets() {
|
||||
if !saved[secret] {
|
||||
run.storageTokens = append(run.storageTokens, []byte(secret))
|
||||
}
|
||||
}
|
||||
require.NotEmpty(t, run.storageTokens)
|
||||
for _, id := range []string{uploaded.(fs.IDer).ID(), stored, damaged} {
|
||||
passphrase, sessionKey := u.NodeSecrets(id)
|
||||
run.nodeSecrets = append(run.nodeSecrets, passphrase, sessionKey)
|
||||
}
|
||||
require.Contains(t, run.log, "refreshing session", "debug output not captured")
|
||||
return run
|
||||
}
|
||||
|
||||
// TestNoSecretsInLogs checks no secret reaches rclone's log at debug
|
||||
// level across sign-in, upload, download and Disconnect.
|
||||
func TestNoSecretsInLogs(t *testing.T) {
|
||||
t.Run("debug", func(t *testing.T) {
|
||||
run := runSignedInSession(t, 0)
|
||||
assertNoSecrets(t, run.log, "password", run.passwords...)
|
||||
assertNoSecrets(t, run.log, "key password", run.keyPassword)
|
||||
assertNoSecrets(t, run.log, "session token", run.sessionTokens...)
|
||||
assertNoSecrets(t, run.log, "pm-storage-token", run.storageTokens...)
|
||||
assertNoSecrets(t, run.log, "node secret", run.nodeSecrets...)
|
||||
})
|
||||
|
||||
// --dump headers shows the headers fshttp doesn't redact, of
|
||||
// which pm-storage-token and x-pm-uid are Proton's, but never the
|
||||
// Authorization header with the access token. --dump bodies shows
|
||||
// the tokens in sign-in and refresh responses, as spec section 7
|
||||
// says, so isn't checked.
|
||||
t.Run("dump headers", func(t *testing.T) {
|
||||
run := runSignedInSession(t, fs.DumpHeaders)
|
||||
require.Contains(t, run.log, "HTTP REQUEST", "headers not dumped")
|
||||
assertNoSecrets(t, run.log, "password", run.passwords...)
|
||||
assertNoSecrets(t, run.log, "key password", run.keyPassword)
|
||||
assertNoSecrets(t, run.log, "session token", run.sessionTokens...)
|
||||
assertNoSecrets(t, run.log, "node secret", run.nodeSecrets...)
|
||||
})
|
||||
}
|
||||
|
||||
// allValues returns every value m held or was set to, by key.
|
||||
func allValues(m *lockedMap) map[string][]string {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
all := map[string][]string{}
|
||||
for k, v := range m.m {
|
||||
all[k] = append(all[k], v)
|
||||
}
|
||||
for k, vs := range m.set {
|
||||
all[k] = append(all[k], vs...)
|
||||
}
|
||||
return all
|
||||
}
|
||||
|
||||
// TestConfigHoldsNoPasswordAfterBrowserSignIn checks browser sign-in
|
||||
// leaves no password in the config, and logs none of its secrets.
|
||||
func TestConfigHoldsNoPasswordAfterBrowserSignIn(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
const password = "browser-Hunter2-9e8d7c"
|
||||
srv := protontest.New(t)
|
||||
u := srv.AddUser("user", password)
|
||||
m := newLockedMap(configmap.Simple{"endpoint": srv.URL()})
|
||||
capture := captureLog(t, 0)
|
||||
var signInURL string
|
||||
require.NoError(t, protondrive.ConfigBrowserSignIn(ctx, "browser", m, func(shown string) {
|
||||
signInURL = shown
|
||||
require.NoError(t, srv.ApproveFork(shown, u))
|
||||
}))
|
||||
|
||||
_, err := protondrive.NewFs(ctx, "browser", "", m)
|
||||
require.NoError(t, err, "the session works")
|
||||
for _, key := range []string{"password", "mailbox_password"} {
|
||||
assert.Empty(t, m.values(key), "%s set", key)
|
||||
}
|
||||
for key, values := range allValues(m) {
|
||||
for _, v := range values {
|
||||
assert.NotContains(t, v, password, "%s holds the password", key)
|
||||
if v != "" {
|
||||
revealed, err := obscure.Reveal(v)
|
||||
assert.False(t, err == nil && strings.Contains(revealed, password), "%s holds the password obscured", key)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
log := capture.String()
|
||||
fragment := signInURL[strings.Index(signInURL, "#")+1:]
|
||||
assert.NotContains(t, log, fragment, "the sign-in URL's secret is logged")
|
||||
var secrets [][]byte
|
||||
for _, secret := range srv.IssuedSecrets() {
|
||||
secrets = append(secrets, []byte(secret))
|
||||
}
|
||||
assertNoSecrets(t, log, "issued secret", secrets...)
|
||||
assertNoSecrets(t, log, "key password", []byte(u.KeyPassword()))
|
||||
}
|
||||
|
||||
// TestPasswordStoredObscured checks password sign-in keeps the password
|
||||
// obscured in the config, as rclone config stores it, and writes no
|
||||
// password to the config itself.
|
||||
func TestPasswordStoredObscured(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
const password, mailboxPassword = "stored-Hunter2-1a2b3c", "stored-mailbox-4d5e6f"
|
||||
srv := protontest.New(t)
|
||||
srv.AddTwoPasswordUser("user", password, mailboxPassword)
|
||||
|
||||
// rclone config obscures the options marked as passwords.
|
||||
info, err := fs.Find("protondrive")
|
||||
require.NoError(t, err)
|
||||
for _, key := range []string{"password", "mailbox_password", "otp_secret_key"} {
|
||||
opt := info.Options.Get(key)
|
||||
require.NotNil(t, opt, key)
|
||||
assert.True(t, opt.IsPassword, "%s is not obscured", key)
|
||||
}
|
||||
|
||||
m := newLockedMap(configmap.Simple{
|
||||
"endpoint": srv.URL(),
|
||||
"username": "user",
|
||||
"password": obscure.MustObscure(password),
|
||||
"mailbox_password": obscure.MustObscure(mailboxPassword),
|
||||
})
|
||||
_, err = protondrive.NewFs(ctx, "obscured", "", m)
|
||||
require.NoError(t, err)
|
||||
for key, plain := range map[string]string{"password": password, "mailbox_password": mailboxPassword} {
|
||||
stored, _ := m.Get(key)
|
||||
assert.NotEqual(t, plain, stored, key)
|
||||
revealed, err := obscure.Reveal(stored)
|
||||
require.NoError(t, err, key)
|
||||
assert.Equal(t, plain, revealed, key)
|
||||
}
|
||||
for key, values := range allValues(m) {
|
||||
for _, v := range values {
|
||||
assert.NotContains(t, v, password, "%s holds the password", key)
|
||||
assert.NotContains(t, v, mailboxPassword, "%s holds the mailbox password", key)
|
||||
}
|
||||
}
|
||||
assert.NotEmpty(t, m.values("client_uid"), "the session is saved")
|
||||
}
|
||||
@@ -5,6 +5,24 @@ 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-11 - Proton Drive refuses a file whose node key signature fails
|
||||
|
||||
**Status:** accepted
|
||||
**Context:** The node passphrase signature was only logged when it
|
||||
failed, as the SDK does, so a server could seal a key of its own to
|
||||
the parent folder's public key and serve any content under it (spec 7
|
||||
puts the server in the threat model; 9.6 asks for an error).
|
||||
**Decision:** Opening such a file fails with an integrity error naming
|
||||
`ignore_signature_errors`, like a content key or manifest signature
|
||||
failure; with the option set it is read, the failure logged once. The
|
||||
node is still listed. Sign-in errors that need a reconnect name the
|
||||
remote through a hint the seam gives the session, so read errors, which
|
||||
don't pass through `translateError`, name it too.
|
||||
**Alternatives:** Skipping the node from listings (a sync would then
|
||||
delete its copy at the destination); leaving it to the SDK's behaviour.
|
||||
**Consequences:** Legacy files whose keys were signed by a since-removed
|
||||
address need `ignore_signature_errors`, which the error says.
|
||||
|
||||
## 2026-11-11 - Proton Drive backend runs on its own client
|
||||
|
||||
**Status:** accepted
|
||||
|
||||
@@ -8,6 +8,30 @@ Small, specific, independently actionable. Remove only when actually done.
|
||||
|
||||
## Next
|
||||
|
||||
- [ ] protondrive: a full read checks the manifest signature only at EOF
|
||||
(spec 6.4, as the SDK does), so a hostile server serving blocks
|
||||
swapped, or an older revision's blocks, of the recorded sizes gets
|
||||
that wrong plaintext handed to the reader before the final `Read`
|
||||
fails (`TestHostileServer` "swapped blocks", "older revision
|
||||
content"). `operations.Copy` discards it, but `rclone cat` and a
|
||||
streaming mount don't. Consider listing every block page and checking
|
||||
the manifest before releasing the first byte, at least when the block
|
||||
list fits in one page; with `ignore_signature_errors` only the SHA1
|
||||
check of a copy catches these.
|
||||
- [ ] protondrive: `--dump headers` logs Proton's `pm-storage-token` and
|
||||
`x-pm-uid` (fshttp redacts only `Authorization`), and `--dump bodies`
|
||||
logs the access, refresh and upload tokens in JSON bodies (seen in
|
||||
`TestNoSecretsInLogs`). Task 20's docs must carry the spec 7 warning;
|
||||
a header redaction list in `fshttp` would be an upstream change.
|
||||
- [ ] protondrive: a name whose signature fails is listed and the file
|
||||
read with only an `ERROR` logged (spec 6.2, the SDK's behaviour), and
|
||||
names aren't bound to their node, so a server can swap the encrypted
|
||||
names of two files in one folder undetected. Raise with Proton.
|
||||
- [ ] protondrive: a hostile 10 MiB name is decrypted in full before
|
||||
`validateName` rejects it (about 230 MiB allocated listing it, the
|
||||
fake included). Consider refusing an encrypted name over a few KiB
|
||||
before decrypting it.
|
||||
|
||||
- [ ] lib/pacer: `TokenDispenser.Get` takes no context, so a cancelled
|
||||
protondrive block download still waits for a download token (held by
|
||||
other in-flight blocks, which finish or fail soon) before it notices.
|
||||
|
||||
@@ -572,7 +572,14 @@ library what must stay readable.
|
||||
(v3 PKESK, SEIPDv1 blocks),
|
||||
`func (u *User) Corrupt(id string, what string)` with `what` one of
|
||||
`"name"`, `"name-signature"`, `"passphrase-signature"`, `"block-hash"`,
|
||||
`"manifest"`, `"swap-blocks"`, `"truncate-blocks"`.
|
||||
`"manifest"`, `"swap-blocks"`, `"truncate-blocks"`, and (Task 16)
|
||||
`"rollback"` (the active revision serves the previous revision's
|
||||
blocks) and `"foreign-block"` (the first block encrypted with another
|
||||
content key).
|
||||
- Secrets for log hygiene tests (Task 16):
|
||||
`func (s *Server) IssuedSecrets() []string` (every access and refresh
|
||||
token, fork selector and block upload or download token issued) and
|
||||
`func (u *User) NodeSecrets(id string) (passphrase, sessionKey []byte)`.
|
||||
- `func (u *User) Dump() []DumpedNode` - decrypted tree for assertions
|
||||
(`ID`, `Path`, `IsFolder`, `Content`, `ModTime`, `SHA1`, `State`, and
|
||||
`Err` joining every decryption, signature, block-hash, manifest and
|
||||
@@ -1154,7 +1161,7 @@ Decisions:
|
||||
|
||||
- Create: `backend/protondrive/security_test.go`
|
||||
|
||||
- [ ] **Step 1: Write the tests** (spec 9.6):
|
||||
- [x] **Step 1: Write the tests** (spec 9.6):
|
||||
- `TestHostileServer` subtests: wrong block hash, swapped blocks,
|
||||
truncated block list, older revision content under the current
|
||||
revision ID, attacker-signed passphrase, names `"../x"`, `"a/b"`, NUL,
|
||||
@@ -1169,8 +1176,8 @@ Decisions:
|
||||
- `TestConfigHoldsNoPasswordAfterBrowserSignIn`, and
|
||||
`TestPasswordStoredObscured` (the stored value differs from the
|
||||
plaintext and `obscure.Reveal` restores it).
|
||||
- [ ] **Step 2: Run** - fix until PASS.
|
||||
- [ ] **Step 3: Commit** `protondrive: add hostile-server and secret-hygiene tests`.
|
||||
- [x] **Step 2: Run** - fix until PASS.
|
||||
- [x] **Step 3: Commit** `protondrive: add hostile-server and secret-hygiene tests`.
|
||||
|
||||
### Task 17: Request budgets and fuzzing
|
||||
|
||||
|
||||
Reference in new issue
Block a user