Compare commits

..
Author SHA1 Message Date
sneak 68ba6bafa8 Fix missing-key errors for restore and deep verify to name both key sources (closes #401)
check / check (push) Successful in 10m25s
The missing-key error for restore and deep verify is one value, errDecryptionKeyRequired, whose text names both places the key can be set: the VAULTIK_AGE_SECRET_KEY environment variable first, then the age_secret_key config file field.

Model: deepseek-v4-pro
2026-11-13 22:24:34 +00:00
16 changed files with 153 additions and 250 deletions

No files matched your search

+4 -6
View File
@@ -468,12 +468,10 @@ destination store. Blobs are NOT touched — deleting blobs requires reading eve
remaining remote manifest (the destination store may hold snapshots this host remaining remote manifest (the destination store may hold snapshots this host
doesn't know about), which is what `vaultik prune` does. The command prints the doesn't know about), which is what `vaultik prune` does. The command prints the
`vaultik prune` invocation to run as a follow-up only when it removed the `vaultik prune` invocation to run as a follow-up only when it removed the
snapshot's metadata from the destination store, and never under `--json`. It snapshot's metadata from the destination store, and never under `--json`. An ID
accepts the same identifiers as `snapshot restore`: a snapshot ID, or a that names no snapshot in the local index or on the destination store is an
remote-only snapshot's remote key (or an unambiguous leading part of it). An error; with `--local-only`, the snapshot must be in the local index. Local row
identifier that names no snapshot in the local index or on the destination store cleanup (files, chunks, blobs the snapshot was the last referrer for) runs
is an error; with `--local-only`, the snapshot must be in the local index. Local
row cleanup (files, chunks, blobs the snapshot was the last referrer for) runs
automatically. If removing the snapshot's metadata from the destination store automatically. If removing the snapshot's metadata from the destination store
fails (for example because the store is unreachable, or the local index holds fails (for example because the store is unreachable, or the local index holds
snapshots and the destination answers that it has no `vaultik-destination.txt`), snapshots and the destination answers that it has no `vaultik-destination.txt`),
-7
View File
@@ -282,13 +282,6 @@ func TestConfigSetKeepsFileThatWouldNotLoad(t *testing.T) {
storageURLKey, testS3URL, storageURLKey, testS3URL,
"s3.secret_access_key is required for s3:// URLs; " + "s3.secret_access_key is required for s3:// URLs; " +
"set s3.access_key_id and s3.secret_access_key first"}, "set s3.access_key_id and s3.secret_access_key first"},
// rclone:// URLs that no command could open.
{configWithoutRecipients, storageURLKey, "rclone:///backups",
"rclone URL missing remote name"},
{configWithoutRecipients, storageURLKey, "rclone://dav,user=x/backups",
"rclone URL must not carry parameters in the remote name"},
{configWithoutRecipients, storageURLKey, "rclone://dav/backups?x=1",
`unknown query parameter in storage URL: "x"`},
// With its reference filled in, the config loads. // With its reference filled in, the config loads.
{levelReference, "blob_size_limit", "1MB", {levelReference, "blob_size_limit", "1MB",
"blob_size_limit must be at least"}, "blob_size_limit must be at least"},
+2 -4
View File
@@ -331,10 +331,8 @@ know about), which is what 'vaultik prune' does. The command prints the
'vaultik prune' invocation to run as a follow-up only when it removed the 'vaultik prune' invocation to run as a follow-up only when it removed the
snapshot's metadata from the destination store, and never under --json. snapshot's metadata from the destination store, and never under --json.
The snapshot may be named by its ID or by its remote key, which An ID that names no snapshot in the local index or on the destination
'snapshot list' prints for a remote-only snapshot. An unambiguous store is an error.
leading part of the key is enough. An identifier that names no snapshot
in the local index or on the destination store is an error.
Use --local-only to skip the remote half (e.g. when you want to forget a Use --local-only to skip the remote half (e.g. when you want to forget a
snapshot locally without touching the destination store); the snapshot snapshot locally without touching the destination store); the snapshot
+24 -11
View File
@@ -21,7 +21,6 @@ import (
"gopkg.in/yaml.v3" "gopkg.in/yaml.v3"
"sneak.berlin/go/vaultik/internal/chunker" "sneak.berlin/go/vaultik/internal/chunker"
"sneak.berlin/go/vaultik/internal/log" "sneak.berlin/go/vaultik/internal/log"
"sneak.berlin/go/vaultik/internal/storageurl"
) )
const appName = "vaultik" const appName = "vaultik"
@@ -66,6 +65,11 @@ var (
"emit (chunk_size times the FastCDC size spread)") "emit (chunk_size times the FastCDC size spread)")
errBadCompression = errors.New("compression_level must be between 1 and 19") errBadCompression = errors.New("compression_level must be between 1 and 19")
errBadS3PartSize = errors.New("s3.part_size must be between 5MiB and 5GiB") errBadS3PartSize = errors.New("s3.part_size must be between 5MiB and 5GiB")
errBadStorageScheme = errors.New(
"storage_url must start with s3://, file://, or rclone://")
errFileURLNotAbsolute = errors.New(
"a file:// storage_url needs an absolute path, " +
"as in file:///path/to/backup")
errIndexPathNotAbsolute = errors.New( errIndexPathNotAbsolute = errors.New(
"index_path and VAULTIK_INDEX_PATH need an absolute path, " + "index_path and VAULTIK_INDEX_PATH need an absolute path, " +
"as in ~/.local/share/vaultik/index.sqlite") "as in ~/.local/share/vaultik/index.sqlite")
@@ -553,20 +557,26 @@ func (c *Config) validateStorage() error {
return nil return nil
} }
// validateStorageURL checks storage_url with the same parser that opens // validateStorageURL validates URL-based storage configuration. File and
// the destination, so a value every command would refuse fails at load. // rclone URLs need no credentials; S3 URLs require the legacy s3.*
// File and rclone URLs need no credentials; S3 URLs require the legacy // credential fields. A file URL must name an absolute path: a relative one
// s3.* credential fields. // would resolve against the working directory, so the destination would
// move with it.
func (c *Config) validateStorageURL() error { func (c *Config) validateStorageURL() error {
parsed, err := storageurl.Parse(c.StorageURL) switch {
if err != nil { case strings.HasPrefix(c.StorageURL, "file://"):
return fmt.Errorf("invalid storage_url: %w", err) // storage.ParseStorageURL applies the same rule, but config
// cannot import storage, which imports config.
if !strings.HasPrefix(c.StorageURL, "file:///") {
return errFileURLNotAbsolute
} }
if parsed.Scheme != storageurl.SchemeS3 {
return nil return nil
} case strings.HasPrefix(c.StorageURL, "rclone://"):
// Rclone storage uses rclone's own config
return nil
case strings.HasPrefix(c.StorageURL, "s3://"):
// S3 storage needs credentials
if c.S3.AccessKeyID == "" { if c.S3.AccessKeyID == "" {
return fmt.Errorf("%w for s3:// URLs", ErrS3KeyIDRequired) return fmt.Errorf("%w for s3:// URLs", ErrS3KeyIDRequired)
} }
@@ -576,6 +586,9 @@ func (c *Config) validateStorageURL() error {
} }
return nil return nil
default:
return errBadStorageScheme
}
} }
// Module exports the config module for fx dependency injection. // Module exports the config module for fx dependency injection.
+2 -3
View File
@@ -10,7 +10,6 @@ import (
"sneak.berlin/go/vaultik/internal/chunker" "sneak.berlin/go/vaultik/internal/chunker"
"sneak.berlin/go/vaultik/internal/log" "sneak.berlin/go/vaultik/internal/log"
"sneak.berlin/go/vaultik/internal/storageurl"
) )
const ( const (
@@ -503,8 +502,8 @@ func TestLoadRejectsRelativeFileURL(t *testing.T) {
} }
_, err = Load(path) _, err = Load(path)
if !errors.Is(err, storageurl.ErrRelativeFilePath) { if !errors.Is(err, errFileURLNotAbsolute) {
t.Fatalf("Load() error = %v, want storageurl.ErrRelativeFilePath", err) t.Fatalf("Load() error = %v, want errFileURLNotAbsolute", err)
} }
if !strings.Contains(err.Error(), "absolute path") { if !strings.Contains(err.Error(), "absolute path") {
+1 -2
View File
@@ -9,7 +9,6 @@ import (
"strings" "strings"
"github.com/spf13/afero" "github.com/spf13/afero"
"sneak.berlin/go/vaultik/internal/storageurl"
) )
// FileStorer implements Storer using the local filesystem. // FileStorer implements Storer using the local filesystem.
@@ -289,7 +288,7 @@ func (f *FileStorer) DeletePartialUploads(ctx context.Context, prefix string) er
// Info returns human-readable storage location information. // Info returns human-readable storage location information.
func (f *FileStorer) Info() Info { func (f *FileStorer) Info() Info {
return Info{ return Info{
Type: storageurl.SchemeFile, Type: schemeFile,
Location: f.basePath, Location: f.basePath,
} }
} }
+5 -11
View File
@@ -2,20 +2,14 @@ package storage
import ( import (
"context" "context"
"errors"
"fmt" "fmt"
"strings" "strings"
"go.uber.org/fx" "go.uber.org/fx"
"sneak.berlin/go/vaultik/internal/config" "sneak.berlin/go/vaultik/internal/config"
"sneak.berlin/go/vaultik/internal/s3" "sneak.berlin/go/vaultik/internal/s3"
"sneak.berlin/go/vaultik/internal/storageurl"
) )
// ErrUnsupportedStorage is returned for a parsed storage URL whose scheme
// has no storage backend.
var ErrUnsupportedStorage = errors.New("unsupported storage scheme")
// defaultS3Region is used when neither the URL nor the config specify one. // defaultS3Region is used when neither the URL nor the config specify one.
const defaultS3Region = "us-east-1" const defaultS3Region = "us-east-1"
@@ -46,19 +40,19 @@ func NewStorer(cfg *config.Config) (Storer, error) {
//nolint:ireturn // factory intentionally returns the Storer interface //nolint:ireturn // factory intentionally returns the Storer interface
func storerFromURL(rawURL string, cfg *config.Config) (Storer, error) { func storerFromURL(rawURL string, cfg *config.Config) (Storer, error) {
parsed, err := storageurl.Parse(rawURL) parsed, err := ParseStorageURL(rawURL)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing storage URL: %w", err) return nil, fmt.Errorf("parsing storage URL: %w", err)
} }
switch parsed.Scheme { switch parsed.Scheme {
case storageurl.SchemeFile: case schemeFile:
return NewFileStorer(parsed.Prefix) return NewFileStorer(parsed.Prefix)
case storageurl.SchemeS3: case schemeS3:
return storerFromParsedS3URL(parsed, cfg) return storerFromParsedS3URL(parsed, cfg)
case storageurl.SchemeRclone: case schemeRclone:
return NewRcloneStorer( return NewRcloneStorer(
context.Background(), parsed.RcloneRemote, parsed.Prefix) context.Background(), parsed.RcloneRemote, parsed.Prefix)
@@ -71,7 +65,7 @@ func storerFromURL(rawURL string, cfg *config.Config) (Storer, error) {
// filling endpoint protocol and region defaults from the config. // filling endpoint protocol and region defaults from the config.
// //
//nolint:ireturn // factory intentionally returns the Storer interface //nolint:ireturn // factory intentionally returns the Storer interface
func storerFromParsedS3URL(parsed *storageurl.URL, cfg *config.Config) (Storer, error) { func storerFromParsedS3URL(parsed *URL, cfg *config.Config) (Storer, error) {
// Build endpoint URL // Build endpoint URL
endpoint := parsed.Endpoint endpoint := parsed.Endpoint
if endpoint == "" { if endpoint == "" {
+1 -2
View File
@@ -15,7 +15,6 @@ import (
"github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config"
"github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/fs/config/configfile"
"github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fs/operations"
"sneak.berlin/go/vaultik/internal/storageurl"
// Import all rclone backends // Import all rclone backends
_ "github.com/rclone/rclone/backend/all" _ "github.com/rclone/rclone/backend/all"
@@ -267,7 +266,7 @@ func (r *RcloneStorer) Info() Info {
} }
return Info{ return Info{
Type: storageurl.SchemeRclone, Type: schemeRclone,
Location: location, Location: location,
} }
} }
@@ -1,7 +1,4 @@
// Package storageurl parses the storage_url config value. The config package storage
// package uses it to refuse a bad value when the config loads; the storage
// package uses it to open the destination.
package storageurl
import ( import (
"errors" "errors"
@@ -13,9 +10,9 @@ import (
// Storage URL scheme names. // Storage URL scheme names.
const ( const (
SchemeFile = "file" schemeFile = "file"
SchemeS3 = "s3" schemeS3 = "s3"
SchemeRclone = "rclone" schemeRclone = "rclone"
) )
// Sentinel errors for storage URL parsing. // Sentinel errors for storage URL parsing.
@@ -28,6 +25,7 @@ var (
ErrMissingRemote = errors.New("rclone URL missing remote name") ErrMissingRemote = errors.New("rclone URL missing remote name")
ErrUnsupportedScheme = errors.New( ErrUnsupportedScheme = errors.New(
"unsupported URL scheme: must start with s3://, file://, or rclone://") "unsupported URL scheme: must start with s3://, file://, or rclone://")
ErrUnsupportedStorage = errors.New("unsupported storage scheme")
ErrURLCredentials = errors.New( ErrURLCredentials = errors.New(
"storage URL must not carry credentials; " + "storage URL must not carry credentials; " +
"set s3.access_key_id and s3.secret_access_key in the config instead") "set s3.access_key_id and s3.secret_access_key in the config instead")
@@ -51,12 +49,12 @@ type URL struct {
RcloneRemote string // rclone remote name (for rclone:// URLs) RcloneRemote string // rclone remote name (for rclone:// URLs)
} }
// Parse parses a storage URL string. // ParseStorageURL parses a storage URL string.
// Supported formats: // Supported formats:
// - s3://bucket/prefix?endpoint=host&region=us-east-1&ssl=true // - s3://bucket/prefix?endpoint=host&region=us-east-1&ssl=true
// - file:///absolute/path/to/backup // - file:///absolute/path/to/backup
// - rclone://remote/path/to/backups // - rclone://remote/path/to/backups
func Parse(rawURL string) (*URL, error) { func ParseStorageURL(rawURL string) (*URL, error) {
if rawURL == "" { if rawURL == "" {
return nil, ErrEmptyStorageURL return nil, ErrEmptyStorageURL
} }
@@ -94,7 +92,7 @@ func parseFileURL(rawPath string) (*URL, error) {
return nil, fmt.Errorf("invalid file URL path: %w", err) return nil, fmt.Errorf("invalid file URL path: %w", err)
} }
return &URL{Scheme: SchemeFile, Prefix: path}, nil return &URL{Scheme: schemeFile, Prefix: path}, nil
} }
// parseS3URL parses an s3://bucket/prefix URL. It rejects credentials in // parseS3URL parses an s3://bucket/prefix URL. It rejects credentials in
@@ -137,7 +135,7 @@ func parseS3URL(rawURL string) (*URL, error) {
} }
return &URL{ return &URL{
Scheme: SchemeS3, Scheme: schemeS3,
Bucket: bucket, Bucket: bucket,
Prefix: strings.TrimPrefix(u.Path, "/"), Prefix: strings.TrimPrefix(u.Path, "/"),
Endpoint: query.Get("endpoint"), Endpoint: query.Get("endpoint"),
@@ -191,7 +189,7 @@ func parseRcloneURL(rawURL string) (*URL, error) {
} }
return &URL{ return &URL{
Scheme: SchemeRclone, Scheme: schemeRclone,
Prefix: strings.TrimPrefix(u.Path, "/"), Prefix: strings.TrimPrefix(u.Path, "/"),
RcloneRemote: remote, RcloneRemote: remote,
}, nil }, nil
@@ -228,9 +226,9 @@ func wrapParseError(err error) error {
// String returns a human-readable representation of the storage URL. // String returns a human-readable representation of the storage URL.
func (u *URL) String() string { func (u *URL) String() string {
switch u.Scheme { switch u.Scheme {
case SchemeFile: case schemeFile:
return "file://" + u.Prefix return "file://" + u.Prefix
case SchemeS3: case schemeS3:
endpoint := u.Endpoint endpoint := u.Endpoint
if endpoint == "" { if endpoint == "" {
endpoint = "s3.amazonaws.com" endpoint = "s3.amazonaws.com"
@@ -241,7 +239,7 @@ func (u *URL) String() string {
} }
return fmt.Sprintf("s3://%s (endpoint: %s)", u.Bucket, endpoint) return fmt.Sprintf("s3://%s (endpoint: %s)", u.Bucket, endpoint)
case SchemeRclone: case schemeRclone:
if u.Prefix != "" { if u.Prefix != "" {
return fmt.Sprintf("rclone://%s/%s", u.RcloneRemote, u.Prefix) return fmt.Sprintf("rclone://%s/%s", u.RcloneRemote, u.Prefix)
} }
@@ -1,4 +1,4 @@
package storageurl_test package storage_test
import ( import (
"errors" "errors"
@@ -6,12 +6,12 @@ import (
"strings" "strings"
"testing" "testing"
"sneak.berlin/go/vaultik/internal/storageurl" "sneak.berlin/go/vaultik/internal/storage"
) )
// TestParseValid checks that each supported scheme parses into the // TestParseStorageURLValid checks that each supported scheme parses into
// expected fields, since those fields decide which backend is built. // the expected fields, since those fields decide which backend is built.
func TestParseValid(t *testing.T) { func TestParseStorageURLValid(t *testing.T) {
t.Parallel() t.Parallel()
const ( const (
@@ -22,27 +22,27 @@ func TestParseValid(t *testing.T) {
cases := []struct { cases := []struct {
name string name string
raw string raw string
want *storageurl.URL want *storage.URL
}{ }{
{ {
name: "file absolute path", name: "file absolute path",
raw: "file:///var/backups/vaultik", raw: "file:///var/backups/vaultik",
want: &storageurl.URL{Scheme: fileScheme, Prefix: "/var/backups/vaultik"}, want: &storage.URL{Scheme: fileScheme, Prefix: "/var/backups/vaultik"},
}, },
{ {
name: "file percent-escaped path is decoded", name: "file percent-escaped path is decoded",
raw: "file:///Volumes/my%20stick/backup", raw: "file:///Volumes/my%20stick/backup",
want: &storageurl.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"}, want: &storage.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"},
}, },
{ {
name: "file path with a literal space", name: "file path with a literal space",
raw: "file:///Volumes/my stick/backup", raw: "file:///Volumes/my stick/backup",
want: &storageurl.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"}, want: &storage.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"},
}, },
{ {
name: "s3 bucket and prefix, ssl defaults on", name: "s3 bucket and prefix, ssl defaults on",
raw: "s3://mybucket/backups/host", raw: "s3://mybucket/backups/host",
want: &storageurl.URL{ want: &storage.URL{
Scheme: "s3", Bucket: bucket, Scheme: "s3", Bucket: bucket,
Prefix: "backups/host", UseSSL: true, Prefix: "backups/host", UseSSL: true,
}, },
@@ -50,12 +50,12 @@ func TestParseValid(t *testing.T) {
{ {
name: "s3 bucket only", name: "s3 bucket only",
raw: "s3://mybucket", raw: "s3://mybucket",
want: &storageurl.URL{Scheme: "s3", Bucket: bucket, UseSSL: true}, want: &storage.URL{Scheme: "s3", Bucket: bucket, UseSSL: true},
}, },
{ {
name: "s3 with endpoint, region, ssl off", name: "s3 with endpoint, region, ssl off",
raw: "s3://mybucket?endpoint=minio.example.com&region=us-west-2&ssl=false", raw: "s3://mybucket?endpoint=minio.example.com&region=us-west-2&ssl=false",
want: &storageurl.URL{ want: &storage.URL{
Scheme: "s3", Bucket: bucket, Scheme: "s3", Bucket: bucket,
Endpoint: "minio.example.com", Region: "us-west-2", UseSSL: false, Endpoint: "minio.example.com", Region: "us-west-2", UseSSL: false,
}, },
@@ -63,14 +63,14 @@ func TestParseValid(t *testing.T) {
{ {
name: "rclone remote and path", name: "rclone remote and path",
raw: "rclone://gdrive/backups/host", raw: "rclone://gdrive/backups/host",
want: &storageurl.URL{ want: &storage.URL{
Scheme: "rclone", RcloneRemote: "gdrive", Prefix: "backups/host", Scheme: "rclone", RcloneRemote: "gdrive", Prefix: "backups/host",
}, },
}, },
{ {
name: "rclone remote only", name: "rclone remote only",
raw: "rclone://gdrive", raw: "rclone://gdrive",
want: &storageurl.URL{Scheme: "rclone", RcloneRemote: "gdrive"}, want: &storage.URL{Scheme: "rclone", RcloneRemote: "gdrive"},
}, },
} }
@@ -78,22 +78,22 @@ func TestParseValid(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
t.Parallel() t.Parallel()
got, err := storageurl.Parse(tc.raw) got, err := storage.ParseStorageURL(tc.raw)
if err != nil { if err != nil {
t.Fatalf("Parse(%q) returned error: %v", tc.raw, err) t.Fatalf("ParseStorageURL(%q) returned error: %v", tc.raw, err)
} }
if !reflect.DeepEqual(got, tc.want) { if !reflect.DeepEqual(got, tc.want) {
t.Errorf("Parse(%q) = %+v, want %+v", tc.raw, got, tc.want) t.Errorf("ParseStorageURL(%q) = %+v, want %+v", tc.raw, got, tc.want)
} }
}) })
} }
} }
// TestParseErrors checks that empty, missing, and unknown-scheme inputs // TestParseStorageURLErrors checks that empty, missing, and unknown-scheme
// fail with the documented sentinel errors instead of parsing to a wrong // inputs fail with the documented sentinel errors instead of parsing to a
// destination. // wrong destination.
func TestParseErrors(t *testing.T) { func TestParseStorageURLErrors(t *testing.T) {
t.Parallel() t.Parallel()
cases := []struct { cases := []struct {
@@ -101,33 +101,34 @@ func TestParseErrors(t *testing.T) {
raw string raw string
wantErr error wantErr error
}{ }{
{"empty url", "", storageurl.ErrEmptyStorageURL}, {"empty url", "", storage.ErrEmptyStorageURL},
{"file empty path", "file://", storageurl.ErrEmptyFilePath}, {"file empty path", "file://", storage.ErrEmptyFilePath},
{"file relative path", "file://dest", storageurl.ErrRelativeFilePath}, {"file relative path", "file://dest", storage.ErrRelativeFilePath},
{"s3 missing bucket", "s3://", storageurl.ErrMissingBucket}, {"s3 missing bucket", "s3://", storage.ErrMissingBucket},
{"s3 missing bucket with path", "s3:///justprefix", storageurl.ErrMissingBucket}, {"s3 missing bucket with path", "s3:///justprefix", storage.ErrMissingBucket},
{"rclone missing remote", "rclone://", storageurl.ErrMissingRemote}, {"rclone missing remote", "rclone://", storage.ErrMissingRemote},
{"unknown scheme", "gs://bucket/x", storageurl.ErrUnsupportedScheme}, {"unknown scheme", "gs://bucket/x", storage.ErrUnsupportedScheme},
{"no scheme", "/local/path", storageurl.ErrUnsupportedScheme}, {"no scheme", "/local/path", storage.ErrUnsupportedScheme},
} }
for _, tc := range cases { for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
t.Parallel() t.Parallel()
_, err := storageurl.Parse(tc.raw) _, err := storage.ParseStorageURL(tc.raw)
if !errors.Is(err, tc.wantErr) { if !errors.Is(err, tc.wantErr) {
t.Errorf("Parse(%q) error = %v, want %v", t.Errorf("ParseStorageURL(%q) error = %v, want %v",
tc.raw, err, tc.wantErr) tc.raw, err, tc.wantErr)
} }
}) })
} }
} }
// TestParseRejectsCredentials checks that a URL carrying credentials in // TestParseStorageURLRejectsCredentials checks that a URL carrying
// its userinfo or in an unknown query parameter is rejected, and that the // credentials in its userinfo or in an unknown query parameter is
// error never echoes the secret-bearing URL back into logs or output. // rejected, and that the error never echoes the secret-bearing URL back
func TestParseRejectsCredentials(t *testing.T) { // into logs or output.
func TestParseStorageURLRejectsCredentials(t *testing.T) {
t.Parallel() t.Parallel()
// Split so the literals never form a "user:pass@" URL pattern that // Split so the literals never form a "user:pass@" URL pattern that
@@ -146,44 +147,44 @@ func TestParseRejectsCredentials(t *testing.T) {
{ {
name: "s3 userinfo", name: "s3 userinfo",
raw: "s3://" + key + ":" + secret + "@mybucket/prefix", raw: "s3://" + key + ":" + secret + "@mybucket/prefix",
wantErr: storageurl.ErrURLCredentials, wantErr: storage.ErrURLCredentials,
secrets: []string{key, secret, "mybucket"}, secrets: []string{key, secret, "mybucket"},
}, },
{ {
name: "s3 userinfo in endpoint", name: "s3 userinfo in endpoint",
raw: "s3://mybucket?endpoint=https://" + raw: "s3://mybucket?endpoint=https://" +
key + ":" + secret + "@minio.example.com", key + ":" + secret + "@minio.example.com",
wantErr: storageurl.ErrURLCredentials, wantErr: storage.ErrURLCredentials,
secrets: []string{key, secret}, secrets: []string{key, secret},
}, },
{ {
name: "s3 userinfo in endpoint without scheme", name: "s3 userinfo in endpoint without scheme",
raw: "s3://mybucket?endpoint=" + key + ":" + secret + "@minio.example.com", raw: "s3://mybucket?endpoint=" + key + ":" + secret + "@minio.example.com",
wantErr: storageurl.ErrURLCredentials, wantErr: storage.ErrURLCredentials,
secrets: []string{key, secret}, secrets: []string{key, secret},
}, },
{ {
name: "s3 unknown query param", name: "s3 unknown query param",
raw: "s3://mybucket?access_key=" + key + "&secret=" + secret, raw: "s3://mybucket?access_key=" + key + "&secret=" + secret,
wantErr: storageurl.ErrURLUnknownParam, wantErr: storage.ErrURLUnknownParam,
secrets: []string{key, secret}, secrets: []string{key, secret},
}, },
{ {
name: "s3 misspelt endpoint", name: "s3 misspelt endpoint",
raw: "s3://mybucket?endpiont=minio.example.com", raw: "s3://mybucket?endpiont=minio.example.com",
wantErr: storageurl.ErrURLUnknownParam, wantErr: storage.ErrURLUnknownParam,
secrets: nil, secrets: nil,
}, },
{ {
name: "rclone userinfo", name: "rclone userinfo",
raw: "rclone://user:" + secret + "@gdrive/backups", raw: "rclone://user:" + secret + "@gdrive/backups",
wantErr: storageurl.ErrURLCredentials, wantErr: storage.ErrURLCredentials,
secrets: []string{secret}, secrets: []string{secret},
}, },
{ {
name: "rclone query param", name: "rclone query param",
raw: "rclone://gdrive/backups?token=" + secret, raw: "rclone://gdrive/backups?token=" + secret,
wantErr: storageurl.ErrURLUnknownParam, wantErr: storage.ErrURLUnknownParam,
secrets: []string{secret}, secrets: []string{secret},
}, },
} }
@@ -192,9 +193,9 @@ func TestParseRejectsCredentials(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
t.Parallel() t.Parallel()
_, err := storageurl.Parse(tc.raw) _, err := storage.ParseStorageURL(tc.raw)
if !errors.Is(err, tc.wantErr) { if !errors.Is(err, tc.wantErr) {
t.Fatalf("Parse(%q) error = %v, want %v", t.Fatalf("ParseStorageURL(%q) error = %v, want %v",
tc.raw, err, tc.wantErr) tc.raw, err, tc.wantErr)
} }
@@ -215,11 +216,11 @@ func TestParseRejectsCredentials(t *testing.T) {
} }
} }
// TestParseRejectsRcloneRemoteParams checks that an rclone remote name // TestParseStorageURLRejectsRcloneRemoteParams checks that an rclone
// carrying parameters (rclone's "remote,param=value" form, which can hold // remote name carrying parameters (rclone's "remote,param=value" form,
// a credential) is rejected without echoing the value, including the URLs // which can hold a credential) is rejected without echoing the value,
// that url.Parse itself refuses. // including the URLs that url.Parse itself refuses.
func TestParseRejectsRcloneRemoteParams(t *testing.T) { func TestParseStorageURLRejectsRcloneRemoteParams(t *testing.T) {
t.Parallel() t.Parallel()
cases := []struct { cases := []struct {
@@ -248,10 +249,10 @@ func TestParseRejectsRcloneRemoteParams(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
t.Parallel() t.Parallel()
_, err := storageurl.Parse(tc.raw) _, err := storage.ParseStorageURL(tc.raw)
if !errors.Is(err, storageurl.ErrRcloneRemoteParams) { if !errors.Is(err, storage.ErrRcloneRemoteParams) {
t.Fatalf("Parse(%q) error = %v, want %v", t.Fatalf("ParseStorageURL(%q) error = %v, want %v",
tc.raw, err, storageurl.ErrRcloneRemoteParams) tc.raw, err, storage.ErrRcloneRemoteParams)
} }
for _, secret := range tc.secrets { for _, secret := range tc.secrets {
@@ -263,10 +264,10 @@ func TestParseRejectsRcloneRemoteParams(t *testing.T) {
} }
} }
// TestParseRejectsUndecodableQuery checks that an s3 or rclone URL whose // TestParseStorageURLRejectsUndecodableQuery checks that an s3 or rclone
// query cannot be decoded is rejected, not read with that part of the // URL whose query cannot be decoded is rejected, not read with that part
// query left out, and that the error does not echo it. // of the query left out, and that the error does not echo it.
func TestParseRejectsUndecodableQuery(t *testing.T) { func TestParseStorageURLRejectsUndecodableQuery(t *testing.T) {
t.Parallel() t.Parallel()
const ( const (
@@ -302,14 +303,14 @@ func TestParseRejectsUndecodableQuery(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
t.Parallel() t.Parallel()
_, err := storageurl.Parse(tc.raw) _, err := storage.ParseStorageURL(tc.raw)
if err == nil { if err == nil {
t.Fatalf("Parse(%q) returned no error", tc.raw) t.Fatalf("ParseStorageURL(%q) returned no error", tc.raw)
} }
if !errors.Is(err, storageurl.ErrURLBadQuery) { if !errors.Is(err, storage.ErrURLBadQuery) {
t.Errorf("Parse(%q) error = %v, want %v", t.Errorf("ParseStorageURL(%q) error = %v, want %v",
tc.raw, err, storageurl.ErrURLBadQuery) tc.raw, err, storage.ErrURLBadQuery)
} }
for _, s := range []string{key, secret, "minio.example.com"} { for _, s := range []string{key, secret, "minio.example.com"} {
@@ -321,17 +322,17 @@ func TestParseRejectsUndecodableQuery(t *testing.T) {
} }
} }
// TestParseFailureHidesURL checks that when url.Parse itself fails, the // TestParseStorageURLParseFailureHidesURL checks that when url.Parse
// wrapped error carries only the inner cause, not the *url.Error whose // itself fails, the wrapped error carries only the inner cause, not the
// text embeds the raw (possibly credential-bearing) URL. // *url.Error whose text embeds the raw (possibly credential-bearing) URL.
func TestParseFailureHidesURL(t *testing.T) { func TestParseStorageURLParseFailureHidesURL(t *testing.T) {
t.Parallel() t.Parallel()
const raw = "s3://mybucket/%zz" const raw = "s3://mybucket/%zz"
_, err := storageurl.Parse(raw) _, err := storage.ParseStorageURL(raw)
if err == nil { if err == nil {
t.Fatalf("Parse(%q) returned no error", raw) t.Fatalf("ParseStorageURL(%q) returned no error", raw)
} }
if strings.Contains(err.Error(), "mybucket") { if strings.Contains(err.Error(), "mybucket") {
-62
View File
@@ -472,68 +472,6 @@ func TestRemoveSnapshot_NotInLocalIndex(t *testing.T) {
assert.Contains(t, out, "Removed snapshot metadata from remote storage") assert.Contains(t, out, "Removed snapshot metadata from remote storage")
} }
// TestRemoveSnapshot_ByRemoteKey checks that a snapshot only the
// destination store holds can be removed by the remote key that
// `snapshot list` shows for it, or by a leading part of that key.
func TestRemoveSnapshot_ByRemoteKey(t *testing.T) {
log.Initialize(log.Config{})
t.Parallel()
remoteKey := snapshot.RemoteSnapshotKey("snapshot-001")
for name, identifier := range map[string]string{
"full key": remoteKey,
"leading part": remoteKey[:8],
} {
t.Run(name, func(t *testing.T) {
t.Parallel()
store := newTestStorer()
addManifest(t, store, "snapshot-001", nil)
tv := vaultik.NewForTesting(store)
tv.Repositories = newLocalIndex(t)
result, err := tv.RemoveSnapshot(identifier,
&vaultik.RemoveOptions{Force: true})
require.NoError(t, err)
assert.True(t, result.RemoteRemoved)
assert.False(t, store.hasKey(remoteKeyPath("snapshot-001")))
})
}
}
// TestRemoveSnapshot_ByRemoteKeyInLocalIndex checks that a snapshot the
// local index holds, named by its remote key, is removed from the local
// index as well as from the destination store.
func TestRemoveSnapshot_ByRemoteKeyInLocalIndex(t *testing.T) {
log.Initialize(log.Config{})
t.Parallel()
store := newTestStorer()
addManifest(t, store, "snapshot-001", nil)
// A backup wrote to this destination, so it carries the marker.
require.NoError(t, store.Put(context.Background(), markerFile,
bytes.NewReader(nil)))
tv := vaultik.NewForTesting(store)
tv.Repositories = newLocalIndex(t, "snapshot-001")
result, err := tv.RemoveSnapshot(snapshot.RemoteSnapshotKey("snapshot-001"),
&vaultik.RemoveOptions{Force: true})
require.NoError(t, err)
assert.True(t, result.RemoteRemoved)
assert.False(t, store.hasKey(remoteKeyPath("snapshot-001")))
snap, err := tv.Repositories.Snapshots.GetByID(context.Background(),
"snapshot-001")
require.NoError(t, err)
assert.Nil(t, snap)
}
// TestRemoveSnapshot_NotInLocalIndexDeleteFails checks that removing a // TestRemoveSnapshot_NotInLocalIndexDeleteFails checks that removing a
// snapshot only the destination store holds fails when its metadata // snapshot only the destination store holds fails when its metadata
// cannot be deleted there, under --force and under --json: nothing was // cannot be deleted there, under --force and under --json: nothing was
+3 -4
View File
@@ -31,10 +31,9 @@ var (
errPathsNotInSnapshot = errors.New("requested path(s) not in the snapshot") errPathsNotInSnapshot = errors.New("requested path(s) not in the snapshot")
errFilesFailedVerify = errors.New("files failed verification") errFilesFailedVerify = errors.New("files failed verification")
errDecryptionKeyRequired = errors.New( errDecryptionKeyRequired = errors.New(
"decryption key required\n\n" + "age secret key is missing; set it in the " +
"Set the VAULTIK_AGE_SECRET_KEY environment variable to your " + "VAULTIK_AGE_SECRET_KEY environment variable or the " +
"age private key file:\n" + "age_secret_key config file field")
" export VAULTIK_AGE_SECRET_KEY=\"$(cat vaultik_backup_private_key.txt)\"")
// errInvalidAgeSecretKey is returned when the configured key does not // errInvalidAgeSecretKey is returned when the configured key does not
// parse as any age identity. It names the source but never the value, // parse as any age identity. It names the source but never the value,
// which is secret, so the message is safe to print and log. // which is secret, so the message is safe to print and log.
+20
View File
@@ -106,3 +106,23 @@ func TestRestoreIdentitiesMissingKey(t *testing.T) {
_, err := v.restoreIdentities() _, err := v.restoreIdentities()
require.ErrorIs(t, err, errDecryptionKeyRequired) require.ErrorIs(t, err, errDecryptionKeyRequired)
} }
// TestMissingKeyErrorsNameBothSources asserts restore and deep verify
// return the same missing-key error, whose text names both places the key
// can be set: the VAULTIK_AGE_SECRET_KEY environment variable first since
// it is preferred, then the age_secret_key config file field.
func TestMissingKeyErrorsNameBothSources(t *testing.T) {
t.Parallel()
const want = "age secret key is missing; set it in " +
"the VAULTIK_AGE_SECRET_KEY environment variable or the " +
"age_secret_key config file field"
v := &Vaultik{Config: &config.Config{}}
_, err := v.restoreIdentities()
require.EqualError(t, err, want)
err = v.RunDeepVerify("any-snapshot", &VerifyOptions{})
require.EqualError(t, err, want)
}
+7 -42
View File
@@ -1467,8 +1467,7 @@ func (v *Vaultik) RemoveSnapshot(
return result, err return result, err
} }
snapshotID, remoteKey, inLocalIndex, err := v.findSnapshotToRemove( inLocalIndex, err := v.checkSnapshotExists(snapshotID, opts.LocalOnly)
snapshotID, opts.LocalOnly)
if err != nil { if err != nil {
return result, err return result, err
} }
@@ -1499,7 +1498,7 @@ func (v *Vaultik) RemoveSnapshot(
} }
result.RemoteRemoved, err = v.removeSnapshotRemote( result.RemoteRemoved, err = v.removeSnapshotRemote(
snapshotID, remoteKey, inLocalIndex, markerErr, opts) snapshotID, inLocalIndex, markerErr, opts)
if err != nil { if err != nil {
return result, err return result, err
} }
@@ -1531,41 +1530,6 @@ func (v *Vaultik) RemoveSnapshot(
return result, nil return result, nil
} }
// findSnapshotToRemove returns the ID of the snapshot that identifier
// names, its remote key, and whether the local index holds it. A remote
// key, or the leading part of one, is resolved on the destination store;
// when the local index holds the snapshot with that key, its ID is
// returned, so it is removed from both.
func (v *Vaultik) findSnapshotToRemove(
identifier string, localOnly bool,
) (string, string, bool, error) {
if !isRemoteKeyOrPrefix(identifier) || localOnly {
inLocalIndex, err := v.checkSnapshotExists(identifier, localOnly)
return identifier, snapshot.RemoteSnapshotKey(identifier),
inLocalIndex, err
}
remoteKey, err := v.resolveSnapshotRemoteKey(identifier)
if err != nil {
return "", "", false, err
}
localIDs, err := v.localSnapshotIDs()
if err != nil {
return "", "", false, fmt.Errorf(
"looking up snapshot in local index: %w", err)
}
for _, id := range localIDs {
if snapshot.RemoteSnapshotKey(id) == remoteKey {
return id, remoteKey, true, nil
}
}
return identifier, remoteKey, false, nil
}
// checkSnapshotExists returns errSnapshotNotFound when the local index // checkSnapshotExists returns errSnapshotNotFound when the local index
// has no row for snapshotID and, unless localOnly is set, the // has no row for snapshotID and, unless localOnly is set, the
// destination store has no metadata for it either. inLocalIndex reports // destination store has no metadata for it either. inLocalIndex reports
@@ -1674,8 +1638,8 @@ func (v *Vaultik) confirmRemoveSnapshot(snapshotID string, opts *RemoveOptions)
return true return true
} }
// removeSnapshotRemote strips the snapshot's metadata, under remoteKey, // removeSnapshotRemote strips the snapshot's metadata from the
// from the destination store. It returns true only when the delete finished // destination store. It returns true only when the delete finished
// without an error and removed at least one object; under LocalOnly it // without an error and removed at least one object; under LocalOnly it
// does nothing. markerErr is the result of checkDestinationMarker; when // does nothing. markerErr is the result of checkDestinationMarker; when
// it is set, nothing is deleted and it is the failure. When the snapshot // it is set, nothing is deleted and it is the failure. When the snapshot
@@ -1687,7 +1651,7 @@ func (v *Vaultik) confirmRemoveSnapshot(snapshotID string, opts *RemoveOptions)
// (`vaultik prune` never removes snapshot metadata that has its // (`vaultik prune` never removes snapshot metadata that has its
// manifest). // manifest).
func (v *Vaultik) removeSnapshotRemote( func (v *Vaultik) removeSnapshotRemote(
snapshotID, remoteKey string, inLocalIndex bool, markerErr error, snapshotID string, inLocalIndex bool, markerErr error,
opts *RemoveOptions, opts *RemoveOptions,
) (bool, error) { ) (bool, error) {
if opts.LocalOnly { if opts.LocalOnly {
@@ -1701,7 +1665,8 @@ func (v *Vaultik) removeSnapshotRemote(
err := markerErr err := markerErr
if err == nil { if err == nil {
deleted, err = v.deleteRemoteSnapshotByKey(remoteKey) deleted, err = v.deleteRemoteSnapshotByKey(
snapshot.RemoteSnapshotKey(snapshotID))
} }
if err != nil && !inLocalIndex { if err != nil && !inLocalIndex {
-5
View File
@@ -163,11 +163,6 @@ func (v *Vaultik) StartOperation(fn func()) func(context.Context) bool {
} }
} }
// CanDecrypt returns true if this Vaultik instance has decryption capabilities
func (v *Vaultik) CanDecrypt() bool {
return v.Config.AgeSecretKey != ""
}
// GetFilesystem returns the filesystem instance used by Vaultik // GetFilesystem returns the filesystem instance used by Vaultik
// //
//nolint:ireturn // afero.Fs is the filesystem abstraction by design //nolint:ireturn // afero.Fs is the filesystem abstraction by design
+2 -8
View File
@@ -23,8 +23,6 @@ import (
// Sentinel errors for snapshot verification failures. // Sentinel errors for snapshot verification failures.
var ( var (
errVerificationFailed = errors.New("verification failed") errVerificationFailed = errors.New("verification failed")
errSecretKeyRequired = errors.New(
"VAULTIK_AGE_SECRET_KEY not set; required for deep verification")
errChunksOutOfOrder = errors.New("chunks out of order") errChunksOutOfOrder = errors.New("chunks out of order")
errChunkHashMismatch = errors.New("chunk hash mismatch") errChunkHashMismatch = errors.New("chunk hash mismatch")
errNegativeChunkLength = errors.New("chunk length is negative") errNegativeChunkLength = errors.New("chunk length is negative")
@@ -106,13 +104,9 @@ func (v *Vaultik) RunDeepVerify(snapshotID string, opts *VerifyOptions) error {
Mode: "deep", Mode: "deep",
} }
if !v.CanDecrypt() {
return v.deepVerifyFailure(result, opts,
errSecretKeyRequired.Error(), errSecretKeyRequired)
}
// Parse the age secret key once, the same way restore does, and reuse // Parse the age secret key once, the same way restore does, and reuse
// the identities for the database and every blob. // the identities for the database and every blob. A missing key fails
// here, before anything is downloaded.
identities, err := v.restoreIdentities() identities, err := v.restoreIdentities()
if err != nil { if err != nil {
return v.deepVerifyFailure(result, opts, err.Error(), err) return v.deepVerifyFailure(result, opts, err.Error(), err)