lanet 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaec61e714b22eea7e3e40e66b6250672b93d15539f6645bc2ded8ea4c282458
-  data.tar.gz: 8f906d539e9878b418b156f7e735898dc04e9d05924ade44bcee23729474907d
+  metadata.gz: a1e22dfda5b58811a99f1d763c3ff32d84b2e8e291ab07b8f1ee90e3c1849446
+  data.tar.gz: 70a12c6ea35bd5981acc401f0a7dc482c2f2161c2a67a8b4ffcefc00ac1777a4
 SHA512:
-  metadata.gz: d33ad462b0f69392f3f4fe4ce44ef405d2a734acf26f6ce892b3b1545f0dacf99cb545bbbc39ce7d2697ec89989ff1ec843e47f74943178faf66b4a284e51888
-  data.tar.gz: 73a1f2985e2592931ff80588358b5e83e10d99da077e7001e6ec12b614d37f30af0c7a2f2546f83382133a61c6b2e5d4ec1961edb02fa4d8803b359efd48e9a0
+  metadata.gz: e45f31e4dacefa4d0622f1fdfe8d8cb48dca0c4ad256481a06f8bf7d1dea2ef231be657db2b8c92c1e129faa8375bdc36221152fb7967cca15ae7bc3c5fce89b
+  data.tar.gz: 4cceff6bc76a51aeebb0bc0585ec9228d53151421927e8e8461e39a79f0208ed3a793455f8b9e0714364ce9cb169e987ab757a29e7ad4ab3acc908ab72f8a11f

data/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2023-11-15
+
+### Added
+- Mesh networking functionality for decentralized communication
+- Auto-discovery of mesh nodes
+- Message routing through intermediate nodes
+- CLI commands for mesh network operations: `mesh start`, `mesh send`, `mesh info`
+- Ruby API methods for creating and managing mesh networks
+
+## [0.3.0] - 2025-03-08
+
+### Added
+- Encrypted file transfer support over LAN
+- New `FileTransfer` class for sending and receiving files securely
+- CLI commands for file transfer operations:
+  - `send-file` - Send a file to a specific target
+  - `receive-file` - Listen for incoming files
+- Progress tracking for file transfers
+- File integrity verification via SHA-256 checksums
+- Support for digital signatures in file transfers
+- File chunking for efficient transfer of large files
+- Comprehensive documentation and examples
+
 ## [0.2.1] - 2025-03-07
 
 ### Fixed

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lanet (0.2.1)
+    lanet (0.4.0)
       thor (~> 1.2)
 
 GEM

data/README.md

@@ -8,16 +8,18 @@ A lightweight, powerful LAN communication tool that enables secure message excha
 
 ## Features
 
-- 🚀 **Simple API** - An intuitive Ruby interface makes network communication straightforward.
-- 🔒 **Built-in encryption** - Optional message encryption with AES-256-GCM for confidentiality.
-- 🔍 **Network scanning** - Automatically discover active devices on your local network.
-- 📡 **Targeted messaging** - Send messages to specific IP addresses.
-- 📣 **Broadcasting** - Send messages to all devices on the network.
-- 🔔 **Host pinging** - Check host availability and measure response times (with a familiar `ping` interface).
-- 🖥️ **Command-line interface** - Perform common network operations directly from your terminal.
-- 🧩 **Extensible** - Easily build custom tools and integrations using the Lanet API.
-- ⚙️ **Configurable:**  Adjust port settings, encryption keys, and network scan ranges.
+- **Simple API** - An intuitive Ruby interface makes network communication straightforward.
+- **Built-in encryption** - Optional message encryption with AES-256-GCM for confidentiality.
+- **Network scanning** - Automatically discover active devices on your local network.
+- **Targeted messaging** - Send messages to specific IP addresses.
+- **Broadcasting** - Send messages to all devices on the network.
+- **Host pinging** - Check host availability and measure response times (with a familiar `ping` interface).
+- **Command-line interface** - Perform common network operations directly from your terminal.
+- **Extensible** - Easily build custom tools and integrations using the Lanet API.
+- **Configurable:**  Adjust port settings, encryption keys, and network scan ranges.
 - **Digital Signatures**: Ensure message authenticity and integrity
+- **File Transfers**: Securely send encrypted files over the LAN with progress tracking and integrity verification
+- **Mesh Networking**: Create resilient mesh networks for decentralized communication, enabling messages to be routed through multiple hops without central infrastructure
 
 ## Security Features
 
@@ -266,6 +268,72 @@ Ping multiple hosts continuously:
 lanet ping --hosts 192.168.1.5,192.168.1.6 --continuous
 ```
 
+#### Sending Files Securely
+
+Send files with encryption:
+
+```bash
+lanet send-file --target 192.168.1.5 --file document.pdf --key "my_secret_key"
+```
+
+Send files with encryption and digital signatures:
+
+```bash
+lanet send-file --target 192.168.1.5 --file document.pdf --key "my_secret_key" --private-key-file lanet_private.key
+```
+
+#### Receiving Files
+
+Listen for incoming files:
+
+```bash
+lanet receive-file --output ./downloads
+```
+
+Receive encrypted files:
+
+```bash
+lanet receive-file --output ./downloads --encryption-key "my_secret_key"
+```
+
+Receive encrypted files with signature verification:
+
+```bash
+lanet receive-file --output ./downloads --encryption-key "my_secret_key" --public-key-file lanet_public.key
+```
+
+#### Mesh Networking
+
+Create a decentralized mesh network where devices can communicate even without direct connectivity:
+
+```bash
+# Start a mesh network node
+lanet mesh start
+
+# Start a mesh network node with custom settings
+lanet mesh start --port 5050 --max-hops 15
+```
+
+Send messages through the mesh network:
+
+```bash
+# Send a message through the mesh network to a specific node ID
+lanet mesh send --target a1b2c3d4-5678-90ef-ghij --message "Hello Mesh Network"
+
+# Send an encrypted message through the mesh network
+lanet mesh send --target a1b2c3d4-5678-90ef-ghij --message "Secret mesh message" --key "secret-key"
+
+# Send a signed message through the mesh network
+lanet mesh send --target a1b2c3d4-5678-90ef-ghij --message "Authenticated mesh message" --private-key-file lanet_private.key
+```
+
+View information about your mesh network:
+
+```bash
+# Display information about mesh network connections
+lanet mesh info
+```
+
 ### Ruby API
 
 You can also use Lanet programmatically in your Ruby applications:
@@ -340,8 +408,60 @@ end
 
 # Ping multiple hosts continuously
 pinger.ping_hosts(['192.168.1.5', '192.168.1.6'], true, true)
+
+# Work with secure file transfers
+file_transfer = Lanet.file_transfer
+file_transfer.send_file('192.168.1.5', 'document.pdf', 'encryption_key') do |progress, bytes, total|
+  puts "Progress: #{progress}% (#{bytes}/#{total} bytes)"
+end
+
+# Receive files
+file_transfer.receive_file('./downloads', 'encryption_key') do |event, data|
+  case event
+  when :start
+    puts "Receiving file: #{data[:file_name]} from #{data[:sender_ip]}"
+  when :progress
+    puts "Progress: #{data[:progress]}%"
+  when :complete
+    puts "File saved to: #{data[:file_path]}"
+  end
+end
+
+# Mesh Networking
+mesh = Lanet.mesh_network
+mesh.start  # Start the mesh node and discovery service
+
+# Send a message through the mesh network
+mesh.send_message(target_node_id, "Hello through the mesh!", "optional-encryption-key")
+
+# Get info about mesh connections
+puts "Node ID: #{mesh.node_id}"
+puts "Connected to #{mesh.connections.size} nodes"
+mesh.connections.each do |node_id, info|
+  puts "  #{node_id} (#{info[:ip]})"
+end
+
+# Properly stop the mesh node
+mesh.stop
 ```
 
+## Mesh Network
+
+The mesh networking feature provides decentralized communication capabilities:
+
+- **Auto-discovery**: Nodes automatically find each other on the network
+- **Multi-hop routing**: Messages can be routed through intermediate nodes
+- **Self-healing**: Adapts to changing network conditions and lost connections
+- **Store and forward**: Messages persist until they can be delivered
+- **End-to-end security**: Messages remain encrypted across multiple hops
+- **Verification**: Digital signatures ensure message integrity through the mesh
+
+Ideal for:
+- IoT networks where devices may not have direct connectivity
+- Ad-hoc networks without fixed infrastructure
+- Networks requiring high resilience and redundancy
+- Applications needing peer-to-peer communication
+
 ## Configuration
 
 Lanet can be configured with several options:
@@ -487,14 +607,106 @@ end
 # monitor.run_continuous_monitoring
 ```
 
-This system:
-- Scans the network to find all connected devices
-- Detects unknown devices and sends alerts
-- Continuously monitors critical devices like servers and network equipment
-- Alerts administrators when a device's status changes
-- Can be extended with additional notification methods
+## Use Case Example: Securely Sharing Files in a Team Environment
+
+This example demonstrates how to use Lanet's file transfer capabilities to securely share files within a team:
+
+```ruby
+require 'lanet'
+require 'fileutils'
+
+class SecureTeamFileSharing
+  def initialize(team_key, keys_dir = '~/.lanet_keys')
+    @team_key = team_key
+    @keys_dir = File.expand_path(keys_dir)
+    @transfer = Lanet.file_transfer
+    
+    # Ensure keys directory exists
+    FileUtils.mkdir_p(@keys_dir) unless Dir.exist?(@keys_dir)
+    
+    # Generate keys if they don't exist
+    unless File.exist?(private_key_path) && File.exist?(public_key_path)
+      puts "Generating new key pair for secure file sharing..."
+      key_pair = Lanet::Signer.generate_key_pair
+      File.write(private_key_path, key_pair[:private_key])
+      File.write(public_key_path, key_pair[:public_key])
+      puts "Keys generated successfully."
+    end
+    
+    # Load the private key
+    @private_key = File.read(private_key_path)
+  end
+  
+  def share_file(target_ip, file_path)
+    unless File.exist?(file_path)
+      puts "Error: File not found: #{file_path}"
+      return false
+    end
+    
+    puts "Sharing file: #{File.basename(file_path)} (#{File.size(file_path)} bytes)"
+    puts "Target: #{target_ip}"
+    puts "Security: Encrypted with team key and digitally signed"
+    
+    begin
+      @transfer.send_file(target_ip, file_path, @team_key, @private_key) do |progress, bytes, total|
+        print "\rProgress: #{progress}% (#{bytes}/#{total} bytes)"
+      end
+      puts "\nFile shared successfully!"
+      true
+    rescue StandardError => e
+      puts "\nError sharing file: #{e.message}"
+      false
+    end
+  end
+  
+  def start_receiver(output_dir = './shared_files')
+    FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+    puts "Listening for incoming files..."
+    puts "Files will be saved to: #{output_dir}"
+    
+    @transfer.receive_file(output_dir, @team_key, File.read(public_key_path)) do |event, data|
+      case event
+      when :start
+        puts "\nIncoming file: #{data[:file_name]} from #{data[:sender_ip]}"
+        puts "Size: #{data[:file_size]} bytes"
+      when :progress
+        print "\rReceiving: #{data[:progress]}% complete"
+      when :complete
+        puts "\nFile received: #{data[:file_path]}"
+        puts "Signature verified: Authentic file from team member"
+      when :error
+        puts "\nError: #{data[:error]}"
+      end
+    end
+  end
+  
+  private
+  
+  def private_key_path
+    File.join(@keys_dir, 'team_private.key')
+  end
+  
+  def public_key_path
+    File.join(@keys_dir, 'team_public.key')
+  end
+end
 
-You can set this up as a scheduled task or service to run continuously on a dedicated machine.
+# Usage:
+# sharing = SecureTeamFileSharing.new("team-secret-key-123")
+#
+# To share a file:
+# sharing.share_file("192.168.1.5", "important_document.pdf")
+#
+# To receive files:
+# sharing.start_receiver("./team_files")
+```
+
+This example:
+- Creates a secure file sharing system with end-to-end encryption
+- Uses team-wide encryption key for confidentiality
+- Implements digital signatures to verify file authenticity
+- Provides real-time progress tracking for both sending and receiving files
+- Handles errors gracefully with user-friendly messages
 
 ## Development