netmap-scanner 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 96dfd02daaa9dfe887fbf0c693d8dd302a6f64eff4c3ebdc759744e5de3c31cb
+  data.tar.gz: 5aa4fbd4522755cba2e0ceacde99232e93fe7ae188bea17bbc8b84ddfb4f2649
+SHA512:
+  metadata.gz: 4d3f9aa90256ac2331f8a2e9de9efa9ab7e59f0c05a9fa7094a4ff72b2d173b6699f037d235fc3d857752ea26094e5c82585aef3b68aea2e318a19c1ee174d21
+  data.tar.gz: e586f72b5787d851dd749dcc21b1c8be0f2af68939eb93552421aada7c4561d1a71c72b0440af7d252ed0d84d531b66caf8a363a2c119a033c9d8a95b418a93e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IshikawaUta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,116 @@
+<p align="center">
+  <img src="assets/logo.png" alt="NetMap Ultimate Logo" width="600">
+</p>
+
+# 🛰️ NetMap Ultimate V1.0
+
+[![Ruby](https://img.shields.io/badge/Ruby-3.x-red.svg)](https://www.ruby-lang.org/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Status](https://img.shields.io/badge/Version-1.0.0--Ultimate-gold.svg)]()
+
+**NetMap Ultimate** adalah alat pemindai jaringan (Network Scanner) berperforma tinggi yang ditulis dalam bahasa Ruby. Dirancang untuk kecepatan dan akurasi, NetMap mampu memetakan seluruh jaringan lokal atau WiFi Anda dalam hitungan detik menggunakan teknologi *Asynchronous I/O*.
+
+---
+
+## ✨ Fitur Utama
+
+### 📡 Ultimate Host Discovery
+- **Multi-Layer Detection**: Menggabungkan ICMP Ping, ARP Cache Lookup (L2), dan TCP Ping Fallback.
+- **ARP Precision**: Deteksi instan perangkat di jaringan lokal dengan membaca tabel ARP sistem secara langsung.
+- **Smart Pn Mode**: Lewati *Host Discovery* dengan flag `-Pn` untuk memindai target yang memblokir semua jenis ping.
+
+### 🏢 Identifikasi & Fingerprinting
+- **OUI Vendor Mapping**: Mengenali merk perangkat (Apple, Cisco, VMware, dll) berdasarkan prefix MAC Address.
+- **OS Prediction**: Tebakan Sistem Operasi (Linux/Unix, Windows, Cisco) menggunakan analisis TTL (*Time To Live*).
+- **Service Grabbing**: Banner grabbing otomatis untuk SSH, MySQL, HTTP, dan layanan populer lainnya.
+
+### ⚡ Performa Tinggi & Kustomisasi
+- **Async Concurrency Engine**: Menangani ratusan tugas pemindaian secara paralel tanpa membebani memori.
+- **Flexible Timing**: 6 template kecepatan dari **Paranoid** hingga **Insane** untuk menyesuaikan diri dengan sensitivitas jaringan target.
+
+---
+
+## 🚀 Instalasi
+
+### Prasyarat
+- **Ruby** >= 3.0
+- **Linux** (Direkomendasikan untuk fitur pemindaian Layer 2 / ARP terbaik)
+
+### Cara Instalasi
+```bash
+git clone https://github.com/IshikawaUta/netmap-scanner.git
+cd netmap-scanner
+bundle install
+```
+
+---
+
+## 📖 Referensi Perintah (CLI Options)
+
+| Opsi | Deskripsi |
+| :--- | :--- |
+| `-p <range>` | Tentukan port (misal: `80,443` atau `1-1024`). |
+| `-sn` | *Ping scan* saja (hanya mencari host yang aktif). |
+| `-Pn` | Lewati *Host Discovery* (anggap host aktif). |
+| `-O` | Aktifkan deteksi Sistem Operasi (OS Detection). |
+| `-sU` | Aktifkan pemindaian berbasis UDP. |
+| `-T <0-5>` | Pilih *Timing Template* (0: Lambat, 5: Sangat Cepat). |
+| `-t <n>` | Atur jumlah *concurrency thread* secara manual. |
+| `-j <file>` | Simpan hasil ke format JSON. |
+| `--html <file>` | Simpan hasil ke laporan HTML yang cantik. |
+| `-g <file>` | Simpan hasil ke format `grepable` (Nmap style). |
+
+---
+
+## 🕒 Timing Templates (-T)
+
+| Template | Nama | Concurrency | Timeout | Karakteristik |
+| :---: | :--- | :---: | :---: | :--- |
+| **0** | Paranoid | 1 | 10.0s | Sangat lambat, untuk melewati IDS/Firewall. |
+| **1** | Sneaky | 5 | 5.0s | Pelan dan hati-hati. |
+| **2** | Polite | 10 | 2.0s | Mengurangi beban pada jaringan/target. |
+| **3** | Normal | 50 | 1.0s | Keseimbangan antara kecepatan dan akurasi (Default). |
+| **4** | Aggressive | 200 | 0.8s | Sangat cepat, cocok untuk jaringan yang stabil. |
+| **5** | Insane | 400 | 0.5s | Sangat agresif, butuh *bandwidth* yang besar. |
+
+---
+
+## 🌀 Scripting Engine (Kustom Audit)
+
+NetMap menyertakan *engine* skrip Ruby yang ringan untuk memperluas kemampuan audit. Anda bisa menambahkan skrip audit sendiri di folder `scripts/`.
+
+**Contoh Skrip (`scripts/my_check.rb`):**
+```ruby
+# Skrip sederhana untuk mendeteksi banner tertentu
+if banner.include?("Apache")
+  "Apache Web Server Terdeteksi"
+elsif port == 8080
+  "Port Proxy Terdeteksi"
+else
+  nil
+end
+```
+
+**Variabel yang tersedia di dalam skrip:**
+- `ip`: Alamat IP target.
+- `port`: Nomor port yang sedang dipindai.
+- `banner`: Banner layanan yang didapat.
+- `os`: Nama Sistem Operasi (jika `-O` aktif).
+- `type`: Jenis protokol (`TCP` atau `UDP`).
+
+---
+
+## 🔧 Persyaratan Sistem & Troubleshooting
+
+- **Privilese Sudo**: Fitur deteksi MAC Address pada jaringan lokal seringkali membutuhkan akses `sudo` atau hak akses tinggi untuk membaca tabel ARP sistem.
+- **Host Discovery**: Jika target berada di balik *firewall* ketat, gunakan `-Pn` untuk memaksakan pemindaian port.
+
+---
+
+## 🤝 Kontribusi
+
+Kontribusi selalu diterima! Rasakan kebebasan untuk mengirimkan Pull Request atau melaporkan bug melalui Issue di GitHub.
+
+## ⚖️ Lisensi
+
+Proyek ini dilisensikan di bawah **MIT License**. Lihat file `LICENSE` untuk informasi lebih lanjut.

data/bin/netmap

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'bundler/setup'
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'netmap'
+
+begin
+  NetMap::CLI.start(ARGV)
+rescue Interrupt
+  puts "\nDihentikan oleh pengguna.".yellow
+  exit 0
+end

data/lib/netmap/cli.rb

@@ -0,0 +1,261 @@
+require 'optparse'
+require 'colorize'
+require_relative 'scanner'
+
+module NetMap
+  class CLI
+    BANNER = <<-'EOF'.cyan
+    _   _      _   __  __             
+   | \ | | ___| |_|  \/  | __ _ _ __  
+   |  \| |/ _ \ __| |\/| |/ _` | '_ \ 
+   | |\  |  __/ |_| |  | | (_| | |_) |
+   |_| \_|\___|\__|_|  |_|\__,_| .__/ 
+                               |_|    
+  [ Network Scanner - By: IshikawaUta ]
+    EOF
+
+    def self.start(args)
+      options = {
+        ports: "21,22,23,25,53,80,110,139,143,443,445,3000,3306,3389,5000,8080,8081,8096,8888,9000",
+        threads: nil,
+        timeout: nil,
+        timing: 3,
+        discovery: true,
+        version_det: false,
+        udp: false,
+        os_detect: false,
+        noping: false,
+        output: nil,
+        output_json: nil,
+        output_grep: nil,
+        output_html: nil
+      }
+
+      # Dukungan manual untuk -Pn dan -P (agar tidak bentrok dengan parser)
+      if ARGV.include?('-Pn') || ARGV.include?('-P')
+        options[:noping] = true
+        ARGV.delete('-Pn')
+        ARGV.delete('-P')
+      end
+      
+      parser = OptionParser.new do |opts|
+        opts.banner = "Penggunaan: netmap [opsi] <target>"
+        opts.separator ""
+        opts.separator "Opsi Pemindaian:"
+
+        opts.on("-p", "--ports RANGE", "Rentang port (misal: 80,443 atau 1-1024)") do |v|
+          options[:ports] = v
+        end
+
+        opts.on("-s TYPE", "Jenis Scan (U: UDP, V: Versi, n: Ping)") do |v|
+          options[:udp] = true if v.include?('U')
+          options[:version_det] = true if v.include?('V')
+          options[:ports] = nil if v.include?('n')
+        end
+
+        opts.on("--udp", "Gunakan pemindaian UDP") { options[:udp] = true }
+        opts.on("--version-all", "Gunakan deteksi versi") { options[:version_det] = true }
+        opts.on("--ping", "Hanya host discovery") { options[:ports] = nil }
+        opts.on("--noping", "Lewati host discovery, anggap host up") { options[:noping] = true }
+
+        opts.on("-O", "--osscan", "Deteksi OS - Tebak sistem operasi target") do
+          options[:os_detect] = true
+        end
+
+        opts.separator ""
+        opts.separator "Opsi Kecepatan (Timing):"
+
+        opts.on("-T", "--timing TEMPLATE", Integer, "Template waktu 0-5 (default: 3)") do |v|
+          options[:timing] = v
+        end
+
+        opts.on("-t", "--threads JUMLAH", Integer, "Jumlah thread/concurrency") do |v|
+          options[:threads] = v
+        end
+
+        opts.separator ""
+        opts.separator "Opsi Output:"
+
+        opts.on("-n", "--output-normal FILE", "Simpan hasil ke file teks (Normal)") do |v|
+          options[:output] = v
+        end
+
+        opts.on("-j", "--json FILE", "Simpan hasil ke file JSON") do |v|
+          options[:output_json] = v
+        end
+
+        opts.on("-g", "--grepable FILE", "Simpan hasil ke format Grepable") do |v|
+          options[:output_grep] = v
+        end
+
+        opts.on("--html FILE", "Simpan hasil ke laporan HTML") do |v|
+          options[:output_html] = v
+        end
+
+        opts.on("-v", "--version", "Tampilkan versi aplikasi") do
+          puts BANNER
+          puts " NetMap Ultimate Version: #{NetMap::VERSION}".yellow
+          exit
+        end
+
+        opts.on("-h", "--help", "Tampilkan bantuan ini") do
+          puts BANNER
+          puts opts
+          exit
+        end
+      end
+
+      begin
+        parser.parse!(args)
+        exit 0 if args.empty? && (puts BANNER; puts parser; true)
+        run_scan(args, options)
+      rescue => e
+        puts "Error: #{e.message}".red
+        exit 1
+      end
+    end
+
+    def self.run_scan(targets, options)
+      puts BANNER
+      puts "\n" + "=".center(75, "=").yellow
+      puts " MEMULAI PEMINDAIAN NETMAP ULTIMATE ".center(75, "=").yellow
+      puts "=".center(75, "=").yellow
+      puts " Waktu    : #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+      puts " Target   : #{targets.join(', ')}"
+      puts " Mode     : #{options[:udp] ? 'UDP Scan' : 'TCP Scan'}"
+      puts " OS Det   : #{options[:os_detect] ? 'Aktif' : 'Non-aktif'}"
+      puts " Ping     : #{options[:noping] ? 'Dinonaktifkan (-Pn)' : 'Aktif'}"
+      puts " Timing   : -T#{options[:timing]}"
+      puts "=".center(75, "=").yellow + "\n"
+
+      scanner = NetMap::Scanner.new(
+        targets, 
+        options[:ports], 
+        threads: options[:threads], 
+        timeout: options[:timeout],
+        timing: options[:timing],
+        discovery: options[:discovery],
+        udp: options[:udp],
+        os_detect: options[:os_detect],
+        noping: options[:noping]
+      )
+      
+      start_time = Time.now
+      results = scanner.run
+      duration = (Time.now - start_time).round(2)
+
+      display_results(results, duration, scanner.active_hosts, scanner)
+      
+      save_results(results, options[:output]) if options[:output]
+      save_json(results, options[:output_json]) if options[:output_json]
+      save_grepable(results, options[:output_grep]) if options[:output_grep]
+      save_html(results, options[:output_html]) if options[:output_html]
+    end
+
+    def self.display_results(results, duration, active_hosts, scanner = nil)
+      if active_hosts.empty?
+        puts "\nTidak ada host aktif ditemukan.".red
+      elsif results.empty? && active_hosts.any?
+        # Jika pingscan saja (-sn), tampilkan tabel host yang ditemukan
+        puts "\n" + "── HASIL PENEMUAN HOST (PING SCAN) ──".center(75, " ").cyan
+        col_widths = { ip: 25, mac_vendor: 50 }
+        
+        puts "┌#{'─' * (col_widths[:ip]+2)}┬#{'─' * (col_widths[:mac_vendor]+2)}┐"
+        puts "│ #{'ALAMAT IP'.ljust(col_widths[:ip])} │ #{'MAC / VENDOR'.ljust(col_widths[:mac_vendor])} │"
+        puts "├#{'─' * (col_widths[:ip]+2)}┼#{'─' * (col_widths[:mac_vendor]+2)}┤"
+
+        active_hosts.each do |ip|
+          arp_info = scanner&.instance_variable_get(:@arp_table)&.[](ip)
+          mac_vendor_text = if arp_info
+            mac = arp_info[:mac]
+            vendor = scanner.send(:get_vendor_by_mac, mac)
+            "#{mac} (#{vendor})"
+          else
+            "N/A (Cek tabel ARP manual)"
+          end
+          
+          puts "│ #{ip.ljust(col_widths[:ip]).green} │ #{mac_vendor_text.ljust(col_widths[:mac_vendor]).light_black} │"
+        end
+        puts "└#{'─' * (col_widths[:ip]+2)}┴#{'─' * (col_widths[:mac_vendor]+2)}┘"
+      else
+        puts "\n"
+        # Dimensi Kolom: IP(15), Port(10), Status(15), OS(15), MAC(30), Banner(45)
+        col_widths = { ip: 15, port: 10, status: 15, os: 15, mac: 30, banner: 45 }
+        
+        # Header
+        puts "┌#{'─' * (col_widths[:ip]+2)}┬#{'─' * (col_widths[:port]+2)}┬#{'─' * (col_widths[:status]+2)}┬#{'─' * (col_widths[:os]+2)}┬#{'─' * (col_widths[:mac]+2)}┬#{'─' * (col_widths[:banner]+2)}┐"
+        puts "│ #{'ALAMAT IP'.ljust(col_widths[:ip])} │ #{'PORT'.ljust(col_widths[:port])} │ #{'STATUS'.ljust(col_widths[:status])} │ #{'OS'.ljust(col_widths[:os])} │ #{'MAC / VENDOR'.ljust(col_widths[:mac])} │ #{'BANNER'.ljust(col_widths[:banner])} │"
+        puts "├#{'─' * (col_widths[:ip]+2)}┼#{'─' * (col_widths[:port]+2)}┼#{'─' * (col_widths[:status]+2)}┼#{'─' * (col_widths[:os]+2)}┼#{'─' * (col_widths[:mac]+2)}┼#{'─' * (col_widths[:banner]+2)}┤"
+
+        results.each do |r|
+          ip_val = r[:ip].ljust(col_widths[:ip]).green
+          port_val = "#{r[:port]}/#{r[:type]}".ljust(col_widths[:port]).yellow
+          status_color = r[:status] == :open ? :light_green : :yellow
+          status_val = r[:status].to_s.ljust(col_widths[:status]).send(status_color)
+          os_val = (r[:os] || "Unknown").ljust(col_widths[:os]).cyan
+          
+          mac_vendor = r[:mac] ? "#{r[:mac]} (#{r[:vendor]})" : "N/A (Local only)"
+          mac_val = mac_vendor[0...(col_widths[:mac])].ljust(col_widths[:mac]).light_black
+          
+          banner_text = (r[:banner] || "").to_s.gsub(/[^[:print:]]/, ' ').strip
+          banner_lines = wrap_text(banner_text, col_widths[:banner])
+          
+          # Baris pertama (dengan semua data)
+          puts "│ #{ip_val} │ #{port_val} │ #{status_val} │ #{os_val} │ #{mac_val} │ #{banner_lines[0].ljust(col_widths[:banner]).italic} │"
+          
+          # Baris tambahan jika banner dibungkus (wraped)
+          if banner_lines.size > 1
+            banner_lines[1..-1].each do |line|
+              puts "│ #{' ' * col_widths[:ip]} │ #{' ' * col_widths[:port]} │ #{' ' * col_widths[:status]} │ #{' ' * col_widths[:os]} │ #{' ' * col_widths[:mac]} │ #{line.ljust(col_widths[:banner]).italic} │"
+            end
+          end
+        end
+        puts "└#{'─' * (col_widths[:ip]+2)}┴#{'─' * (col_widths[:port]+2)}┴#{'─' * (col_widths[:status]+2)}┴#{'─' * (col_widths[:os]+2)}┴#{'─' * (col_widths[:mac]+2)}┴#{'─' * (col_widths[:banner]+2)}┘"
+      end
+      
+      puts "\nSelesai dalam #{duration} detik. Total host aktif: #{active_hosts.size}. Port terbuka: #{results.size}".cyan
+    end
+
+    def self.wrap_text(text, width)
+      return [text] if text.size <= width
+      lines = []
+      while text.size > width
+        # Cari spasi terdekat untuk pemotongan yang rapi
+        chunk_end = text.rindex(' ', width) || width
+        lines << text[0...chunk_end].strip
+        text = text[chunk_end..-1].strip
+      end
+      lines << text unless text.empty?
+      lines
+    end
+
+    def self.save_json(results, filename)
+      require 'json'
+      File.write(filename, JSON.pretty_generate(results))
+      puts "Hasil JSON disimpan: #{filename}".green
+    end
+
+    def self.save_grepable(results, filename)
+      content = results.map do |r|
+        "Host: #{r[:ip]}\tPorts: #{r[:port]}/#{r[:status]}/#{r[:type]}//#{r[:banner]}//\tOS: #{r[:os]}"
+      end.join("\n")
+      File.write(filename, content)
+      puts "Hasil Grepable disimpan: #{filename}".green
+    end
+
+    def self.save_html(results, filename)
+      require_relative 'html_reporter'
+      NetMap::HTMLReporter.generate(results, filename)
+      puts "Laporan HTML disimpan: #{filename}".green
+    end
+
+    def self.save_results(results, filename)
+      File.open(filename, "w") do |f|
+        f.puts "Hasil Pemindaian NetMap Ultimate - #{Time.now}"
+        f.puts "=" * 50
+        results.each { |r| f.puts "IP: #{r[:ip]} | Port: #{r[:port]}/#{r[:type]} | Status: #{r[:status]} | OS: #{r[:os]} | Banner: #{r[:banner]}" }
+      end
+      puts "Hasil Normal disimpan: #{filename}".green
+    end
+  end
+end

data/lib/netmap/html_reporter.rb

@@ -0,0 +1,78 @@
+module NetMap
+  class HTMLReporter
+    def self.generate(results, filename)
+      html = <<~HTML
+        <!DOCTYPE html>
+        <html lang="id">
+        <head>
+          <meta charset="UTF-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <title>Laporan Pemindaian NetMap Ultimate</title>
+          <style>
+            body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background-color: #f4f7f6; color: #333; margin: 0; padding: 20px; }
+            .container { max-width: 1000px; margin: auto; background: white; padding: 30px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+            h1 { color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 10px; }
+            .stats { display: flex; gap: 20px; margin-bottom: 30px; }
+            .stat-card { flex: 1; background: #3498db; color: white; padding: 20px; border-radius: 8px; text-align: center; }
+            .stat-card.green { background: #27ae60; }
+            table { width: 100%; border-collapse: collapse; margin-top: 20px; }
+            th { background: #34495e; color: white; text-align: left; padding: 12px; }
+            td { padding: 12px; border-bottom: 1px solid #ddd; }
+            tr:hover { background-color: #f1f1f1; }
+            .status-open { color: #27ae60; font-weight: bold; }
+            .os-tag { background: #ecf0f1; padding: 2px 8px; border-radius: 4px; font-size: 0.9em; }
+            .mac-tag { font-family: monospace; color: #7f8c8d; font-size: 0.9em; }
+            footer { margin-top: 50px; text-align: center; font-size: 0.8em; color: #7f8c8d; }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <h1>Laporan Pemindaian NetMap</h1>
+            <p>Waktu Pemindaian: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}</p>
+            
+            <div class="stats">
+              <div class="stat-card">
+                <h3>Total Port Terbuka</h3>
+                <p style="font-size: 2em; margin: 0;">#{results.size}</p>
+              </div>
+              <div class="stat-card green">
+                <h3>Target Unik</h3>
+                <p style="font-size: 2em; margin: 0;">#{results.map { |r| r[:ip] }.uniq.size}</p>
+              </div>
+            </div>
+
+            <table>
+              <thead>
+                <tr>
+                  <th>Alamat IP</th>
+                  <th>Port</th>
+                  <th>Status</th>
+                  <th>Sistem Operasi</th>
+                  <th>MAC / Vendor</th>
+                  <th>Layanan / Banner</th>
+                </tr>
+              </thead>
+              <tbody>
+                #{results.map { |r| "
+                <tr>
+                  <td>#{r[:ip]}</td>
+                  <td>#{r[:port]}/#{r[:type]}</td>
+                  <td><span class='status-open'>#{r[:status]}</span></td>
+                  <td><span class='os-tag'>#{r[:os] || 'Unknown'}</span></td>
+                  <td><span class='mac-tag'>#{r[:mac] || 'N/A'} #{"(#{r[:vendor]})" if r[:vendor]}</span></td>
+                  <td><code>#{r[:banner]}</code></td>
+                </tr>" }.join}
+              </tbody>
+            </table>
+
+            <footer>
+              Dihasilkan secara otomatis oleh NetMap Ultimate Upgrade - By IshikawaUta
+            </footer>
+          </div>
+        </body>
+        </html>
+      HTML
+      File.write(filename, html)
+    end
+  end
+end

data/lib/netmap/scanner.rb

@@ -0,0 +1,472 @@
+require 'socket'
+require 'ipaddr'
+require 'timeout'
+
+module NetMap
+  class Scanner
+    attr_reader :targets, :ports, :threads, :timeout, :timing_template, :discovery_mode, :active_hosts
+
+    TIMING_TEMPLATES = {
+      0 => { threads: 1,   timeout: 10.0 }, # Paranoid
+      1 => { threads: 5,   timeout: 5.0 },  # Sneaky
+      2 => { threads: 10,  timeout: 2.0 },  # Polite
+      3 => { threads: 50,  timeout: 1.0 },  # Normal
+      4 => { threads: 200, timeout: 0.8 },  # Aggressive
+      5 => { threads: 400, timeout: 0.5 }   # Insane (Capped at 400 threads/0.5s)
+    }
+
+    def initialize(targets, ports, threads: nil, timeout: nil, timing: 3, discovery: true, udp: false, os_detect: false, noping: false)
+      @timing_template = TIMING_TEMPLATES[timing] || TIMING_TEMPLATES[3]
+      @targets = parse_targets(targets)
+      @ports = parse_ports(ports)
+      @threads = threads || @timing_template[:threads]
+      @timeout = timeout || @timing_template[:timeout]
+      @discovery_mode = discovery
+      @udp_mode = udp
+      @os_detect_mode = os_detect
+      @noping_mode = noping
+      @active_hosts = []
+      @results = []
+      
+      # Inisialisasi Script Engine
+      require_relative 'script_engine'
+      script_dir = File.join(File.expand_path('../../../', __FILE__), 'scripts')
+      @script_engine = ScriptEngine.new(script_dir)
+    end
+
+    def run
+      @arp_table = get_arp_table # Pastikan tabel ARP selalu terisi
+      
+      if @noping_mode
+        @active_hosts = @targets
+        puts "Mode -Pn aktif: Melewati Host Discovery, menganggap host ALIVE.".yellow
+      elsif @discovery_mode
+        puts "Melakukan Host Discovery (mencari host aktif)...".yellow
+        discover_hosts
+        puts "Host aktif ditemukan: #{@active_hosts.size}".green
+        return [] if @ports.empty?
+      else
+        @active_hosts = @targets
+      end
+
+      return [] if @active_hosts.empty?
+
+      scan_type = @udp_mode ? "UDP" : "TCP"
+      puts "Memulai pemindaian port #{scan_type} pada #{@active_hosts.size} host (Async Mode)...".yellow
+      
+      tasks_list = []
+      @active_hosts.each { |ip| @ports.each { |port| tasks_list << { ip: ip, port: port } } }
+      total_tasks = tasks_list.size
+      completed = 0
+      
+      require 'async'
+      require 'async/barrier'
+      require 'async/semaphore'
+
+      Async do |task|
+        barrier = Async::Barrier.new
+        semaphore = Async::Semaphore.new(@threads, parent: barrier)
+        
+        tasks_list.each do |t|
+          semaphore.async do
+            if @udp_mode
+              scan_udp_port(t[:ip], t[:port])
+            else
+              scan_port(t[:ip], t[:port])
+            end
+            completed += 1
+            print_progress(completed, total_tasks) if total_tasks > 10
+          end
+        end
+        barrier.wait
+      end
+
+      puts "\n" if total_tasks > 10
+      
+      # Refresh tabel ARP (Setelah koneksi dibuat, sistem operasi mengupdate cache ARP)
+      @arp_table = get_arp_table
+
+      # Tambahkan info MAC dan Vendor ke setiap hasil
+      @results.each do |r|
+        arp_info = @arp_table[r[:ip]]
+        if arp_info
+          r[:mac] = arp_info[:mac]
+          r[:vendor] = get_vendor_by_mac(r[:mac])
+        end
+      end
+      
+      @results.sort_by { |r| [r[:ip], r[:port]] }
+    end
+
+    private
+
+    def scan_udp_port(ip, port)
+      # UDP Scan: Best effort
+      begin
+        family = ip.include?(':') ? Socket::AF_INET6 : Socket::AF_INET
+        socket = Socket.new(family, Socket::SOCK_DGRAM, 0)
+        sockaddr = Socket.pack_sockaddr_in(port, ip)
+        
+        socket.send("", 0, sockaddr)
+        
+        if IO.select([socket], nil, nil, @timeout)
+          socket.recvfrom(512)
+          banner = format_banner("UDP Response Detected", port)
+          res = { ip: ip, port: port, status: :open, banner: banner, type: "UDP" }
+          @script_engine.run_scripts(res)
+          @results << res
+        else
+          banner = format_banner("", port)
+          banner = "No Response" if banner == "Penyajian banner gagal"
+          res = { ip: ip, port: port, status: :"open|filtered", banner: banner, type: "UDP" }
+          @script_engine.run_scripts(res)
+          @results << res
+        end
+        socket.close
+      rescue Errno::ECONNREFUSED
+        # Port UDP tertutup
+      rescue => _e
+      end
+    end
+
+    private
+
+    def discover_hosts
+      @arp_table = get_arp_table
+      
+      # 1. ICMP Ping paralel (Cepat)
+      puts "[1] Mencoba ICMP Ping...".light_black
+      discover_hosts_icmp
+      
+      # 2. Cross-reference dengan Tabel ARP (Layer 2)
+      puts "[2] Memeriksa Tabel ARP...".light_black
+      discover_hosts_arp
+      
+      # 3. TCP Ping (Fallback untuk firewall ketat)
+      if @active_hosts.size < @targets.size
+        puts "[3] Mencoba TCP Ping (Port Umum)...".light_black
+        discover_hosts_tcp
+      end
+      
+      @active_hosts.uniq!
+    end
+
+    def discover_hosts_icmp
+      require 'async'
+      require 'async/barrier'
+      require 'async/semaphore'
+      require 'open3'
+
+      Async do |task|
+        barrier = Async::Barrier.new
+        semaphore = Async::Semaphore.new(50, parent: barrier) # Limit parallel pings
+        mutex = Mutex.new
+
+        @targets.each do |ip|
+          semaphore.async do
+            # Gunakan perintah ping sistem (-W timeout -c jumlah)
+            _stdout, _stderr, status = Open3.capture3("ping -c 1 -W 0.2 #{ip}")
+            if status.success?
+              mutex.synchronize { @active_hosts << ip }
+            end
+          end
+        end
+        barrier.wait
+      end
+    end
+
+    def discover_hosts_arp
+      @targets.each do |ip|
+        # Jika IP ada di tabel ARP dan statusnya bukan incomplete (0x0), anggap UP
+        if @arp_table[ip] && @arp_table[ip][:mac] != "00:00:00:00:00:00"
+          @active_hosts << ip
+        end
+      end
+    end
+
+    def discover_hosts_tcp
+      require 'async'
+      require 'async/barrier'
+      require 'async/semaphore'
+
+      ping_ports = [80, 443, 22, 445, 3389, 8080]
+      Async do |task|
+        barrier = Async::Barrier.new
+        semaphore = Async::Semaphore.new(@threads, parent: barrier)
+        mutex = Mutex.new
+
+        @targets.each do |ip|
+          next if @active_hosts.include?(ip)
+          semaphore.async do
+            is_up = false
+            ping_ports.each do |port|
+              begin
+                family = ip.include?(':') ? Socket::AF_INET6 : Socket::AF_INET
+                s = Socket.new(family, Socket::SOCK_STREAM, 0)
+                sockaddr = Socket.pack_sockaddr_in(port, ip)
+                s.connect_nonblock(sockaddr) rescue nil
+                if IO.select(nil, [s], nil, 0.2)
+                  is_up = true; s.close; break
+                end
+                s.close
+              rescue; next; end
+            end
+            mutex.synchronize { @active_hosts << ip } if is_up
+          end
+        end
+        barrier.wait
+      end
+    end
+
+    def get_arp_table
+      table = {}
+      return table unless File.exist?('/proc/net/arp')
+      
+      File.readlines('/proc/net/arp').drop(1).each do |line|
+        parts = line.split(/\s+/)
+        # IP address (0), HW type (1), Flags (2), HW address (3), Mask (4), Device (5)
+        table[parts[0]] = { mac: parts[3], device: parts[5] }
+      end
+      table
+    end
+
+    def get_vendor_by_mac(mac)
+      return "Unknown" if mac.nil? || mac == "00:00:00:00:00:00"
+      
+      # Deteksi Locally Administered Address (LAA) - Umum di Docker/VM
+      # Oktet pertama memiliki bit kedua bernilai 1 (x2, x6, xA, xE)
+      first_octet = mac.split(/[:-]/)[0].to_i(16)
+      return "Virtual/Randomized (LAA)" if (first_octet & 0b10) != 0
+
+      prefix = mac.gsub(/[:-]/, '').upcase[0..5]
+      
+      # OUI Mapping Gede-gedean
+      vendors = {
+        "00000C" => "Cisco", "000502" => "Apple", "000C29" => "VMware", 
+        "001422" => "Dell", "00163E" => "Xen/AWS", "001A11" => "Google",
+        "005056" => "VMware", "0242AC" => "Docker", "080027" => "Oracle/VB",
+        "18AF61" => "Apple", "20DFB9" => "Samsung", "3C5AB4" => "Google",
+        "44650D" => "Amazon", "525400" => "QEMU/KVM", "B827EB" => "Raspberry Pi",
+        "DCA632" => "Raspberry Pi", "F4F5D8" => "Google", "F01898" => "Apple",
+        "000142" => "Cisco", "0002B3" => "Intel", "00040E" => "Linksys",
+        "000CF1" => "Intel", "001310" => "Linksys", "001565" => "Yealink",
+        "00216A" => "Intel", "0026B9" => "Dell", "3052CB" => "Liteon (Acer/HP)",
+        "408D5C" => "Giga-Byte", "5065F3" => "TP-Link", "60A44C" => "ASUSTek",
+        "708BC0" => "Intel", "80E650" => "Intel", "90F1AA" => "TP-Link",
+        "A42BB0" => "TP-Link", "C02568" => "TP-Link", "E4F042" => "Xiaomi",
+        "E84E06" => "TP-Link", "F8FF12" => "Apple", "F43167" => "TP-Link"
+      }
+      vendors[prefix] || "Unknown Vendor"
+    end
+
+    def parse_targets(targets_raw)
+      ips = []
+      targets_raw.each do |target|
+        begin
+          if target.include?('/')
+            # Mendukung CIDR IPv4 dan IPv6
+            # Untuk IPv6 / notation, IPAddr ruby mendukungnya
+            addr = IPAddr.new(target)
+            addr.to_range.each { |ip| ips << ip.to_s }
+          else
+            ips << IPAddr.new(target).to_s
+          end
+        rescue ArgumentError
+          puts "Peringatan: Format IP tidak valid - #{target}".red
+        end
+      end
+      ips.uniq
+    end
+
+    def parse_ports(ports_raw)
+      return [] if ports_raw.nil? || ports_raw.empty?
+      ports = []
+      ports_raw.split(',').each do |p|
+        if p.include?('-')
+          low, high = p.split('-').map(&:to_i)
+          (low..high).each { |port| ports << port }
+        else
+          ports << p.to_i
+        end
+      end
+      ports.uniq.select { |p| p > 0 && p < 65536 }
+    end
+
+    def scan_port(ip, port)
+      begin
+        family = ip.include?(':') ? Socket::AF_INET6 : Socket::AF_INET
+        # Gunakan Timeout eksplisit untuk keamanan
+        Timeout.timeout(@timeout + 0.5) do
+          socket = Socket.new(family, Socket::SOCK_STREAM, 0)
+          sockaddr = Socket.pack_sockaddr_in(port, ip)
+          
+          begin
+            socket.connect_nonblock(sockaddr)
+          rescue IO::WaitWritable
+            # Gunakan buffer timeout sedikit lebih lama dari global untuk IO select
+            select_timeout = [@timeout, 0.5].max
+            unless IO.select(nil, [socket], nil, select_timeout)
+              socket.close
+              raise Timeout::Error
+            end
+            
+            # Verifikasi koneksi setelah select
+            begin
+              socket.connect_nonblock(sockaddr)
+            rescue Errno::EISCONN
+              # Koneksi sudah mapan
+            rescue => e
+              socket.close
+              raise e
+            end
+          end
+
+          # Jika sampai sini, berarti koneksi berhasil
+          os_info = @os_detect_mode ? detect_os(socket) : nil
+          banner = probe_service(ip, port, socket)
+          socket.close
+          
+          result = { ip: ip, port: port, status: :open, banner: banner, os: os_info, type: "TCP" }
+          @script_engine.run_scripts(result)
+          @results << result
+        end
+      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::EINVAL
+        # Port tertutup atau tidak terjangkau
+      rescue => _e
+        # Error lainnya (termasuk socket tertutup)
+      end
+    end
+
+    def detect_os(socket)
+      begin
+        # Tebak OS berdasarkan TTL paket yang diterima
+        # Di Linux/Unix, kita bisa mengambilnya via IP_TTL
+        ttl = socket.getsockopt(Socket::IPPROTO_IP, Socket::IP_TTL).int rescue nil
+        return "Unknown" unless ttl
+
+        case ttl
+        when 0..64 then "Linux/Unix"
+        when 65..128 then "Windows"
+        when 129..255 then "Cisco/Solaris"
+        else "Unknown (#{ttl})"
+        end
+      rescue
+        "Detection Failed"
+      end
+    end
+
+    def probe_service(ip, port, socket)
+      # Daftar port yang kemungkinan besar adalah HTTP
+      http_ports = [80, 81, 8080, 8081, 8096, 443, 8443, 3000, 3001, 5000, 8888, 9000]
+      
+      banner = grab_banner(socket)
+      
+      if http_ports.include?(port) || banner.empty?
+        # Coba probe HTTP jika port umum atau jika banner kosong (silent service)
+        http_info = grab_http_info(socket, port)
+        return http_info unless http_info.empty?
+      end
+      
+      format_banner(banner, port)
+    end
+
+    def format_banner(banner, port)
+      # Jika banner kosong, kita tetap coba identifikasi via port
+      clean_banner = (banner || "").gsub(/[^[:print:]]/, ' ')
+      
+      case port
+      when 3306
+        return "Database: MySQL/MariaDB" if clean_banner.strip.empty?
+        if clean_banner =~ /(\d+\.\d+\.\d+-(?:MariaDB|MySQL)[^\s]*)/
+          "Database: #{$1}"
+        else
+          "MySQL/MariaDB Database"
+        end
+      when 22
+        return "SSH Service" if clean_banner.strip.empty?
+        clean_banner[/SSH-\d+\.\d+-([^\s]*)/] ? "SSH: #{$1}" : clean_banner
+      when 53
+        "Domain Name System (DNS)"
+      when 80, 8080, 443, 8443
+        clean_banner.strip.empty? ? "HTTP Service" : clean_banner.strip
+      else
+        clean_banner.strip.empty? ? "Penyajian banner gagal" : clean_banner.strip
+      end
+    end
+
+    def grab_http_info(socket, port)
+      begin
+        # Gunakan print dan flush untuk memastikan data terkirim
+        request = "GET / HTTP/1.1\r\n" \
+                  "Host: 127.0.0.1\r\n" \
+                  "User-Agent: NetMap/2.0\r\n" \
+                  "Accept: */*\r\n" \
+                  "Connection: close\r\n" \
+                  "\r\n"
+        
+        socket.print(request)
+        socket.flush
+        
+        response = ""
+        # Timeout sedikit lebih lama untuk server yang lambat memproses
+        Timeout.timeout(2.0) do
+          # Baca sampai socket ditutup atau timeout
+          while (chunk = socket.read(1024))
+            response << chunk
+            break if response.include?("\r\n\r\n") || response.size > 8192
+          end
+        end
+        
+        return "" if response.empty?
+        
+        # Ekstrak informasi
+        server = response[/Server: (.*)/i, 1]
+        title = response[/<title>(.*)<\/title>/im, 1]
+        
+        info = []
+        if server
+          if server.include?("Eksa") || server.include?("Eks-Cent") || response.include?("EKSA")
+            info << "Eksa Server (#{server.strip})"
+          else
+            info << "HTTP Server: #{server.strip}"
+          end
+        elsif response.include?("Eksa Server") || response.include?("Eks-Cent")
+          info << "Eksa Server (Detected)"
+        end
+        
+        info << "Title: #{title.strip}" if title
+        
+        # Jika tidak ada info spesifik tapi berhasil konek HTTP
+        if info.empty? && response.include?("HTTP/")
+          status = response[/\AHTTP\/1\.\d (\d+)/, 1]
+          info << "HTTP Service (Status: #{status})"
+        end
+        
+        info.compact.join(' | ')
+      rescue => _e
+        ""
+      end
+    end
+
+    def grab_banner(socket)
+      begin
+        socket.read_nonblock(512).strip.gsub(/[^[:print:]]/, '')
+      rescue IO::WaitReadable
+        IO.select([socket], nil, nil, 0.5)
+        retry if IO.select([socket], nil, nil, 0.1)
+        ""
+      rescue
+        ""
+      end
+    end
+
+    def print_progress(current, total)
+      percent = (current.to_f / total * 100).round(1)
+      print "\rMemproses: #{percent}% (#{current}/#{total})".cyan
+    end
+
+    def yield_result(result)
+      # Placeholder untuk real-time reporting jika dibutuhkan
+    end
+  end
+end

data/lib/netmap/script_engine.rb

@@ -0,0 +1,53 @@
+module NetMap
+  class ScriptEngine
+    def initialize(script_dir)
+      @script_dir = script_dir
+      @scripts = load_scripts
+    end
+
+    def load_scripts
+      scripts = []
+      return scripts unless Dir.exist?(@script_dir)
+
+      Dir.glob(File.join(@script_dir, "*.rb")).each do |script_path|
+        begin
+          script_code = File.read(script_path)
+          scripts << { name: File.basename(script_path), code: script_code }
+        rescue => e
+          puts "Error loading script #{script_path}: #{e.message}".red
+        end
+      end
+      scripts
+    end
+
+    def run_scripts(result)
+      @scripts.each do |script|
+        begin
+          # Lingkungan eksekusi skrip sederhana
+          # Skrip harus mengembalikan string jika ada temuan, atau nil
+          # Konteks: ip, port, banner, os
+          context = result
+          finding = eval_script(script[:code], context)
+          if finding && !finding.empty?
+            result[:banner] = "#{result[:banner]} | [#{script[:name]}: #{finding}]"
+          end
+        rescue
+          # Abaikan error skrip agar scan tetap jalan
+        end
+      end
+    end
+
+    private
+
+    def eval_script(code, context)
+      # Simulasikan DSL skrip sederhana menggunakan instance_eval pada context object
+      # Ini menghindari peringatan "unused variable" dan memberikan sandbox ringan
+      dsl_context = Object.new
+      context.each do |key, value|
+        dsl_context.define_singleton_method(key) { value }
+      end
+      
+      dsl_context.instance_eval(code)
+    end
+  end
+end

data/lib/netmap/version.rb

@@ -0,0 +1,3 @@
+module NetMap
+  VERSION = "1.0.0"
+end

data/lib/netmap.rb

@@ -0,0 +1,9 @@
+require_relative 'netmap/version'
+require_relative 'netmap/scanner'
+require_relative 'netmap/script_engine'
+require_relative 'netmap/html_reporter'
+require_relative 'netmap/cli'
+
+module NetMap
+  # Entry point untuk library NetMap
+end

data/scripts/http_check.rb

@@ -0,0 +1,9 @@
+# Skrip Deteksi Judul HTTP
+# Skrip ini berjalan jika port 80, 8080, atau 443 terbuka
+if [80, 8080, 443, 8443].include?(port)
+  "Mungkin layanan Web (Perlu probe lanjut)"
+elsif banner.include?("HTTP")
+  "Layanan Web Terdeteksi"
+else
+  nil
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: netmap-scanner
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- IshikawaUta
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.38'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.38'
+- !ruby/object:Gem::Dependency
+  name: async-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.43'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.43'
+description: NetMap is a powerful network scanner featuring parallel host discovery,
+  OS detection, service fingerprinting, and a custom Ruby scripting engine.
+email:
+- komikers09@gmail.com
+executables:
+- netmap
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- assets/logo.png
+- bin/netmap
+- lib/netmap.rb
+- lib/netmap/cli.rb
+- lib/netmap/html_reporter.rb
+- lib/netmap/scanner.rb
+- lib/netmap/script_engine.rb
+- lib/netmap/version.rb
+- scripts/http_check.rb
+homepage: https://github.com/IshikawaUta
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/IshikawaUta
+  source_code_uri: https://github.com/IshikawaUta/netmap-scanner
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: High-performance Network Scanner with Scripting Engine
+test_files: []