Files
Multi-Hoster-Upload/lib/online-backup-manager.js
SucukdeluxeandClaude Opus 5.5 0b30a9180a
CI / verify (push) Canceled after 0s
Migrate credential encryption to the async safeStorage API
Electron 45 deprecates the synchronous safeStorage methods and Electron 46
removes them. Credential encryption now uses encryptStringAsync,
decryptStringAsync and isAsyncEncryptionAvailable.

- secret-store: async encryptField/decryptField/encryptCredentials/
  decryptCredentials, decryptFieldWithStatus exposes shouldReEncrypt.
  Unavailable or failing encryption still rejects with the existing
  SECRET_STORE_* codes; legacy plaintext stays readable.
- config-store: the first load runs asynchronously through init();
  writes encrypt before the atomic write. A synchronous load() of an
  encrypted config before init() fails with SECRET_STORE_NOT_READY and
  schedules a refresh. Values flagged with shouldReEncrypt are
  re-encrypted once after loading.
- main: await configStore.init() after app ready, before the first load.
- MCP access store and online backup keyring await the async helpers;
  MCP saves keep their call order.

Existing enc:v1 values written with encryptString stay readable: on
Windows both APIs use the same v10 format and Local State key, verified
in both directions with real Electron 41 and 45.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 07:57:54 +02:00

159 lines
5.4 KiB
JavaScript

const {
DEFAULT_ONLINE_BACKUP_RETENTION,
createOnlineBackup,
deleteOnlineBackup,
uploadOnlineBackup
} = require('./online-backup');
const { KEYRING_ERROR_CODES } = require('./online-backup-keyring');
const ERRORS = Object.freeze({
list: 'Online-Sicherungen konnten nicht geladen werden',
create: 'Online-Sicherung konnte nicht erstellt werden',
copy: 'Online-Sicherungsschlüssel konnte nicht kopiert werden',
delete: 'Online-Sicherung konnte nicht gelöscht werden',
notFound: 'Online-Sicherungsschlüssel wurde nicht gefunden'
});
const KEYRING_MESSAGES = Object.freeze({
[KEYRING_ERROR_CODES.structure]: 'Gespeicherter Online-Schlüsselbund ist beschädigt',
[KEYRING_ERROR_CODES.unavailable]: 'Sichere Schlüsselspeicherung ist nicht verfügbar',
[KEYRING_ERROR_CODES.decrypt]: 'Gespeicherter Online-Sicherungsschlüssel konnte nicht entschlüsselt werden',
[KEYRING_ERROR_CODES.mismatch]: 'Gespeicherte Online-Sicherungskennung stimmt nicht mit dem Schlüssel überein',
[KEYRING_ERROR_CODES.duplicate]: 'Gespeicherte Online-Sicherungskennung ist mehrdeutig',
[KEYRING_ERROR_CODES.recovered]: 'Online-Schlüsselbund wurde aus einer Wiederherstellungsdatei geladen',
[KEYRING_ERROR_CODES.encrypt]: 'Online-Sicherungsschlüssel konnte nicht sicher vorbereitet werden',
[KEYRING_ERROR_CODES.plan]: 'Online-Sicherung konnte lokal nicht eindeutig entfernt werden'
});
function sanitizeEntry(entry) {
return {
id: entry.id,
displayKey: entry.displayKey,
createdAt: entry.createdAt,
expiresAt: entry.expiresAt ?? null,
...(entry.sourceIp ? { sourceIp: entry.sourceIp } : {})
};
}
function sanitizeCreatedEntry(entry, key) {
return {
id: entry.id,
displayKey: `${key.slice(0, 9)}…${key.slice(-4)}`,
createdAt: entry.createdAt,
expiresAt: entry.expiresAt ?? null,
...(entry.sourceIp ? { sourceIp: entry.sourceIp } : {})
};
}
function keyringFailure(error, fallback) {
const message = KEYRING_MESSAGES[error?.code];
if (!message) return { ok: false, error: fallback };
return { ok: false, code: error.code, error: message };
}
function createOnlineBackupManager({
keyring,
loadSettings,
appVersion,
createBackup = createOnlineBackup,
uploadBackup = uploadOnlineBackup,
deleteBackup = deleteOnlineBackup,
loadRecoveryPublicKey = async () => null,
copyText
}) {
let mutation = Promise.resolve();
function serialize(operation) {
const next = mutation.catch(() => {}).then(operation);
mutation = next;
return next;
}
async function listEntries() {
const snapshot = await keyring.list();
if (!snapshot || !Array.isArray(snapshot.entries) || !Array.isArray(snapshot.issues)) throw new Error(ERRORS.list);
return {
entries: snapshot.entries.map(sanitizeEntry),
issues: snapshot.issues
};
}
async function createTransaction(retention) {
const createdAt = new Date().toISOString();
const settings = await loadSettings();
const recoveryPublicKey = await loadRecoveryPublicKey();
const created = createBackup(settings, appVersion(), createdAt, retention, recoveryPublicKey);
let prepared = await keyring.prepare(created.key, createdAt, created.expiresAt ?? null);
const metadata = await uploadBackup(created.record);
if (metadata?.sourceIp) prepared = Object.freeze({ ...prepared, sourceIp: metadata.sourceIp });
try {
await keyring.commit(prepared);
} catch (error) {
try {
await deleteBackup(created.key);
} catch {}
throw error;
}
return { ok: true, entry: sanitizeCreatedEntry(prepared, created.key) };
}
async function deleteTransaction(id) {
const plan = await keyring.prepareRemove(id);
if (!plan) return { ok: false, notFound: true, error: ERRORS.notFound };
const outcome = await deleteBackup(plan.key);
if (!outcome?.deleted && !outcome?.notFound) throw new Error(ERRORS.delete);
await keyring.commitRemove(plan);
return { ok: true, removedId: id, notFound: outcome.notFound };
}
async function listManaged() {
try {
const snapshot = await listEntries();
const issue = snapshot.issues[0];
if (!issue) return { ok: true, entries: snapshot.entries };
const message = KEYRING_MESSAGES[issue] || ERRORS.list;
if (snapshot.entries.length || issue === KEYRING_ERROR_CODES.recovered) {
return {
ok: true,
entries: snapshot.entries,
warningCode: issue,
warning: message
};
}
return { ok: false, entries: [], code: issue, error: message };
} catch (error) {
return keyringFailure(error, ERRORS.list);
}
}
async function createManaged(retention = DEFAULT_ONLINE_BACKUP_RETENTION) {
try {
return await serialize(() => createTransaction(retention));
} catch (error) {
return keyringFailure(error, ERRORS.create);
}
}
async function copyManaged(id) {
try {
const key = await keyring.getKey(id);
if (!key) return { ok: false, notFound: true, error: ERRORS.notFound };
await copyText(key);
return { ok: true };
} catch (error) {
return keyringFailure(error, ERRORS.copy);
}
}
async function deleteManaged(id) {
try {
return await serialize(() => deleteTransaction(id));
} catch (error) {
return keyringFailure(error, ERRORS.delete);
}
}
return Object.freeze({ listManaged, createManaged, copyManaged, deleteManaged });
}
module.exports = { createOnlineBackupManager };