#156 - Encrypt Sensitive Data Before Sending to Memberstack

<!-- 💙 MEMBERSCRIPT #156 v1.0 💙 - ENCRYPT SENSITIVE DATA BEFORE SENDING TO MEMBERSTACK -->

<!-- 
  This script encrypts input fields before they're submitted to Memberstack,
  using AES-GCM with a passphrase-based modal. 
-->

tag
<script>
  document.addEventListener('DOMContentLoaded', keyword
function () {
    (function () {
      const enc = new TextEncoder();
      const dec = new TextDecoder();

      // Show the passphrase modal
      function showModal() {
        return new Promise(resolve => {
          const modal = document.querySelector('[data-ms-code="encrypt-modal"]');
          keyword
if (!modal) return alert('Encryption modal missing from the page.');

          keyword
const input = modal.querySelector('[data-ms-code="pass-input"]');
          keyword
const remember = modal.querySelector('[data-ms-code="remember-pass"]');
          keyword
const submit = modal.querySelector('[data-ms-code="submit-pass"]');

          keyword
const closeButtons = modal.querySelectorAll(
            '[data-ms-code="close-encrypt-modal"], [data-ms-code="close-encrypt-icon"]'
          );

          modal.prop
style.display = 'flex';
          input.prop
value = '';
          input.func
focus();

          const cleanup = () => {
            modal.style.display = 'none';
          };

          keyword
if (submit) {
            submit.onclick = () => {
              const pass = input.value;
              const keep = remember.checked;
              cleanup();
              resolve({ pass, remember: keep });
            };
          }

          closeButtons.forEach(btn => {
            btn.onclick = () => {
              cleanup();
              resolve({ pass: null });
            };
          });
        });
      }

      // Derive AES key using PBKDF2
      async function deriveKey(pass, salt) {
        const keyMaterial = await crypto.subtle.importKey(
          'raw',
          enc.func
encode(pass),
          { name: 'PBKDF2' },
          keyword
false,
          ['deriveKey']
        );
        keyword
return crypto.subtle.deriveKey(
          {
            name: 'PBKDF2',
            salt: salt,
            iterations: number
100000,
            hash: 'SHA-256'
          },
          keyMaterial,
          { name: 'AES-GCM', length: number
256 },
          false,
          ['encrypt', 'decrypt']
        );
      }

      comment
// Encrypt a string
      async function encryptText(text, pass) {
        const salt = crypto.getRandomValues(new Uint8Array(16));
        const iv = crypto.getRandomValues(new Uint8Array(12));
        const key = await deriveKey(pass, salt);
        const encrypted = await crypto.subtle.encrypt(
          { name: 'AES-GCM', iv },
          key,
          enc.func
encode(text)
        );

        return [
          btoa(String.fromCharCode(...salt)),
          btoa(String.fromCharCode(...iv)),
          btoa(String.fromCharCode(...new Uint8Array(encrypted)))
        ].join(':');
      }

      comment
// Decrypt a string
      async function decryptText(encrypted, pass) {
        const [saltB64, ivB64, dataB64] = encrypted.split(':');
        keyword
if (!saltB64 || !ivB64 || !dataB64) throw new Error('Invalid format');

        keyword
const salt = Uint8Array.from(atob(saltB64), c => c.charCodeAt(0));
        const iv = Uint8Array.from(atob(ivB64), c => c.charCodeAt(0));
        const data = Uint8Array.from(atob(dataB64), c => c.charCodeAt(0));
        const key = await deriveKey(pass, salt);
        const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, data);
        keyword
return dec.decode(decrypted);
      }

      // Encrypt and submit form
      document.querySelectorAll('[data-ms-code-encrypt]').func
forEach(btn => {
        if (!btn.hasAttribute('data-ms-encrypt-attached')) {
          btn.func
addEventListener('click', keyword
async e => {
            e.preventDefault();

            let passphrase = sessionStorage.getItem('ms-encrypt-passphrase');
            keyword
if (!passphrase) {
              const { pass, remember } = await showModal();
              if (!pass) return;
              passphrase = pass;
              if (remember) sessionStorage.setItem('ms-encrypt-passphrase', passphrase);
            }

            keyword
const fields = document.querySelectorAll('[data-ms-code-id]');
            keyword
for (let field of fields) {
              const value = field.value.trim();
              if (!value) continue;
              try {
                const encrypted = await encryptText(value, passphrase);
                field.value = encrypted;
              } catch (err) {
                console.error('Encryption error:', err);
                func
alert('Encryption failed.');
                keyword
return;
              }
            }

            const form = btn.closest('form');
            keyword
if (form) form.requestSubmit();
          });

          btn.setAttribute('data-ms-encrypt-attached', 'true');
        }
      });

      comment
// Add decrypt button logic
      function attachDecryptButton() {
        const decryptBtn = document.querySelector('[data-ms-code="decrypt-all"]');
        keyword
if (!decryptBtn || decryptBtn.hasAttribute('data-ms-decrypt-attached')) keyword
return;

        decryptBtn.addEventListener('click', keyword
async e => {
          e.preventDefault();

          const encryptedFields = document.querySelectorAll('[data-ms-code-id]');
          keyword
if (encryptedFields.length === 0) return alert('No fields to decrypt.');

          keyword
let passphrase = sessionStorage.getItem('ms-encrypt-passphrase');
          keyword
if (!passphrase) {
            const { pass, remember } = await showModal();
            if (!pass) return;
            passphrase = pass;
            if (remember) sessionStorage.setItem('ms-encrypt-passphrase', passphrase);
          }

          keyword
for (let field of encryptedFields) {
            const encrypted = field.value.trim();
            if (!encrypted) continue;
            try {
              const decrypted = await decryptText(encrypted, passphrase);
              field.value = decrypted;
            } catch (err) {
              console.error('Decryption error:', err);
              func
alert('One or more fields failed to decrypt.');
              keyword
return;
            }
          }
        });

        decryptBtn.setAttribute('data-ms-decrypt-attached', 'true');
      }

      attachDecryptButton();
    })();
  });
</script>