Files
SHiNE-server/shine-UI/js/services/key-vault.js
T

198 lines
7.5 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { t } from '../i18n/index.js';
import {
decryptJsonWithStoragePwd,
encryptJsonWithStoragePwd,
} from './crypto-utils.js';
const DB_NAME = 'shine-ui-auth';
const DB_VERSION = 1;
const STORE_SECRETS = 'encrypted-secrets';
const STORE_SESSIONS = 'session-keys';
const FALLBACK_SECRETS_KEY = 'shine-ui-auth-secrets-fallback-v1';
const FALLBACK_SESSIONS_KEY = 'shine-ui-auth-sessions-fallback-v1';
// Некоторые браузеры/расширения временно ломают IndexedDB и возвращают
// только «UnknownError: Internal error». В памяти держим только текущие
// значения, а в localStorage — те же зашифрованные secrets и session material,
// которые раньше хранились в IndexedDB.
const memorySecrets = new Map();
const memorySessions = new Map();
function normalizeLoginStorageKey(login) {
return String(login || '').trim().toLowerCase();
}
function readFallbackRow(storageKey, login) {
try {
if (typeof localStorage === 'undefined') return null;
const rows = JSON.parse(localStorage.getItem(storageKey) || '{}');
return rows?.[normalizeLoginStorageKey(login)] || null;
} catch {
return null;
}
}
function writeFallbackRow(storageKey, login, row) {
try {
if (typeof localStorage === 'undefined') return;
const rows = JSON.parse(localStorage.getItem(storageKey) || '{}');
rows[normalizeLoginStorageKey(login)] = row;
localStorage.setItem(storageKey, JSON.stringify(rows));
} catch {
// Память остаётся последним fallback для текущей вкладки.
}
}
function deleteFallbackRows(storageKey) {
try { localStorage?.removeItem(storageKey); } catch {}
}
function sanitizePersistentSecrets(keys) {
const source = keys && typeof keys === 'object' ? keys : {};
const safe = { ...source };
// Recovery/root private key is intentionally ephemeral: it may exist in RAM
// during a protected operation, but must never be persisted on the device.
delete safe.rootKey;
return safe;
}
function openDb() {
return new Promise((resolve, reject) => {
const request = indexedDB.open(DB_NAME, DB_VERSION);
request.onupgradeneeded = () => {
const db = request.result;
if (!db.objectStoreNames.contains(STORE_SECRETS)) {
db.createObjectStore(STORE_SECRETS, { keyPath: 'login' });
}
if (!db.objectStoreNames.contains(STORE_SESSIONS)) {
db.createObjectStore(STORE_SESSIONS, { keyPath: 'login' });
}
};
request.onsuccess = () => resolve(request.result);
request.onerror = () => reject(request.error || new Error(t('remaining.key_storage.indexeddb_is_unavailable')));
});
}
async function put(storeName, value) {
const db = await openDb();
await new Promise((resolve, reject) => {
const tx = db.transaction(storeName, 'readwrite');
tx.objectStore(storeName).put(value);
tx.oncomplete = () => resolve();
tx.onerror = () => reject(tx.error || new Error(t('remaining.key_storage.could_not_write_to_indexeddb')));
});
db.close();
}
async function get(storeName, key) {
const db = await openDb();
const result = await new Promise((resolve, reject) => {
const tx = db.transaction(storeName, 'readonly');
const req = tx.objectStore(storeName).get(key);
req.onsuccess = () => resolve(req.result || null);
req.onerror = () => reject(req.error || new Error(t('remaining.key_storage.could_not_read_from_indexeddb')));
});
db.close();
return result;
}
export async function saveEncryptedUserSecrets(login, storagePwd, keys) {
const safeKeys = sanitizePersistentSecrets(keys);
const encrypted = await encryptJsonWithStoragePwd(safeKeys, storagePwd);
const normalizedLogin = normalizeLoginStorageKey(login);
const row = {
login: normalizedLogin,
encrypted,
updatedAtMs: Date.now(),
};
memorySecrets.set(normalizedLogin, row);
try {
await put(STORE_SECRETS, row);
} catch {
writeFallbackRow(FALLBACK_SECRETS_KEY, normalizedLogin, row);
}
}
export async function loadEncryptedUserSecrets(login, storagePwd) {
const normalizedLogin = normalizeLoginStorageKey(login);
let row = null;
try { row = await get(STORE_SECRETS, normalizedLogin); } catch {}
row = row || memorySecrets.get(normalizedLogin) || readFallbackRow(FALLBACK_SECRETS_KEY, normalizedLogin);
if (!row?.encrypted && normalizedLogin !== String(login || '').trim()) {
try { row = await get(STORE_SECRETS, String(login || '').trim()); } catch {}
}
if (!row?.encrypted) {
throw new Error('На устройстве нет сохранённых ключей для этого логина');
}
const decrypted = await decryptJsonWithStoragePwd(row.encrypted, storagePwd);
const safe = sanitizePersistentSecrets(decrypted);
// Одноразовая очистка контейнеров, созданных старыми версиями UI, где rootKey
// мог быть сохранён. Перезаписываем тем же storagePwd уже без Recovery private key.
if (decrypted && typeof decrypted === 'object' && Object.prototype.hasOwnProperty.call(decrypted, 'rootKey')) {
const encrypted = await encryptJsonWithStoragePwd(safe, storagePwd);
const cleanedRow = {
login: normalizedLogin,
encrypted,
updatedAtMs: Date.now(),
};
memorySecrets.set(normalizedLogin, cleanedRow);
try { await put(STORE_SECRETS, cleanedRow); } catch { writeFallbackRow(FALLBACK_SECRETS_KEY, normalizedLogin, cleanedRow); }
}
return safe;
}
export async function updateEncryptedUserSecrets(login, storagePwd, updater) {
if (typeof updater !== 'function') {
throw new Error('updateEncryptedUserSecrets: updater должен быть функцией');
}
const current = await loadEncryptedUserSecrets(login, storagePwd);
const next = await updater(current);
if (!next || typeof next !== 'object') {
throw new Error('updateEncryptedUserSecrets: updater должен вернуть объект secrets');
}
const safe = sanitizePersistentSecrets(next);
await saveEncryptedUserSecrets(login, storagePwd, safe);
return safe;
}
export async function saveSessionMaterial(login, material) {
const normalizedLogin = normalizeLoginStorageKey(login);
const row = {
login: normalizedLogin,
...material,
updatedAtMs: Date.now(),
};
memorySessions.set(normalizedLogin, row);
try {
await put(STORE_SESSIONS, row);
} catch {
writeFallbackRow(FALLBACK_SESSIONS_KEY, normalizedLogin, row);
}
}
export async function loadSessionMaterial(login) {
const normalizedLogin = normalizeLoginStorageKey(login);
let row = null;
try { row = await get(STORE_SESSIONS, normalizedLogin); } catch {}
row = row || memorySessions.get(normalizedLogin) || readFallbackRow(FALLBACK_SESSIONS_KEY, normalizedLogin);
if (row || normalizedLogin === String(login || '').trim()) return row;
try { return await get(STORE_SESSIONS, String(login || '').trim()); } catch { return null; }
}
export async function clearClientAuthData() {
memorySecrets.clear();
memorySessions.clear();
deleteFallbackRows(FALLBACK_SECRETS_KEY);
deleteFallbackRows(FALLBACK_SESSIONS_KEY);
await new Promise((resolve, reject) => {
const request = indexedDB.deleteDatabase(DB_NAME);
request.onsuccess = () => resolve();
request.onerror = () => reject(request.error || new Error('Не удалось очистить IndexedDB'));
request.onblocked = () => reject(new Error('Очистка IndexedDB заблокирована открытыми соединениями'));
});
}