lanet 0.5.1 → 1.0.0

data/lib/lanet/encryptor.rb

@@ -3,71 +3,93 @@
 require "openssl"
 require "digest"
 require "base64"
+require_relative "config"
 require_relative "signer"
 
 module Lanet
+  # Encryptor class for message encryption/decryption and signing
   class Encryptor
-    # Constants
-    CIPHER_ALGORITHM = "AES-256-CBC"
+    # Message type prefixes
     ENCRYPTED_PREFIX = "E"
     PLAINTEXT_PREFIX = "P"
     SIGNED_ENCRYPTED_PREFIX = "SE"
     SIGNED_PLAINTEXT_PREFIX = "SP"
-    IV_SIZE = 16
+
+    # Delimiters and sizes
     SIGNATURE_DELIMITER = "||SIG||"
-    MAX_KEY_LENGTH = 64
 
     # Error class for encryption/decryption failures
     class Error < StandardError; end
 
+    # Message type enumeration
+    module MessageType
+      ENCRYPTED = :encrypted
+      PLAINTEXT = :plaintext
+      SIGNED_ENCRYPTED = :signed_encrypted
+      SIGNED_PLAINTEXT = :signed_plaintext
+    end
+
     # Prepares a message with encryption and/or signing
     # @param message [String] the message to prepare
     # @param encryption_key [String, nil] encryption key or nil for plaintext
     # @param private_key [String, nil] PEM-encoded private key for signing or nil for unsigned
     # @return [String] prepared message with appropriate prefix
     def self.prepare_message(message, encryption_key, private_key = nil)
-      if private_key.nil? || private_key.empty?
-        prepare_unsigned_message(message, encryption_key)
-      else
-        # Sign the message
-        signature = Signer.sign(message.to_s, private_key)
-        message_with_signature = "#{message}#{SIGNATURE_DELIMITER}#{signature}"
+      message_str = message.to_s
+      has_encryption = !encryption_key.nil? && !encryption_key.empty?
+      has_signature = !private_key.nil? && !private_key.empty?
+
+      case [has_signature, has_encryption]
+      when [false, false]
+        prepare_plaintext(message_str)
+      when [false, true]
+        prepare_encrypted(message_str, encryption_key)
+      when [true, false]
+        prepare_signed_plaintext(message_str, private_key)
+      when [true, true]
+        prepare_signed_encrypted(message_str, encryption_key, private_key)
+      end
+    end
 
-        return "#{SIGNED_PLAINTEXT_PREFIX}#{message_with_signature}" if encryption_key.nil? || encryption_key.empty?
+    # Prepare a plaintext message
+    def self.prepare_plaintext(message)
+      "#{PLAINTEXT_PREFIX}#{message}"
+    end
 
-        # Signed but not encrypted
+    # Prepare an encrypted but unsigned message
+    def self.prepare_encrypted(message, key)
+      encrypted_data = encrypt_data(message, key)
+      "#{ENCRYPTED_PREFIX}#{encrypted_data}"
+    end
 
-        # Signed and encrypted
-        begin
-          cipher = OpenSSL::Cipher.new("AES-128-CBC")
-          cipher.encrypt
-          cipher.key = derive_key(encryption_key)
-          iv = cipher.random_iv
-          encrypted = cipher.update(message_with_signature) + cipher.final
-          encoded = Base64.strict_encode64(iv + encrypted)
-          "#{SIGNED_ENCRYPTED_PREFIX}#{encoded}"
-        rescue StandardError => e
-          raise Error, "Encryption failed: #{e.message}"
-        end
+    # Prepare a signed but unencrypted message
+    def self.prepare_signed_plaintext(message, private_key)
+      signature = Signer.sign(message, private_key)
+      message_with_signature = "#{message}#{SIGNATURE_DELIMITER}#{signature}"
+      "#{SIGNED_PLAINTEXT_PREFIX}#{message_with_signature}"
+    end
 
-      end
+    # Prepare a signed and encrypted message
+    def self.prepare_signed_encrypted(message, encryption_key, private_key)
+      signature = Signer.sign(message, private_key)
+      message_with_signature = "#{message}#{SIGNATURE_DELIMITER}#{signature}"
+      encrypted_data = encrypt_data(message_with_signature, encryption_key)
+      "#{SIGNED_ENCRYPTED_PREFIX}#{encrypted_data}"
     end
 
-    # Original prepare_message renamed
-    def self.prepare_unsigned_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
+    # Encrypt data with the given key
+    # @param data [String] data to encrypt
+    # @param key [String] encryption key
+    # @return [String] base64-encoded encrypted data with IV
+    def self.encrypt_data(data, key)
+      cipher = OpenSSL::Cipher.new(Config::CIPHER_ALGORITHM)
+      cipher.encrypt
+      cipher.key = derive_key(key)
+      iv = cipher.random_iv
+      encrypted = cipher.update(data) + cipher.final
+      Base64.strict_encode64(iv + encrypted)
+    rescue StandardError => e
+      raise Error, "Encryption failed: #{e.message}"
     end
 
     # Processes a message, decrypting and verifying if necessary
@@ -78,42 +100,68 @@ module Lanet
     def self.process_message(data, encryption_key = nil, public_key = nil)
       return { content: "[Empty message]", verified: false } if data.nil? || data.empty?
 
-      prefix = data[0..0] # First character for simple prefixes
-      prefix = data[0..1] if data.length > 1 && %w[SE SP].include?(data[0..1]) # Two characters for complex prefixes
-      content = data[prefix.length..]
+      message_type, content = parse_message_type(data)
 
-      case prefix
-      when ENCRYPTED_PREFIX
-        if encryption_key.nil? || encryption_key.strip.empty?
-          { content: "[Encrypted message received, but no key provided]", verified: false }
-        else
-          begin
-            decrypted = decode_encrypted_message(content, encryption_key)
-            { content: decrypted, verified: false }
-          rescue StandardError => e
-            { content: "Decryption failed: #{e.message}", verified: false }
-          end
-        end
-      when PLAINTEXT_PREFIX
+      case message_type
+      when MessageType::ENCRYPTED
+        process_encrypted_message(content, encryption_key)
+      when MessageType::PLAINTEXT
         { content: content, verified: false }
-      when SIGNED_ENCRYPTED_PREFIX
-        if encryption_key.nil? || encryption_key.strip.empty?
-          { content: "[Signed encrypted message received, but no encryption key provided]", verified: false }
-        else
-          begin
-            decrypted = decode_encrypted_message(content, encryption_key)
-            process_signed_content(decrypted, public_key)
-          rescue StandardError => e
-            { content: "Processing signed encrypted message failed: #{e.message}", verified: false }
-          end
-        end
-      when SIGNED_PLAINTEXT_PREFIX
+      when MessageType::SIGNED_ENCRYPTED
+        process_signed_encrypted_message(content, encryption_key, public_key)
+      when MessageType::SIGNED_PLAINTEXT
         process_signed_content(content, public_key)
       else
         { content: "[Invalid message format]", verified: false }
       end
     end
 
+    # Parse the message type from the prefix
+    # @param data [String] the raw message data
+    # @return [Array<Symbol, String>] message type and content
+    def self.parse_message_type(data)
+      # Check for two-character prefixes first
+      if data.length > 1 && data[0..1] == SIGNED_ENCRYPTED_PREFIX
+        [MessageType::SIGNED_ENCRYPTED, data[2..]]
+      elsif data.length > 1 && data[0..1] == SIGNED_PLAINTEXT_PREFIX
+        [MessageType::SIGNED_PLAINTEXT, data[2..]]
+      elsif data[0] == ENCRYPTED_PREFIX
+        [MessageType::ENCRYPTED, data[1..]]
+      elsif data[0] == PLAINTEXT_PREFIX
+        [MessageType::PLAINTEXT, data[1..]]
+      else
+        [nil, data]
+      end
+    end
+
+    # Process an encrypted message
+    def self.process_encrypted_message(content, encryption_key)
+      if encryption_key.nil? || encryption_key.strip.empty?
+        { content: "[Encrypted message received, but no key provided]", verified: false }
+      else
+        begin
+          decrypted = decrypt_data(content, encryption_key)
+          { content: decrypted, verified: false }
+        rescue Error => e
+          { content: "Decryption failed: #{e.message}", verified: false }
+        end
+      end
+    end
+
+    # Process a signed and encrypted message
+    def self.process_signed_encrypted_message(content, encryption_key, public_key)
+      if encryption_key.nil? || encryption_key.strip.empty?
+        { content: "[Signed encrypted message received, but no encryption key provided]", verified: false }
+      else
+        begin
+          decrypted = decrypt_data(content, encryption_key)
+          process_signed_content(decrypted, public_key)
+        rescue Error => e
+          { content: "Processing signed encrypted message failed: #{e.message}", verified: false }
+        end
+      end
+    end
+
     # Process content that contains a signature
     def self.process_signed_content(content, public_key)
       if content.include?(SIGNATURE_DELIMITER)
@@ -135,28 +183,39 @@ module Lanet
       end
     end
 
+    # Derive a key from the provided password
+    # @param key [String] the password/key to derive from
+    # @return [String] derived key of appropriate size
     def self.derive_key(key)
-      # Add validation to reject keys that are too long
-      if key && key.length > MAX_KEY_LENGTH
-        raise Error,
-              "Encryption key is too long (maximum #{MAX_KEY_LENGTH} characters)"
-      end
-
+      validate_key_length(key)
       digest = OpenSSL::Digest.new("SHA256")
-      OpenSSL::PKCS5.pbkdf2_hmac(key, "salt", 1000, 16, digest)
+      OpenSSL::PKCS5.pbkdf2_hmac(key, "salt", 1000, Config::KEY_SIZE, digest)
+    end
+
+    # Validate key length
+    def self.validate_key_length(key)
+      return unless key && key.length > Config::MAX_KEY_LENGTH
+
+      raise Error, "Encryption key is too long (maximum #{Config::MAX_KEY_LENGTH} characters)"
     end
 
-    def self.decode_encrypted_message(content, key)
+    # Decrypt encrypted content
+    # @param content [String] base64-encoded encrypted data with IV
+    # @param key [String] decryption key
+    # @return [String] decrypted data
+    def self.decrypt_data(content, key)
       decoded = Base64.strict_decode64(content)
-      iv = decoded[0...16]
-      ciphertext = decoded[16..]
+      iv = decoded[0...Config::IV_SIZE]
+      ciphertext = decoded[Config::IV_SIZE..]
 
-      decipher = OpenSSL::Cipher.new("AES-128-CBC")
+      decipher = OpenSSL::Cipher.new(Config::CIPHER_ALGORITHM)
       decipher.decrypt
       decipher.key = derive_key(key)
       decipher.iv = iv
 
       decipher.update(ciphertext) + decipher.final
+    rescue StandardError => e
+      raise Error, "Decryption failed: #{e.message}"
     end
   end
 end

data/lib/lanet/file_transfer.rb

@@ -9,21 +9,16 @@ require "base64"
 require "json"
 require "socket"
 require "timeout"
+require_relative "config"
+require_relative "transfer_state"
 
 module Lanet
+  # FileTransfer handles secure file transmission over the network
   class FileTransfer
-    # Constants
-    # Use smaller chunks in tests to avoid "Message too long" errors
-    CHUNK_SIZE = if ENV["LANET_TEST_CHUNK_SIZE"]
-                   ENV["LANET_TEST_CHUNK_SIZE"].to_i
-                 elsif ENV["RACK_ENV"] == "test"
-                   8192 # 8KB in test environment
-                 else
-                   65_536 # 64KB in production
-                 end
-
-    MAX_RETRIES = 3
-    TIMEOUT = ENV["RACK_ENV"] == "test" ? 2 : 10 # Seconds
+    # Use configuration constants
+    CHUNK_SIZE = Config::CHUNK_SIZE
+    MAX_RETRIES = Config::MAX_RETRIES
+    TIMEOUT = Config::FILE_TRANSFER_TIMEOUT
 
     # Message types
     FILE_HEADER = "FH"  # File metadata
@@ -204,17 +199,19 @@ module Lanet
     def handle_file_header(sender_ip, message_data, active_transfers, encryption_key, callback)
       header = JSON.parse(message_data)
       transfer_id = header["id"]
-      active_transfers[transfer_id] = {
+
+      # Create new transfer state
+      active_transfers[transfer_id] = TransferState.new(
+        transfer_id: transfer_id,
         sender_ip: sender_ip,
         file_name: header["name"],
         file_size: header["size"],
-        expected_checksum: header["checksum"],
-        temp_file: Tempfile.new([File.basename(header["name"], ".*"), File.extname(header["name"])]),
-        chunks_received: 0,
-        timestamp: Time.now
-      }
+        expected_checksum: header["checksum"]
+      )
+
       ack_message = Lanet::Encryptor.prepare_message("#{FILE_ACK}#{transfer_id}", encryption_key)
       @sender.send_to(sender_ip, ack_message)
+
       callback&.call(:start, {
                        transfer_id: transfer_id,
                        sender_ip: sender_ip,
@@ -229,19 +226,18 @@ module Lanet
       chunk = JSON.parse(message_data)
       transfer_id = chunk["id"]
       transfer = active_transfers[transfer_id]
-      if transfer && transfer[:sender_ip] == sender_ip
+
+      if transfer && transfer.sender_ip == sender_ip
         chunk_data = Base64.strict_decode64(chunk["data"])
-        transfer[:temp_file].write(chunk_data)
-        transfer[:chunks_received] += 1
-        bytes_received = transfer[:temp_file].size
-        progress = (bytes_received.to_f / transfer[:file_size] * 100).round(2)
+        transfer.write_chunk(chunk_data)
+
         callback&.call(:progress, {
                          transfer_id: transfer_id,
                          sender_ip: sender_ip,
-                         file_name: transfer[:file_name],
-                         progress: progress,
-                         bytes_received: bytes_received,
-                         total_bytes: transfer[:file_size]
+                         file_name: transfer.file_name,
+                         progress: transfer.progress,
+                         bytes_received: transfer.bytes_received,
+                         total_bytes: transfer.file_size
                        })
       end
     rescue JSON::ParserError => e
@@ -252,32 +248,34 @@ module Lanet
       end_data = JSON.parse(message_data)
       transfer_id = end_data["id"]
       transfer = active_transfers[transfer_id]
-      if transfer && transfer[:sender_ip] == sender_ip
-        transfer[:temp_file].close
-        calculated_checksum = calculate_file_checksum(transfer[:temp_file].path)
-        if calculated_checksum == transfer[:expected_checksum]
-          final_path = File.join(output_dir, transfer[:file_name])
-          FileUtils.mv(transfer[:temp_file].path, final_path)
-          ack_message = Lanet::Encryptor.prepare_message("#{FILE_ACK}#{transfer_id}", encryption_key)
-          @sender.send_to(sender_ip, ack_message)
-          callback&.call(:complete, {
-                           transfer_id: transfer_id,
-                           sender_ip: sender_ip,
-                           file_name: transfer[:file_name],
-                           file_path: final_path
-                         })
-        else
-          error_msg = "Checksum verification failed"
-          send_error(sender_ip, transfer_id, error_msg, encryption_key)
-          callback&.call(:error, {
-                           transfer_id: transfer_id,
-                           sender_ip: sender_ip,
-                           error: error_msg
-                         })
-        end
-        transfer[:temp_file].unlink
-        active_transfers.delete(transfer_id)
+
+      return unless transfer && transfer.sender_ip == sender_ip
+
+      if transfer.verify_checksum
+        final_path = File.join(output_dir, transfer.file_name)
+        FileUtils.mv(transfer.temp_file.path, final_path)
+
+        ack_message = Lanet::Encryptor.prepare_message("#{FILE_ACK}#{transfer_id}", encryption_key)
+        @sender.send_to(sender_ip, ack_message)
+
+        callback&.call(:complete, {
+                         transfer_id: transfer_id,
+                         sender_ip: sender_ip,
+                         file_name: transfer.file_name,
+                         file_path: final_path
+                       })
+      else
+        error_msg = "Checksum verification failed"
+        send_error(sender_ip, transfer_id, error_msg, encryption_key)
+        callback&.call(:error, {
+                         transfer_id: transfer_id,
+                         sender_ip: sender_ip,
+                         error: error_msg
+                       })
       end
+
+      transfer.cleanup
+      active_transfers.delete(transfer_id)
     rescue JSON::ParserError => e
       send_error(sender_ip, "unknown", "Invalid end marker format: #{e.message}", encryption_key)
     end
@@ -285,31 +283,25 @@ module Lanet
     def handle_file_error(sender_ip, message_data, active_transfers, callback)
       error_data = JSON.parse(message_data)
       transfer_id = error_data["id"]
-      if callback && active_transfers[transfer_id]
-        callback.call(:error, {
-                        transfer_id: transfer_id,
-                        sender_ip: sender_ip,
-                        error: error_data["message"]
-                      })
-        if active_transfers[transfer_id]
-          active_transfers[transfer_id][:temp_file].close
-          active_transfers[transfer_id][:temp_file].unlink
-          active_transfers.delete(transfer_id)
-        end
-      end
+      transfer = active_transfers[transfer_id]
+
+      return unless callback && transfer
+
+      callback.call(:error, {
+                      transfer_id: transfer_id,
+                      sender_ip: sender_ip,
+                      error: error_data["message"]
+                    })
+
+      transfer.cleanup
+      active_transfers.delete(transfer_id)
     rescue JSON::ParserError
       # Ignore malformed error messages
     end
 
     def cleanup_transfers(active_transfers)
-      active_transfers.each_value do |transfer|
-        transfer[:temp_file].close
-        begin
-          transfer[:temp_file].unlink
-        rescue StandardError
-          nil
-        end
-      end
+      active_transfers.each_value(&:cleanup)
+      active_transfers.clear
     end
   end
 end

data/lib/lanet/receiver.rb

@@ -1,21 +1,77 @@
 # frozen_string_literal: true
 
 require "socket"
+require_relative "config"
 
 module Lanet
+  # Receiver class for UDP message reception
   class Receiver
+    class ReceiveError < StandardError; end
+
+    attr_reader :port
+
     def initialize(port)
       @port = port
-      @socket = UDPSocket.new
-      @socket.bind("0.0.0.0", @port)
+      @socket = nil
+      @closed = false
+      @running = false
+      initialize_socket
     end
 
-    def listen(&block)
+    def listen(buffer_size: Config::SMALL_BUFFER, &block)
+      raise ReceiveError, "Receiver is closed" if @closed
+      raise ArgumentError, "Block is required" unless block_given?
+
+      @running = true
+
       loop do
-        data, addr = @socket.recvfrom(1024)
-        ip = addr[3]
-        block.call(data, ip)
+        break unless @running
+
+        begin
+          data, addr = @socket.recvfrom(buffer_size)
+          ip = addr[3]
+          block.call(data, ip) if data && ip
+        rescue IOError, Errno::EBADF => e
+          break if @closed
+
+          raise ReceiveError, "Socket error: #{e.message}"
+        rescue StandardError => e
+          Config.logger.error("Error receiving message: #{e.message}")
+          # Continue listening despite errors
+        end
       end
+    rescue Interrupt
+      Config.logger.info("Receiver interrupted")
+      stop
+    ensure
+      close unless @closed
+    end
+
+    def stop
+      @running = false
+    end
+
+    def close
+      return if @closed
+
+      @running = false
+      @socket&.close
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    private
+
+    def initialize_socket
+      @socket = UDPSocket.new
+      @socket.bind("0.0.0.0", @port)
+    rescue Errno::EADDRINUSE
+      raise ReceiveError, "Port #{@port} is already in use"
+    rescue StandardError => e
+      raise ReceiveError, "Failed to initialize socket: #{e.message}"
     end
   end
 end

data/lib/lanet/sender.rb

@@ -3,19 +3,51 @@
 require "socket"
 
 module Lanet
+  # Sender class for UDP message transmission
   class Sender
+    class SendError < StandardError; end
+
     def initialize(port)
       @port = port
-      @socket = UDPSocket.new
-      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+      @socket = nil
+      @closed = false
+      initialize_socket
     end
 
     def send_to(target_ip, message)
+      raise SendError, "Sender is closed" if @closed
+      raise ArgumentError, "Invalid IP address" if target_ip.nil? || target_ip.empty?
+      raise ArgumentError, "Message cannot be nil" if message.nil?
+
       @socket.send(message, 0, target_ip, @port)
+    rescue Errno::ENETUNREACH, Errno::EHOSTUNREACH => e
+      raise SendError, "Network unreachable: #{e.message}"
+    rescue StandardError => e
+      raise SendError, "Failed to send message: #{e.message}"
     end
 
     def broadcast(message)
-      @socket.send(message, 0, "255.255.255.255", @port)
+      send_to("255.255.255.255", message)
+    end
+
+    def close
+      return if @closed
+
+      @socket&.close
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    private
+
+    def initialize_socket
+      @socket = UDPSocket.new
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+    rescue StandardError => e
+      raise SendError, "Failed to initialize socket: #{e.message}"
     end
   end
 end

data/lib/lanet/version.rb

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

data/lib/lanet.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require "lanet/version"
+require "lanet/config"
 require "lanet/sender"
 require "lanet/receiver"
 require "lanet/scanner"
 require "lanet/encryptor"
+require "lanet/transfer_state"
 require "lanet/cli"
 require "lanet/ping"
 require "lanet/file_transfer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lanet
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Davide Santangelo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-20 00:00:00.000000000 Z
+date: 2025-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -68,7 +68,10 @@ dependencies:
         version: '3.0'
 description: Lanet provides a simple yet powerful API for LAN device discovery, secure
   messaging, and real-time network monitoring. Features include encrypted communications,
-  network scanning, targeted and broadcast messaging, and host pinging capabilities.
+  network scanning, targeted and broadcast messaging, host pinging, secure file transfers,
+  mesh networking, and advanced traceroute capabilities. Version 1.0.0 brings significant
+  architectural improvements with better resource management, enhanced error handling,
+  and improved code quality while maintaining 100% backward compatibility.
 email:
 - davide.santangelo@example.com
 executables: