msid 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bf25c3ca34367f6073a84e93f267d835f34f56775664a23dc913d2143f9b5b61
+  data.tar.gz: 94ca6e504098733c75dd7017a42343d5ee41af696c9acc95f7b44824d9b15ba4
+SHA512:
+  metadata.gz: 7652b3c1bce0ad68794440ce3a6d8a572d038ae38ef4c22e47af028e1a40f0aac148a969c9255e4dd7e1adec0605eaf84c76dcb9d305ba8346d93ab36f4fa952
+  data.tar.gz: 1675bb45cc39e7060bb3eecdd0ff64b1362b6761c0304e384759695a24b61a62cf078bd826a0d9e0a081475664403e924c832e6fa2daf18f03fefeaa6b4c8fa1

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in msid.gemspec
+gemspec
+
+gem 'minitest', '~> 5.0'
+gem 'rake', '~> 13.0'

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    msid (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.25.5)
+    rake (13.3.0)
+
+PLATFORMS
+  arm64-darwin-24
+  ruby
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  msid!
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.6.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Davide Santangelo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,169 @@
+# 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.
+
+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.
+
+## 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
+# => "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
+
+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'
+```
+
+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.
+
+```sh
+$ msid
+a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2
+```
+
+## 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.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/lib/msid/version.rb

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

data/lib/msid.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'msid/version'
+require 'socket'
+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?
+
+        components.push(salt.to_s) 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}"
+      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
+
+      # @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(',')
+      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
+end

data/msid.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lib/msid/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'msid'
+  spec.version       = Msid::VERSION
+  spec.authors       = ['Davide Santangelo']
+  spec.email         = ['']
+
+  spec.summary       = 'Generates a unique machine fingerprint ID.'
+  spec.description   = 'Creates a unique and secure machine fingerprint ID by gathering various system hardware and software identifiers. Designed to be difficult to replicate on another machine.'
+  spec.homepage      = 'https://github.com/davidesantangelo/msid'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: msid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Davide Santangelo
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-06-27 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
+  on another machine.
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/msid.rb
+- lib/msid/version.rb
+- msid.gemspec
+homepage: https://github.com/davidesantangelo/msid
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/davidesantangelo/msid
+  source_code_uri: https://github.com/davidesantangelo/msid
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Generates a unique machine fingerprint ID.
+test_files: []