e2edecrypt

type Cleanup struct {
	Versions bool `json:"versions"`
	Trash    bool `json:"trash"`
}

type ConvertFailure struct {
	Path string
	Err  error
}

type ConvertIO interface {
	// List is the raw listing of a folder.
	List(dir string) ([]ConvertRow, error)
	// Head is the first bytes of a file (at least 9 when it has them).
	Head(path string) ([]byte, error)
	// Convert encrypts the file `row` (in `dir`) under the folder key and
	// writes it over itself as a conversion write, on condition that it is
	// still the file listed (expect). Errors when the server refuses (a
	// changed file: 412).
	Convert(dir string, row ConvertRow, expect string) error
	// Stopped is asked between files.
	Stopped() bool
}

type ConvertProgress struct {
	// Total is the files found (everything but the key file and sidecars).
	Total int
	// Done is the files converted by this run; Large of them as STREAM.
	Done, Large int
	// Skipped is the files already encrypted (converted earlier, or written
	// encrypted).
	Skipped int
	// Failed is the files that could not be read or written; Failures says
	// which and why.
	Failed   int
	Failures []ConvertFailure
	// OnFile, when set, is told every file as its turn comes.
	OnFile func(path string, size int64)
}

type ConvertRow struct {
	// Path is the entry's full path on the server (adapter://rel).
	Path string
	// Name is its stored name.
	Name string
	Dir  bool
	// Size in bytes and Modified in Unix milliseconds, as listed; -1 when the
	// listing did not say. Together they are the write's precondition.
	Size     int64
	Modified int64
}

type CorruptError struct {
	Path string // plaintext path where known, with the stored name
	Err  error
}

type CreateOptions struct {
	// Iterations of PBKDF2. Never fewer than MinIterations; 0 means that.
	Iterations int
	// EscrowPublicKey is the installation's escrow key (base64 SPKI DER, as
	// /api/capabilities publishes it), or "" for no escrow slot.
	EscrowPublicKey string
	// EncryptNames makes a level-2 folder (v3, feature "names").
	EncryptNames bool
	// NamesPending marks the names slot pending: an existing folder whose
	// entries still carry their plaintext names (enableNames does the same).
	NamesPending bool
	// Rand is where every random byte comes from; nil is crypto/rand.
	Rand io.Reader
}

type Created struct {
	// Marker is the key file, ready to write as `.filex-e2e.json`.
	Marker []byte
	// Keys are the folder key (and the name key, at level 2).
	Keys *Keys
	// RecoveryKey is shown ONCE. filex never stores it.
	RecoveryKey string
}

type DirVaultSource struct {
	FS       fs.FS
	PackLog2 int
	// contains filtered or unexported fields
}

type EncryptTreeJob struct {
	// contains filtered or unexported fields
}

type EncryptTreeOptions struct {
	// Out is the output folder. Empty: "<input>-encrypted" next to the input.
	Out string
	// Names encrypts file and folder names too (level 2).
	Names bool
	// EscrowPublicKey is an installation's escrow key (base64 SPKI) to seal
	// the folder key to, or "" for none.
	EscrowPublicKey string
	// Iterations and Rand are for tests; writers use MinIterations and
	// crypto/rand.
	Iterations int
	Rand       io.Reader
}

type EncryptTreeResult struct {
	Out   string
	Files int
	Dirs  int
	// Kept is the files a resumed run found already written.
	Kept int
	// Large is the files written as STREAM (over 200 MB).
	Large    int
	Warnings []string
}

type EncryptedName struct {
	Stored         string // the entry's name on the server
	Encoded        string // the encoded ciphertext S (without a folder's ".D")
	SidecarName    string // set only for a long name
	SidecarContent string
}

type FxeHeader struct {
	// contains filtered or unexported fields
}

type FxeKeys struct {
	DEK  []byte
	Name string
}

type Job struct {
	Marker *Marker
	// contains filtered or unexported fields
}

type Keys struct {
	FMK      []byte
	Names    *NameKey
	Previous []byte
}

type Marker struct {
	V      int
	Salt   []byte
	Iter   int
	Verify string
	Fmk    string // "" (v1), "kek" or "wrapped"
	FmkPw  string
	Rk     *RecoverySlot
	Req    []string
	Names  *NamesSlot
	// Rekey is the previous FMK sealed under the current one, while a re-key
	// (a password change that replaced the folder key) is re-wrapping the
	// files' keys. Feature "rekey"; nil otherwise.
	Rekey *RekeySlot
	// ConvPending: an existing folder is being encrypted in place (feature
	// "conv"); files it has not reached yet are still plaintext.
	ConvPending bool
	// Vault is the `vault` block of a vault's key file (level 3, feature
	// "vault"; docs/E2E-VAULT-FORMAT.md); nil for levels 1 and 2.
	Vault *e2e.VaultInfo
}

type NameKey struct {
	Long   int    // shortening threshold the folder was created with
	RootID []byte // the encrypted root's own folder id
	// contains filtered or unexported fields
}

type NameKind int

type NamePassIO interface {
	// List is the raw listing of a folder (stored names).
	List(dir string) ([]ConvertRow, error)
	// ReadSidecar is a sibling sidecar's content; ok is false when there is
	// none.
	ReadSidecar(dir, name string) ([]byte, bool)
	WriteSidecar(dir, name, content string) error
	// Rename gives row (in dir) the stored name `to`.
	Rename(dir string, row ConvertRow, to string) error
	// Stopped is asked between entries.
	Stopped() bool
}

type NamePassProgress struct {
	// Seen is the entries found needing a name; Renamed of them were given
	// one, Repaired of those had been moved without being re-sealed.
	Seen, Renamed, Repaired int
	// Failed is the entries that could not be renamed (no permission, a name
	// a disk cannot hold, a name that cannot be read at all).
	Failed   int
	Failures []ConvertFailure
}

type NameState int

type NamesSlot struct {
	Alg  string `json:"alg"`
	Enc  string `json:"enc"`
	Long int    `json:"long"`
	Key  string `json:"key"`
	// RootID is the encrypted root's own folder id (16 bytes, base64url):
	// the associated data of every name directly inside the root.
	RootID  string `json:"root_id"`
	Pending bool   `json:"pending,omitempty"`
}

type OpenOptions struct {
	// Out is the output directory. Empty: "<input>-decrypted" next to it
	// (".zip" dropped).
	Out string
	// MarkerPath is an explicit .filex-e2e.json, for an input that does not
	// carry its own (a subfolder, a single file, a zip made below the root).
	MarkerPath string
	// GOOS overrides runtime.GOOS for the output-name rules (tests).
	GOOS string
	// Generation, for a vault, decrypts that generation (one still kept)
	// instead of the latest. 0: the latest that verifies.
	Generation uint64
}

type RecoverySlot struct {
	Salt string `json:"salt"`
	Blob string `json:"blob"`
}

type RekeySlot struct {
	From    string `json:"from"`
	Pending bool   `json:"pending"`
}

type Result struct {
	Out      string
	Files    int
	Dirs     int
	Warnings []string
}

type StoredName struct {
	Kind    NameKind
	Hash    string // long, longdir, sidecar: the 43-character hash they share
	Encoded string // file, dir: the encoded ciphertext S
	DirID   []byte // dir, longdir: the folder's id
}

type UnsupportedError struct{ Features []string }

type VaultCommit struct {
	// Index is the new generation as readers will decode it.
	Index *VaultIndex
	// File is the index file to store as v/idx/<generation>.fxi.
	File []byte
	// Written are the packs this writer stored (orphans if the index is
	// never stored).
	Written [][16]byte
}

type VaultContent struct {
	ID        [16]byte
	ChunkLog2 int
	Extents   []VaultExtent
}

type VaultDecryptOptions struct {
	// Out is the directory to write; it must not exist.
	Out string
	// Generation, when not 0, decrypts that kept generation instead of the
	// latest.
	Generation uint64
	// GOOS overrides runtime.GOOS for the output-name rules (tests).
	GOOS string
	// Sleep is VaultLoadOptions.Sleep.
	Sleep func(ctx context.Context, d time.Duration) error
}

type VaultExtent struct {
	Pack   [16]byte
	Offset int64
	Length int64
}

type VaultGCPlan struct {
	// Indexes are the expired generations whose index files go.
	Indexes []uint64
	// Packs go: graveyard packs whose last user expired, and orphans.
	Packs [][16]byte
	// Forget are the graveyard packs this pass deletes or finds gone: the
	// next commit drops them from the graveyard (VaultWriter.ForgetGrave).
	Forget [][16]byte
}

type VaultGrave struct {
	Pack [16]byte
	Died uint64
}

type VaultIndex struct {
	Generation uint64
	Tree       *VaultTree
	// Packs is the pack table: every pack the tree uses, ascending.
	Packs [][16]byte
	// Grave is the graveyard, ascending by pack id.
	Grave []VaultGrave
	// ReadOnly, when not "", is why a writer must not write this vault
	// (extension bytes a newer filex wrote).
	ReadOnly string
	// BodyLen is the length of the body; Size the index file's (0 for an
	// index that was not read from a file).
	BodyLen int
	Size    int64
	// ModTime is when the index file was written, where the source says.
	ModTime time.Time
}

type VaultKeys struct {
	// contains filtered or unexported fields
}

type VaultLatestSource interface {
	LatestGeneration(ctx context.Context) (uint64, error)
}

type VaultLoadOptions struct {
	// Generation, when not 0, loads that generation instead of the latest
	// (`--generation N`): an older one that is still kept.
	Generation uint64
	// Seen is the highest generation this session has seen of the vault; a
	// lower latest is a rollback (read-only). 0: none.
	Seen uint64
	// Sleep waits before a damaged latest is fetched again; nil sleeps for
	// real (and stops with ctx).
	Sleep func(ctx context.Context, d time.Duration) error
}

type VaultNode struct {
	Name  string
	Dir   bool
	MTime int64 // milliseconds since 1970
	Size  int64 // a file's plaintext bytes
	// Content is where a file's bytes are; nil for a folder, a 0-byte file,
	// or a file whose bytes are not stored yet (Local).
	Content *VaultContent
	// Local is the caller's own (`filex vault mount` keeps a pending file's
	// spool here). It is never encoded.
	Local any
	// contains filtered or unexported fields
}

type VaultObject struct {
	Generation uint64   // an index file
	Pack       [16]byte // a pack
	Size       int64
	ModTime    time.Time // zero: the source does not say
}

type VaultPackReader func(ctx context.Context, id [16]byte, off, n int64) ([]byte, error)

type VaultPackSink func(ctx context.Context, id [16]byte, pack []byte) error

type VaultReader struct {
	// contains filtered or unexported fields
}

type VaultSource interface {
	// ListIndexes lists the index files (well-formed names only).
	ListIndexes(ctx context.Context) ([]VaultObject, error)
	// ListPacks lists the packs (well-formed names only).
	ListPacks(ctx context.Context) ([]VaultObject, error)
	// ReadIndex reads one index file whole. More than e2e.VaultIndexReadMax
	// bytes is refused before they are read (a damage error).
	ReadIndex(ctx context.Context, generation uint64) ([]byte, error)
	// ReadPack reads n bytes of a pack from off.
	ReadPack(ctx context.Context, id [16]byte, off, n int64) ([]byte, error)
}

type VaultState struct {
	// Index is the generation shown: the latest that verifies, or the one
	// asked for. An empty vault at generation 0 has an empty one.
	Index *VaultIndex
	// Latest is the newest generation present (Index.Generation unless it
	// is damaged or an older one was asked for).
	Latest uint64
	// DamagedLatest: the newest generation does not verify; Index is an
	// older one, read-only, until its owner continues from it.
	DamagedLatest bool
	// RolledBack: the latest is older than one this session saw.
	RolledBack bool
}

type VaultTree struct {
	// contains filtered or unexported fields
}

type VaultWriter struct {
	// contains filtered or unexported fields
}

type VaultWriterConfig struct {
	Keys     *VaultKeys
	PackLog2 int
	// Base is the latest generation, which the commit follows; nil is an
	// empty vault at generation 0 (the creation commit writes generation 1).
	Base *VaultIndex
	// Rand is where every random byte comes from; nil is crypto/rand.
	Rand io.Reader
	// Sink stores packs as they close.
	Sink VaultPackSink
}