无需Chrome扩展，通过经典C代码注入修改浏览器DOM及页面内容可行吗？

Absolutely—you don’t need Chrome extensions to dynamically tweak page content like replacing images or injecting scripts. Let’s break down practical, C-based approaches tailored for your local setup, including ways to automate this remotely/periodically.

Option 1: Chrome Remote Debugging Protocol (CDP) – The Easiest Automation-Friendly Approach #

This is my go-to for your use case because it avoids low-level process injection headaches and plays nicely with automation. Chrome has a built-in remote debugging interface that lets you send commands to control tabs and execute JavaScript—all from a C program.

How to Implement It: #

1. Launch Chrome with Remote Debugging Enabled

   • On Windows: chrome.exe --remote-debugging-port=9222
   • On Linux/macOS: google-chrome --remote-debugging-port=9222
     This opens a debug port that your C client can connect to.

2. Write a C Client to Send CDP Commands
   Your C program will do three key things:

   • Send an HTTP GET request to http://localhost:9222/json to get the list of open tabs (targets)
   • Pick the target for Stack Overflow (look for the url field containing stackoverflow.com)
   • Establish a WebSocket connection to the target’s webSocketDebuggerUrl, then send JSON commands to execute your DOM-modifying JavaScript.

   Example JS snippets you’d send:

   • Replace all images:

     document.querySelectorAll('img').forEach(img => img.src = 'file:///C:/your-images/your-image.jpg');
     

   • Inject and run a script:

     const injectScript = document.createElement('script');
     injectScript.textContent = 'console.log("Injected script running!");';
     document.body.appendChild(injectScript);
     

   In C, you can use libraries like libcurl for HTTP/WebSocket handling to simplify this.

3. Automate/Remote Execution

   • Compile your C program remotely, then transfer it to your local machine via SSH or a file transfer tool.
   • Set up a scheduled task (Windows Task Scheduler) or cron job (Linux/macOS) to run the program at specific times.
   • For remote triggering, you could even add a simple network listener to your C program, so you can send a signal from your remote build server to kick off the DOM modification.

Option 2: Low-Level Process Injection (Windows/Linux) #

If you want to dive into classic C injection (no external protocols), you can inject code directly into Chrome’s renderer processes (each tab runs in its own renderer process).

Windows: DLL Injection #

1. Identify the Chrome Renderer Process
   Use tools like tasklist (or C’s CreateToolhelp32Snapshot API) to find the PID of the renderer process associated with the Stack Overflow tab. Look for processes named chrome.exe with the --type=renderer command line argument.

2. Write a Injectable DLL
   Your DLL will hook into the renderer process and execute JavaScript via Chrome’s V8 engine. You’ll need to:

   • Use CreateRemoteThread to inject the DLL into the renderer process.
   • In the DLL’s DllMain function, locate V8 engine functions (like v8::Context::GetCurrent() and v8::Script::Run()) using pattern scanning or known offsets (note: these offsets can change with Chrome updates).
   • Compile your DOM-modifying JS into a V8 script and execute it in the current page context.

   This is more complex and may trigger antivirus alerts, but it’s pure C-based injection.

Linux/macOS: ptrace or LD_PRELOAD #

• ptrace: Attach to the Chrome renderer process, write your JavaScript into the process’s memory, then call V8’s script execution function via ptrace to run it. This requires understanding Chrome’s memory layout and V8’s API.
• LD_PRELOAD: Create a shared library that overrides a function Chrome uses (like getaddrinfo), then in the overridden function, inject your JS via V8. Launch Chrome with LD_PRELOAD=/path/to/your/lib.so google-chrome to load your library.

Key Notes #

• Security: Process injection may be flagged as malicious by antivirus software. If you go this route, whitelist your program or test in a sandboxed environment.
• Chrome Updates: Low-level injection relies on Chrome’s internal structures, which change with updates. CDP is more stable since it’s an official API.
• Automation: CDP is far easier to automate remotely—you don’t have to worry about process IDs or memory offsets changing between runs.

内容的提问来源于stack exchange，提问作者Edd Eddie