sparoid 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7838b331849e520e484b7c061e7f0b176b5e21127f4e56cb5b82226fea8724ee
-  data.tar.gz: 530254c56b3311043f4264243d358c736e7c3253e29c0d8c1a89dd1d5473bb43
+  metadata.gz: e31fd430f74d9eabc1cae19dfe70b1ad40511850ecf77d1e5b436e5dfc206836
+  data.tar.gz: 6fc3c4fa8f4a9e0cc2d63e26138e89b03c689481c1a3b42be46493aad653d2ae
 SHA512:
-  metadata.gz: '085c9e8b9fc3684f79501c146320dc332e4d0303e68a7e359ff38d30bfd32e87dd8826cf7e9c82259df50214738be52fc5862b4e5adc6bade33aee3ed0f9d224'
-  data.tar.gz: b931da160e4bf5603b147b695ac1e4858a059652d93732ba629f6ee334275e51e77208d72dbf165ad397f15da3f590571cdd383fc56c96daec67b0f6e7e84d28
+  metadata.gz: c445dc3e34df5a0a51c654d0e8447a7d96cb8ba675d105680bfa74a0b0fdedc98364123a375ac3fe7213e1c17200b1ce1181a19f944d22f4998d2f730239bfdd
+  data.tar.gz: 3a91e79c4030419da559578051f4abef33aceaa8e20a3fd1a3202959342030941f5d6bb7c33e31fe1dfa2107dea2b63bcda1719eb2b50cd0551a23630b5f1c78

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [2.1.0] - 2026-03-10
+
+- Aligning CLI with Crystal client interface (`send`/`connect` subcommands with flags)
+- Detect public IPv6 via UDP socket probe instead of interface enumeration
+- Remove v2 message format, only send v1 (with IPv4 or IPv6 address)
+
 ## [2.0.0] - 2026-02-19
 
 - Add IPv6 support

data/exe/sparoid

@@ -1,9 +1,5 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-begin
-  require_relative "../lib/sparoid/cli"
-  Sparoid::CLI.start
-rescue Interrupt
-  exit 1
-end
+require_relative "../lib/sparoid/cli"
+Sparoid::CLI.run

data/lib/sparoid/cli.rb

@@ -1,56 +1,66 @@
 # frozen_string_literal: true
 
-require "thor"
+require "optparse"
 require_relative "../sparoid"
 
 module Sparoid
   # CLI
-  class CLI < Thor
-    map "-v" => :version
+  module CLI
+    def self.run(args = ARGV) # rubocop:disable Metrics/AbcSize
+      subcommand = args.shift
+      host = "0.0.0.0"
+      port = 8484
+      tcp_port = 22
+      config_path = "~/.sparoid.ini"
 
-    desc "auth HOST [PORT]", "Send a authorization packet"
-    method_option :config, desc: "Path to a config file, INI format, with key and hmac-key", default: "~/.sparoid.ini"
-    def auth(host, port = 8484)
-      send_auth(host, port, options[:config])
-    rescue Errno::ENOENT
-      abort "Sparoid: Config not found"
-    rescue StandardError => e
-      pp e.backtrace
-      abort "Sparoid: #{e.message} (#{host})"
-    end
-
-    desc "connect HOST PORT [SPA-PORT]", "Send a SPA, TCP connect, and then pass the FD back to the parent"
-    method_option :config, desc: "Path to a config file, INI format, with key and hmac-key", default: "~/.sparoid.ini"
-    def connect(host, port, spa_port = 8484)
-      ips = send_auth(host, spa_port, options[:config])
-      Sparoid.fdpass(ips, port)
+      case subcommand
+      when "keygen"
+        Sparoid.keygen
+      when "send"
+        parse_send_options!(args, binding)
+        key, hmac_key = read_keys(config_path)
+        Sparoid.auth(key, hmac_key, host, port)
+      when "connect"
+        parse_connect_options!(args, binding)
+        key, hmac_key = read_keys(config_path)
+        ips = Sparoid.auth(key, hmac_key, host, port)
+        Sparoid.fdpass(ips, tcp_port)
+      when "--version"
+        puts Sparoid::VERSION
+      else
+        puts "Usage: sparoid [subcommand] [options]"
+        puts ""
+        puts "Subcommands: keygen, send, connect"
+        puts "Use --version to show version"
+        exit 1
+      end
     rescue StandardError => e
-      abort "Sparoid: #{e.message} (#{host})"
+      warn "Sparoid error: #{e.message}"
+      exit 1
     end
 
-    desc "keygen", "Generate an encryption key and a HMAC key"
-    def keygen
-      Sparoid.keygen
+    def self.parse_send_options!(args, ctx, banner: "send")
+      OptionParser.new do |p|
+        p.banner = "Usage: sparoid #{banner} [options]"
+        p.on("-h HOST", "--host=HOST", "Host to send to") { |v| ctx.local_variable_set(:host, v) }
+        p.on("-p PORT", "--port=PORT", "UDP port (default: 8484)") { |v| ctx.local_variable_set(:port, v.to_i) }
+        p.on("-c PATH", "--config=PATH", "Path to config file") { |v| ctx.local_variable_set(:config_path, v) }
+        yield p if block_given?
+      end.parse!(args)
     end
 
-    desc "version", "Show version and exit"
-    def version
-      puts "#{Sparoid::VERSION} (ruby)"
+    def self.parse_connect_options!(args, ctx)
+      parse_send_options!(args, ctx, banner: "connect") do |p|
+        p.on("-P PORT", "--tcp-port=PORT", "TCP port (default: 22)") { |v| ctx.local_variable_set(:tcp_port, v.to_i) }
+      end
     end
 
-    def self.exit_on_failure?
-      true
+    def self.read_keys(config_path)
+      parse_ini(config_path).values_at("key", "hmac-key")
     end
 
-    private
-
-    def send_auth(host, port, config)
-      key, hmac_key = get_keys(parse_ini(config))
-      Sparoid.auth(key, hmac_key, host, port.to_i)
-    end
-
-    def parse_ini(path)
-      File.readlines(File.expand_path(path)).map! { |line| line.split("=", 2).map!(&:strip) }.to_h
+    def self.parse_ini(path)
+      File.readlines(File.expand_path(path)).to_h { |line| line.split("=", 2).map(&:strip) }
     rescue Errno::ENOENT
       {
         "key" => ENV.fetch("SPAROID_KEY", nil),
@@ -58,8 +68,6 @@ module Sparoid
       }
     end
 
-    def get_keys(config)
-      config.values_at("key", "hmac-key")
-    end
+    private_class_method :parse_send_options!, :parse_connect_options!, :read_keys, :parse_ini
   end
 end

data/lib/sparoid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sparoid
-  VERSION = "2.0.0"
+  VERSION = "2.1.1"
 end

data/lib/sparoid.rb

@@ -4,7 +4,7 @@ require_relative "sparoid/version"
 require "socket"
 require "openssl"
 require "resolv"
-require "timeout"
+require "net/http"
 
 # Single Packet Authorisation client
 module Sparoid # rubocop:disable Metrics/ModuleLength
@@ -17,6 +17,8 @@ module Sparoid # rubocop:disable Metrics/ModuleLength
     "ipv4.icanhazip.com"
   ].freeze
 
+  GOOGLE_DNS_V6 = ["2001:4860:4860::8888", 53].freeze
+
   # Send an authorization packet
   def auth(key, hmac_key, host, port, open_for_ip: nil)
     addrs = resolve_ip_addresses(host, port)
@@ -79,40 +81,16 @@ module Sparoid # rubocop:disable Metrics/ModuleLength
   private
 
   def generate_messages(ip)
-    messages = if ip
-                 create_messages(string_to_ip(ip))
-               else
-                 generate_public_ip_messages
-               end
-
-    messages.flatten.sort_by!(&:bytesize)
-  end
-
-  def generate_public_ip_messages
-    messages = []
-    ipv6_native = false
-    public_ipv6_with_range.each do |addr, prefixlen|
-      ipv6 = Resolv::IPv6.create(addr)
-      messages << message_v2(ipv6, prefixlen)
-      ipv6_native = true
-    end
-
-    cached_public_ips.each do |ip|
-      next if ip.is_a?(Resolv::IPv6) && ipv6_native
-
-      messages << create_messages(ip)
-    end
-    messages
-  end
-
-  def create_messages(ip)
-    case ip
-    when Resolv::IPv4
-      [message(ip), message_v2(ip, 32)]
-    when Resolv::IPv6
-      [message_v2(ip, 128)]
+    if ip
+      [message(string_to_ip(ip))]
     else
-      raise ArgumentError, "Unsupported IP type #{ip.class}"
+      ips = cached_public_ips
+      native_ipv6 = public_ipv6_by_udp
+      if native_ipv6
+        ips = ips.grep_v(Resolv::IPv6)
+        ips << Resolv::IPv6.create(native_ipv6)
+      end
+      ips.map { |i| message(i) }
     end
   end
 
@@ -150,26 +128,13 @@ module Sparoid # rubocop:disable Metrics/ModuleLength
     hmac + data
   end
 
+  # Message format: version(4) + timestamp(8) + nonce(16) + ip(4 or 16)
+  # https://github.com/84codes/sparoid/blob/main/src/message.cr
   def message(ip)
     version = 1
     ts = (Time.now.utc.to_f * 1000).floor
     nounce = OpenSSL::Random.random_bytes(16)
-    [version, ts, nounce, ip.address].pack("N q> a16 a4")
-  end
-
-  # Message format can be found the server repository:
-  # https://github.com/84codes/sparoid/blob/main/src/message.cr
-  def message_v2(ip, range = nil)
-    version = 2
-    ts = (Time.now.utc.to_f * 1000).floor
-    nounce = OpenSSL::Random.random_bytes(16)
-    family = case ip
-             when Resolv::IPv4 then 4
-             when Resolv::IPv6 then 6
-             else raise ArgumentError, "Unsupported IP type #{ip.class}"
-             end
-    range ||= (family == 4 ? 32 : 128)
-    [version, ts, nounce, family, ip.address, range].pack("N q> a16 C a* C")
+    [version, ts, nounce, ip.address].pack("N q> a16 a*")
   end
 
   def cached_public_ips
@@ -217,25 +182,15 @@ module Sparoid # rubocop:disable Metrics/ModuleLength
     end
   end
 
-  def public_ips(port = 80) # rubocop:disable Metrics/AbcSize
+  def public_ips(port = 80)
     URLS.map do |host|
-      Timeout.timeout(5) do
-        Socket.tcp(host, port, connect_timeout: 3, resolv_timeout: 3) do |sock|
-          sock.sync = true
-          sock.print "GET / HTTP/1.1\r\nHost: #{host}\r\nConnection: close\r\n\r\n"
-          status = sock.readline(chomp: true)
-          raise(ResolvError, "#{host}:#{port} response: #{status}") unless status.start_with? "HTTP/1.1 200 "
-
-          content_length = 0
-          until (header = sock.readline(chomp: true)).empty?
-            if (m = header.match(/^Content-Length: (\d+)/))
-              content_length = m[1].to_i
-            end
-          end
-          ip = sock.read(content_length).chomp
-          string_to_ip(ip)
-        end
-      end
+      http = Net::HTTP.new(host, port)
+      http.open_timeout = 3
+      http.read_timeout = 5
+      response = http.get("/")
+      raise(ResolvError, "#{host}:#{port} response: #{response.code}") unless response.is_a?(Net::HTTPSuccess)
+
+      string_to_ip(response.body.chomp)
     rescue StandardError
       nil
     end.compact
@@ -261,24 +216,26 @@ module Sparoid # rubocop:disable Metrics/ModuleLength
     raise(ResolvError, "Sparoid failed to resolv #{host}")
   end
 
-  def public_ipv6_with_range
-    global_ipv6_ifs = Socket.getifaddrs.select do |addr|
-      addrinfo = addr.addr
-      addrinfo&.ipv6? && global_ipv6?(addrinfo)
-    end
-
-    global_ipv6_ifs.map do |iface|
-      addrinfo = iface.addr
-      netmask_addr = IPAddr.new(iface.netmask.ip_address)
-      prefixlen = netmask_addr.to_i.to_s(2).count("1")
-      next addrinfo.ip_address, prefixlen
-    end
+  # Get the public IPv6 address by asking the OS which source address
+  # it would use to reach a well-known IPv6 destination.
+  # Returns nil if no global IPv6 address is available.
+  def public_ipv6_by_udp
+    socket = UDPSocket.new(Socket::AF_INET6)
+    socket.connect(*GOOGLE_DNS_V6)
+    addr = socket.local_address
+    return addr.ip_address if global_ipv6?(addr)
+
+    nil
+  rescue StandardError
+    nil
+  ensure
+    socket&.close
   end
 
-  def global_ipv6?(addrinfo)
-    !(addrinfo.ipv6_mc_global? || addrinfo.ipv6_loopback? || addrinfo.ipv6_v4mapped? ||
-      addrinfo.ipv6_linklocal? || addrinfo.ipv6_multicast? || addrinfo.ipv6_sitelocal? ||
-      addrinfo.ip_address.start_with?("fd00"))
+  def global_ipv6?(addr)
+    !(addr.ipv6_loopback? || addr.ipv6_linklocal? || addr.ipv6_unspecified? ||
+      addr.ipv6_sitelocal? || addr.ipv6_multicast? || addr.ipv6_v4mapped? ||
+      addr.ip_address.start_with?("fd", "fc"))
   end
 
   class Error < StandardError; end

data/sparoid.gemspec

@@ -26,6 +26,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "thor"
   spec.metadata["rubygems_mfa_required"] = "true"
 end

metadata

@@ -1,28 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparoid
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Carl Hörberg
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+dependencies: []
 email:
 - carl@84codes.com
 executables: