Struct FileBackend 

pub struct FileBackend { /* private fields */ }

Filesystem-backed keychain.

Thread-safe — KeychainBackend is Send + Sync, and all operations use OS-level atomic primitives (rename, unlink). Multiple FileBackend instances pointing at the same root directory coexist without mutual serialization; the tmp-file names include a random suffix so concurrent writes to the same BackendKey do not step on each other’s tmp files.

Example

use std::sync::Arc;
use dig_keystore::{
    backend::{FileBackend, BackendKey, KeychainBackend},
};

let backend: Arc<dyn KeychainBackend> = Arc::new(
    FileBackend::new("/var/lib/dig/keys")
);
backend.write(&BackendKey::new("v1"), b"...").unwrap();

Implementations

impl FileBackend

pub fn new(root: impl Into<PathBuf>) -> Self

Create a new file backend rooted at root.

The directory is not created immediately — it is lazily created on the first write call (with mode 0700 on Unix). This lets callers construct a FileBackend in tests without side effects; no files are written until the first write.

Example

use dig_keystore::backend::FileBackend;
let be = FileBackend::new("/var/lib/dig/keys");
let _ = be;  // directory not created yet

pub fn root(&self) -> &Path

The root directory this backend writes to.

Trait Implementations

impl KeychainBackend for FileBackend

fn read(&self, key: &BackendKey) -> Result<Vec<u8>>

Read the entire file at <root>/<key>.dks.

Returns KeystoreError::Backend wrapping an io::Error with ErrorKind::NotFound if the file does not exist.

fn write(&self, key: &BackendKey, data: &[u8]) -> Result<()>

Atomically write data to <root>/<key>.dks.

Steps:

1. Ensure root exists.
2. Create sibling <key>.dks.tmp.<random> file, mode 0600 on Unix.
3. Write data, fsync the file handle.
4. rename the tmp file onto the final name.
5. On Unix, fsync the containing directory so the rename is durable.
6. On error in step 4, best-effort unlink the tmp file.

The random suffix in step 2 is not cryptographic — it exists only to disambiguate two concurrent writes to the same key from the same process. Uses a hash of (nanoseconds_since_epoch, pid).

fn delete(&self, key: &BackendKey) -> Result<()>

Best-effort secure delete, then unlink.

Steps:

1. No-op if file does not exist (idempotent).
2. Open the file for writing; overwrite with zeros in 4 KiB chunks.
3. fsync the overwritten file so zeros hit storage.
4. unlink the file.

Step 2 is best-effort. On SSDs with flash translation layer or on copy-on-write filesystems (btrfs, ZFS), the zero pass may not reach the sectors that held the ciphertext. Use full-disk encryption for stronger guarantees.

fn list(&self, prefix: &str) -> Result<Vec<BackendKey>>

Enumerate keys whose names start with prefix.

Scans the root directory; skips any file that:

• does not end in .dks
• has a non-UTF-8 name
• does not start with prefix

Returns an empty vec if the root directory does not exist.

fn exists(&self, key: &BackendKey) -> Result<bool>

Cheap override — Path::exists stats without opening the file.