@nwct/demo 1.0.0

package/.idea/mapping-net-main.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/mapping-net-main.iml" filepath="$PROJECT_DIR$/.idea/mapping-net-main.iml" />
+    </modules>
+  </component>
+</project>

package/README.md

@@ -0,0 +1,113 @@
+# nodejs 实现的 tcp 内网穿透、映射外网服务
+
+### 使用安装
+
+- `npm i -g @mapping/net`，安装完成通过以下指令启动服务
+  - `mapping server --server_port 81 --token "helloServer"`
+
+
+- `npm init mapping`，免安装可以直接使用以下指令
+  - 客户端：`npm init mapping client --server_addr 166.169.66.99 --server_port 81 --token "helloServer" --local_ip 127.0.0.1 --local_port 4000 --remote_port 80`
+  - 服务端：`npm init mapping server --server_port 81 --token "helloServer"`
+
+
+- 通过`git`安装
+  - `git clone https://github.com/code-ba/mapping-net.git`
+  - `cd mapping-net && npm install`
+  - 通过指令启动，如`npm run client` or `npm run server`（启动多个服务需要配置）
+    - 配置`config.client.js`、`config.server.js`
+  - 通过指令启动单个服务：
+    - `node bin/index.js client --server_addr 166.169.66.99`
+    - `node bin/index.js server --server_port 81`
+
+
+---
+
+### 指令
+
+- 客户端
+```c
+$ mapping client --help
+Usage: mapping client [options]
+Options:
+  --server_addr <server_addr>  服务端地址（默认：0.0.0.0）
+  --server_port <server_port>  服务端端口（默认：10000）
+  --token <token>              连接令牌（默认：aksda@$@#kjsk）
+  --timeout <timeout>          请求超时时间（默认：3000）
+  --interval <interval>        连接令牌（默认：5000）
+  --binds <binds>              连接令牌（默认：ssh）
+  --local_ip <local_ip>        内网被转发的ip（默认：127.0.0.1）
+  --local_port <local_port>    内网被转发的端口（默认：80）
+  --remote_port <remote_port>  服务端映射的端口（默认：80）
+  -h, --help                   display help for command
+```
+
+- 服务端
+```c
+$ mapping server --help
+Usage: mapping server [options]
+Options:
+  --server_addr <server_addr>  服务端地址（默认：0.0.0.0）
+  --server_port <server_port>  服务端端口（默认：10000）
+  --token <token>              连接令牌（默认：aksda@$@#kjsk）
+  -h, --help                   display help for comman
+```
+
+- 服务端后台启动方式
+  - `pm2 start -- run server`相当于`npm run server`（全局安装`pm2`可使用：`npm install -g pm2`）
+
+---
+
+### 客户端配置
+
+```js
+// config.client.js
+module.exports={
+  server_addr: "166.66.66.66",//服务端地址，纯IP，必须改
+  server_port: 10000,//服务端端口，客户端和服务端必须保持一致
+  token: "aksd()@$@#kjsk",//连接令牌，客户端和服务端必须保持一致
+  timeout: 3000,//请求超时时间
+  interval: 5000,//异常重试
+  binds: {//绑定内网应用
+    ssh: {
+      local_ip: "127.0.0.1",//当前内网被转发的ip
+      local_port: 80,//当前内网被转发的端口
+      remote_port: 10001,//服务端映射的端口
+    },
+    aria2: {
+      local_ip: "192.168.199.193",//当前内网被转发的ip
+      local_port: 6800,//当前内网被转发的端口
+      remote_port: 10002,//服务端映射的端口
+    },
+    aria2Ng: {
+      local_ip: "127.0.0.1",//当前内网被转发的ip
+      local_port: 80,//当前内网被转发的端口
+      remote_port: 10003,//服务端映射的端口
+    }
+  }
+}
+```
+
+---
+
+### 服务端配置
+
+```js
+// config.server.js
+module.exports={
+  server_addr: "0.0.0.0",//服务端地址 一般是0.0.0.0或127.0.0.1，一般不需要改
+  server_port: 10000,//服务端端口，客户端和服务端必须保持一致
+  token: "aksd()@$@#kjsk",//连接令牌，客户端和服务端必须保持一致
+}
+```
+
+---
+
+### 打赏
+
+您的支持是我持续更新的动力！
+
+<img src="https://cdn.jsdelivr.net/gh/cxvh/static@main/img/20210218193037.png" width="200" height="200" alt="微信">
+<img src="https://cdn.jsdelivr.net/gh/cxvh/static@main/img/20210218192738.jpg" width="200" height="200" alt="支付宝">
+
+---

package/bin/index.js

@@ -0,0 +1,7 @@
+#! /usr/bin/env node
+const importLocal=require('import-local')
+if(importLocal(__filename)){
+  require('npmlog').info('正在使用本地版本')
+}else{
+  require('../lib')(process.argv.slice(2))
+}

package/config.client.js

@@ -0,0 +1,25 @@
+module.exports={
+  server_addr: "8.141.174.71",//服务端地址，纯IP，必须改
+  server_port: 6001,//服务端端口，客户端和服务端必须保持一致
+  token: "aksda@$@#kjsk",//连接令牌，客户端和服务端必须保持一致
+  timeout: 3000,//请求超时时间
+  interval: 5000,//异常重试
+  binds: {//绑定内网应用
+    ssh: {
+      local_ip: "127.0.0.1",//当前内网被转发的ip
+      local_port: 80,//当前内网被转发的端口
+      remote_port: 8080,// 远程的端口
+    }
+    // ,
+    // aria2: {
+    //   local_ip: "192.168.199.193",//当前内网被转发的ip
+    //   local_port: 6800,//当前内网被转发的端口
+    //   remote_port: 10002,//服务端映射的端口
+    // },
+    // aria2Ng: {
+    //   local_ip: "127.0.0.1",//当前内网被转发的ip
+    //   local_port: 90,//当前内网被转发的端口
+    //   remote_port: 10003,//服务端映射的端口
+    // }
+  }
+}

package/config.server.js

@@ -0,0 +1,5 @@
+module.exports={
+  server_addr: "0.0.0.0",//服务端地址 一般是0.0.0.0或127.0.0.1，一般不需要改
+  server_port: 6001,//服务端端口，客户端和服务端必须保持一致
+  token: "aksda@$@#kjsk",//连接令牌，客户端和服务端必须保持一致，不支持空格
+}

package/lib/client.js

@@ -0,0 +1,132 @@
+const net = require('net');
+const log=require('npmlog');
+const envConfig=require('../config.client')
+const defaultSsh={
+    local_ip: "127.0.0.1",//当前内网被转发的ip
+    local_port: 80,//当前内网被转发的端口
+    remote_port: 80,//服务端映射的端口
+}
+// 配置
+const CONFIG = {
+    server_addr: "166.66.66.66",//服务端地址
+    server_port: 10000,//服务端端口
+    token: "aksda@$@#kjsk",//连接令牌
+    timeout: 3000,//请求超时时间
+    interval: 5000,//异常重试
+    binds: {//绑定内网应用
+        ssh: defaultSsh
+    },
+    ...envConfig
+};
+// 用于校验请求的code
+let CODE;
+let linkClient;
+let runClient=false;
+function listenClient(cmdObj) {
+    if(cmdObj){
+        CONFIG.server_addr=cmdObj.server_addr||CONFIG.server_addr;
+        CONFIG.server_port=cmdObj.server_port||CONFIG.server_port;
+        CONFIG.token=cmdObj.token||CONFIG.token;
+        CONFIG.timeout=cmdObj.timeout||CONFIG.timeout;
+        CONFIG.interval=cmdObj.interval||CONFIG.interval;
+        const binds=cmdObj.binds||'ssh';
+        var local_ip,local_port,remote_port
+        if(CONFIG.binds[binds]){
+            local_ip=cmdObj.local_ip||CONFIG.binds[binds].local_ip||defaultSsh.local_ip
+            local_port=cmdObj.local_port||CONFIG.binds[binds].local_port||defaultSsh.local_port
+            remote_port=cmdObj.remote_port||CONFIG.binds[binds].remote_port||defaultSsh.remote_port
+        }
+        CONFIG.binds[binds]={
+            local_ip,local_port,remote_port
+        }
+    }
+    log.info('客户端配置文件：',JSON.stringify(CONFIG,null,2))
+    if(runClient===false){
+        runClient=true;
+        tryError();
+    }
+    // 创建用于连接校验服务端的 客户端连接
+    linkClient = net.createConnection({ port: CONFIG.server_port, host: CONFIG.server_addr }, () => {
+        // 创建用于校验请求的code
+        CODE = (+new Date());
+        // 发送数据校验
+        linkClient.write(JSON.stringify({ token: CONFIG.token, code: CODE, type: 'register', binds: CONFIG.binds }));
+        console.log(`[${(new Date()).toLocaleString()}] 正在尝试连接...`);
+    });
+    linkClient.setTimeout(CONFIG.timeout);
+    linkClient.on('data', (data) => {
+        try {
+            data = JSON.parse(data);
+            // 校验请求
+            if (data.code == CODE) {
+                if (data.type == 'register') {
+                    console.log(`[${(new Date()).toLocaleString()}] 已连接到服务器 ${CONFIG.server_addr}:${CONFIG.server_port}`);
+                } else {
+                    // 请求标识
+                    let key = data.key;
+                    // 应用名称
+                    let name = data.name;
+                    // 本地的应用
+                    let localApp = CONFIG.binds[name];
+                    if (!localApp) linkClient.end();
+                    // 创建服务端用的Socket
+                    let serverClient = new net.Socket();
+                    serverClient.setTimeout(CONFIG.timeout);
+                    // 创建局域网内的Socket
+                    let localClient = new net.Socket();
+                    localClient.setTimeout(CONFIG.timeout);
+
+                    // 连接服务端
+                    serverClient.connect(CONFIG.server_port, CONFIG.server_addr, function () {
+                        serverClient.write(JSON.stringify({ type: 'connect', key: key }));
+                        // 连接本地服务器
+                        localClient.connect(localApp.local_port, localApp.local_ip, function () {
+                            console.log(`[${(new Date()).toLocaleString()}] [${name}] ${localApp.local_port}<===>${localApp.remote_port}`);
+                        });
+                        // 本地数据转发服务端
+                        localClient.pipe(serverClient);
+                        localClient.on('end', function (data) {
+                            serverClient.end();
+                        });
+                    })
+                    serverClient.on('error', function (err) {
+                        console.error(`[${(new Date()).toLocaleString()}] 访问服务器异常，${err.message}`);
+                        localClient.end();
+                    })
+                    localClient.on('error', function (err) {
+                        console.error(`[${(new Date()).toLocaleString()}] 局域网访问异常，${err.message}`);
+                        serverClient.end();
+                    });
+                    // 服务端数据转发本地
+                    serverClient.pipe(localClient);
+                    serverClient.on('end', function (data) {
+                        localClient.end();
+                    });
+                }
+                return;
+            }
+        } catch (error) {
+            // 异常
+        }
+        return linkClient.end();
+    });
+    linkClient.on('error', (err) => {
+        console.error(`[${(new Date()).toLocaleString()}] 异常:` + err.message);
+    });
+    linkClient.on('end', () => {
+        log.error(`[${(new Date()).toLocaleString()}] 已从服务器 ${CONFIG.server_port}:${CONFIG.server_port} 断开`)
+    });
+}
+
+//异常重试
+function tryError(){
+    setInterval(() => {
+        if (linkClient.readyState == "closed") {
+            linkClient.end();
+            log.warn(`[${(new Date()).toLocaleString()}] 正在重新连接服务器...`)
+            listenClient();
+        }
+    }, CONFIG.interval);
+}
+
+module.exports=listenClient;

package/lib/index.js

@@ -0,0 +1,50 @@
+module.exports = core;
+const log=require('npmlog')
+const colors=require('colors');
+const commander=require('commander');
+const program=new commander.Command();
+
+const pkg=require('../package.json');
+const client=require('./client')
+const server=require('./server')
+
+async function core() {
+  try{
+      // 命令注册
+      registerCommand()
+  }catch(e){
+      log.error(e.message);
+      if(program.debug){
+          console.log(e)
+      }
+  }
+}
+function registerCommand(){
+  program
+    .name(Object.keys(pkg.bin)[0])
+    .usage('<command> [options]')
+    .version(pkg.version)
+  // 命令注册
+  program
+      .command('client')
+      .option('--server_addr <server_addr>','服务端地址（默认：0.0.0.0）')
+      .option('--server_port <server_port>','服务端端口（默认：10000）')
+      .option('--local_port <local_port>','内网被转发的端口（默认：80）')
+      .action(client);
+  program
+      .command('server')
+      .action(server);
+  // 对未知命令进行监听
+  program.on('command:*',function(obj){
+      const availableCommands=program.commands.map(cmd=>cmd.name())
+      console.log(colors.red("未知命令："+obj[0]));
+      if(availableCommands.length>0){
+          console.log(colors.red("可用命令："+availableCommands.join(",")));
+      }
+  })
+  // 解析参数
+  program.parse(process.argv)
+  if(program.args&&program.args.length<1){
+      program.outputHelp()
+  }
+}

package/lib/server.js

@@ -0,0 +1,128 @@
+const net = require('net');
+const log=require('npmlog');
+const envConfig=require('../config.server')
+// 配置
+const CONFIG = {
+    server_addr: "0.0.0.0",//服务端地址 一般是0.0.0.0或127.0.0.1
+    server_port: 10000,//服务端端口
+    token: "aksda@$@#kjsk",//连接令牌
+    ...envConfig
+};
+
+// 客户端链接集
+let linkClients = {};
+// 客户端绑定的应用
+let clientBings = {};
+// 连接记录
+let socketRecords = {};
+// 删除相关信息
+const removeInfo = function (id) {
+    if (linkClients[id]) {
+        linkClients[id] = null;
+        delete linkClients[id];
+    }
+    for (let k in clientBings) {
+        let d = clientBings[k];
+        if (id == d.linkId) {
+            d.forwardServer.close();
+            clientBings[k] = null;
+            delete clientBings[k];
+        }
+    }
+};
+// 端口转发服务 用于开放访问
+function createForwardServer(conf) {
+    let forwardServer = net.createServer((socket) => {
+        // 判断客户是否在线
+        if (!linkClients[conf.linkId]) return socket.end();
+        let id = [socket.remoteAddress, socket.remoteFamily, socket.remotePort].join("_");
+        if (!socketRecords[id]) socketRecords[id] = { bind: socket };
+        // 发送需要数据 告诉客户端 开启新的连接用于访问
+        conf.linkSocket.write(JSON.stringify({ key: id, name: conf.name, code: conf.code }));
+        socket.on('error', () => {
+            socket.end();
+        });
+        socket.on('end', () => {
+            if (socketRecords[id]) {
+                if (socketRecords[id].bind) socketRecords[id].client.end();
+                if (socketRecords[id].client) socketRecords[id].bind.end();
+                delete socketRecords[id];
+            }
+        })
+    });
+    forwardServer.listen(conf.remote_port, () => {
+        console.log(`[${(new Date()).toLocaleString()}] [${conf.name}] 转发服务开启  ${conf.local_port}<===>${conf.remote_port}`);
+    });
+    return forwardServer;
+}
+// 远程监听访问 用于穿透
+const listenServer = net.createServer((socket) => {
+    let id = [socket.remoteAddress, socket.remoteFamily, socket.remotePort].join("_");
+    console.log(`[${(new Date()).toLocaleString()}] ${socket.remoteAddress}:${socket.remotePort} 上线...`);
+    if (!linkClients[id]) {
+        // 保存连接
+        linkClients[id] = socket;
+        socket.on('data', (data) => {
+            try {
+                try {
+                    data = JSON.parse(data);
+                } catch (error) {
+                    return;
+                }
+                let [token, type, code, binds] = [data.token, data.type, data.code, data.binds];
+                if (token != token) return socket.end();
+                if (type == 'register') {// 客户端注册
+                    for (let k in binds) {
+                        let d = binds[k];
+                        if (!clientBings[k]) {
+                            [d.code, d.name, d.linkSocket, d.linkId] = [data.code, k, socket, id];
+                            d.forwardServer = createForwardServer(d);//绑定客户端App对应服务端开放的端口服务
+                            clientBings[k] = d;
+                        }
+                    }
+                    return socket.write(JSON.stringify({ code: code, type: type, id: id }));
+                } else if (type == 'connect') {// 客户端连接
+                    let id = data.key;
+                    let socketRecord = socketRecords[id];
+                    if (socketRecord && socketRecord.bind && !socketRecord.client) {
+                        socket.firstConnection = false;
+                        socketRecord.client = socket;//设置 客户端连接soket
+                        // 数据转发
+                        socket.pipe(socketRecord.bind);
+                        socketRecord.bind.pipe(socket);
+                        socketRecord.bind.on('end', () => {
+                            socket.end();
+                        });
+                        socketRecord.bind.on('error', (err) => {
+                            socket.end();
+                        });
+                        return;
+                    }
+                }
+            } catch (error) {
+                //
+                removeInfo(id);
+            }
+            socket.end();
+        });
+        socket.on('error', (err) => {
+            //
+            removeInfo(id);
+        })
+        socket.on('end', (data) => {
+            removeInfo(id);
+        });
+    }
+});
+function listenServe(cmdObj){
+    if(cmdObj){
+        CONFIG.server_addr=cmdObj.server_addr||CONFIG.server_addr;
+        CONFIG.server_port=cmdObj.server_port||CONFIG.server_port;
+        CONFIG.token=cmdObj.token||CONFIG.token;
+    }
+    log.info('服务端配置文件：',JSON.stringify(CONFIG,null,2))
+    // 启动服务端监听
+    listenServer.listen(CONFIG.server_port, CONFIG.server_addr);
+}
+
+module.exports=listenServe;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@nwct/demo",
+  "version": "1.0.0",
+  "description": "Internal network penetration, mapping external network",
+  "main": "bin/index.js",
+  "bin": {
+    "demo": "bin/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node bin/index.js client",
+    "client": "node bin/index.js client",
+    "server": "node bin/index.js server"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/code-ba/mapping-net.git"
+  },
+  "keywords": [
+    "network",
+    "mapping"
+  ],
+  "author": "Baran",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/code-ba/mapping-net/issues"
+  },
+  "homepage": "https://github.com/code-ba/mapping-net#readme",
+  "dependencies": {
+    "colors": "^1.4.0",
+    "commander": "^8.0.0",
+    "import-local": "^3.0.2",
+    "npmlog": "^4.1.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}