RubyGems - lanet - Versions diffs - 0.1.0 - Mend

lanet 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

data/index.html ADDED Viewed

@@ -0,0 +1,233 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Lanet - Lightweight LAN Communication Tool for Networking</title>
+  <style>
+    body {
+      font-family: 'Arial', sans-serif;
+      line-height: 1.6;
+      color: #333;
+      margin: 0;
+      padding: 0;
+      background-color: #f4f4f4;
+    }
+    .container {
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 20px;
+    }
+    header {
+      background: linear-gradient(90deg, #007BFF, #0056b3);
+      color: white;
+      padding: 40px 0;
+      text-align: center;
+      box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    }
+    header h1 {
+      font-size: 3em;
+      margin: 0;
+    }
+    header p {
+      font-size: 1.2em;
+      margin-top: 10px;
+    }
+    .badges {
+      margin-top: 20px;
+    }
+    .badges img {
+      margin: 0 10px;
+    }
+    section {
+      margin: 40px 0;
+      padding: 20px;
+      background-color: white;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    }
+    h2 {
+      color: #007BFF;
+      font-size: 2em;
+      margin-bottom: 20px;
+    }
+    h3 {
+      color: #0056b3;
+      font-size: 1.5em;
+      margin-top: 30px;
+    }
+    code {
+      background-color: #f4f4f4;
+      padding: 2px 4px;
+      border-radius: 4px;
+      font-family: 'Courier New', monospace;
+    }
+    pre {
+      background-color: #f4f4f4;
+      padding: 15px;
+      border-radius: 8px;
+      overflow-x: auto;
+    }
+    .feature-list {
+      list-style-type: none;
+      padding: 0;
+    }
+    .feature-list li {
+      margin: 10px 0;
+      font-size: 1.1em;
+    }
+    .feature-list li::before {
+      content: '🚀';
+      margin-right: 10px;
+    }
+    .cli-example, .api-example {
+      margin: 20px 0;
+    }
+    .cli-example h4, .api-example h4 {
+      margin-bottom: 10px;
+      font-size: 1.2em;
+    }
+    footer {
+      text-align: center;
+      padding: 20px;
+      background-color: #007BFF;
+      color: white;
+      margin-top: 40px;
+    }
+    footer a {
+      color: white;
+      text-decoration: none;
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div class="container">
+      <h1>Lanet</h1>
+      <p>A lightweight, powerful LAN communication tool for Networking</p>
+      <div class="badges">
+        <a href="https://badge.fury.io/rb/lanet"><img src="https://badge.fury.io/rb/lanet.svg" alt="Gem Version"></a>
+        <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License"></a>
+      </div>
+    </div>
+  </header>
+  <div class="container">
+    <section id="about">
+      <h2>About Lanet</h2>
+      <p>Lanet is a lightweight and powerful LAN communication tool for Ruby that enables secure message exchange between devices on the same network. It simplifies peer-to-peer networking with built-in encryption, network discovery, and both targeted and broadcast messaging capabilities.</p>
+    </section>
+    <section id="features">
+      <h2>Features</h2>
+      <ul class="feature-list">
+        <li>Simple API - An intuitive Ruby interface for straightforward network communication.</li>
+        <li>Built-in encryption - Optional message encryption with AES-256-GCM for confidentiality.</li>
+        <li>Network scanning - Automatically discover active devices on your local network.</li>
+        <li>Targeted messaging - Send messages to specific IP addresses.</li>
+        <li>Broadcasting - Send messages to all devices on the network.</li>
+        <li>Host pinging - Check host availability and measure response times (with a familiar <code>ping</code> interface).</li>
+        <li>Command-line interface - Perform common network operations directly from your terminal.</li>
+        <li>Extensible - Easily build custom tools and integrations using the Lanet API.</li>
+        <li>Configurable - Adjust port settings, encryption keys, and network scan ranges.</li>
+      </ul>
+    </section>
+    <section id="installation">
+      <h2>Installation</h2>
+      <p>Add this line to your application's Gemfile:</p>
+      <pre><code>gem 'lanet'</code></pre>
+      <p>And then execute:</p>
+      <pre><code>bundle install</code></pre>
+      <p>Or install it yourself as:</p>
+      <pre><code>gem install lanet</code></pre>
+    </section>
+    <section id="usage">
+      <h2>Usage</h2>
+      <h3>Command Line Interface (CLI)</h3>
+      <div class="cli-example">
+        <h4>Scanning the network</h4>
+        <pre><code>lanet scan --range 192.168.1.0/24</code></pre>
+        <p>With verbose output (shows hostname, MAC address, open ports, and response time):</p>
+        <pre><code>lanet scan --range 192.168.1.0/24 --verbose</code></pre>
+      </div>
+      <div class="cli-example">
+        <h4>Sending a message to a specific target</h4>
+        <pre><code>lanet send --target 192.168.1.5 --message "Hello there!"</code></pre>
+        <p>Sending an encrypted message:</p>
+        <pre><code>lanet send --target 192.168.1.5 --message "Secret message" --key "my_secret_key"</code></pre>
+      </div>
+      <div class="cli-example">
+        <h4>Broadcasting a message to all devices</h4>
+        <pre><code>lanet broadcast --message "Announcement for everyone!"</code></pre>
+      </div>
+      <div class="cli-example">
+        <h4>Pinging a specific host</h4>
+        <pre><code>lanet ping --host 192.168.1.5</code></pre>
+      </div>
+      <h3>Ruby API</h3>
+      <div class="api-example">
+        <h4>Scanning the network</h4>
+        <pre><code>require 'lanet'
+scanner = Lanet.scanner
+active_ips = scanner.scan('192.168.1.0/24')
+puts "Found devices: #{active_ips.join(', ')}"</code></pre>
+      </div>
+      <div class="api-example">
+        <h4>Sending a message</h4>
+        <pre><code>sender = Lanet.sender
+sender.send_to('192.168.1.5', 'Hello from Ruby!')</code></pre>
+        <p>Broadcasting a message:</p>
+        <pre><code>sender.broadcast('Announcement to all devices!')</code></pre>
+      </div>
+      <div class="api-example">
+        <h4>Listening for messages</h4>
+        <pre><code>receiver = Lanet.receiver
+receiver.listen do |data, ip|
+  puts "Received from #{ip}: #{data}"
+end</code></pre>
+      </div>
+    </section>
+    <section id="configuration">
+      <h2>Configuration</h2>
+      <p>Lanet can be configured with several options:</p>
+      <ul>
+        <li><strong>Port</strong>: Default is 5000, but can be changed for both sending and receiving.</li>
+        <li><strong>Encryption Keys</strong>: Use your own encryption keys for secure communication.</li>
+        <li><strong>Custom Ranges</strong>: Scan specific network ranges to discover devices.</li>
+      </ul>
+    </section>
+    <section id="development">
+      <h2>Development</h2>
+      <p>After checking out the repo, run <code>bin/setup</code> to install dependencies. Then, run <code>rake spec</code> to run the tests.</p>
+      <p>To install this gem locally, run <code>bundle exec rake install</code>.</p>
+    </section>
+    <section id="contributing">
+      <h2>Contributing</h2>
+      <p>Bug reports and pull requests are welcome on GitHub at <a href="https://github.com/davidesantangelo/lanet">https://github.com/davidesantangelo/lanet</a>. Follow these steps:</p>
+      <ol>
+        <li>Fork the repository</li>
+        <li>Create your feature branch (<code>git checkout -b my-new-feature</code>)</li>
+        <li>Commit your changes (<code>git commit -am 'Add some feature'</code>)</li>
+        <li>Push to the branch (<code>git push origin my-new-feature</code>)</li>
+        <li>Create a new Pull Request</li>
+      </ol>
+    </section>
+    <section id="license">
+      <h2>License</h2>
+      <p>The gem is available under the <a href="https://opensource.org/licenses/MIT">MIT License</a>.</p>
+    </section>
+  </div>
+  <footer>
+    <p>&copy; 2025 Lanet. All rights reserved. | <a href="https://github.com/davidesantangelo/lanet">View on GitHub</a></p>
+  </footer>
+</body>
+</html>

data/lib/lanet/cli.rb ADDED Viewed

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+require "thor"
+require "lanet/sender"
+require "lanet/receiver"
+require "lanet/scanner"
+require "lanet/ping"
+require "lanet/encryptor"
+module Lanet
+  class CLI < Thor
+    # Add this method to silence Thor errors and disable exit on failure
+    def self.exit_on_failure?
+      false
+    end
+    desc "send --target IP --message MSG [--key KEY] [--port PORT]", "Send a message to a specific target"
+    option :target, required: true
+    option :message, required: true
+    option :key
+    option :port, type: :numeric, default: 5000
+    def send
+      sender = Sender.new(options[:port])
+      message = Encryptor.prepare_message(options[:message], options[:key])
+      sender.send_to(options[:target], message)
+      puts "Message sent to #{options[:target]}"
+    end
+    desc "broadcast --message MSG [--key KEY] [--port PORT]", "Broadcast a message to all devices"
+    option :message, required: true
+    option :key
+    option :port, type: :numeric, default: 5000
+    def broadcast
+      sender = Sender.new(options[:port])
+      message = Encryptor.prepare_message(options[:message], options[:key])
+      sender.broadcast(message)
+      puts "Message broadcasted"
+    end
+    desc "scan --range CIDR [--timeout TIMEOUT] [--threads THREADS] [--verbose]",
+         "Scan for active devices in the given range"
+    option :range, required: true
+    option :timeout, type: :numeric, default: 1
+    option :threads, type: :numeric, default: 32
+    option :verbose, type: :boolean, default: false
+    def scan
+      scanner = Scanner.new
+      results = scanner.scan(
+        options[:range],
+        options[:timeout],
+        options[:threads],
+        options[:verbose]
+      )
+      puts "\nActive devices:"
+      if options[:verbose]
+        results.each do |host|
+          puts "─" * 50
+          puts "IP: #{host[:ip]}"
+          puts "Hostname: #{host[:hostname]}" if host[:hostname]
+          puts "MAC: #{host[:mac]}" if host[:mac] # Add this line to display MAC addresses
+          puts "Response time: #{host[:response_time]}ms" if host[:response_time]
+          puts "Detection method: #{host[:detection_method]}" if host[:detection_method]
+          next unless host[:ports] && !host[:ports].empty?
+          puts "Open ports:"
+          host[:ports].each do |port, service|
+            puts "  - #{port}: #{service}"
+          end
+        end
+        puts "─" * 50
+        puts "Found #{results.size} active hosts."
+      else
+        results.each { |ip| puts ip }
+      end
+    end
+    desc "listen [--port PORT] [--key KEY]", "Listen for incoming messages"
+    option :port, type: :numeric, default: 5000
+    option :key
+    def listen
+      receiver = Receiver.new(options[:port])
+      puts "Listening on port #{options[:port]}..."
+      receiver.listen do |data, ip|
+        message = Encryptor.process_message(data, options[:key])
+        puts "From #{ip}: #{message}"
+      end
+    end
+    desc "ping [HOST]", "Ping a host or multiple hosts with real-time output"
+    option :host, type: :string, desc: "Single host to ping"
+    option :hosts, type: :string, desc: "Comma-separated list of hosts to ping"
+    option :timeout, type: :numeric, default: 1, desc: "Ping timeout in seconds"
+    option :count, type: :numeric, default: 5, desc: "Number of ping packets to send"
+    option :quiet, type: :boolean, default: false, desc: "Only display summary"
+    option :continuous, type: :boolean, default: false, desc: "Ping continuously until interrupted"
+    def ping(target_host = nil)
+      # Support both traditional command (lanet ping 192.168.1.1) and option-style (--host)
+      target = target_host || options[:host] || options[:hosts]
+      unless target
+        puts "Error: Missing host to ping"
+        puts "Usage: lanet ping HOST"
+        puts "   or: lanet ping --host HOST"
+        puts "   or: lanet ping --hosts HOST1,HOST2,HOST3"
+        return
+      end
+      pinger = Lanet::Ping.new(timeout: options[:timeout], count: options[:count])
+      if target_host || options[:host]
+        # For a single host, we use real-time output unless quiet is specified
+        host = target_host || options[:host]
+        if options[:quiet]
+          result = pinger.ping_host(host, false, options[:continuous])
+          display_ping_summary(host, result)
+        else
+          pinger.ping_host(host, true, options[:continuous]) # Real-time output with optional continuous mode
+        end
+      else
+        hosts = options[:hosts].split(",").map(&:strip)
+        if options[:quiet]
+          results = pinger.ping_hosts(hosts, false, options[:continuous])
+          hosts.each do |host|
+            display_ping_summary(host, results[host])
+            puts "\n" unless host == hosts.last
+          end
+        else
+          # Real-time output for multiple hosts
+          pinger.ping_hosts(hosts, true, options[:continuous])
+        end
+      end
+    end
+    private
+    def display_ping_details(host, result)
+      # Display header like standard ping command
+      puts "PING #{host} (#{host}): 56 data bytes"
+      if result[:status]
+        # Display individual ping responses
+        unless options[:quiet]
+          result[:responses].each do |response|
+            puts "64 bytes from #{host}: icmp_seq=#{response[:seq]} ttl=#{response[:ttl]} time=#{response[:time]} ms"
+          end
+        end
+        # Display summary
+        transmitted = options[:count]
+        received = result[:responses].size
+        loss_pct = ((transmitted - received) / transmitted.to_f * 100).round(1)
+        puts "\n--- #{host} ping statistics ---"
+        puts "#{transmitted} packets transmitted, #{received} packets received, #{loss_pct}% packet loss"
+        if received.positive?
+          times = result[:responses].map { |r| r[:time] }
+          min = times.min
+          avg = times.sum / times.size
+          max = times.max
+          mdev = Math.sqrt(times.map { |t| (t - avg)**2 }.sum / times.size).round(3)
+          puts "round-trip min/avg/max/stddev = #{min}/#{avg.round(3)}/#{max}/#{mdev} ms"
+        end
+      else
+        puts "No response from #{host}"
+        puts result[:output] if result[:output].to_s.strip != ""
+      end
+    end
+    # Display only the summary portion
+    def display_ping_summary(host, result)
+      if result[:status]
+        transmitted = options[:count]
+        received = result[:responses].size
+        loss_pct = ((transmitted - received) / transmitted.to_f * 100).round(1)
+        puts "--- #{host} ping statistics ---"
+        puts "#{transmitted} packets transmitted, #{received} packets received, #{loss_pct}% packet loss"
+        if received.positive?
+          times = result[:responses].map { |r| r[:time] }
+          min = times.min
+          avg = times.sum / times.size
+          max = times.max
+          mdev = Math.sqrt(times.map { |t| (t - avg)**2 }.sum / times.size).round(3)
+          puts "round-trip min/avg/max/stddev = #{min}/#{avg.round(3)}/#{max}/#{mdev} ms"
+        end
+      else
+        puts "No response from #{host}"
+      end
+    end
+    def display_ping_result(host, result)
+      # Keep the old method for backward compatibility
+      puts "Host: #{host}"
+      puts "Status: #{result[:status] ? "reachable" : "unreachable"}"
+      if result[:status]
+        puts "Response time: #{result[:response_time]}ms"
+        puts "Packet loss: #{result[:packet_loss]}%"
+      end
+      return unless options[:verbose]
+      puts "\nOutput:"
+      puts result[:output]
+    end
+    # Override method_missing to provide helpful error messages for common mistakes
+    def method_missing(method, *args)
+      if method.to_s == "ping" && args.any?
+        invoke "ping", [], { host: args.first, timeout: options[:timeout], count: options[:count],
+                             quiet: options[:quiet], continuous: options[:continuous] }
+      else
+        super
+      end
+    end
+    def respond_to_missing?(method, include_private = false)
+      method.to_s == "ping" || super
+    end
+  end
+end

data/lib/lanet/encryptor.rb ADDED Viewed

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+require "openssl"
+require "digest"
+require "base64"
+module Lanet
+  class Encryptor
+    # Constants
+    CIPHER_ALGORITHM = "AES-256-CBC"
+    ENCRYPTED_PREFIX = "E"
+    PLAINTEXT_PREFIX = "P"
+    IV_SIZE = 16
+    # Error class for encryption/decryption failures
+    class Error < StandardError; end
+    # Encrypts a message if key is provided, otherwise marks it as plaintext
+    # @param message [String] the message to prepare
+    # @param key [String, nil] encryption key or nil for plaintext
+    # @return [String] prepared message with appropriate prefix
+    def self.prepare_message(message, key)
+      return PLAINTEXT_PREFIX + message.to_s if key.nil? || key.empty?
+      begin
+        cipher = OpenSSL::Cipher.new("AES-128-CBC")
+        cipher.encrypt
+        cipher.key = derive_key(key)
+        iv = cipher.random_iv
+        encrypted = cipher.update(message.to_s) + cipher.final
+        encoded = Base64.strict_encode64(iv + encrypted)
+        "#{ENCRYPTED_PREFIX}#{encoded}"
+      rescue StandardError => e
+        raise Error, "Encryption failed: #{e.message}"
+      end
+    end
+    # Processes a message, decrypting if necessary
+    # @param data [String] the data to process
+    # @param key [String, nil] decryption key or nil
+    # @return [String] processed message
+    def self.process_message(data, key)
+      return "[Empty message]" if data.nil? || data.empty?
+      prefix = data[0]
+      content = data[1..]
+      case prefix
+      when ENCRYPTED_PREFIX
+        if key.nil? || key.strip.empty?
+          "[Encrypted message received, but no key provided]"
+        else
+          begin
+            decode_encrypted_message(content, key)
+          rescue StandardError => e
+            "Decryption failed: #{e.message}"
+          end
+        end
+      when PLAINTEXT_PREFIX
+        content
+      else
+        "[Invalid message format]"
+      end
+    end
+    def self.derive_key(key)
+      digest = OpenSSL::Digest.new("SHA256")
+      OpenSSL::PKCS5.pbkdf2_hmac(key, "salt", 1000, 16, digest)
+    end
+    def self.decode_encrypted_message(content, key)
+      decoded = Base64.strict_decode64(content)
+      iv = decoded[0...16]
+      ciphertext = decoded[16..]
+      decipher = OpenSSL::Cipher.new("AES-128-CBC")
+      decipher.decrypt
+      decipher.key = derive_key(key)
+      decipher.iv = iv
+      decipher.update(ciphertext) + decipher.final
+    end
+  end
+end