前端安全存储方案

const safeStorage = {
  set(key, value, ttlMs) {
    const record = {
      value,
      expireAt: ttlMs ? Date.now() + ttlMs : null,
    };
    localStorage.setItem(key, JSON.stringify(record));
  },
  get(key) {
    const raw = localStorage.getItem(key);
    if (!raw) return null;
    try {
      const record = JSON.parse(raw);
      if (record.expireAt && Date.now() > record.expireAt) {
        localStorage.removeItem(key); // 过期自动清理
        return null;
      }
      return record.value;
    } catch {
      return null; // 数据被篡改/损坏时安全降级
    }
  },
  remove(key) {
    localStorage.removeItem(key);
  },
};

safeStorage.set('theme', 'dark', 7 * 24 * 60 * 60 * 1000); // 存 7 天

// 从口令派生密钥（PBKDF2），再用 AES-GCM 加解密
async function deriveKey(passphrase, salt) {
  const enc = new TextEncoder();
  const baseKey = await crypto.subtle.importKey(
    'raw', enc.encode(passphrase), 'PBKDF2', false, ['deriveKey']
  );
  return crypto.subtle.deriveKey(
    { name: 'PBKDF2', salt, iterations: 100000, hash: 'SHA-256' },
    baseKey,
    { name: 'AES-GCM', length: 256 },
    false,
    ['encrypt', 'decrypt']
  );
}

async function encryptAndStore(key, plainText) {
  const enc = new TextEncoder();
  const salt = crypto.getRandomValues(new Uint8Array(16));
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const cryptoKey = await deriveKey('user-passphrase', salt);
  const cipher = await crypto.subtle.encrypt(
    { name: 'AES-GCM', iv }, cryptoKey, enc.encode(plainText)
  );
  // 把 salt + iv + 密文一起存，解密时需要
  const payload = {
    salt: Array.from(salt),
    iv: Array.from(iv),
    data: Array.from(new Uint8Array(cipher)),
  };
  localStorage.setItem(key, JSON.stringify(payload));
}

async function loadAndDecrypt(key) {
  const raw = localStorage.getItem(key);
  if (!raw) return null;
  const { salt, iv, data } = JSON.parse(raw);
  const cryptoKey = await deriveKey('user-passphrase', new Uint8Array(salt));
  const plain = await crypto.subtle.decrypt(
    { name: 'AES-GCM', iv: new Uint8Array(iv) },
    cryptoKey,
    new Uint8Array(data)
  );
  return new TextDecoder().decode(plain);
}

// Express：令牌存 HttpOnly Cookie，杜绝 JS 读取
res.cookie('sessionId', sessionId, {
  httpOnly: true,   // JS 无法访问，XSS 也偷不走
  secure: true,     // 仅 HTTPS
  sameSite: 'strict', // 抵御 CSRF
  maxAge: 3600000,  // 1 小时
  path: '/',
});

function secureLogout() {
  // 清空 storage
  localStorage.clear();
  sessionStorage.clear();
  // 通知后端清除 HttpOnly Cookie（前端无法直接删）
  fetch('/api/logout', { method: 'POST', credentials: 'include' });
  // 清理内存中的敏感引用
  window.__USER__ = null;
}

import { openDB } from 'idb';

const dbPromise = openDB('app-cache', 1, {
  upgrade(db) {
    db.createObjectStore('documents', { keyPath: 'id' });
  },
});

export async function saveDoc(doc) {
  const db = await dbPromise;
  await db.put('documents', doc); // 敏感字段应先加密再存
}

export async function getDoc(id) {
  const db = await dbPromise;
  return (await dbPromise) && db.get('documents', id);
}

// ===== 前端：内存令牌管理器 + 自动刷新 =====
class TokenManager {
  #accessToken = null;      // 私有字段，仅存内存
  #expireAt = 0;            // access token 过期时间戳
  #refreshing = null;       // 正在刷新的 Promise，防并发重复刷新

  setAccessToken(token, expiresInSec) {
    this.#accessToken = token;
    this.#expireAt = Date.now() + expiresInSec * 1000;
  }

  // 判断是否临近过期（留 30 秒缓冲）
  #isExpiring() {
    return !this.#accessToken || Date.now() > this.#expireAt - 30_000;
  }

  // 静默刷新：浏览器自动携带 HttpOnly refresh Cookie
  async #refresh() {
    const res = await fetch('/api/auth/refresh', {
      method: 'POST',
      credentials: 'include', // 关键：带上 Cookie
    });
    if (!res.ok) throw new Error('refresh failed');
    const { accessToken, expiresIn } = await res.json();
    this.setAccessToken(accessToken, expiresIn);
    return accessToken;
  }

  // 取一个可用的 access token（必要时先刷新），并发安全
  async getValidToken() {
    if (!this.#isExpiring()) return this.#accessToken;
    // 若已有刷新在途，复用同一个 Promise，避免并发多次刷新
    if (!this.#refreshing) {
      this.#refreshing = this.#refresh().finally(() => {
        this.#refreshing = null;
      });
    }
    return this.#refreshing;
  }

  clear() {
    this.#accessToken = null;
    this.#expireAt = 0;
  }
}

export const tokenManager = new TokenManager();

// ===== 封装 fetch：自动附加 access token + 401 重试 =====
export async function authFetch(url, options = {}) {
  const token = await tokenManager.getValidToken();
  const doFetch = (t) =>
    fetch(url, {
      ...options,
      credentials: 'include',
      headers: { ...options.headers, Authorization: `Bearer ${t}` },
    });

  let res = await doFetch(token);
  if (res.status === 401) {
    // access token 可能刚失效，强制刷新一次再重试
    tokenManager.clear();
    const fresh = await tokenManager.getValidToken();
    res = await doFetch(fresh);
  }
  return res;
}

// ===== 服务端(Express)：登录下发 + 刷新接口 =====
// 登录成功：access token 走响应体(前端存内存)，refresh token 走 HttpOnly Cookie
app.post('/api/auth/login', async (req, res) => {
  const user = await verifyCredentials(req.body);
  const accessToken = signAccessToken(user, '15m');
  const refreshToken = signRefreshToken(user, '30d');

  res.cookie('refreshToken', refreshToken, {
    httpOnly: true,
    secure: true,
    sameSite: 'strict',
    path: '/api/auth/refresh', // 仅刷新接口可见，最小暴露面
    maxAge: 30 * 24 * 3600 * 1000,
  });
  res.json({ accessToken, expiresIn: 900 }); // 900s = 15min
});

// 刷新：校验 refresh Cookie，签发新 access token
app.post('/api/auth/refresh', async (req, res) => {
  const token = req.cookies.refreshToken;
  if (!token) return res.status(401).json({ error: 'no refresh token' });
  try {
    const payload = verifyRefreshToken(token);
    const accessToken = signAccessToken(payload, '15m');
    res.json({ accessToken, expiresIn: 900 });
  } catch {
    res.status(401).json({ error: 'invalid refresh token' });
  }
});

// 生成高熵 code_verifier，并派生 SHA-256 的 code_challenge
function base64UrlEncode(bytes) {
  return btoa(String.fromCharCode(...bytes))
    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
}

export async function createPkcePair() {
  const verifierBytes = crypto.getRandomValues(new Uint8Array(32));
  const codeVerifier = base64UrlEncode(verifierBytes);

  const digest = await crypto.subtle.digest(
    'SHA-256', new TextEncoder().encode(codeVerifier)
  );
  const codeChallenge = base64UrlEncode(new Uint8Array(digest));

  // verifier 只在换码时用一次，用 sessionStorage 临时存(跳转后要读回)
  sessionStorage.setItem('pkce_verifier', codeVerifier);
  return { codeVerifier, codeChallenge };
}

// 每个 refresh token 记录所属 family 与是否已用过
app.post('/api/auth/refresh', async (req, res) => {
  const raw = req.cookies.refreshToken;
  const record = await db.refreshTokens.findByHash(sha256(raw));

  if (!record) return res.status(401).end();

  // 重放检测：已被使用过的令牌又出现 → 整条 family 撤销
  if (record.used) {
    await db.refreshTokens.revokeFamily(record.familyId);
    return res.status(401).json({ error: 'token reuse detected' });
  }

  await db.refreshTokens.markUsed(record.id); // 旧的作废
  const newRefresh = signRefreshToken(record.userId);
  await db.refreshTokens.save({
    hash: sha256(newRefresh),
    familyId: record.familyId, // 同一 family 延续
    userId: record.userId,
    used: false,
  });

  res.cookie('refreshToken', newRefresh, {
    httpOnly: true, secure: true, sameSite: 'strict',
    path: '/api/auth/refresh', maxAge: 30 * 24 * 3600 * 1000,
  });
  res.json({ accessToken: signAccessToken(record.userId, '15m'), expiresIn: 900 });
});

import argon2 from 'argon2-browser';

async function deriveKeyArgon2(passphrase, salt) {
  const { hash } = await argon2.hash({
    pass: passphrase,
    salt,                 // Uint8Array，至少 16 字节随机盐
    type: argon2.ArgonType.Argon2id,
    time: 3,              // 迭代轮数
    mem: 64 * 1024,       // 内存开销 64MB
    parallelism: 1,
    hashLen: 32,          // 输出 32 字节 → AES-256 密钥
  });
  // 把原始字节导入为不可导出的 CryptoKey
  return crypto.subtle.importKey(
    'raw', hash, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']
  );
}

import { openDB } from 'idb';

const KEY_DB = openDB('secure-keys', 1, {
  upgrade(db) { db.createObjectStore('keys'); },
});

// 首次生成不可导出的 AES-GCM 密钥并持久化
export async function getOrCreateKey() {
  const db = await KEY_DB;
  let key = await db.get('keys', 'aes-key');
  if (!key) {
    key = await crypto.subtle.generateKey(
      { name: 'AES-GCM', length: 256 },
      false,          // extractable=false：无法导出原始密钥字节
      ['encrypt', 'decrypt']
    );
    await db.put('keys', key, 'aes-key'); // 直接存 CryptoKey 对象
  }
  return key;
}

export async function encryptField(plainText) {
  const key = await getOrCreateKey();
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const cipher = await crypto.subtle.encrypt(
    { name: 'AES-GCM', iv }, key, new TextEncoder().encode(plainText)
  );
  return { iv: Array.from(iv), data: Array.from(new Uint8Array(cipher)) };
}

export async function decryptField({ iv, data }) {
  const key = await getOrCreateKey();
  const plain = await crypto.subtle.decrypt(
    { name: 'AES-GCM', iv: new Uint8Array(iv) }, key, new Uint8Array(data)
  );
  return new TextDecoder().decode(plain);
}

// 用 __Host- 前缀锁定会话 Cookie，杜绝子域覆盖
res.cookie('__Host-session', sessionId, {
  httpOnly: true, secure: true, sameSite: 'strict', path: '/',
  // 注意：使用 __Host- 前缀时绝不能设置 domain
});

// 第三方嵌入组件写分区 Cookie(需同时带 Secure)
res.cookie('widget_state', value, {
  httpOnly: true, secure: true, sameSite: 'none', partitioned: true,
});

async function reportQuota() {
  if (!navigator.storage?.estimate) return;
  const { usage, quota } = await navigator.storage.estimate();
  const usedMB = (usage / 1024 / 1024).toFixed(2);
  const quotaMB = (quota / 1024 / 1024).toFixed(2);
  const percent = ((usage / quota) * 100).toFixed(1);
  console.log(`已用 ${usedMB}MB / 配额 ${quotaMB}MB (${percent}%)`);
  return { usage, quota };
}

async function ensurePersistent() {
  if (!navigator.storage?.persist) return false;
  const already = await navigator.storage.persisted();
  if (already) return true;
  const granted = await navigator.storage.persist(); // 可能触发权限/静默判定
  console.log(granted ? '已获持久化存储' : '仍为尽力而为存储');
  return granted;
}

// Service Worker：显式跳过敏感接口，不进缓存
self.addEventListener('fetch', (event) => {
  const url = new URL(event.request.url);
  const SENSITIVE = ['/api/account', '/api/auth', '/api/payment'];
  if (SENSITIVE.some((p) => url.pathname.startsWith(p))) {
    return; // 直接走网络，不缓存
  }
  event.respondWith(
    caches.match(event.request).then((hit) => hit || fetch(event.request))
  );
});

// 简易同意闸门：非必要存储要先过 consent 检查
const consent = {
  get(cat) {
    try { return JSON.parse(localStorage.getItem('consent') || '{}')[cat] === true; }
    catch { return false; }
  },
};

function setAnalytics(key, value) {
  if (!consent.get('analytics')) return; // 未同意分析类，直接不存
  localStorage.setItem(key, value);
}

class SignedStorage {
  constructor(namespace, version, hmacKey) {
    this.prefix = `${namespace}:v${version}:`;
    this.keyPromise = crypto.subtle.importKey(
      'raw', new TextEncoder().encode(hmacKey),
      { name: 'HMAC', hash: 'SHA-256' }, false, ['sign', 'verify']
    );
  }

  async #sign(text) {
    const key = await this.keyPromise;
    const sig = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(text));
    return btoa(String.fromCharCode(...new Uint8Array(sig)));
  }

  async set(key, value) {
    const body = JSON.stringify(value);
    const sig = await this.#sign(body);
    localStorage.setItem(this.prefix + key, JSON.stringify({ body, sig }));
  }

  async get(key) {
    const raw = localStorage.getItem(this.prefix + key);
    if (!raw) return null;
    try {
      const { body, sig } = JSON.parse(raw);
      const expected = await this.#sign(body);
      if (sig !== expected) {
        localStorage.removeItem(this.prefix + key); // 签名不符 → 判定篡改，丢弃
        return null;
      }
      return JSON.parse(body);
    } catch {
      return null;
    }
  }
}

// 方式一：storage 事件(仅在"其它"标签页触发，写入方自身不触发)
window.addEventListener('storage', (e) => {
  if (e.key === 'auth-state' && e.newValue === null) {
    // 别的标签登出了 → 本标签同步清理并跳登录
    tokenManager.clear();
    location.href = '/login';
  }
});

// 方式二：BroadcastChannel(结构化消息，更清晰)
const authChannel = new BroadcastChannel('auth');
authChannel.onmessage = (e) => {
  if (e.data.type === 'logout') {
    tokenManager.clear();
    location.href = '/login';
  }
};
export function broadcastLogout() {
  authChannel.postMessage({ type: 'logout' });
}

import { openDB } from 'idb';

class EncryptedStore {
  constructor(dbName, storeName) {
    this.storeName = storeName;
    this.dbPromise = openDB(dbName, 1, {
      upgrade(db) {
        if (!db.objectStoreNames.contains('keys')) db.createObjectStore('keys');
        if (!db.objectStoreNames.contains(storeName)) db.createObjectStore(storeName);
      },
    });
  }

  async #key() {
    const db = await this.dbPromise;
    let key = await db.get('keys', 'k');
    if (!key) {
      key = await crypto.subtle.generateKey(
        { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']
      );
      await db.put('keys', key, 'k');
    }
    return key;
  }

  async put(id, value) {
    const key = await this.#key();
    const iv = crypto.getRandomValues(new Uint8Array(12));
    const cipher = await crypto.subtle.encrypt(
      { name: 'AES-GCM', iv }, key, new TextEncoder().encode(JSON.stringify(value))
    );
    const db = await this.dbPromise;
    await db.put(this.storeName, { iv: Array.from(iv), data: Array.from(new Uint8Array(cipher)) }, id);
  }

  async get(id) {
    const db = await this.dbPromise;
    const rec = await db.get(this.storeName, id);
    if (!rec) return null;
    const key = await this.#key();
    const plain = await crypto.subtle.decrypt(
      { name: 'AES-GCM', iv: new Uint8Array(rec.iv) }, key, new Uint8Array(rec.data)
    );
    return JSON.parse(new TextDecoder().decode(plain));
  }
}

// 无痕模式/配额为 0/被禁用时，localStorage 可能抛异常，需探测 + 内存兜底
function createStorage() {
  let available = false;
  try {
    const probe = '__probe__';
    localStorage.setItem(probe, '1');
    localStorage.removeItem(probe);
    available = true;
  } catch {
    available = false; // 降级到内存 Map
  }

  const memory = new Map();
  return {
    get(k) {
      return available ? localStorage.getItem(k) : (memory.get(k) ?? null);
    },
    set(k, v) {
      if (!available) return memory.set(k, v);
      try {
        localStorage.setItem(k, v);
      } catch (e) {
        // 配额超限(QuotaExceededError)：清理旧数据或降级到内存
        if (e.name === 'QuotaExceededError') memory.set(k, v);
      }
    },
    isPersistent: available,
  };
}

// main.js：主线程只发指令，不接触密钥/明文令牌
const worker = new Worker('/crypto-worker.js');
export function encryptViaWorker(plainText) {
  return new Promise((resolve) => {
    const id = crypto.randomUUID();
    const onMsg = (e) => {
      if (e.data.id !== id) return;
      worker.removeEventListener('message', onMsg);
      resolve(e.data.result);
    };
    worker.addEventListener('message', onMsg);
    worker.postMessage({ id, action: 'encrypt', plainText });
  });
}

// crypto-worker.js：密钥只存在于 Worker 作用域内
let cryptoKey = null;
async function getKey() {
  if (!cryptoKey) {
    cryptoKey = await crypto.subtle.generateKey(
      { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']
    );
  }
  return cryptoKey;
}
self.onmessage = async (e) => {
  const { id, action, plainText } = e.data;
  if (action === 'encrypt') {
    const key = await getKey();
    const iv = crypto.getRandomValues(new Uint8Array(12));
    const cipher = await crypto.subtle.encrypt(
      { name: 'AES-GCM', iv }, key, new TextEncoder().encode(plainText)
    );
    self.postMessage({ id, result: { iv: Array.from(iv), data: Array.from(new Uint8Array(cipher)) } });
  }
};