用NodeJS实现HTTP/HTTPS代理

用NodeJS实现HTTP/HTTPS代理

在本教程中，我们将探讨如何使用Node.js实现一个简单的HTTP/HTTPS代理。此代理可以用于转发客户端请求到指定的目标服务器，并将响应返回给客户端。

基本思路

代理服务器需要监听客户端的请求，并将这些请求转发到目标服务器。然后，代理服务器接收目标服务器的响应，并将其返回给客户端。为了简化问题，我们假设所有请求都是通过TCP连接进行的。

示例代码

以下是使用Node.js实现HTTP/HTTPS代理的基本代码：

const net = require('net');

let serverIp = "127.0.0.1";
let localPort = 8894;
let localFlag = 0;

if (process.argv.length >= 3) {
    serverIp = process.argv[2];
    localPort = 8893;
    localFlag = 1;
}

// 创建一个本地服务器，监听指定端口
net.createServer((client) => {
    let buffer = new Buffer(0);

    // 监听客户端的数据发送事件
    client.on('data', (data) => {
        buffer = buffer_add(buffer, data);

        if (buffer_find_body(buffer) == -1) return;

        let req = parse_request(buffer);

        if (req === false) return;

        client.removeAllListeners('data');
        relay_connection(req);
    });

    // 处理请求并连接目标服务器
    function relay_connection(req) {
        console.log(`${req.method} ${req.host}:${req.port}`);

        if (req.method !== 'CONNECT') {
            let _body_pos = buffer_find_body(buffer);

            if (_body_pos < 0) _body_pos = buffer.length;

            let header = buffer.slice(0, _body_pos).toString('utf8');

            // 替换连接头
            header = header.replace(/(proxy-)?connection\:.+\r\n/ig, '')
                .replace(/Keep-Alive\:.+\r\n/i, '')
                .replace("\r\n", '\r\nConnection: close\r\n');

            buffer = buffer_add(new Buffer(header, 'utf8'), buffer.slice(_body_pos));
        }

        if (localFlag) {
            for (let i = 0; i < buffer.length; i++) {
                buffer[i] += 1;
            }
        }

        client.pause();

        // 建立到目标服务器的连接
        let server = localFlag ? net.createConnection(8894, serverIp) : net.createConnection(req.port, req.host);

        server.pause();

        // 交换服务器与浏览器的数据
        client.on('data', (data) => {
            if (!server.closeflag) {
                server.write(data);
            }
        });

        server.on('data', (data) => {
            if (!client.closeflag) {
                for (let i = 0; i < data.length; i++) {
                    data[i] += localFlag ? 1 : -1;
                }
                client.write(data);
            }
        });

        client.on('end', () => {
            client.closeflag = 1;
        });

        server.on('end', () => {
            server.closeflag = 1;
        });

        server.on('connect', (socket) => {
            client.resume();
            server.resume();

            if (req.method === 'CONNECT') {
                if (localFlag) {
                    server.write(buffer);
                    client.write(new Buffer("HTTP/1.1 200 Connection established\r\nConnection: close\r\n\r\n"));
                }
            } else {
                server.write(buffer);
            }
        });
    }
}).listen(localPort);

console.log(`Proxy server running at localhost:${localPort}`);

process.on('uncaughtException', (err) => {
    console.log("\nError!!!");
    console.log(err);
});

// 解析请求头部
function parse_request(buffer) {
    let s = buffer.toString('utf8');

    let method = s.split('\n')[0].match(/^([A-Z]+)\s/)[1];

    if (method === 'CONNECT') {
        let arr = s.match(/^([A-Z]+)\s([^\:\s]+)\:(\d+)\sHTTP\/(\d.\d)/);

        if (arr && arr[1] && arr[2] && arr[3] && arr[4])
            return {
                method: arr[1],
                host: arr[2],
                port: arr[3],
                httpVersion: arr[4]
            };
    } else {
        let arr = s.match(/^([A-Z]+)\s([^\s]+)\sHTTP\/(\d.\d)/);

        if (arr && arr[1] && arr[2] && arr[3]) {
            let host = s.match(/Host\:\s+([^\n\s\r]+)/)[1];

            if (host) {
                let _p = host.split(':', 2);
                return {
                    method: arr[1],
                    host: _p[0],
                    port: _p[1] ? _p[1] : 80,
                    path: arr[2],
                    httpVersion: arr[3]
                };
            }
        }
    }

    return false;
}

// 合并两个Buffer对象
function buffer_add(buf1, buf2) {
    if (!localFlag) {
        for (let i = 0; i < buf2.length; i++) {
            buf2[i] -= 1;
        }
    }

    let re = new Buffer(buf1.length + buf2.length);

    buf1.copy(re);
    buf2.copy(re, buf1.length);

    return re;
}

// 查找头部结束标记位置
function buffer_find_body(b) {
    for (let i = 0, len = b.length - 3; i < len; i++) {
        if (b[i] == 0x0d && b[i + 1] == 0x0a && b[i + 2] == 0x0d && b[i + 3] == 0x0a) {
            return i + 4;
        }
    }

    return -1;
}

代码解析

1. 创建代理服务器：

   • 使用net.createServer创建一个本地服务器，监听指定端口。
   • 当有客户端连接时，启动一个回调函数处理客户端数据。

2. 解析请求：

   • parse_request函数解析HTTP请求头，提取请求方法、目标主机和端口等信息。

3. 数据转发：

   • 将客户端数据转发到目标服务器。
   • 接收目标服务器的数据并转发回客户端。
   • 使用buffer_add和buffer_find_body函数处理数据缓冲区。

4. 异常处理：

   • 使用process.on('uncaughtException')捕获未处理的异常。

总结

通过上述代码，我们可以实现一个简单的HTTP/HTTPS代理服务器。该代理服务器能够处理客户端的HTTP请求，并将请求转发到目标服务器，再将响应返回给客户端。希望这个示例能帮助你理解如何使用Node.js实现一个基本的代理服务器。