wire-vpn 1.0.0 → 1.0.1

package/binding.gyp

@@ -0,0 +1,32 @@
+{
+  "targets": [
+    {
+      "target_name": "wirevpn",
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      "sources": [
+        "src/addon/vpn.cc"
+      ],
+      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
+      "libraries": [
+        "-lsodium"
+      ],
+      "conditions": [
+        ["OS=='linux'", {
+          "libraries": ["-lsodium"]
+        }],
+        ["OS=='mac'", {
+          "xcode_settings": {
+            "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+            "CLANG_CXX_LIBRARY": "libc++",
+            "MACOSX_DEPLOYMENT_TARGET": "10.15"
+          },
+          "libraries": ["-lsodium"]
+        }]
+      ]
+    }
+  ]
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = os.homedir() + '/.vpn';
+const CONFIG_FILE = CONFIG_DIR + '/config.json';
+const KEY_FILE = CONFIG_DIR + '/keys.json';
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+        }
+    }
+    catch (e) { }
+    return null;
+}
+let activeConnection = null;
+commander_1.program
+    .name('vpn')
+    .description('Native VPN CLI')
+    .version('1.0.0');
+commander_1.program
+    .command('init')
+    .alias('i')
+    .description('Generate new private and public keys')
+    .action(async () => {
+    ensureConfigDir();
+    const nativeModule = require('../build/Release/wirevpn.node');
+    const crypto = new nativeModule.CryptoEngine();
+    const keypair = crypto.generateKeypair();
+    const keys = {
+        privateKey: keypair.privateKey.toString('hex'),
+        publicKey: keypair.publicKey.toString('hex'),
+        createdAt: new Date().toISOString()
+    };
+    fs.writeFileSync(KEY_FILE, JSON.stringify(keys, null, 2));
+    console.log('Keys generated successfully!');
+    console.log(`Public Key: ${keys.publicKey}`);
+    console.log(`Private Key saved to: ${KEY_FILE}`);
+});
+commander_1.program
+    .command('up <config>')
+    .alias('u')
+    .description('Start VPN connection')
+    .option('-d, --debug', 'Enable debug mode')
+    .action(async (configPath, options) => {
+    let config;
+    if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    else {
+        const saved = loadConfig();
+        if (saved) {
+            config = saved;
+        }
+        else {
+            console.error(`Config file not found: ${configPath}`);
+            process.exit(1);
+        }
+    }
+    if (fs.existsSync(KEY_FILE)) {
+        const keys = JSON.parse(fs.readFileSync(KEY_FILE, 'utf-8'));
+        config.privateKey = keys.privateKey;
+        config.publicKey = keys.publicKey;
+    }
+    const { VPNConnection } = require('./lib/vpn');
+    activeConnection = new VPNConnection(config, options.debug || false);
+    try {
+        await activeConnection.init();
+        await activeConnection.up();
+        console.log('\nVPN is running. Press Ctrl+C to stop.\n');
+        const statusInterval = setInterval(() => {
+            if (activeConnection) {
+                const stats = activeConnection.getStatus();
+                const peerList = activeConnection.getPeers();
+                process.stdout.write(`\rActive: ${peerList.length} peers | `);
+                for (const [key, stat] of Object.entries(stats)) {
+                    const s = stat;
+                    process.stdout.write(`TX: ${(s.txBytes / 1024).toFixed(1)}KB RX: ${(s.rxBytes / 1024).toFixed(1)}KB `);
+                }
+            }
+        }, 1000);
+        process.on('SIGINT', async () => {
+            clearInterval(statusInterval);
+            if (activeConnection) {
+                await activeConnection.down();
+            }
+            console.log('\nVPN stopped.');
+            process.exit(0);
+        });
+    }
+    catch (err) {
+        console.error(`Failed to start VPN: ${err.message}`);
+        process.exit(1);
+    }
+});
+commander_1.program
+    .command('down')
+    .alias('d')
+    .description('Stop VPN connection')
+    .action(async () => {
+    if (activeConnection) {
+        await activeConnection.down();
+        activeConnection = null;
+        console.log('VPN connection closed');
+    }
+    else {
+        console.log('No active VPN connection found');
+    }
+});
+commander_1.program
+    .command('status')
+    .alias('s')
+    .description('Display statistics')
+    .action(() => {
+    if (!activeConnection) {
+        console.log('VPN is not running. Use "vpn up" first.');
+        return;
+    }
+    const stats = activeConnection.getStatus();
+    if (Object.keys(stats).length === 0) {
+        console.log('No active peers');
+        return;
+    }
+    console.log('Peer Statistics:');
+    for (const [peer, stat] of Object.entries(stats)) {
+        const s = stat;
+        console.log(`  ${peer.substring(0, 16)}...`);
+        console.log(`    TX: ${(s.txBytes / 1024).toFixed(2)} KB (${s.txPackets} packets)`);
+        console.log(`    RX: ${(s.rxBytes / 1024).toFixed(2)} KB (${s.rxPackets} packets)`);
+        console.log(`    Endpoint: ${s.endpoint}`);
+        console.log(`    Last seen: ${s.lastSeen}s ago\n`);
+    }
+});
+commander_1.program
+    .command('list')
+    .alias('l')
+    .description('List connected peers')
+    .action(() => {
+    if (!activeConnection) {
+        console.log('VPN is not running. Use "vpn up" first.');
+        return;
+    }
+    const peers = activeConnection.getPeers();
+    if (peers.length === 0) {
+        console.log('No peers connected');
+    }
+    else {
+        console.log(`Connected peers (${peers.length}):`);
+        peers.forEach((peer, idx) => {
+            console.log(`  ${idx + 1}. ${peer.substring(0, 16)}...`);
+        });
+    }
+});
+commander_1.program.parse();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { VPNConnection, VPNConfig, VPNPeer } from './lib/vpn';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VPNConnection = void 0;
+var vpn_1 = require("./lib/vpn");
+Object.defineProperty(exports, "VPNConnection", { enumerable: true, get: function () { return vpn_1.VPNConnection; } });

package/dist/lib/vpn.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from 'events';
+export interface VPNPeer {
+    publicKey: string;
+    endpoint: string;
+    allowedIPs: string[];
+}
+export interface VPNConfig {
+    privateKey?: string;
+    publicKey?: string;
+    address: string;
+    port: number;
+    peers: VPNPeer[];
+    mtu?: number;
+}
+export declare class VPNConnection extends EventEmitter {
+    private tun;
+    private crypto;
+    private stats;
+    private running;
+    private debugMode;
+    private udpSocket;
+    private config;
+    private peerMap;
+    private readInterval;
+    constructor(config: VPNConfig, debug?: boolean);
+    init(): Promise<void>;
+    up(): Promise<void>;
+    down(): Promise<void>;
+    getStatus(): any;
+    getPeers(): string[];
+    private getPeerKey;
+}

package/dist/lib/vpn.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VPNConnection = void 0;
+const events_1 = require("events");
+const dgram = __importStar(require("dgram"));
+const nativeModule = require('../../build/Release/wirevpn.node');
+class VPNConnection extends events_1.EventEmitter {
+    constructor(config, debug = false) {
+        super();
+        this.running = false;
+        this.debugMode = false;
+        this.readInterval = null;
+        this.config = config;
+        this.debugMode = debug;
+        this.tun = new nativeModule.TunDevice();
+        this.crypto = new nativeModule.CryptoEngine();
+        this.stats = nativeModule.StatsCollector;
+        this.peerMap = new Map();
+        this.udpSocket = null;
+    }
+    async init() {
+        let privateKey = this.config.privateKey;
+        if (!privateKey) {
+            const keypair = this.crypto.generateKeypair();
+            privateKey = keypair.privateKey.toString('hex');
+            this.config.privateKey = privateKey;
+            this.config.publicKey = keypair.publicKey.toString('hex');
+            console.log(`Generated new keypair - Public: ${this.config.publicKey}`);
+        }
+        else {
+            this.crypto.setPrivateKey(Buffer.from(privateKey, 'hex'));
+        }
+        for (const peer of this.config.peers) {
+            this.crypto.setPeerPublicKey(Buffer.from(peer.publicKey, 'hex'));
+            this.peerMap.set(peer.publicKey, peer);
+        }
+    }
+    async up() {
+        const tunFd = this.tun.open();
+        if (tunFd < 0) {
+            throw new Error('Failed to open TUN device');
+        }
+        this.tun.configure(this.config.address, this.config.mtu || 1500);
+        this.udpSocket = dgram.createSocket('udp4');
+        await new Promise((resolve) => {
+            this.udpSocket.bind(this.config.port, () => resolve());
+        });
+        this.running = true;
+        this.udpSocket.on('message', (data, rinfo) => {
+            const decrypted = this.crypto.decrypt(data);
+            if (decrypted && decrypted.length > 0) {
+                const peerKey = this.getPeerKey(rinfo.address, rinfo.port);
+                if (this.stats && this.stats.recordRx) {
+                    this.stats.recordRx(peerKey, decrypted.length, `${rinfo.address}:${rinfo.port}`);
+                }
+                this.tun.write(decrypted);
+            }
+        });
+        this.readInterval = setInterval(() => {
+            if (!this.running)
+                return;
+            const packet = this.tun.read();
+            if (packet && packet.length > 0) {
+                if (this.debugMode) {
+                    const hexdump = this.tun.getHexDump(packet);
+                    console.log(`[DEBUG] TUN packet (${packet.length} bytes):\n${hexdump}`);
+                }
+                const encrypted = this.crypto.encrypt(packet);
+                if (encrypted && encrypted.length > 0) {
+                    for (const peer of this.peerMap.values()) {
+                        const [host, port] = peer.endpoint.split(':');
+                        this.udpSocket.send(encrypted, parseInt(port), host);
+                        if (this.stats && this.stats.recordTx) {
+                            this.stats.recordTx(peer.publicKey, encrypted.length, peer.endpoint);
+                        }
+                    }
+                }
+            }
+        }, 10);
+        console.log(`VPN UP - Interface: ${this.tun.name}, IP: ${this.config.address}, Port: ${this.config.port}`);
+    }
+    async down() {
+        this.running = false;
+        if (this.readInterval) {
+            clearInterval(this.readInterval);
+            this.readInterval = null;
+        }
+        if (this.udpSocket) {
+            this.udpSocket.close();
+            this.udpSocket = null;
+        }
+        this.tun.close();
+        console.log('VPN DOWN - Interface closed');
+    }
+    getStatus() {
+        if (this.stats && this.stats.getStats) {
+            return this.stats.getStats();
+        }
+        return {};
+    }
+    getPeers() {
+        if (this.stats && this.stats.getAllPeers) {
+            return this.stats.getAllPeers();
+        }
+        return [];
+    }
+    getPeerKey(ip, port) {
+        for (const [key, peer] of this.peerMap.entries()) {
+            if (peer.endpoint === `${ip}:${port}`) {
+                return key;
+            }
+        }
+        return `${ip}:${port}`;
+    }
+}
+exports.VPNConnection = VPNConnection;

package/package/binding.gyp

@@ -0,0 +1,32 @@
+{
+  "targets": [
+    {
+      "target_name": "wirevpn",
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      "sources": [
+        "src/addon/vpn.cc"
+      ],
+      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
+      "libraries": [
+        "-lsodium"
+      ],
+      "conditions": [
+        ["OS=='linux'", {
+          "libraries": ["-lsodium"]
+        }],
+        ["OS=='mac'", {
+          "xcode_settings": {
+            "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+            "CLANG_CXX_LIBRARY": "libc++",
+            "MACOSX_DEPLOYMENT_TARGET": "10.15"
+          },
+          "libraries": ["-lsodium"]
+        }]
+      ]
+    }
+  ]
+}