passw 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3141c86801808c3cc779ddfc545e1d1421447894e5e689b1dd9ac2ef9d9554c8
-  data.tar.gz: ee4c7f89f378859666dd9c088eadef2c37db8aba9fe448d45819969fe88718ec
+  metadata.gz: 861aa536ac1b2f8f9f6962d996b1f5a9e8cef01a81d3a74b81c35bbe1c1efab2
+  data.tar.gz: 73b49a46d9c1d4945cace67566be4966416d9b96baec77fbf847aad0132e1210
 SHA512:
-  metadata.gz: dac19c051d61d46c09ca31f86da80849edac4b8236eb048de36b1d151cd4352fb096fbd686b3e8016b3751676b2938d79f686b032c93e2967c46c0d2b78d72e9
-  data.tar.gz: 6316b7adf6dc0d6e31c40323bdbe81a829788a12c5e560bca5fdb3c45f54f05151f75fd7f0bfc35a107c7ef5f34fc3089770be1c2660ba0e6ca04f73bf346985
+  metadata.gz: 9212c895b7a18ebc4bf1c4058733060c385b7b589004c0ae6905f4c4906f842ddd763be4ceae279872c6838e05bb604f89d7ff4199643b3b3861c0c62a6cd3e9
+  data.tar.gz: d46c2ea84faba50fc396f9ffb293d38f311140fe0cfd9a2bdbe95ed4564e0685114273c6ea275bbf9ea38a359cf78a9b6d3f10374840a6d4ebc338cbfab423b6

data/bin/passw

@@ -1,10 +1,80 @@
 #!/usr/bin/env ruby
 
+require 'optparse'
 require 'rubygems'
-require File.expand_path('../lib/passw', File.dirname(__FILE__))
+require_relative '../lib/passw'
 
-if !ARGV.empty?
-  puts Passw.generate(ARGV[0])
-else
-  puts "Passw Usage: passw <length>"
-end
+# Default options
+options = {
+  lowercase: true,
+  uppercase: true,
+  symbols: true,
+  numbers: true,
+  duplicates: true,
+  enforce_types: true,
+  avoid_sequences: false,
+  exclude: [],
+  min_length: 8
+}
+
+# Define and parse options
+OptionParser.new do |opts|
+  opts.banner = "Usage: passw <length> [options]"
+
+  opts.on("-l", "--lowercase", "Include lowercase letters (default: true)") do
+    options[:lowercase] = true
+  end
+
+  opts.on("-u", "--uppercase", "Include uppercase letters (default: true)") do
+    options[:uppercase] = true
+  end
+
+  opts.on("-s", "--symbols", "Include symbols (default: true)") do
+    options[:symbols] = true
+  end
+
+  opts.on("-n", "--numbers", "Include numbers (default: true)") do
+    options[:numbers] = true
+  end
+
+  opts.on("-d", "--no-duplicates", "Disallow duplicate characters") do
+    options[:duplicates] = false
+  end
+
+  opts.on("-e", "--enforce-types", "Ensure at least one of each selected type (default: true)") do
+    options[:enforce_types] = true
+  end
+
+  opts.on("-a", "--avoid-sequences", "Avoid sequential characters") do
+    options[:avoid_sequences] = true
+  end
+
+  opts.on("-x", "--exclude CHARS", "Exclude specific characters (comma-separated, e.g., 'O,0,I,l')") do |chars|
+    options[:exclude] = chars.split(',')
+  end
+
+  opts.on("-m", "--min-length LENGTH", Integer, "Set minimum password length (default: 8)") do |min_length|
+    options[:min_length] = min_length
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end.parse!
+
+# Ensure length is provided and valid
+if ARGV.empty?
+  puts "Error: You must specify a password length."
+  puts "Usage: passw <length> [options]"
+  exit
+end
+
+length = ARGV[0].to_i
+if length <= 0
+  puts "Error: Please enter a valid positive integer for length."
+  exit
+end
+
+# Generate and print the password
+puts Passw.generate(length, options)

data/lib/passw.rb

@@ -1,68 +1,120 @@
 module Passw
-  # Generate a password with the sepecified options
+  # Generate a password with specified options
   # Params:
   # +length+:: the length of the password
   # +options+:: a hash defining the attributes for the password
   def self.generate(length, options = {})
     defaults = {
-      lowercase:  true, # Allow lower case characters
-      uppercase:  true, # Allow uppercase characters
-      symbols:    true, # Allow symbols
-      numbers:    true, # Allow numbers 
-      duplicates: true  # Allow characters to be duplicated (less secure if true)
+      lowercase:        true,  # Allow lowercase characters
+      uppercase:        true,  # Allow uppercase characters
+      symbols:          true,  # Allow symbols
+      numbers:          true,  # Allow numbers
+      duplicates:       true,  # Allow duplicates
+      enforce_types:    true,  # Ensure at least one of each selected character type
+      avoid_sequences:  true,  # Avoid sequential/repeating characters
+      exclude:          [],    # Characters to exclude from password
+      min_length:       8      # Minimum password length
     }
-    
-    defaults.merge!(options)
-    
-    buffer = []
-    
-    buffer += lowercase if defaults[:lowercase]
-    buffer += uppercase if defaults[:uppercase]
-    buffer += symbols   if defaults[:symbols]
-    buffer += numbers   if defaults[:numbers]
-    
-    base = []
-    
-    buffer_length = buffer.length
-
-    (0...length.to_i).each do |i|
-      if defaults[:duplicates]
-        base << buffer[srand % buffer_length]
+
+    # Merge user options with defaults
+    settings = defaults.merge(options)
+
+    # Enforce minimum length
+    length = [length.to_i, settings[:min_length]].max
+
+    # Build character set based on options
+    character_set = build_character_set(settings)
+    return '' if character_set.empty?
+
+    # Filter out excluded characters
+    character_set -= settings[:exclude]
+
+    # Generate the password with necessary character types enforced
+    password = generate_password(character_set, length, settings)
+
+    # Calculate and display password entropy
+    entropy = calculate_entropy(character_set.size, length)
+
+    password.shuffle.join
+  end
+
+  private
+
+  # Build the character set based on the specified options
+  def self.build_character_set(settings)
+    character_set = []
+    character_set += lowercase if settings[:lowercase]
+    character_set += uppercase if settings[:uppercase]
+    character_set += symbols   if settings[:symbols]
+    character_set += numbers   if settings[:numbers]
+    character_set
+  end
+
+  # Generate the password based on options
+  def self.generate_password(character_set, length, settings)
+    password = []
+
+    # Ensure at least one character from each type if enforce_types is enabled
+    if settings[:enforce_types]
+      password << lowercase.sample if settings[:lowercase]
+      password << uppercase.sample if settings[:uppercase]
+      password << symbols.sample if settings[:symbols]
+      password << numbers.sample if settings[:numbers]
+    end
+
+    # Fill the rest of the password
+    while password.length < length
+      candidate = character_set.sample
+
+      if settings[:duplicates]
+        password << candidate
       else
-        loop do
-          candidate = buffer[srand % buffer_length]
-          
-          if !base.include? candidate
-            base << candidate
-            break
-          end
-          
-          # Ensure that this loop does not run forever if duplicates are disallowed
-          # In this case, we're limited to the collective size of buffered characters
-          
-          break if base.length == buffer_length - 1
+        # Avoid duplicates if duplicates option is false
+        next if password.include?(candidate)
+        password << candidate
+      end
+
+      # Avoid sequences/repeating characters if avoid_sequences is true
+      if settings[:avoid_sequences] && password.size > 1
+        next_char = password[-1]
+        prev_char = password[-2]
+        if next_char.ord == prev_char.ord + 1 || next_char.ord == prev_char.ord - 1
+          password.pop
         end
       end
     end
-    
-    base.shuffle.join
+    password
   end
 
-  private 
+  # Entropy calculation
+  def self.calculate_entropy(charset_size, length)
+    (Math.log2(charset_size) * length).round(2)
+  end
+
+  # Assess password strength based on entropy value
+  def self.password_strength(entropy)
+    case entropy
+    when 0..27   then "Very Weak"
+    when 28..35  then "Weak"
+    when 36..59  then "Reasonable"
+    when 60..127 then "Strong"
+    else              "Very Strong"
+    end
+  end
 
   def self.symbols
     %w[! " ' # $ % & ( ) * + , - . / : ; < = > ? ` ~ { | } @ ^]
   end
 
   def self.lowercase
-    %w[a b c d e f g h i j k l m n o p q r s t u v w x y z]
-  end  
+    ('a'..'z').to_a
+  end
 
   def self.uppercase
-    %w[A B C D E F G H I J K L M N O P Q R S T U V W X Y Z]
-  end    
+    ('A'..'Z').to_a
+  end
 
   def self.numbers
-    %w[0 1 2 3 4 5 6 7 8 9]
+    ('0'..'9').to_a
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: passw
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Sean Nieuwoudt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-11 00:00:00.000000000 Z
+date: 2024-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -16,36 +16,30 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.7'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.7.0
+        version: '5.25'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.7'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.7.0
+        version: '5.25'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: 13.2.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
-description: Passw is a simple, customizable password generator for Ruby that allows
-  you to generate secure passwords easily
+        version: 13.2.1
+description: Passw is a Ruby library for generating secure passwords, supporting length,
+  character types, exclusions, and entropy-based strength assessment.
 email: sean@isean.co.za
 executables:
 - passw
@@ -56,9 +50,11 @@ files:
 - lib/passw.rb
 homepage: https://github.com/sn/passw
 licenses:
-- GPL-3.0
-metadata: {}
-post_install_message: 
+- GPL-3.0-or-later
+metadata:
+  changelog_uri: https://github.com/sn/passw/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/sn/passw#readme
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -66,15 +62,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: Passw is a simple, customizable password generator for Ruby
+summary: Customizable Ruby library for secure password generation with character and
+  strength options.
 test_files: []