lanet 0.1.0

data/lib/lanet/ping.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require "English"
+require "open3"
+require "timeout"
+
+module Lanet
+  class Ping
+    attr_reader :timeout, :count
+
+    def initialize(timeout: 1, count: 3)
+      @timeout = timeout
+      @count = count
+      @continuous = false
+    end
+
+    # Ping a single host with real-time output
+    # @param host [String] The IP address or hostname to ping
+    # @param realtime [Boolean] Whether to print output in real-time
+    # @param continuous [Boolean] Whether to ping continuously until interrupted
+    # @return [Hash] Result with status, response time, and output
+    def ping_host(host, realtime = false, continuous = false)
+      @continuous = continuous
+
+      result = {
+        host: host,
+        status: false,
+        response_time: nil,
+        packet_loss: 100,
+        output: "",
+        responses: [] # Store individual ping responses
+      }
+
+      begin
+        # Command varies by OS
+        ping_cmd = ping_command(host)
+
+        # Use different approaches based on output mode
+        if realtime
+          process_realtime_ping(ping_cmd, result)
+        else
+          # Use backticks for quiet mode - much more reliable than Open3 for this case
+          process_quiet_ping(ping_cmd, result)
+        end
+      rescue Timeout::Error
+        result[:output] = "Ping timed out after #{@timeout * 2} seconds"
+      rescue Interrupt
+        # Handle Ctrl+C gracefully for continuous mode
+        print_ping_statistics(host, result) if realtime
+        exit(0) if realtime # Only exit if in realtime mode - otherwise let the caller handle it
+      rescue StandardError => e
+        result[:output] = "Error: #{e.message}"
+      end
+
+      # Only print statistics in realtime mode and not continuous
+      print_ping_statistics(host, result) if realtime && !@continuous
+
+      result
+    end
+
+    # Check if a host is reachable
+    # @param host [String] The IP address or hostname to check
+    # @return [Boolean] True if the host is reachable
+    def reachable?(host)
+      ping_host(host)[:status]
+    end
+
+    # Get the response time for a host
+    # @param host [String] The IP address or hostname to check
+    # @return [Float, nil] The response time in ms, or nil if unreachable
+    def response_time(host)
+      ping_host(host)[:response_time]
+    end
+
+    # Ping multiple hosts in parallel
+    # @param hosts [Array<String>] Array of IP addresses or hostnames
+    # @param realtime [Boolean] Whether to print output in real-time
+    # @param continuous [Boolean] Whether to ping continuously until interrupted
+    # @return [Hash] Results indexed by host
+    def ping_hosts(hosts, realtime = false, continuous = false)
+      results = {}
+      if realtime
+        # For real-time output, run pings sequentially
+        hosts.each do |host|
+          results[host] = ping_host(host, true, continuous)
+          puts "\n" unless host == hosts.last
+        end
+      else
+        # For non-realtime output, run pings in parallel
+        threads = []
+
+        hosts.each do |host|
+          threads << Thread.new do
+            results[host] = ping_host(host)
+          end
+        end
+
+        threads.each(&:join)
+      end
+      results
+    end
+
+    private
+
+    def process_quiet_ping(ping_cmd, result)
+      # Use backticks for simplest, most reliable execution in quiet mode
+      Timeout.timeout(@timeout * @count * 2) do
+        output = `#{ping_cmd}`
+        result[:output] = output
+        exit_status = $CHILD_STATUS.exitstatus
+
+        # Process the output
+        if exit_status.zero? || output.include?("bytes from")
+          result[:status] = true
+
+          # Extract individual ping responses
+          extract_ping_responses(output, result)
+
+          # Calculate average response time
+          if result[:responses].any?
+            result[:response_time] = result[:responses].map { |r| r[:time] }.sum / result[:responses].size
+          end
+
+          # Extract packet loss
+          result[:packet_loss] = ::Regexp.last_match(1).to_f if output =~ /(\d+(?:\.\d+)?)% packet loss/
+        else
+          # No responses
+          result[:status] = false
+          result[:packet_loss] = 100.0
+        end
+      end
+    rescue Timeout::Error
+      result[:output] = "Ping timed out after #{@timeout * @count * 2} seconds"
+    rescue StandardError => e
+      result[:output] = "Error: #{e.message}"
+    end
+
+    def process_realtime_ping(ping_cmd, result)
+      all_output = ""
+      thread = nil
+
+      begin
+        Open3.popen3(ping_cmd) do |_stdin, stdout, _stderr, process_thread|
+          thread = process_thread
+          stdout_thread = Thread.new do
+            # Read stdout in real time
+            while (line = stdout.gets)
+              all_output += line
+              print line # Print in real-time
+
+              # Parse and store responses as they come
+              case RbConfig::CONFIG["host_os"]
+              when /mswin|mingw|cygwin/
+                if line =~ /Reply from .* time=(\d+)ms TTL=(\d+)/
+                  seq = result[:responses].size
+                  ttl = ::Regexp.last_match(2).to_i
+                  time = ::Regexp.last_match(1).to_f
+                  result[:responses] << { seq: seq, ttl: ttl, time: time }
+                end
+              else
+                if line =~ /icmp_seq=(\d+) ttl=(\d+) time=([\d.]+) ms/
+                  seq = ::Regexp.last_match(1).to_i
+                  ttl = ::Regexp.last_match(2).to_i
+                  time = ::Regexp.last_match(3).to_f
+                  result[:responses] << { seq: seq, ttl: ttl, time: time }
+                end
+              end
+
+              # For non-continuous mode, exit when we've collected enough responses
+              break if !@continuous && result[:responses].size >= @count
+            end
+          rescue IOError
+            # Stream may be closed - this is ok
+          end
+
+          # Wait for the stdout thread to complete or the process to exit
+          if @continuous
+            stdout_thread.join # Wait indefinitely in continuous mode
+          else
+            # For non-continuous mode, wait for completion with a reasonable timeout
+            begin
+              Timeout.timeout(@timeout * @count * 2) do
+                process_thread.join
+              end
+            rescue Timeout::Error
+              # If it takes too long, we'll terminate below in the ensure block
+            ensure
+              stdout_thread.kill if stdout_thread.alive?
+            end
+          end
+
+          # Set success status
+          result[:status] = !result[:responses].empty?
+          result[:output] = all_output
+
+          # Calculate response time
+          if result[:responses].any?
+            result[:response_time] = result[:responses].map { |r| r[:time] }.sum / result[:responses].size
+
+            # Calculate packet loss for non-continuous mode
+            unless @continuous
+              total_expected = @count
+              result[:packet_loss] = ((total_expected - result[:responses].size) / total_expected.to_f * 100).round(1)
+            end
+          end
+        end
+      rescue IOError => e
+        # Handle IOError specifically
+        result[:output] += "\nWarning: IO operation failed: #{e.message}"
+      ensure
+        # Clean up any threads and processes
+        if thread&.alive?
+
+          begin
+            Process.kill("TERM", thread.pid)
+          rescue StandardError
+            nil
+          end
+
+        end
+      end
+    end
+
+    def print_ping_statistics(host, result)
+      puts "\n--- #{host} ping statistics ---"
+      if result[:responses].any?
+        avg_time = result[:responses].map { |r| r[:time] }.sum / result[:responses].size
+        min_time = result[:responses].map { |r| r[:time] }.min
+        max_time = result[:responses].map { |r| r[:time] }.max
+
+        # Calculate proper packet loss
+        if @continuous
+          highest_seq = result[:responses].map { |r| r[:seq] }.max
+          unique_seqs = result[:responses].map { |r| r[:seq] }.uniq.size
+          transmitted = highest_seq + 1
+          packet_loss = ((transmitted - unique_seqs) / transmitted.to_f * 100).round(1)
+
+          puts "#{transmitted} packets transmitted, #{unique_seqs} packets received, #{packet_loss}% packet loss"
+        else
+          # Normal mode - compare against expected count
+          packet_loss = ((@count - result[:responses].size) / @count.to_f * 100).round(1)
+          puts "#{@count} packets transmitted, #{result[:responses].size} packets received, #{packet_loss}% packet loss"
+        end
+
+        puts "round-trip min/avg/max = #{min_time.round(3)}/#{avg_time.round(3)}/#{max_time.round(3)} ms"
+      else
+        puts "0 packets transmitted, 0 packets received, 100% packet loss"
+      end
+    end
+
+    def ping_command(host)
+      if @continuous
+        # Continuous mode - don't specify count
+        case RbConfig::CONFIG["host_os"]
+        when /mswin|mingw|cygwin/
+          # Windows - use -t for continuous ping
+          "ping -t -w #{@timeout * 1000} #{host}"
+        when /darwin/
+          # macOS - for continuous ping, simply omit the count parameter
+          "ping #{host}"
+        else
+          # Linux/Unix - no count flag means continuous
+          "ping -W #{@timeout} #{host}"
+        end
+      else
+        # Normal mode with count
+        case RbConfig::CONFIG["host_os"]
+        when /mswin|mingw|cygwin/
+          # Windows
+          "ping -n #{@count} -w #{@timeout * 1000} #{host}"
+        when /darwin/
+          # macOS
+          "ping -c #{@count} #{host}"
+        else
+          # Linux/Unix
+          "ping -c #{@count} -W #{@timeout} #{host}"
+        end
+      end
+    end
+
+    def extract_ping_responses(output, result)
+      # Extract individual ping responses based on OS format
+      case RbConfig::CONFIG["host_os"]
+      when /mswin|mingw|cygwin/
+        # Windows format
+        output.scan(/Reply from .* time=(\d+)ms TTL=(\d+)/).each_with_index do |match, seq|
+          result[:responses] << { seq: seq, ttl: match[1].to_i, time: match[0].to_f }
+        end
+      else
+        # Unix-like format (Linux/macOS)
+        output.scan(/icmp_seq=(\d+) ttl=(\d+) time=([\d.]+) ms/).each do |match|
+          result[:responses] << { seq: match[0].to_i, ttl: match[1].to_i, time: match[2].to_f }
+        end
+      end
+    end
+  end
+end

data/lib/lanet/receiver.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Lanet
+  class Receiver
+    def initialize(port)
+      @port = port
+      @socket = UDPSocket.new
+      @socket.bind("0.0.0.0", @port)
+    end
+
+    def listen(&block)
+      loop do
+        data, addr = @socket.recvfrom(1024)
+        ip = addr[3]
+        block.call(data, ip)
+      end
+    end
+  end
+end

data/lib/lanet/scanner.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "English"
+require "ipaddr"
+require "socket"
+require "timeout"
+require "resolv"
+
+module Lanet
+  class Scanner
+    COMMON_PORTS = {
+      21 => "FTP",
+      22 => "SSH",
+      23 => "Telnet",
+      25 => "SMTP",
+      80 => "HTTP",
+      443 => "HTTPS",
+      3389 => "RDP",
+      5900 => "VNC",
+      8080 => "HTTP-ALT",
+      137 => "NetBIOS",
+      139 => "NetBIOS",
+      445 => "SMB",
+      1025 => "RPC",
+      8443 => "HTTPS-ALT"
+    }.freeze
+
+    # Ports to check during scan
+    QUICK_CHECK_PORTS = [80, 443, 22, 445, 139, 8080].freeze
+
+    def initialize
+      @hosts = []
+      @mutex = Mutex.new
+    end
+
+    # Scan network and return active hosts
+    def scan(cidr, timeout = 1, max_threads = 32, verbose = false)
+      @verbose = verbose
+      @timeout = timeout
+
+      # Clear previous scan results
+      @hosts = []
+
+      # Get the range of IP addresses to scan
+      range = IPAddr.new(cidr).to_range
+
+      # Create a queue of IPs to scan
+      queue = Queue.new
+      range.each { |ip| queue << ip.to_s }
+
+      total_ips = queue.size
+      completed = 0
+
+      # Pre-populate ARP table to improve MAC address resolution
+      update_arp_table(cidr, max_threads)
+
+      # Create worker threads to process the queue
+      threads = Array.new([max_threads, total_ips].min) do
+        Thread.new do
+          while (ip = begin
+            queue.pop(true)
+          rescue ThreadError
+            nil
+          end)
+            scan_host(ip)
+            @mutex.synchronize do
+              completed += 1
+              if total_ips < 100 || (completed % 10).zero? || completed == total_ips
+                print_progress(completed,
+                               total_ips)
+              end
+            end
+          end
+        end
+      end
+
+      begin
+        threads.each(&:join)
+        print_progress(total_ips, total_ips)
+        puts "\nScan complete. Found #{@hosts.size} active hosts."
+        @verbose ? @hosts : @hosts.map { |h| h[:ip] }
+      rescue Interrupt
+        puts "\nScan interrupted. Returning partial results..."
+        @verbose ? @hosts : @hosts.map { |h| h[:ip] }
+      end
+    end
+
+    private
+
+    def print_progress(completed, total)
+      percent = (completed.to_f / total * 100).round(1)
+      print "\rScanning network: #{percent}% complete (#{completed}/#{total})"
+    end
+
+    def update_arp_table(cidr, max_threads = 10)
+      # Use fast ping method to update ARP table
+      range = IPAddr.new(cidr).to_range
+      queue = Queue.new
+      range.each { |ip| queue << ip.to_s }
+
+      total = queue.size
+      processed = 0
+
+      threads = Array.new([max_threads, total].min) do
+        Thread.new do
+          while (ip = begin
+            queue.pop(true)
+          rescue ThreadError
+            nil
+          end)
+            # Use system ping to update ARP table
+            system("ping -c 1 -W 1 #{ip} > /dev/null 2>&1 &")
+            sleep 0.01 # Small delay to prevent overwhelming the system
+            processed += 1
+          end
+        end
+      end
+
+      # Wait for ping operations to complete
+      threads.each(&:join)
+      sleep 1 # Give the system time to update ARP table
+    end
+
+    def scan_host(ip)
+      # Skip special addresses to save time
+      return if ip.end_with?(".0") && !ip.end_with?(".0.0") # Skip network addresses except 0.0.0.0
+
+      # Use multiple methods to detect if a host is alive
+      is_active = false
+      detection_method = nil
+      response_time = nil
+      start_time = Time.now
+      open_ports = []
+
+      # Method 1: Try TCP port scan (most reliable)
+      tcp_result = tcp_port_scan(ip, QUICK_CHECK_PORTS)
+      if tcp_result[:active]
+        is_active = true
+        detection_method = "TCP"
+        open_ports = tcp_result[:open_ports]
+      end
+
+      # Method 2: Try ICMP ping if TCP didn't work
+      unless is_active
+        ping_result = ping_check(ip)
+        if ping_result
+          is_active = true
+          detection_method = "ICMP"
+        end
+      end
+
+      # Method 3: If host is a common network device (e.g., router), check with UDP
+      if !is_active && (ip.end_with?(".1") || ip.end_with?(".254") || ip.end_with?(".255"))
+        udp_result = udp_check(ip)
+        if udp_result
+          is_active = true
+          detection_method = "UDP"
+        end
+      end
+
+      # Method 4: ARP Check - if we have a MAC, the host is likely active
+      unless is_active
+        mac_address = get_mac_address(ip)
+        if mac_address && mac_address != "(incomplete)"
+          is_active = true
+          detection_method = "ARP"
+        end
+      end
+
+      # For broadcast addresses, always consider them active
+      if ip.end_with?(".255") || ip == "255.255.255.255"
+        is_active = true
+        detection_method = "Broadcast"
+      end
+
+      # Calculate response time
+      response_time = ((Time.now - start_time) * 1000).round(2) if is_active
+
+      return unless is_active
+
+      # For active hosts, collect more information if in verbose mode
+      host_info = {
+        ip: ip,
+        mac: get_mac_address(ip),
+        response_time: response_time,
+        detection_method: detection_method
+      }
+
+      if @verbose
+        # For verbose mode, try to resolve hostname
+        begin
+          Timeout.timeout(1) do
+            host_info[:hostname] = Resolv.getname(ip)
+          end
+        rescue Resolv::ResolvError, Timeout::Error
+          host_info[:hostname] = "Unknown"
+        end
+
+        # For verbose mode, scan more ports if TCP detection method was successful
+        if detection_method == "TCP"
+          extra_ports = tcp_port_scan(ip, COMMON_PORTS.keys - QUICK_CHECK_PORTS)[:open_ports]
+          open_ports += extra_ports
+        end
+
+        host_info[:ports] = open_ports.map { |port| [port, COMMON_PORTS[port] || "Unknown"] }.to_h
+      end
+
+      @mutex.synchronize { @hosts << host_info }
+    rescue StandardError => e
+      puts "\nError scanning host #{ip}: #{e.message}" if $DEBUG
+    end
+
+    def tcp_port_scan(ip, ports)
+      open_ports = []
+      is_active = false
+
+      ports.each do |port|
+        Timeout.timeout(@timeout) do
+          socket = TCPSocket.new(ip, port)
+          is_active = true
+          open_ports << port
+          socket.close
+        end
+      rescue Errno::ECONNREFUSED
+        # Connection refused means host is up but port is closed
+        is_active = true
+      rescue StandardError
+        # Other errors mean port is probably closed or filtered
+      end
+
+      { active: is_active, open_ports: open_ports }
+    end
+
+    def ping_check(ip)
+      cmd = case RbConfig::CONFIG["host_os"]
+            when /darwin/
+              "ping -c 1 -W 1 #{ip}"
+            when /linux/
+              "ping -c 1 -W 1 #{ip}"
+            when /mswin|mingw|cygwin/
+              "ping -n 1 -w 1000 #{ip}"
+            else
+              "ping -c 1 -W 1 #{ip}"
+            end
+
+      system("#{cmd} > /dev/null 2>&1")
+      $CHILD_STATUS.exitstatus.zero?
+    end
+
+    def udp_check(ip)
+      common_udp_ports = [53, 67, 68, 123, 137, 138, 1900, 5353]
+
+      common_udp_ports.each do |port|
+        Timeout.timeout(0.5) do
+          socket = UDPSocket.new
+          socket.connect(ip, port)
+          socket.send("PING", 0)
+          socket.close
+          return true
+        end
+      rescue Errno::ECONNREFUSED
+        return true # Connection refused means host is up
+      rescue StandardError
+        # Try next port
+      end
+      false
+    end
+
+    def get_mac_address(ip)
+      return "ff:ff:ff:ff:ff:ff" if ip.end_with?(".255") # Special case for broadcast
+
+      # Get MAC from ARP table
+      cmd = case RbConfig::CONFIG["host_os"]
+            when /darwin/
+              "arp -n #{ip}"
+            when /linux/
+              "arp -n #{ip}"
+            when /mswin|mingw|cygwin/
+              "arp -a #{ip}"
+            else
+              "arp -n #{ip}"
+            end
+
+      output = `#{cmd}`
+
+      if output =~ /([0-9a-fA-F]{1,2}[:-][0-9a-fA-F]{1,2}[:-][0-9a-fA-F]{1,2}[:-][0-9a-fA-F]{1,2}[:-][0-9a-fA-F]{1,2}[:-][0-9a-fA-F]{1,2})/
+        ::Regexp.last_match(1).downcase
+      else
+        "(incomplete)"
+      end
+    end
+  end
+end

data/lib/lanet/sender.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Lanet
+  class Sender
+    def initialize(port)
+      @port = port
+      @socket = UDPSocket.new
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+    end
+
+    def send_to(target_ip, message)
+      @socket.send(message, 0, target_ip, @port)
+    end
+
+    def broadcast(message)
+      @socket.send(message, 0, "255.255.255.255", @port)
+    end
+  end
+end

data/lib/lanet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lanet
+  VERSION = "0.1.0"
+end

data/lib/lanet.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "lanet/version"
+require "lanet/sender"
+require "lanet/receiver"
+require "lanet/scanner"
+require "lanet/encryptor"
+require "lanet/cli"
+require "lanet/ping"
+
+module Lanet
+  class Error < StandardError; end
+
+  # Default port used for communication
+  DEFAULT_PORT = 5000
+
+  # Creates a new sender instance
+  def self.sender(port = DEFAULT_PORT)
+    Sender.new(port)
+  end
+
+  # Creates a new receiver instance
+  def self.receiver(port = DEFAULT_PORT)
+    Receiver.new(port)
+  end
+
+  # Creates a new scanner instance
+  def self.scanner
+    Scanner.new
+  end
+
+  # Helper to encrypt a message
+  def self.encrypt(message, key)
+    Encryptor.prepare_message(message, key)
+  end
+
+  # Helper to decrypt a message
+  def self.decrypt(data, key)
+    Encryptor.process_message(data, key)
+  end
+
+  def self.pinger(timeout: 1, count: 3)
+    Ping.new(timeout: timeout, count: count)
+  end
+end

data/sig/lanet.rbs

@@ -0,0 +1,4 @@
+module Lanet
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end