added filter

Author: CoNETProject

package.json

@@ -1,7 +1,7 @@
 {
     "name": "@conet.project/conet-proxy",
 
-    "version": "0.12.1",
+    "version": "0.12.2",
 
     "license": "UNLICENSED",
     "files": [

src/localServer/define.d.ts

@@ -693,7 +693,7 @@ interface requestObj {
 interface VE_IPptpStream {
     type?: string
     buffer: string
-    host: string|null
+    host: string
     port: number
     cmd: string
     //ATYP: number
@@ -868,4 +868,9 @@ interface assetPrice {
 interface assetOracle {
 	lastUpdate: number
 	assets: assetPrice[]
+}
+
+type filterRule = {
+    DOMAIN: string[]
+    IP: string[]
 }

src/localServer/localGateway.ts

@@ -63,4 +63,5 @@ start()
 //			curl -v -x http://127.0.0.1:8888 "https://www.google.com"
 //          curl -v -x socks4a://localhost:8888 "https://www.google.com"
 //          curl -v -x socks4://localhost:8888 "https://www.google.com"
-//          curl -v -x socks5h://localhost:8888 "https://www.google.com"
+//          curl -v -x socks5h://localhost:8888 "https://www.google.com"
+//          curl -v -x socks5h://localhost:3002 "https://www.google.com"

src/localServer/localServer.ts

@@ -210,6 +210,11 @@ type Native_StartVPNObj = {
 	exitNode: nodes_info[]
 }
 
+type filterRule = {
+    DOMAIN: string[]
+    IP: string[]
+}
+
 const appsPath: string = join ( __dirname )
 export class Daemon {
     private logsPool: proxyLogs[] = []
@@ -266,7 +271,21 @@ export class Daemon {
             return this.initialize ()
         })
 
+        app.post ( '/rule', ( req: any, res: any ) => {
+            const vpnObj = req.body.data
+            try {
+                const data: filterRule = JSON.parse(vpnObj)
+                logger(inspect(data, false, 3, true))
+            if (_proxyServer) {
+                _proxyServer.rule(data)
+            }
+            } catch (ex) {
+                logger(`/rule JSON.parse(vpnObj) Error`)
+            }
 
+            
+            return res.end()
+        })
 
         app.post ( '/postMessage', ( req: any, res: any ) => {
             const post_data: postData = req.body

src/localServer/proxyServer.ts

@@ -16,6 +16,7 @@ import { ethers } from 'ethers'
 import * as Crypto from 'crypto'
 import IP from 'ip'
 import {resolve4} from 'node:dns'
+import OS from 'node:os'
 import {createConnection} from 'node:net'
 
 const _HTTP_200 = ( body: string ) => {
@@ -27,6 +28,11 @@ const _HTTP_200 = ( body: string ) => {
 	return ret
 }
 
+type filterRule = {
+    DOMAIN: string[]
+    IP: string[]
+}
+
 const _HTTP_200V2 = `HTTP/1.1 200 Connection Established\r\n\r\n`
 
 
@@ -46,6 +52,8 @@ const getHostIpv4: (host: string) => Promise<string> = (host: string) => new Pro
 })
 
 
+
+
 const httpProxy = ( clientSocket: Net.Socket, _buffer: Buffer, agent: string, proxyServer: proxyServer) => {
 	const httpHead = new HttpProxyHeader ( _buffer )
 	const hostName = httpHead.host
@@ -280,6 +288,66 @@ const ConnectToProxyNode = (cmd : SICommandObj, SaaSnode: nodes_info, entryNode:
 
 }
 
+const isLocalhost = (hostname) => {
+    if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1') {
+        return true
+    }
+    try {
+        const hostIP = require('dns').lookupSync(hostname)
+        const networkInterfaces = OS.networkInterfaces()
+        const isPublic = IP.isPublic(hostIP)
+
+        if (!isPublic) {
+            return true
+        }
+        for (const name of Object.keys(networkInterfaces)) {
+            if (!networkInterfaces[name]) {
+                continue
+            }
+
+            for (const net of networkInterfaces[name]) {
+                if (net.address === hostIP) {
+                    return true
+                }
+            }
+        }
+        return false
+    } catch (error) {
+        return false
+    }
+}
+
+
+const ConnectViaLocal = (uuuu : VE_IPptpStream, resoestSocket: Net.Socket ) => {
+    const port = uuuu.port
+	const host = uuuu.host
+    
+    const socket = createConnection ( port, host, () => {
+
+        socket.pipe(resoestSocket).pipe(socket)
+        
+        const data = Buffer.from(uuuu.buffer, 'base64')
+        if (data) {
+            socket.write (data)
+        }
+        
+        resoestSocket.resume()
+    })
+
+    socket.once ( 'end', () => {
+        // logger (Colors.red(`socks5Connect host [${host}:${port}] on END!`))
+        resoestSocket.end().destroy()
+    })
+
+    socket.on ( 'error', err => {
+        resoestSocket.end().destroy()
+        logger (Colors.red(`socks5Connect [${host}:${port}] on Error! [${err.message}]`))
+    })
+    
+    
+
+
+}
 
 export class proxyServer {
 
@@ -294,6 +362,7 @@ export class proxyServer {
 	public useGatWay = true
 	public clientSockets: Set<Net.Socket> = new Set()
 	public currentWallet: ethers.Wallet
+    public ruleData: filterRule|null = null
 
 	private startLocalProxy = async () => {
 
@@ -363,8 +432,62 @@ export class proxyServer {
 
 	}
 
+    private checkRule = (host: string) => {
+        
+        const isIpAddress = IP.isV4Format(host)
+        
+        if (isIpAddress) {
+            const isPublic = IP.isPublic(host)
+
+            if (!isPublic) {
+                return true
+            }
+
+            if (!this.ruleData) {
+                return false
+            }
+
+            const index = this.ruleData.IP.findIndex(n => IP.cidrSubnet(n).contains(host))
+            if (index > -1) {
+                return false
+            }
+
+            return true
+        }
+
+        const isLocal = isLocalhost (host)
+        if (isLocal) {
+            return true
+        }
+
+        if (!this.ruleData) {
+            return false
+        }
+        const hostName = host.toLowerCase()
+        const index = this.ruleData.DOMAIN.findIndex(n => {
+            const splitN = n.split('.').filter(n => n.length)
+            const regExpData = splitN.join('\.')
+            const regionRule = new RegExp(`(^|\\.)${regExpData}$`)
+            return regionRule.test(hostName)
+        })
+        
+        if (index > -1 ) {
+            return true
+        }
+
+        return false
+    }
+
+
 	public requestGetWay = async (uuuu : VE_IPptpStream, socket: Net.Socket ) => {
 
+
+        if (this.checkRule(uuuu.host)) {
+            logger(`Direct to connect ${uuuu.host}:${uuuu.port} Server!`)
+            return ConnectViaLocal(uuuu, socket)
+        }
+        logger(`package ${uuuu.host}:${uuuu.port} to Layer Minus Protocol!`)
+        
 		const upChannel_SaaS_node  = getRandomSaaSNode(this._egressNodes)
 
 
@@ -424,6 +547,11 @@ export class proxyServer {
 
 		}
 	})
+
+    public rule = (_rule: filterRule) => {
+        _rule.DOMAIN = _rule.DOMAIN.map(n=> n.toLowerCase())
+        this.ruleData = _rule
+    }
 }
 
 //		curl -v -x http://127.0.0.1:3002 "https://www.google.com"

src/localServer/socks.ts

@@ -101,12 +101,17 @@ export class socks5 {
 			}
 		}
 
-
+        
 
 		//		PAYMENT REQUIRE
 
 
 		this.socket.once ( 'data', ( _data: Buffer ) => {
+            
+            if (!req.host) {
+                return this.stopConnection(req)
+            }
+
 			const uuuu : VE_IPptpStream = {
 				uuid: this.uuid,
 				host: req.host,
@@ -116,6 +121,8 @@ export class socks5 {
 				ssl: isSslFromBuffer (_data),
 				order: 0
 			}
+
+
 
 			return this.proxyServer.requestGetWay ( uuuu, this.socket )
 		})

src/localServer/workers/electron/index.html

@@ -10,8 +10,8 @@
     <link rel="apple-touch-icon" href="/logo192.png" />
     <link rel="manifest" href="/manifest.json" />
     <title>Silent Pass</title>
-    <script defer="defer" src="/static/js/main.f47ca665.js"></script>
-    <link href="/static/css/main.18155f27.css" rel="stylesheet">
+    <script defer="defer" src="/static/js/main.74dc99d2.js"></script>
+    <link href="/static/css/main.db965d91.css" rel="stylesheet">
 </head>
 
 <body><noscript>You need to enable JavaScript to run this app.</noscript>