fazer-lang 3.2.1 → 3.3.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [3.2.1] - 2026-01-25
+
+### Added
+- **Cross-Platform**: Added `install_system.sh` for easy installation on Linux and macOS.
+- **Build System**: Updated `fazer build` to support Linux/Mac targets (generates portable bash launcher).
+- **Examples**: Added `VoidNet.fz`, a stylish TCP console application with ASCII art.
+
+### Changed
+- **Documentation**: Updated `README.md` and `docs/GUIDE.md` with cross-platform installation instructions.
+
 ## [3.2.0] - 2026-01-24
 
 ### Added

package/README.md

@@ -46,6 +46,23 @@ fazer scan google.com
 fazer whois microsoft.com
 ```
 
+## Cryptage / Protection de Code
+
+Pour distribuer un script sans révéler son code source (obfuscation/cryptage) :
+
+```bash
+fazer compile mon_script.fz
+```
+
+Cela génère un fichier `mon_script.fzc` (Fazer Compiled/Crypted).
+Ce fichier est chiffré (AES-256) mais peut être exécuté directement par n'importe quel interpréteur Fazer :
+
+```bash
+fazer mon_script.fzc
+```
+
+Cela permet de partager des outils "privés" tout en gardant la portabilité du fichier.
+
 ## Création d'Exécutable (.exe / Binaire)
 
 Transformez vos scripts Fazer en applications portables et natives :

package/docs/GUIDE.md

@@ -28,7 +28,13 @@ Fazer est un langage de programmation moderne, simple et puissant. Il est "batte
 
 ### Installation
 1.  **Téléchargez** le dossier `fazer-lang`.
-2.  **Exécutez** le script `install_system.ps1` (double-clic).
+2.  **Installation** :
+    *   **Windows** : Exécutez `install_system.ps1` (double-clic).
+    *   **Linux / Mac** : Ouvrez un terminal et lancez :
+        ```bash
+        chmod +x install_system.sh
+        ./install_system.sh
+        ```
 3.  C'est tout ! Ouvrez un terminal et tapez `fazer` pour vérifier.
 
 ### Votre Premier Script ("Hello World")

package/fazer.js

@@ -2,7 +2,7 @@
 "use strict";
 
 /*
-  Fazer v2 — interpreter "batteries included"
+  Fazer v3.3.1 — interpreter "batteries included"
   - Chevrotain lexer/parser → AST
   - Runtime with scopes, functions, pipes, lists/maps, property/index access
   - Stdlib: fs/path/crypto/encoding/ui
@@ -4962,6 +4962,20 @@ const ASCII_FONTS = {
 
       // [GFX] Native Game & App Engine (No HTML required)
       Math: Math,
+
+      // [STR] String Manipulation
+      str_split: (s, sep) => String(s).split(sep),
+      str_sub: (s, start, end) => String(s).substring(start, end),
+      str_replace: (s, a, b) => String(s).split(a).join(b),
+      str_trim: (s) => String(s).trim(),
+      str_len: (s) => String(s).length,
+      str_lower: (s) => String(s).toLowerCase(),
+      str_upper: (s) => String(s).toUpperCase(),
+      str_contains: (s, sub) => String(s).includes(sub),
+      str_starts: (s, sub) => String(s).startsWith(sub),
+      str_ends: (s, sub) => String(s).endsWith(sub),
+      str_index: (s, sub) => String(s).indexOf(sub),
+
       gfx: {
           _width: 800,
           _height: 600,
@@ -5368,8 +5382,23 @@ const ASCII_FONTS = {
 
             queue.forEach(cmd => {
                 if (cmd.op === 'clear') {
-                    // Parse hex color if needed, for now just black/grey
-                    gl.clearColor(0.1, 0.1, 0.1, 1.0);
+                    // Parse hex color or object
+                    let r = 0.1, g = 0.1, b = 0.1;
+                    if (cmd.color) {
+                        if (typeof cmd.color === 'string') {
+                            if (cmd.color.startsWith('#')) {
+                                const hex = cmd.color.substring(1);
+                                r = parseInt(hex.substring(0,2), 16)/255;
+                                g = parseInt(hex.substring(2,4), 16)/255;
+                                b = parseInt(hex.substring(4,6), 16)/255;
+                            }
+                        } else if (typeof cmd.color === 'object') {
+                            r = cmd.color.r !== undefined ? cmd.color.r : 0.1;
+                            g = cmd.color.g !== undefined ? cmd.color.g : 0.1;
+                            b = cmd.color.b !== undefined ? cmd.color.b : 0.1;
+                        }
+                    }
+                    gl.clearColor(r, g, b, 1.0);
                     gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
                     
                     // Clear Overlay
@@ -5378,6 +5407,24 @@ const ASCII_FONTS = {
                     // Update Matrices
                     Mat4.perspective(state.P, 45 * Math.PI / 180, canvas.width/canvas.height, 0.1, 1000.0);
                 }
+                else if (cmd.op === 'rect') {
+                     ctx.fillStyle = cmd.color;
+                     ctx.fillRect(cmd.x, cmd.y, cmd.w, cmd.h);
+                }
+                else if (cmd.op === 'circle') {
+                     ctx.beginPath();
+                     ctx.arc(cmd.x, cmd.y, cmd.r, 0, Math.PI * 2);
+                     ctx.fillStyle = cmd.color;
+                     ctx.fill();
+                }
+                else if (cmd.op === 'line') {
+                     ctx.beginPath();
+                     ctx.moveTo(cmd.x1, cmd.y1);
+                     ctx.lineTo(cmd.x2, cmd.y2);
+                     ctx.strokeStyle = cmd.color;
+                     ctx.lineWidth = cmd.width || 1;
+                     ctx.stroke();
+                }
                 else if (cmd.op === 'text') {
                     ctx.font = (cmd.size || 20) + 'px monospace';
                     ctx.fillStyle = cmd.color || 'white';
@@ -5536,10 +5583,7 @@ Add-Type -TypeDefinition $code -Language CCSharp
           },
           
           // Process Manipulation
-          kill: (pid) => {
-              try { process.kill(Number(pid)); return true; } catch(e) { return false; }
-          },
-
+          
           // Administrator Check
           is_admin: () => {
               try {
@@ -5551,147 +5595,33 @@ Add-Type -TypeDefinition $code -Language CCSharp
 
       // [NET] Advanced Network Operations
       net: {
-          // Socket Connect / Port Scan
-          connect: async (host, port, timeout=2000) => {
-             return new Promise(resolve => {
-                 const socket = new (require("net").Socket)();
-                 socket.setTimeout(Number(timeout));
-                 socket.on('connect', () => { socket.destroy(); resolve(true); });
-                 socket.on('timeout', () => { socket.destroy(); resolve(false); });
-                 socket.on('error', (e) => { socket.destroy(); resolve(false); });
-                 socket.connect(Number(port), String(host));
-             });
-          },
-          
-          // Get Public IP (External)
-          public_ip: async () => {
-              try {
-                  const res = await builtins.fetch("https://api.ipify.org");
-                  return res.body;
-              } catch(e) { return "0.0.0.0"; }
-          },
-          
-          // DNS Lookup
-          dns: async (domain) => {
-             const dns = require("dns").promises;
-             try { return await dns.resolve(String(domain)); } catch(e) { return []; }
-          },
-          
-          // Network Interfaces
-          interfaces: () => require("os").networkInterfaces()
-      },
-
-      // [OSINT] Open Source Intelligence Tools
-      osint: {
-          // Whois Query
-          whois: async (domain) => {
-              return new Promise(resolve => {
-                  const client = require("net").createConnection(43, "whois.iana.org", () => {
-                      client.write(domain + "\r\n");
-                  });
-                  let data = "";
-                  client.on("data", (chunk) => data += chunk);
-                  client.on("end", () => resolve(data));
-                  client.on("error", (err) => resolve("Error: " + err.message));
+          // TCP Listener
+          listen: (port, on_connect) => {
+              const net = require("net");
+              const server = net.createServer(async (socket) => {
+                  const client = {
+                      ip: socket.remoteAddress,
+                      send: (d) => { try { socket.write(String(d)); return true; } catch(e){ return false; } },
+                      close: () => socket.destroy(),
+                      on_data: (fn) => {
+                          socket.on('data', async (d) => {
+                              if (fn && fn.__fnref__) await this._call(fn, [d.toString()], this.global);
+                          });
+                      }
+                  };
+                  if (on_connect && on_connect.__fnref__) {
+                      await this._call(on_connect, [client], this.global);
+                  }
               });
+              
+              server.on('error', (e) => console.error("Net Error:", e.message));
+              server.listen(Number(port));
+              
+              return {
+                  close: () => server.close()
+              };
           },
-          
-          // Google Dorking Helper (Generates URL)
-          dork_url: (query) => {
-              return "https://www.google.com/search?q=" + encodeURIComponent(String(query));
-          },
-          
-          // User Agent Generator
-          ua: () => {
-              const agents = [
-                  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
-                  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15",
-                  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36"
-              ];
-              return agents[Math.floor(Math.random() * agents.length)];
-          }
-      },
-
-
-      // ──────────────────────────────────────────────────────────────────────────
-      // FAZER SECURITY & INNOVATION SUITE (v3.0)
-      // ──────────────────────────────────────────────────────────────────────────
-
-      // [SYS] System & DLL Manipulation
-      sys: {
-          // PowerShell Bridge (The Core)
-          ps: (script) => {
-              try {
-                  const cmd = `powershell -NoProfile -ExecutionPolicy Bypass -Command "& { ${String(script).replace(/"/g, '\"')} }"`;
-                  return require("child_process").execSync(cmd, { encoding: 'utf8', maxBuffer: 1024*1024*50 }).trim();
-              } catch(e) { return "Error: " + e.message; }
-          },
-          
-          ps_json: (script) => {
-             try {
-                 const s = String(script).replace(/"/g, '\"');
-                 const cmd = `powershell -NoProfile -ExecutionPolicy Bypass -Command "& { ${s} } | ConvertTo-Json -Depth 2 -Compress"`;
-                 const out = require("child_process").execSync(cmd, { encoding: 'utf8', maxBuffer: 1024*1024*50 }).trim();
-                 return JSON.parse(out);
-             } catch(e) { return null; }
-          },
-
-          // DLL / Assembly Loading & Execution
-          dll_load: (path) => {
-              // Loads a DLL into the current PS session context (simulated via static calls for now)
-              // Since each sys.ps call is a new process, we need a way to persist or use a single session.
-              // For now, we provide a helper to generate the loading script snippet.
-              return `[System.Reflection.Assembly]::LoadFrom("${String(path).replace(/\\/g, '\\\\')}");`;
-          },
-          
-          // Native Memory Forensic (Read Process Memory)
-          mem_dump: (pid, outputFile) => {
-              // Uses MiniDumpWriteDump via P/Invoke in PowerShell
-              const ps = `
-$code = @"
-using System;
-using System.Runtime.InteropServices;
-using System.Diagnostics;
-using System.IO;
-
-public class MiniDump {
-    [DllImport("dbghelp.dll", EntryPoint = "MiniDumpWriteDump", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
-    public static extern bool MiniDumpWriteDump(IntPtr hProcess, uint processId, SafeHandle hFile, uint dumpType, IntPtr exceptionParam, IntPtr userStreamParam, IntPtr callbackParam);
-
-    public static void Dump(int pid, string filename) {
-        Process target = Process.GetProcessById(pid);
-        using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.ReadWrite, FileShare.Write)) {
-            MiniDumpWriteDump(target.Handle, (uint)target.Id, fs.SafeFileHandle, 2, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
-        }
-    }
-}
-"@
-Add-Type -TypeDefinition $code -Language CCSharp
-[MiniDump]::Dump(${Number(pid)}, "${String(outputFile)}")
-"Done"
-`;
-              try {
-                  require("child_process").execSync(`powershell -NoProfile -Command "${ps.replace(/"/g, '\"')}"`);
-                  return true;
-              } catch(e) { return false; }
-          },
-          
-          // Administrator Check
-          is_admin: () => {
-              try {
-                  const out = require("child_process").execSync('powershell -Command "([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)"', { encoding: 'utf8' }).trim();
-                  return out === "True";
-              } catch(e) { return false; }
-          },
-          
-          // System Info
-          pid: () => process.pid,
-          arch: () => process.arch,
-          platform: () => process.platform,
-      },
 
-      // [NET] Advanced Network Operations
-      net: {
           // Socket Connect / Port Scan
           connect: async (host, port, timeout=2000) => {
              return new Promise(resolve => {
@@ -5703,6 +5633,31 @@ Add-Type -TypeDefinition $code -Language CCSharp
                  socket.connect(Number(port), String(host));
              });
           },
+
+          // Persistent TCP Client (Reverse Shell / C2)
+          tcp_connect: (host, port, on_connect) => {
+              const net = require("net");
+              const socket = new net.Socket();
+              
+              const client = {
+                  send: (d) => { try { socket.write(String(d)); return true; } catch(e){ return false; } },
+                  close: () => socket.destroy(),
+                  on_data: (fn) => {
+                       socket.on('data', async (d) => {
+                           if (fn && fn.__fnref__) await this._call(fn, [d.toString()], this.global);
+                       });
+                  }
+              };
+              
+              socket.connect(Number(port), String(host), async () => {
+                  if (on_connect && on_connect.__fnref__) {
+                      await this._call(on_connect, [client], this.global);
+                  }
+              });
+              
+              socket.on('error', (e) => console.error("TCP Client Error:", e.message));
+              return client;
+          },
           
           // Get Public IP (External)
           public_ip: async () => {
@@ -5753,12 +5708,17 @@ Add-Type -TypeDefinition $code -Language CCSharp
           }
       },
 
+
+
+
       fs: {
           read: (path) => { try { return require('fs').readFileSync(String(path), 'utf8'); } catch(e) { return null; } },
           write: (path, data) => { try { require('fs').writeFileSync(String(path), String(data)); return true; } catch(e) { return false; } },
           append: (path, data) => { try { require('fs').appendFileSync(String(path), String(data)); return true; } catch(e) { return false; } },
           exists: (path) => require('fs').existsSync(String(path)),
-          mkdir: (path) => { try { require('fs').mkdirSync(String(path), {recursive:true}); return true; } catch(e) { return false; } }
+          mkdir: (path) => { try { require('fs').mkdirSync(String(path), {recursive:true}); return true; } catch(e) { return false; } },
+          list: (path) => { try { return require('fs').readdirSync(String(path)); } catch(e) { return []; } },
+          delete: (path) => { try { require('fs').rmSync(String(path), {recursive:true, force:true}); return true; } catch(e) { return false; } }
       },
 
       // [WEBVIEW] Modern HTML/CSS UI
@@ -6010,9 +5970,9 @@ ascii_art: (text, fontName) => {
           await rt.run(ast);
           
           const exports = {};
-          console.log("Exporting vars from module...");
+          // console.log("Exporting vars from module...");
           for (const [k, v] of rt.global.vars) {
-              console.log("Exporting:", k, v);
+              // console.log("Exporting:", k, v);
               if (k === "__builtins__" || builtins[k]) continue; 
               
               let value = v.value;
@@ -6451,9 +6411,24 @@ $results | ConvertTo-Json -Compress
         }
       },
       
-      server: (port, handlerName) => {
-        // This old implementation is deprecated/removed in favor of the async one below
-        throw new FazerError("This server signature is deprecated. Use server(port, router_obj).");
+      http_server: (port, handler) => {
+          const http = require('http');
+          const server = http.createServer(async (req, res) => {
+              if (handler && handler.__fnref__) {
+                  const result = await this._call(handler, [{
+                      method: req.method,
+                      url: req.url,
+                      headers: req.headers
+                  }], this.global);
+                  
+                  res.writeHead(200, { 'Content-Type': 'text/html' });
+                  res.end(String(result));
+              } else {
+                  res.end("Fazer Server Running");
+              }
+          });
+          server.listen(Number(port));
+          console.log(`HTTP Server running on port ${port}`);
       },
 
       sleep: (ms) => new Promise((resolve) => setTimeout(resolve, Number(ms))),
@@ -8846,6 +8821,45 @@ async function main() {
           console.log(require("crypto").randomUUID());
       },
       
+      "compile": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer compile <file.fz> [-o output.fzc]${colors.reset}`);
+          const fs = require("fs");
+          const path = require("path");
+          const crypto = require("crypto");
+          
+          const inputFile = args[0];
+          if (!fs.existsSync(inputFile)) return console.error(`${colors.red}[!] File not found: ${inputFile}${colors.reset}`);
+          
+          let outputFile = inputFile.replace(/\.fz$/i, ".fzc");
+          if (args[1] === "-o" && args[2]) outputFile = args[2];
+          
+          console.log(`${colors.cyan}[*] Compiling/Encrypting ${inputFile}...${colors.reset}`);
+          
+          try {
+              const content = fs.readFileSync(inputFile, "utf8");
+              // Simple obfuscation/encryption using a hardcoded key (Security through obscurity, but sufficient for basic protection)
+              // We use AES-256-CTR with a fixed key/iv derived from a salt, or just a simple key.
+              // To make it portable, the interpreter must know the key. We'll use a hardcoded key in the interpreter.
+              const KEY = Buffer.from("46617a65724c616e675365637265743132334b6579214023", "hex"); // "FazerLangSecret123Key!@#" in hex (24 bytes) - wait, needs 32 for AES-256 or 16 for AES-128
+              // Let's use a simpler XOR-based or standard AES approach.
+              // We'll use a static key for now so any Fazer interpreter can run it.
+              const STATIC_KEY = crypto.createHash('sha256').update("FazerLangPublicRuntimeKey2026").digest();
+              const iv = crypto.randomBytes(16);
+              const cipher = crypto.createCipheriv('aes-256-cbc', STATIC_KEY, iv);
+              let encrypted = cipher.update(content, 'utf8', 'hex');
+              encrypted += cipher.final('hex');
+              
+              // File Format: FZC01[IV_HEX][ENCRYPTED_HEX]
+              const data = `FZC01${iv.toString('hex')}${encrypted}`;
+              fs.writeFileSync(outputFile, data, "utf8");
+              
+              console.log(`${colors.green}[+] Success! Compiled to: ${outputFile}${colors.reset}`);
+              console.log(`${colors.yellow}[i] You can now distribute '${outputFile}'. It can be run with 'fazer ${outputFile}' but cannot be easily read.${colors.reset}`);
+          } catch(e) {
+              console.error(`${colors.red}[!] Error: ${e.message}${colors.reset}`);
+          }
+      },
+
       // --- SYSTEM / UTILS ---
       "ls": async (args) => {
           const fs = require("fs");
@@ -9009,7 +9023,26 @@ async function main() {
     process.exit(1);
   }
 
-  const code = fs.readFileSync(filePath, "utf8");
+  let code = fs.readFileSync(filePath, "utf8");
+
+  // --- DECRYPT IF FZC ---
+  if (code.startsWith("FZC01")) {
+      try {
+          const crypto = require("crypto");
+          const STATIC_KEY = crypto.createHash('sha256').update("FazerLangPublicRuntimeKey2026").digest();
+          const iv = Buffer.from(code.substring(5, 37), 'hex');
+          const encryptedText = code.substring(37);
+          const decipher = crypto.createDecipheriv('aes-256-cbc', STATIC_KEY, iv);
+          let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
+          decrypted += decipher.final('utf8');
+          code = decrypted;
+      } catch(e) {
+          console.error("Error: Failed to decrypt .fzc file. It might be corrupted or version mismatch.");
+          process.exit(1);
+      }
+  }
+  // ----------------------
+
   const lex = lexer.tokenize(code);
   if (lex.errors.length) {
     console.error("Lexer error:", lex.errors[0].message || String(lex.errors[0]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fazer-lang",
-  "version": "3.2.1",
+  "version": "3.3.1",
   "description": "Fazer — The Red Team Language. Native modules for C2 Implant, WiFi Recon, Steganography (LSB), Process Injection, Crypto, 3D Game Engine, and Automation. Secure, powerful, standalone.",
   "main": "fazer.js",
   "types": "index.d.ts",