backend-macos.js

// ====================================================================
// backend-macos.js — warstwa macOS dla BitLockPick
//
// macOS NIE ma natywnego BitLockera. Ten backend używa OPEN-SOURCE:
//   • dislocker  (brew install dislocker) — odszyfrowuje wolumin BitLocker
//   • macFUSE    (brew install --cask macfuse) — montowanie FUSE
//   • ntfs-3g / wbudowany mount_ntfs — montowanie odszyfrowanego NTFS (read-only)
//
// Ograniczenia względem Windows:
//   • NIE można enable/disable/lock BitLockera (to zarządzanie jest Windows-only).
//   • Odblokowanie = zamontowanie woluminu READ-ONLY.
//   • Polecenia uprzywilejowane (dislocker, mount) idą przez natywny prompt
//     administratora macOS (osascript "with administrator privileges") —
//     hasło wpisuje użytkownik w bezpiecznym oknie systemu, nie w aplikacji.
//
// UWAGA: dokładne wywołania dislocker/hdiutil bywają wersjozależne —
// wymaga weryfikacji na realnym macOS. Zaznaczone // TODO(mac-test).
// ====================================================================

const { exec } = require('child_process');
const os = require('os');
const path = require('path');

const WORK_DIR = path.join(os.tmpdir(), 'bitlockpick');

// --- pomocnicze: uruchom polecenie shell (bez uprawnień) ---
function sh(cmd, opts = {}) {
  return new Promise((resolve) => {
    exec(cmd, { maxBuffer: 1024 * 1024 * 16, ...opts }, (error, stdout, stderr) => {
      resolve({ success: !error, stdout: stdout || '', stderr: stderr || '', error });
    });
  });
}

// --- uruchom polecenie z uprawnieniami administratora (natywny prompt macOS) ---
// Użytkownik autoryzuje w oknie systemowym; aplikacja nie widzi hasła.
function shAdmin(cmd, promptText) {
  // Escape podwójnych cudzysłowów i backslashy do wnętrza AppleScript "do shell script"
  const inner = cmd.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
  const prompt = (promptText || 'BitLockPick potrzebuje uprawnień administratora').replace(/"/g, '\\"');
  const osa = `do shell script "${inner}" with prompt "${prompt}" with administrator privileges`;
  // -e AppleScript
  return sh(`osascript -e '${osa.replace(/'/g, "'\\''")}'`);
}

// Waliduje identyfikator dysku (np. disk4s1) — zapobiega wstrzyknięciu
function safeDiskId(id) {
  const m = String(id || '').trim().match(/^(disk[0-9]+(s[0-9]+)?)$/);
  return m ? m[1] : null;
}

// Sanityzacja klucza odzyskiwania (cyfry, myślniki)
function safeRecoveryKey(key) {
  return String(key || '').trim().replace(/[^0-9-]/g, '');
}

// ====================================================================
// Wykrywanie zależności
// ====================================================================
async function checkDeps() {
  const [dl, meta, mf] = await Promise.all([
    sh('command -v dislocker'),
    sh('command -v dislocker-metadata'),
    sh('test -d "/Library/Filesystems/macfuse.fs" -o -d "/Library/Filesystems/osxfuse.fs" && echo yes')
  ]);
  return {
    dislocker: dl.success && !!dl.stdout.trim(),
    dislockerMetadata: meta.success && !!meta.stdout.trim(),
    macfuse: mf.success && mf.stdout.trim() === 'yes'
  };
}

// ====================================================================
// Lista woluminów (kształt kompatybilny z rendererem — pola jak w Windows)
//   Letter  = identyfikator dysku (diskXsY) — używany jako opaque id
//   IsLocked = true dla nie-zamontowanych / nierozpoznanych (kandydat BitLocker)
// ====================================================================
async function getDrives() {
  // diskutil zwraca plist; konwertujemy na JSON przez plutil
  const listRes = await sh('diskutil list -plist physical | plutil -convert json -o - -');
  if (!listRes.success) {
    return { success: false, error: 'Nie udało się odczytać listy dysków (diskutil).' };
  }

  let parsed;
  try { parsed = JSON.parse(listRes.stdout); } catch (e) {
    return { success: false, error: 'Błąd parsowania diskutil plist: ' + e.message };
  }

  const deps = await checkDeps();
  const drives = [];

  // Zbierz wszystkie identyfikatory partycji
  const disks = (parsed.AllDisksAndPartitions || []);
  for (const disk of disks) {
    const parts = disk.Partitions || [];
    for (const p of parts) {
      const id = p.DeviceIdentifier;
      if (!id) continue;

      // Szczegóły partycji
      const infoRes = await sh(`diskutil info -plist ${id} | plutil -convert json -o - -`);
      let info = {};
      try { info = JSON.parse(infoRes.stdout); } catch (_) {}

      const mountPoint = info.MountPoint || '';
      const content = info.Content || p.Content || '';
      const fs = info.FilesystemName || info.FilesystemType || '';
      const size = info.TotalSize || p.Size || 0;
      const free = info.FreeSpace || 0;
      const isMounted = !!mountPoint;

      // Heurystyka BitLockera: partycja typu "Microsoft Basic Data" która nie zamontowała
      // się jako czytelny system plików, LUB nierozpoznany FS. dislocker potwierdzi.
      const looksBitLocker = !isMounted && (content === 'Microsoft Basic Data' || !fs);

      drives.push({
        Letter: id,                         // diskXsY jako opaque id
        Label: info.VolumeName || p.VolumeName || 'Dysk',
        FileSystem: fs || 'Nieznany',
        Size: size,
        SizeRemaining: free,
        MountPoint: mountPoint,
        EncryptionStatus: looksBitLocker ? 'FullyEncrypted' : (isMounted ? 'None' : 'None'),
        ProtectionStatus: looksBitLocker ? 'Unknown' : 'Off',
        EncryptionPercentage: null,
        IsLocked: looksBitLocker,
        KeyProtectors: []
      });
    }
  }

  return {
    success: true,
    data: {
      BitLockerSupported: deps.dislocker,   // "wsparcie" = czy dislocker jest zainstalowany
      Deps: deps,
      Drives: drives
    }
  };
}

// ====================================================================
// Odblokuj + zamontuj (read-only) wolumin BitLocker przez dislocker
// ====================================================================
async function unlockDrive({ letter, password, type }) {
  const id = safeDiskId(letter);
  if (!id) return { success: false, error: 'Nieprawidłowy identyfikator dysku.' };

  const deps = await checkDeps();
  if (!deps.dislocker) {
    return { success: false, error: 'Brak dislocker. Zainstaluj: brew install dislocker (oraz macFUSE).' };
  }

  const decDir = path.join(WORK_DIR, id, 'decrypted');
  const mntDir = path.join(WORK_DIR, id, 'mount');

  // Zbuduj opcję klucza/hasła dislockera.
  // UWAGA: w dislockerze -p/--recovery-password = klucz odzyskiwania,
  // -u/--user-password = hasło użytkownika, a -r = --readonly (NIE klucz!).
  let keyOpt;
  if (type === 'password') {
    const safePw = String(password).replace(/"/g, '\\"');
    keyOpt = `--user-password="${safePw}"`;
  } else {
    const key = safeRecoveryKey(password);
    keyOpt = `--recovery-password=${key}`;
  }

  // 1) utwórz katalogi, 2) dislocker -r (readonly) -> plik odszyfrowany, 3) zamontuj NTFS read-only
  // TODO(mac-test): dokładny mount NTFS zależy od wersji (mount_ntfs vs ntfs-3g).
  const cmd = [
    `mkdir -p '${decDir}' '${mntDir}'`,
    `dislocker -r -V /dev/${id} ${keyOpt} -- '${decDir}'`,
    `hdiutil attach -readonly -nomount '${decDir}/dislocker-file' >/dev/null 2>&1 || true`,
    `mount -t ntfs -r -o loop '${decDir}/dislocker-file' '${mntDir}' 2>/dev/null || mount_ntfs '${decDir}/dislocker-file' '${mntDir}' 2>/dev/null || true`
  ].join(' && ');

  const res = await shAdmin(cmd, 'BitLockPick: odblokowanie dysku BitLocker (dislocker)');
  if (res.success) {
    return { success: true, mountPoint: mntDir };
  }
  return { success: false, error: (res.stderr || res.error?.message || 'Odblokowanie nie powiodło się. Sprawdź klucz i czy dislocker/macFUSE są zainstalowane.') };
}

// ====================================================================
// Operacje niedostępne na macOS (BitLocker management jest Windows-only)
// ====================================================================
function notSupported() {
  return Promise.resolve({
    success: false,
    error: 'Ta operacja (szyfrowanie/blokowanie/wyłączanie BitLockera) jest dostępna tylko na Windows. Na macOS można odblokować i zamontować dysk (read-only).'
  });
}
const lockDrive = notSupported;
const enableBitLocker = notSupported;
const disableBitLocker = notSupported;
const getBackupKey = () => Promise.resolve({ success: false, error: 'Odczyt klucza z woluminu nie jest wspierany na macOS.' });

// ====================================================================
// Recovery Lab — brute-force przez dislocker (dla ~1 brakującego bloku)
// startRecovery(params, { onProgress, onDone }) — analogicznie do Windows.
// Zwraca uchwyt { stop() }.
// ====================================================================
function startRecovery({ letter, blocks, startOffset = 0 }, cb) {
  const id = safeDiskId(letter);
  if (!id) { cb.onDone({ success: false, error: 'Nieprawidłowy identyfikator dysku.' }); return { stop() {} }; }

  const known = [];
  for (let i = 0; i < 8; i++) {
    const b = String((blocks || [])[i] || '').trim();
    known.push(/^[0-9]{6}$/.test(b) ? b : '');
  }
  const unknown = [];
  for (let i = 0; i < 8; i++) if (known[i] === '') unknown.push(i);
  if (unknown.length === 0) { cb.onDone({ success: false, error: 'Zaznacz co najmniej jeden nieznany blok.' }); return { stop() {} }; }

  const total = Math.pow(65536, unknown.length);
  const CAP = 200000;
  if (total > CAP) { cb.onDone({ success: false, error: `Zbyt duża przestrzeń (${total}). Limit online ~${CAP}.` }); return { stop() {} }; }

  const decDir = path.join(WORK_DIR, id, 'rec');
  let stopped = false;
  let i = Math.max(0, Math.floor(Number(startOffset) || 0));
  const counters = new Array(unknown.length).fill(0);
  let rem = i;
  for (let j = unknown.length - 1; j >= 0; j--) {
    counters[j] = rem % 65536;
    rem = Math.floor(rem / 65536);
  }

  cb.onProgress({ tried: i, total });

  // Uwaga: dislocker per-kandydat jest wolny (spawn procesu). Dla ~1 bloku wykonalne.
  // TODO(mac-test): rozważyć szybszy test klucza jeśli dislocker udostępni dry-run.
  const step = async () => {
    if (stopped || i >= total) {
      if (!stopped) cb.onDone({ success: false, notfound: true });
      return;
    }
    const parts = known.slice();
    for (let j = 0; j < unknown.length; j++) {
      parts[unknown[j]] = String(counters[j] * 11).padStart(6, '0');
    }
    const key = parts.join('-');

    // Próba odszyfrowania — sukces = poprawny klucz (-p = recovery password, -r = readonly)
    const cmd = `mkdir -p '${decDir}' && dislocker -r -V /dev/${id} --recovery-password=${key} -- '${decDir}'`;
    const res = await sh(cmd); // bez sudo próbnie; realnie dislocker może wymagać root -> patrz TODO
    if (res.success) {
      cb.onDone({ success: true, key, letter: id });
      return;
    }

    // inkrementuj odometr
    let k = 0;
    while (k < unknown.length) {
      counters[k]++;
      if (counters[k] < 65536) break;
      counters[k] = 0; k++;
    }
    i++;
    if (i % 100 === 0) cb.onProgress({ tried: i, total });
    setImmediate(step);
  };
  setImmediate(step);

  return { stop() { stopped = true; } };
}

module.exports = {
  checkDeps,
  getDrives,
  unlockDrive,
  lockDrive,
  enableBitLocker,
  disableBitLocker,
  getBackupKey,
  startRecovery
};