Blog | G5 Cyber Security

Client-Side Encryption: Managing Access

G5 Cyber Security

TL;DR

When data is encrypted on the client’s device (like in your browser), controlling who can see it becomes trickier. This guide explains how to manage access using keys, secure storage, and careful design of your application.

Understanding the Problem

Traditional server-side encryption relies on the server to protect decryption keys. With client-side encryption, the user’s device holds those keys. This is great for privacy but means you need ways to:

Solution: Key Management & Access Control

  1. Key Generation: Generate a unique encryption key for each user or data set. Never use the same key twice for different users’ data. Use a strong cryptographic library (e.g., Web Crypto API in browsers).
  2. Secure Key Storage: This is crucial! Options include:
    • Browser Storage (with caveats): Use IndexedDB or localStorage, but these are not inherently secure. Encrypt the key before storing it in browser storage using a user’s password (or another strong authentication factor).
    • Password-Based Key Derivation: Use a robust Password-Based Key Derivation Function (PBKDF) like PBKDF2 or Argon2 to derive an encryption key from the user’s password. This makes it harder for attackers to crack the key even if they get access to the storage.
    • Hardware Security Modules (HSMs): For very high security, consider using a HSM if available in your environment.
  3. Access Control Implementation: Implement a system where users don’t directly have the encryption key but can request access to decrypt data.
    • Data Encryption with Unique Keys: Each piece of data should be encrypted using a unique symmetric key.
    • Key Encryption with User-Specific Keys: Encrypt each data key with a different key derived from the user’s credentials (e.g., password).
    • Access Request Process: When a user wants to access data:
      1. The user authenticates (e.g., enters their password).
      2. Their password is used to derive the correct decryption key for that specific piece of data.
      3. The data key is decrypted, allowing access to the original data.
  4. Key Revocation: If a user’s access needs to be revoked:
    • Invalidate their credentials (e.g., force password reset). This will prevent them from deriving the decryption keys for any new data.
    • For existing encrypted data, you may need to re-encrypt it with new keys if complete security is required.
  5. Sharing Data: To share data:
    • Encrypt the data key with multiple user-specific keys. Each authorized user can then decrypt the data key using their own credentials.
    • Consider time-limited access tokens for sharing, adding an extra layer of security.

Code Example (Conceptual – JavaScript with Web Crypto API)

This is a simplified example to illustrate the concepts. Do not use this code directly in production without thorough review and testing!

async function encryptData(data, password) { 
  const encoder = new TextEncoder();
  const keyMaterial = await window.crypto.subtle.deriveKey(
    {
      name: "PBKDF2",
      salt: crypto.getRandomValues(new Uint8Array(16)),
      iterations: 10000,
      hash: "SHA-256"
    },
    password, // User's password
    "AES-GCM",
    false, // user presence required
    ["encryption"] 
  );

  const iv = crypto.getRandomValues(new Uint8Array(12));
  const encryptedData = await window.crypto.subtle.encrypt({
    name: "AES-GCM",
    iv: iv,
  }, keyMaterial, encoder.encode(data));

  return { ciphertext: new Uint8Array(encryptedData), iv };
}

async function decryptData(ciphertext, password) {
  const decoder = new TextDecoder();
  const keyMaterial = await window.crypto.subtle.deriveKey(
    {
      name: "PBKDF2",
      salt: ciphertext.salt,
      iterations: 10000,
      hash: "SHA-256"
    },
    password, // User's password
    "AES-GCM",
    false, // user presence required
    ["encryption"] 
  );

  const decryptedData = await window.crypto.subtle.decrypt({
    name: "AES-GCM",
    iv: ciphertext.iv,
  }, keyMaterial, ciphertext.data);

  return decoder.decode(decryptedData);
}

Important Considerations

Exit mobile version