msid 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf25c3ca34367f6073a84e93f267d835f34f56775664a23dc913d2143f9b5b61
-  data.tar.gz: 94ca6e504098733c75dd7017a42343d5ee41af696c9acc95f7b44824d9b15ba4
+  metadata.gz: a66c2777ff91a9d45dadccdfeed8d8428ce55b153ab5dfb47fbe933042ac918c
+  data.tar.gz: 417965adb88e1fb02a1907f786d7fe09119958ed5ce5707e010399eb35c9f334
 SHA512:
-  metadata.gz: 7652b3c1bce0ad68794440ce3a6d8a572d038ae38ef4c22e47af028e1a40f0aac148a969c9255e4dd7e1adec0605eaf84c76dcb9d305ba8346d93ab36f4fa952
-  data.tar.gz: 1675bb45cc39e7060bb3eecdd0ff64b1362b6761c0304e384759695a24b61a62cf078bd826a0d9e0a081475664403e924c832e6fa2daf18f03fefeaa6b4c8fa1
+  metadata.gz: a427b6baad02240f442fea21a66ec814404be918c2070c0006521e91387ad4b89f8ec26a649f4bb4bf2e157f40814b243e45855571adaab3822b8ac487a24ed3
+  data.tar.gz: 2cd36016dafbf2a3da4e0f9a421e23bc29d62ad858de5dd0ca96fd811a6410249c2a72d9ee0b6d408c782fe3fae2bb1a47aa021f0baf0e12117cc3f402b7ca91

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    msid (0.1.0)
+    msid (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,169 +1,41 @@
 # msid
 
-`msid` is a Ruby gem for generating a unique and secure machine fingerprint ID. It gathers a wide range of system identifiers to create a hash that is highly specific to the machine it's run on.
+`msid` generates a **unique, secure, and consistent machine fingerprint** for Ruby applications. It gathers hardware identifiers (CPU, Mac Address, Disk UUIDs, etc.) to create a specific SHA-256 hash.
 
-This is useful for licensing, device identification, or any scenario where you need to reliably identify a specific machine.
-
-## How It Works
-
-`msid` collects the following system information:
-- Hostname
-- All MAC addresses
-- CPU model and core count
-- Total RAM
-- OS and kernel information
-- Hardware Serial Number
-- Hardware UUID
-- Motherboard Serial Number
-- Root disk volume UUID
-- System Model Identifier
-- GPU Information
-- BIOS/Firmware Information
-- Serial numbers of all physical disks
-
-It then combines these components into a single string and uses the SHA-256 algorithm to produce a consistent, unique fingerprint.
-
-## Use Cases
-
-Here are some practical scenarios where `msid` can be valuable:
-
-### Software Licensing
-- **Offline License Activation**: Bind software licenses to specific machines without requiring constant internet validation.
-- **Trial Period Management**: Track installations to prevent users from repeatedly installing trial versions.
-- **License Auditing**: Keep track of which machines have your software installed for compliance purposes.
-
-### Security Applications
-- **Multi-factor Authentication**: Add an extra layer of security by validating not just "something you know" (password) but also "something you have" (the specific device).
-- **Session Security**: Detect when a user's session moves to a different machine, potentially indicating session hijacking.
-- **Fraud Detection**: Flag accounts that suddenly access your service from multiple different machines in rapid succession.
-
-### System Management
-- **Asset Tracking**: Inventory management for IT departments to track hardware across an organization.
-- **Configuration Management**: Associate specific configurations or settings with particular machines.
-- **Environment-specific Features**: Enable or disable features based on the hardware environment.
-
-### DevOps and Deployment
-- **Environment Fingerprinting**: Distinguish between development, staging, and production environments.
-- **Deployment Validation**: Ensure that deployments only happen from authorized build machines.
-- **Infrastructure Auditing**: Track which servers or virtual machines are running your applications.
-
-### Usage Analytics
-- **Device Demographics**: Gather anonymous statistics about what kinds of machines are running your software.
-- **Installation Metrics**: Track unique installations versus reinstallations.
-- **Hardware Compatibility**: Identify hardware configurations where your software performs well or poorly.
+Useful for licensing, analytics, and security.
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
 ```ruby
 gem 'msid'
 ```
 
-And then execute:
-
-    $ bundle install
-
-Or install it yourself as:
-
-    $ gem install msid
-
 ## Usage
 
-### From Ruby
-
-You can generate the machine ID from your Ruby code.
-
 ```ruby
 require 'msid'
 
-# Generate the default ID
-machine_id = Msid.generate
-puts machine_id
+# Generate Machine ID
+Msid.generate
 # => "a1b2c3d4..."
-```
-
-#### Using a Salt
-
-For enhanced security, you can provide a `salt`. This is useful if you want to generate different IDs for different applications on the same machine.
-
-```ruby
-require 'msid'
-
-# Generate an ID with a salt
-app_specific_id = Msid.generate(salt: 'my-super-secret-app-key')
-puts app_specific_id
-# => "e5f6g7h8..." (different from the one without a salt)
-```
-
-### With IRB (for local development)
-
-If you are developing the gem locally, you can test it with `irb`. From the root directory of the gem, run `irb` with the `-I` flag to add the `lib` directory to Ruby's load path.
 
-```sh
-$ irb -I lib
-```
-
-Then, inside `irb`, you can require and use the gem:
-
-```ruby
-irb(main):001:0> require 'msid'
-=> true
-irb(main):002:0> Msid.generate
-=> "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2"
-```
-
-### In a Rails Application
+# With Salt (Recommended for App-Specific IDs)
+Msid.generate(salt: 'my-secret-app-key')
 
-To use `msid` in a Rails application, add it to your `Gemfile`.
-
-If you are developing the gem locally, you can use the `path` option:
-```ruby
-# Gemfile
-gem 'msid', path: '/path/to/your/msid/gem'
+# Inspect Gathered Data (New in v0.2.0)
+Msid.info
+# => {:hostname=>"MacBook-Pro.local", :cpu_model=>"Apple M1", ...}
 ```
 
-If the gem is on RubyGems, add it normally:
-```ruby
-# Gemfile
-gem 'msid'
-```
-
-Then run `bundle install`.
-
-Now you can use it anywhere in your Rails application, including the Rails console:
-
-```sh
-$ rails console
-```
-
-```ruby
-# In Rails console
-irb(main):001:0> Msid.generate
-=> "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2"
-
-# For extra security, you can use a Rails secret as a salt
-irb(main):002:0> Msid.generate(salt: Rails.application.credentials.secret_key_base)
-=> "f1e2d3c4b5a6f7e8d9c0b1a2f3e4d5c6b7a8f9e0d1c2b3a4f5e6d7c8b9a0f1e2"
-```
-
-### From the Command Line
-
-The gem provides a command-line executable to easily retrieve the machine ID.
+### CLI
 
 ```sh
 $ msid
-a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2
+a1b2c3d4...
 ```
 
-## Development
-
-After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests.
-
 ## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/davidesantangelo/msid.
+Bug reports and pull requests are welcome on [GitHub](https://github.com/davidesantangelo/msid).
 
 ## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+MIT License.

data/lib/msid/source.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Msid
+  # Base class for platform-specific data sources.
+  # Subclasses should implement methods to gather system information.
+  class Source
+    # @return [Hash] A hash containing all gathered system information.
+    def gather
+      {
+        hostname: hostname,
+        mac_addresses: mac_addresses,
+        cpu_model: cpu_model,
+        cpu_cores: cpu_cores,
+        memory: memory,
+        os_kernel: os_kernel,
+        serial_number: serial_number,
+        hardware_uuid: hardware_uuid,
+        board_serial: board_serial,
+        disk_uuid: disk_uuid,
+        model_identifier: model_identifier,
+        gpu_model: gpu_model,
+        bios_version: bios_version,
+        disk_serials: disk_serials
+      }
+    end
+
+    protected
+
+    # Executes a shell command and returns its stripped stdout.
+    # Returns nil if the command fails or an error occurs.
+    def run(command)
+      stdout, _stderr, status = Open3.capture3(command)
+      status.success? ? stdout.strip : nil
+    rescue StandardError
+      nil
+    end
+
+    # Normalize a string/array for consistent ID generation
+    def normalize(value)
+      case value
+      when Array
+        value.compact.map { |v| normalize(v) }.reject(&:empty?).sort.join(',')
+      when String
+        value.strip
+      else
+        value
+      end
+    end
+
+    # Abstract methods to be implemented by subclasses
+    %i[hostname mac_addresses cpu_model cpu_cores memory os_kernel
+       serial_number hardware_uuid board_serial disk_uuid
+       model_identifier gpu_model bios_version disk_serials].each do |method|
+      define_method(method) { nil }
+    end
+  end
+end

data/lib/msid/sources/darwin.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'msid/source'
+require 'socket'
+
+module Msid
+  module Sources
+    # MacOS specific data source implementation.
+    class Darwin < Source
+      def hostname
+        Socket.gethostname
+      end
+
+      def mac_addresses
+        run("ifconfig -a | grep -o -E '([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}'")&.split("\n")
+      end
+
+      def cpu_model
+        sysctl('machdep.cpu.brand_string')
+      end
+
+      def cpu_cores
+        sysctl('hw.ncpu')
+      end
+
+      def memory
+        sysctl('hw.memsize')
+      end
+
+      def os_kernel
+        "#{RUBY_PLATFORM}-#{run('uname -r')}"
+      end
+
+      def serial_number
+        # system_profiler is slow, try ioreg first? 
+        # For stability, sticking to system_profiler but ideally we'd cache this if called multiple times.
+        # However, for a one-off generation, a single call is fine. 
+        # We can optimize by asking for *only* the specific data type.
+        run("system_profiler SPHardwareDataType | awk '/Serial Number/{print $4}'")
+      end
+
+      def hardware_uuid
+        run("system_profiler SPHardwareDataType | awk '/Hardware UUID/ {print $3}'")
+      end
+
+      def board_serial
+        # macOS doesn't easily expose this to user space without root or private entitlements sometimes.
+        nil 
+      end
+
+      def disk_uuid
+        run("diskutil info / | awk '/Volume UUID/{print $3}'")
+      end
+
+      def model_identifier
+        sysctl('hw.model') # Faster than system_profiler
+      end
+
+      def gpu_model
+        run("system_profiler SPDisplaysDataType | grep 'Chipset Model:' | awk -F': ' '{print $2}'")
+      end
+
+      def bios_version
+        run("system_profiler SPHardwareDataType | awk '/Boot ROM Version/ {print $4}'")
+      end
+
+      def disk_serials
+        run("system_profiler SPStorageDataType | grep 'Serial Number:' | awk '{print $3}'")&.split("\n")
+      end
+
+      private
+
+      def sysctl(key)
+        run("sysctl -n #{key}")
+      end
+    end
+  end
+end

data/lib/msid/sources/linux.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'msid/source'
+require 'socket'
+
+module Msid
+  module Sources
+    # Linux specific data source implementation.
+    class Linux < Source
+      def hostname
+        Socket.gethostname
+      end
+
+      def mac_addresses
+        # More reliable than parsing `ip` command output
+        Dir.glob('/sys/class/net/*/address').map { |f| File.read(f).strip }
+      rescue StandardError
+        []
+      end
+
+      def cpu_model
+        run("grep 'model name' /proc/cpuinfo | uniq | awk -F': ' '{print $2}'")
+      end
+
+      def cpu_cores
+        run('nproc')
+      end
+
+      def memory
+        run("grep MemTotal /proc/meminfo | awk '{print $2}'")
+      end
+
+      def os_kernel
+        "#{RUBY_PLATFORM}-#{run('uname -r')}"
+      end
+
+      def serial_number
+        run('cat /sys/class/dmi/id/product_serial')
+      end
+
+      def hardware_uuid
+        run('cat /sys/class/dmi/id/product_uuid')
+      end
+
+      def board_serial
+        run('cat /sys/class/dmi/id/board_serial')
+      end
+
+      def disk_uuid
+        device = run("df / | tail -n1 | awk '{print $1}'")
+        run("lsblk -no UUID #{device}") if device
+      end
+
+      def model_identifier
+        run('cat /sys/class/dmi/id/product_name')
+      end
+
+      def gpu_model
+        run("lspci | grep -i 'vga\\|3d\\|2d' | head -n 1 | awk -F': ' '{print $3}'")
+      end
+
+      def bios_version
+        vendor = run('cat /sys/class/dmi/id/bios_vendor')
+        version = run('cat /sys/class/dmi/id/bios_version')
+        "#{vendor}-#{version}" if vendor && version
+      end
+
+      def disk_serials
+        run('lsblk -d -o serial -n')&.split("\n")
+      end
+    end
+  end
+end

data/lib/msid/sources/windows.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'msid/source'
+require 'socket'
+
+module Msid
+  module Sources
+    # Windows specific data source implementation.
+    class Windows < Source
+      def hostname
+        Socket.gethostname
+      end
+
+      def mac_addresses
+        run('getmac /v /fo csv | findstr /V "Disconnected"')
+          &.lines
+          &.map { |line| line.split(',')[2]&.gsub('"', '')&.strip }
+      end
+
+      def cpu_model
+        wmic('cpu get name')&.gsub('Name=', '')
+      end
+
+      def cpu_cores
+        wmic('cpu get NumberOfCores')
+      end
+
+      def memory
+        wmic('ComputerSystem get TotalPhysicalMemory')
+      end
+
+      def os_kernel
+        "#{RUBY_PLATFORM}-#{run('ver')}"
+      end
+
+      def serial_number
+        wmic('bios get serialnumber')
+      end
+
+      def hardware_uuid
+        wmic('csproduct get uuid')
+      end
+
+      def board_serial
+        wmic('baseboard get serialnumber')
+      end
+
+      def disk_uuid
+        run('vol c: | findstr "Serial Number"')&.split&.last
+      end
+
+      def model_identifier
+        wmic('csproduct get name')
+      end
+
+      def gpu_model
+        wmic('path win32_videocontroller get name')
+      end
+
+      def bios_version
+        run('wmic bios get manufacturer,version /format:list')
+      end
+
+      def disk_serials
+        wmic('diskdrive get serialnumber')&.split("\n")
+      end
+
+      private
+
+      # Helper to run wmic commands and strip headers
+      def wmic(query)
+        # WMIC output often contains the header repeated or extra whitespace.
+        # This is a basic filter based on the original implementation's logic (using findstr /V).
+        # We'll rely on the specific parsing logic from original which used findstr /V "HeaderName"
+        # Since we want to be generic here, let's keep it simple:
+        # Original: run('wmic cpu get NumberOfCores | findstr /V "NumberOfCores"')
+        # So we just construct that command.
+        
+        # Extract the property name from the query "cpu get NumberOfCores" -> "NumberOfCores"
+        # This is valid for simple "get X" queries.
+        property = query.split.last
+        run("wmic #{query} | findstr /V \"#{property}\"")
+      end
+    end
+  end
+end

data/lib/msid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Msid
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/msid.rb

@@ -1,248 +1,64 @@
 # frozen_string_literal: true
 
 require 'msid/version'
-require 'socket'
+require 'msid/source'
 require 'digest'
-require 'open3'
 
 module Msid
   class Error < StandardError; end
 
-  # Generates a unique machine fingerprint ID.
-  #
-  # The fingerprint is created by collecting various system identifiers,
-  # combining them into a single string, and then hashing it with SHA-256.
-  # This makes the ID highly unique to the machine it's generated on.
   class Generator
     class << self
-      # Gathers a collection of machine-specific identifiers.
-      # @return [Array<String>] a list of identifiers.
-      def gather_components
-        [
-          hostname,
-          all_mac_addresses,
-          cpu_info,
-          cpu_cores,
-          total_memory,
-          os_info,
-          serial_number,
-          hardware_uuid,
-          baseboard_serial,
-          disk_uuid,
-          system_model,
-          gpu_info,
-          bios_info,
-          all_disk_serials
-        ].compact.reject(&:empty?)
-      end
-
       # Generates the unique machine ID.
       # @param salt [String, nil] An optional salt to add to the fingerprint.
       # @return [String] The SHA-256 hash representing the machine ID.
       def generate(salt: nil)
         components = gather_components
-        raise Error, 'Could not gather any machine identifiers.' if components.empty?
+        raise Error, 'Could not gather any machine identifiers.' if components.values.reject { |v| v.nil? || v.empty? }.empty?
 
-        components.push(salt.to_s) if salt
+        data_string = components.values.compact.reject(&:empty?).join(':')
+        data_string += ":#{salt}" if salt
 
-        data_string = components.join(':')
         Digest::SHA256.hexdigest(data_string)
       end
 
-      private
-
-      # Executes a shell command and returns its stripped stdout.
-      # Returns nil if the command fails or an error occurs.
-      def run_command(command)
-        stdout, _stderr, status = Open3.capture3(command)
-        status.success? ? stdout.strip : nil
-      rescue StandardError
-        nil
-      end
-
-      # @return [String, nil] The machine's hostname.
-      def hostname
-        Socket.gethostname
-      rescue StandardError
-        nil
-      end
-
-      # @return [String, nil] A sorted, concatenated string of all MAC addresses.
-      def all_mac_addresses
-        macs = case RUBY_PLATFORM
-               when /darwin/ # macOS
-                 run_command("ifconfig -a | grep -o -E '([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}'")&.split("\n")
-               when /linux/
-                 # Read from /sys/class/net, which is more reliable than parsing `ip` command output
-                 begin
-                   Dir.glob('/sys/class/net/*/address').map { |f| File.read(f).strip }
-                 rescue StandardError
-                   []
-                 end
-               when /mswin|mingw/ # Windows
-                 run_command('getmac /v /fo csv | findstr /V "Disconnected"')
-               &.lines
-               &.map { |line| line.split(',')[2]&.gsub('"', '')&.strip }
-               else
-                 []
-               end
-        macs&.compact&.reject(&:empty?)&.sort&.join(',')
-      end
-
-      # @return [String, nil] CPU model information.
-      def cpu_info
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command('sysctl -n machdep.cpu.brand_string')
-        when /linux/
-          run_command("grep 'model name' /proc/cpuinfo | uniq | awk -F': ' '{print $2}'")
-        when /mswin|mingw/
-          run_command('wmic cpu get name /format:list | findstr "Name="')&.gsub('Name=', '')
-        end
-      end
-
-      # @return [String, nil] Number of CPU cores.
-      def cpu_cores
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command('sysctl -n hw.ncpu')
-        when /linux/
-          run_command('nproc')
-        when /mswin|mingw/
-          run_command('wmic cpu get NumberOfCores | findstr /V "NumberOfCores"')
-        end
-      end
-
-      # @return [String, nil] Total physical memory in bytes or KB.
-      def total_memory
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command('sysctl -n hw.memsize')
-        when /linux/
-          run_command("grep MemTotal /proc/meminfo | awk '{print $2}'")
-        when /mswin|mingw/
-          run_command('wmic ComputerSystem get TotalPhysicalMemory | findstr /V "TotalPhysicalMemory"')
-        end
-      end
-
-      # @return [String, nil] Operating system and kernel information.
-      def os_info
-        kernel_info = case RUBY_PLATFORM
-                      when /mswin|mingw/
-                        run_command('ver')
-                      else
-                        run_command('uname -r')
-                      end
-        "#{RUBY_PLATFORM}-#{kernel_info}"
+      # Returns a hash of all gathered components.
+      # @return [Hash]
+      def info
+        gather_components
       end
 
-      # @return [String, nil] The machine's hardware serial number.
-      def serial_number
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command("system_profiler SPHardwareDataType | awk '/Serial Number/{print $4}'")
-        when /linux/
-          run_command('cat /sys/class/dmi/id/product_serial')
-        when /mswin|mingw/
-          run_command('wmic bios get serialnumber | findstr /V "SerialNumber"')
-        end
-      end
-
-      # @return [String, nil] The machine's hardware UUID.
-      def hardware_uuid
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command("system_profiler SPHardwareDataType | awk '/Hardware UUID/ {print $3}'")
-        when /linux/
-          run_command('cat /sys/class/dmi/id/product_uuid')
-        when /mswin|mingw/
-          run_command('wmic csproduct get uuid | findstr /V "UUID"')
-        end
-      end
-
-      # @return [String, nil] The machine's baseboard serial number.
-      def baseboard_serial
-        case RUBY_PLATFORM
-        when /darwin/
-          nil # Not easily available/distinct from system serial on macOS
-        when /linux/
-          run_command('cat /sys/class/dmi/id/board_serial')
-        when /mswin|mingw/
-          run_command('wmic baseboard get serialnumber | findstr /V "SerialNumber"')
-        end
-      end
-
-      # @return [String, nil] The UUID of the root volume.
-      def disk_uuid
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command("diskutil info / | awk '/Volume UUID/{print $3}'")
-        when /linux/
-          device = run_command("df / | tail -n1 | awk '{print $1}'")
-          run_command("lsblk -no UUID #{device}") if device
-        when /mswin|mingw/
-          run_command('vol c: | findstr "Serial Number"')&.split&.last
-        end
-      end
-
-      # @return [String, nil] The machine's system model identifier.
-      def system_model
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command("system_profiler SPHardwareDataType | awk '/Model Identifier/ {print $3}'")
-        when /linux/
-          run_command('cat /sys/class/dmi/id/product_name')
-        when /mswin|mingw/
-          run_command('wmic csproduct get name | findstr /V "Name"')
-        end
-      end
-
-      # @return [String, nil] The machine's GPU information.
-      def gpu_info
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command("system_profiler SPDisplaysDataType | grep 'Chipset Model:' | awk -F': ' '{print $2}'")
-        when /linux/
-          run_command("lspci | grep -i 'vga\\|3d\\|2d' | head -n 1 | awk -F': ' '{print $3}'")
-        when /mswin|mingw/
-          run_command('wmic path win32_videocontroller get name | findstr /V "Name"')
-        end
-      end
-
-      # @return [String, nil] The machine's BIOS/firmware information.
-      def bios_info
-        case RUBY_PLATFORM
-        when /darwin/
-          run_command("system_profiler SPHardwareDataType | awk '/Boot ROM Version/ {print $4}'")
-        when /linux/
-          vendor = run_command('cat /sys/class/dmi/id/bios_vendor')
-          version = run_command('cat /sys/class/dmi/id/bios_version')
-          "#{vendor}-#{version}" if vendor && version
-        when /mswin|mingw/
-          run_command('wmic bios get manufacturer,version /format:list')
-        end
-      end
+      private
 
-      # @return [String, nil] A sorted, concatenated string of all physical disk serial numbers.
-      def all_disk_serials
-        serials = case RUBY_PLATFORM
-                  when /darwin/
-                    run_command("system_profiler SPStorageDataType | grep 'Serial Number:' | awk '{print $3}'")&.split("\n")
-                  when /linux/
-                    run_command('lsblk -d -o serial -n')&.split("\n")
-                  when /mswin|mingw/
-                    run_command('wmic diskdrive get serialnumber | findstr /V "SerialNumber"')&.split("\n")
-                  else
-                    []
-                  end
-        serials&.compact&.map(&:strip)&.reject(&:empty?)&.sort&.join(',')
+      def gather_components
+        @components ||= source.gather
+      end
+
+      def source
+        @source ||= case RUBY_PLATFORM
+                    when /darwin/
+                      require 'msid/sources/darwin'
+                      Msid::Sources::Darwin.new
+                    when /linux/
+                      require 'msid/sources/linux'
+                      Msid::Sources::Linux.new
+                    when /mswin|mingw/
+                      require 'msid/sources/windows'
+                      Msid::Sources::Windows.new
+                    else
+                      raise Error, "Unsupported platform: #{RUBY_PLATFORM}"
+                    end
       end
     end
   end
 
   # Shortcut for Msid::Generator.generate
-  # @param salt [String, nil] An optional salt to add to the fingerprint.
   def self.generate(salt: nil)
     Generator.generate(salt: salt)
   end
+
+  # Shortcut for Msid::Generator.info
+  def self.info
+    Generator.info
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: msid
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Davide Santangelo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-27 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies: []
 description: Creates a unique and secure machine fingerprint ID by gathering various
   system hardware and software identifiers. Designed to be difficult to replicate
@@ -25,6 +25,10 @@ files:
 - README.md
 - Rakefile
 - lib/msid.rb
+- lib/msid/source.rb
+- lib/msid/sources/darwin.rb
+- lib/msid/sources/linux.rb
+- lib/msid/sources/windows.rb
 - lib/msid/version.rb
 - msid.gemspec
 homepage: https://github.com/davidesantangelo/msid