resfss

resfss API

Local list (this browser). del needs your manage token (saved on upload) or member API key. × drops from list only.

/ Upload Sort

Uploads (14d)

Storage split

Encryption

Top users

auto-refresh 15s

Filter

crypto.js

// resfss client-side encryption — same logic as internal/crypto (Go)
// RSFC chunked AES-256-GCM + Argon2id wrapped DEK

const ARGON2_TIME = 3;
const ARGON2_MEM = 19456;
const ARGON2_PAR = 4;
const SALT_LEN = 16;
const NONCE_LEN = 12;
const KEY_LEN = 32;
const CHUNK_PLAIN = 4 << 20;
const CHUNK_MAGIC = 'RSFC';

async function deriveKey(password, salt) {
  const { hash } = await argon2.hash({
    pass: password,
    salt,
    time: ARGON2_TIME,
    mem: ARGON2_MEM,
    hashLen: KEY_LEN,
    parallelism: ARGON2_PAR,
    type: argon2.ArgonType.Argon2id,
    raw: true,
  });
  return crypto.subtle.importKey('raw', hash, 'AES-GCM', false, ['encrypt', 'decrypt']);
}

async function wrapKey(password, dek) {
  const salt = crypto.getRandomValues(new Uint8Array(SALT_LEN));
  const kek = await deriveKey(password, salt);
  const nonce = crypto.getRandomValues(new Uint8Array(NONCE_LEN));
  const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce }, kek, dek);
  return JSON.stringify({
    salt: b64(salt),
    nonce: b64(nonce),
    ciphertext: b64(new Uint8Array(ct)),
  });
}

async function unwrapKey(password, wrappedJSON) {
  const wk = JSON.parse(wrappedJSON);
  const salt = unb64(wk.salt);
  const nonce = unb64(wk.nonce);
  const ct = unb64(wk.ciphertext);
  const kek = await deriveKey(password, salt);
  return new Uint8Array(await crypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce }, kek, ct));
}

function chunkHeader() {
  const h = new Uint8Array(12);
  h[0] = CHUNK_MAGIC.charCodeAt(0);
  h[1] = CHUNK_MAGIC.charCodeAt(1);
  h[2] = CHUNK_MAGIC.charCodeAt(2);
  h[3] = CHUNK_MAGIC.charCodeAt(3);
  h[4] = 1;
  new DataView(h.buffer).setUint32(8, CHUNK_PLAIN, false);
  return h;
}

async function encryptChunk(key, plain) {
  const nonce = crypto.getRandomValues(new Uint8Array(NONCE_LEN));
  const ct = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce }, key, plain));
  const meta = new Uint8Array(NONCE_LEN + 4 + ct.length);
  meta.set(nonce, 0);
  new DataView(meta.buffer).setUint32(NONCE_LEN, ct.length, false);
  meta.set(ct, NONCE_LEN + 4);
  return meta;
}

async function encryptFile(file, password) {
  const dek = crypto.getRandomValues(new Uint8Array(KEY_LEN));
  const key = await crypto.subtle.importKey('raw', dek, 'AES-GCM', false, ['encrypt']);
  const parts = [chunkHeader()];
  let offset = 0;
  while (offset < file.size) {
    const end = Math.min(offset + CHUNK_PLAIN, file.size);
    const buf = new Uint8Array(await file.slice(offset, end).arrayBuffer());
    parts.push(await encryptChunk(key, buf));
    offset = end;
  }
  const wrapped_key = await wrapKey(password, dek);
  return { ciphertext: new Blob(parts), wrapped_key };
}

async function decryptFile(ciphertext, password, wrappedKeyJSON) {
  const dek = await unwrapKey(password, wrappedKeyJSON);
  const blob = ciphertext instanceof Blob ? ciphertext : new Blob([ciphertext]);
  const head = new Uint8Array(await blob.slice(0, 12).arrayBuffer());
  if (head[0] !== CHUNK_MAGIC.charCodeAt(0) || head[1] !== CHUNK_MAGIC.charCodeAt(1) ||
      head[2] !== CHUNK_MAGIC.charCodeAt(2) || head[3] !== CHUNK_MAGIC.charCodeAt(3)) {
    throw new Error('invalid ciphertext format');
  }
  const key = await crypto.subtle.importKey('raw', dek, 'AES-GCM', false, ['decrypt']);
  const parts = [];
  let offset = 12;
  while (offset < blob.size) {
    const meta = new Uint8Array(await blob.slice(offset, offset + NONCE_LEN + 4).arrayBuffer());
    const ctLen = new DataView(meta.buffer).getUint32(NONCE_LEN, false);
    offset += NONCE_LEN + 4;
    const ct = new Uint8Array(await blob.slice(offset, offset + ctLen).arrayBuffer());
    offset += ctLen;
    const pt = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: meta.slice(0, NONCE_LEN) }, key, ct);
    parts.push(new Uint8Array(pt));
  }
  const total = parts.reduce((n, p) => n + p.length, 0);
  const out = new Uint8Array(total);
  let pos = 0;
  for (const p of parts) {
    out.set(p, pos);
    pos += p.length;
  }
  return out;
}

function b64(buf) {
  return btoa(String.fromCharCode(...buf));
}

function unb64(s) {
  return Uint8Array.from(atob(s), c => c.charCodeAt(0));
}

Register

API key

Usage

Profile

Delete account

Uploads (14d)

Storage split

Encryption

Top users

Auth

Limits

Anonymous

Member

Rate limit (RPM)

Share

Login

Register

API key

Usage

Profile

Delete account

Uploads (14d)

Storage split

Encryption

Top users

Auth

Limits

Anonymous

Member

Rate limit (RPM)