polypass 1.0.0

data/lib/polypass.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'literate_randomizer'
+require 'polypass/alpha_numeric'
+require 'polypass/alpha_symbol'
+require 'polypass/helpers'
+require 'polypass/natural_language'
+require 'polypass/version'
+require 'securerandom'
+require 'yaml'
+
+# The polymorphous password generator
+class Polypass
+  attr_accessor :length, :output_type
+
+  def initialize(length = 32, output_type = 'stdout')
+    @length = length.to_i
+    @output_type = output_type.to_s
+  end
+
+  # Set of general built-in helper methods
+  include PolypassHelpers
+
+  # Create and generate secure random alphanumeric passwords
+  class AlphaNumeric < Polypass
+    include PolypassAlphaNumeric
+  end
+
+  # Create and generate secure random alphanumeric symbol passwords
+  class AlphaSymbol < Polypass
+    include PolypassAlphaSymbol
+  end
+
+  # Create and generate secure random natural language passwords
+  class NaturalLanguage < Polypass
+    include PolypassNaturalLanguage
+  end
+end

data/lib/polypass/alpha_numeric.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Polypass::AlphaNumberic Class methods
+module PolypassAlphaNumeric
+  def initialize(length = 32, output_type = 'stdout')
+    super(length, output_type)
+  end
+
+  def create
+    case @output_type
+    when 'stdout'
+      random_element(random_sample_set('alphanumeric', @length))
+    when 'json'
+      output_json({ 'password' => random_element(random_sample_set('alphanumeric', @length)) })
+    when 'yaml'
+      output_yaml({ 'password' => random_element(random_sample_set('alphanumeric', @length)) })
+    end
+  end
+end

data/lib/polypass/alpha_symbol.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Polypass::AlphaSymbol Class methods
+module PolypassAlphaSymbol
+  def initialize(length = 32, output_type = 'stdout')
+    super(length, output_type)
+  end
+
+  def create
+    case @output_type
+    when 'stdout'
+      random_element(random_sample_set('alphasymbol', @length))
+    when 'json'
+      output_json({ 'password' => random_element(random_sample_set('alphasymbol', @length)) })
+    when 'yaml'
+      output_yaml({ 'password' => random_element(random_sample_set('alphasymbol', @length)) })
+    end
+  end
+end

data/lib/polypass/cli.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'polypass'
+require 'thor'
+
+# Thor powered command-line interface
+class PolypassCLI < Thor
+  desc 'version', 'print the version of Polypass'
+  def version
+    puts 'polypass ' + Polypass::VERSION
+  end
+
+  desc 'create TYPE', 'create a TYPE secure random generated password'
+  option :length, aliases: ['-l'], required: false, type: :numeric,
+                  desc: 'length of password'
+  option :output, aliases: ['-o'], required: false, type: :string,
+                  desc: 'type of output formatter. Valid types are: stdout, json, yaml'
+  long_desc <<-LONGDESC
+    `polypass create TYPE` will generate a new secure random password.
+
+    TYPE is the type of password Polypass will create such as alphanumeric,
+    alphanumeric with symbols, natural language, and more.
+
+    TYPE can be one of the following values:
+
+    alphanum alphasym natural
+  LONGDESC
+  def create(type)
+    length = options[:length].nil? ? 32 : options[:length]
+    output = options[:output].nil? ? 'stdout' : options[:output]
+
+    unless ['stdout', 'json', 'yaml'].include?(output)
+      raise ArgumentError,
+            output + ' is not a valid output type. ' +
+            'Available types include: stdout, json, yaml'
+    end
+
+    case type
+    when 'alphanum'
+      puts 'Generating a new secure random alphanumeric password:'
+      puts Polypass::AlphaNumeric.new(length, output).create
+    when 'alphasym'
+      puts 'Generating a new secure random alphanumeric symbol password:'
+      puts Polypass::AlphaSymbol.new(length, output).create
+    when 'natural'
+      length = options[:length].nil? ? 4 : options[:length]
+      puts 'Generating a new secure random natural language password:'
+      puts Polypass::NaturalLanguage.new(length, output).create
+    else
+      raise ArgumentError,
+            type + ' is not a valid password type. Avaiable types include: alphanum, alphasym, natural'
+    end
+  end
+end

data/lib/polypass/helpers.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Collection of general Polypass helper methods
+module PolypassHelpers
+  def alphanumeric_chars
+    characters = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+    return characters
+  end
+
+  def alphasymbol_chars
+    characters = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+    characters += %w(! @ # $ % ^ & * \( \) { } [ ] - _ ~ < > ? ; : ` ~ / + = , . |)
+    return characters
+  end
+
+  def output_json(hash)
+    JSON.pretty_generate(hash)
+  end
+
+  def output_yaml(hash)
+    YAML.dump(hash)
+  end
+
+  def random_element(array)
+    array[SecureRandom.random_number(array.size)].to_s
+  end
+
+  def random_number(integer = 1000)
+    (SecureRandom.random_number(integer) + (SecureRandom.random_number(100) + 1)).to_i
+  end
+
+  def random_sample_chars(chars, length = 32)
+    (1..length).map { chars[SecureRandom.random_number(chars.size)] }.join
+  end
+
+  def random_sample_set(chartype, length = 32, rounds = 1000)
+    random_chars = Array.new
+    (1..random_number(rounds)).each do
+      case chartype
+      when 'alphanumeric'
+        random_chars << random_sample_chars(alphanumeric_chars, length)
+      when 'alphasymbol'
+        random_chars << random_sample_chars(alphasymbol_chars, length)
+      else
+        raise ArgumentError,
+              chartype + 'is an invalid chartype argument. alphanumeric and alphasymbol are the ' +
+              'only valid chartype arguments for the random_sample_set method'
+      end
+    end
+    return random_chars
+  end
+end

data/lib/polypass/natural_language.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Polypass::NaturalLanguage Class methods
+module PolypassNaturalLanguage
+  attr_accessor :language_data
+
+  def initialize(length = 32, output_type = 'stdout')
+    super(length, output_type)
+    @language_data = Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data')) + '/*.txt')
+  end
+
+  def init_language_randomizer
+    return LiterateRandomizer.create(
+      {
+        source_material_file: random_element(@language_data),
+        randomizer:  SecureRandom.random_number(Random.new_seed)
+      }
+    )
+  end
+
+  def create
+    language = init_language_randomizer
+    case @output_type
+    when 'stdout'
+      language.sentence + random_element(random_sample_set('alphanumeric', @length))
+    when 'json'
+      output_json({ 'password' => language.sentence + random_element(random_sample_set('alphanumeric', @length)) })
+    when 'yaml'
+      output_yaml({ 'password' => language.sentence + random_element(random_sample_set('alphanumeric', @length)) })
+    end
+  end
+end

data/lib/polypass/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Polypass
+  VERSION = '1.0.0'
+end

data/polypass.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'polypass/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'polypass'
+  s.date        = '2018-07-12'
+  s.version     = Polypass::VERSION
+  s.authors     = ['Shane R. Sofos']
+  s.email       = ['ssofos@gmail.com']
+  s.homepage    = 'https://shanesofos.com/projects/polypass'
+  s.license     = 'GPL-3.0'
+  s.metadata    = { 'source_code_uri' => 'https://gitlab.com/ssofos/polypass' }
+  s.description = 'The polymorphous password generator.'
+  s.summary     =
+    'A simple multitool that can generate different types of passwords ' +
+    'including secure random, alphanumeric, natural language, and custom, ' +
+    'salt, hash, and output them in different formats for personal and application consumption.'
+
+  s.files         = %x(git ls-files).split($INPUT_RECORD_SEPARATOR)
+  s.bindir        = ['bin']
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+
+  s.add_dependency 'literate_randomizer'
+  s.add_dependency 'thor'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rubocop', '<=0.56.0'
+  s.add_development_dependency 'simplecov'
+
+  s.required_ruby_version = '>= 2.4.0'
+end

data/spec/polypass_alpha_numeric_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'polypass'
+
+describe Polypass::AlphaNumeric do
+  before :all do
+    @polypass_alphanumeric = Polypass::AlphaNumeric.new
+  end
+
+  it 'is a Polypass::AlphaNumeric object' do
+    expect(@polypass_alphanumeric).to be_kind_of(Polypass::AlphaNumeric)
+  end
+
+  it 'should respond to 2 arguments when initialized' do
+    expect(Polypass).to respond_to(:new).with(2).arguments
+  end
+
+  describe '#length' do
+    it 'returns the length of the generated password as Integer class object' do
+      expect(@polypass_alphanumeric.length).to be_kind_of(Integer).and eq(32)
+    end
+  end
+
+  describe '#output_type' do
+    it 'returns the output type for generated passwords as a String class object' do
+      expect(@polypass_alphanumeric.output_type).to be_kind_of(String).and eq('stdout')
+    end
+  end
+
+  describe '.create' do
+    context 'stdout output type' do
+      it 'returns a secure random generated alphanumeric 32 character password as a String class object' do
+        expect(@polypass_alphanumeric.create).to be_kind_of(String)
+        expect(@polypass_alphanumeric.create.length).to eq(32)
+      end
+    end
+
+    context 'json output type' do
+      it 'returns a secure random generated alphanumeric 32 character password as JSON formatted String class object' do
+        expect(Polypass::AlphaNumeric.new(32, 'json').create).to be_kind_of(String)
+      end
+    end
+
+    context 'yaml output type' do
+      it 'returns a secure random generated alphanumeric 32 character password as YAML formatted String class object' do
+        expect(Polypass::AlphaNumeric.new(32, 'yaml').create).to be_kind_of(String)
+      end
+    end
+  end
+end

data/spec/polypass_alpha_symbol_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'polypass'
+
+describe Polypass::AlphaSymbol do
+  before :all do
+    @polypass_alphasymbol = Polypass::AlphaSymbol.new
+  end
+
+  it 'is a Polypass::AlphaSymbol object' do
+    expect(@polypass_alphasymbol).to be_kind_of(Polypass::AlphaSymbol)
+  end
+
+  it 'should respond to 2 arguments when initialized' do
+    expect(Polypass).to respond_to(:new).with(2).arguments
+  end
+
+  describe '#length' do
+    it 'returns the length of the generated password as Integer class object' do
+      expect(@polypass_alphasymbol.length).to be_kind_of(Integer).and eq(32)
+    end
+  end
+
+  describe '#output_type' do
+    it 'returns the output type for generated passwords as a String class object' do
+      expect(@polypass_alphasymbol.output_type).to be_kind_of(String).and eq('stdout')
+    end
+  end
+
+  describe '.create' do
+    context 'stdout output type' do
+      it 'returns a secure random generated alphanumeric symbol 32 character password as a String class object' do
+        expect(@polypass_alphasymbol.create).to be_kind_of(String)
+        expect(@polypass_alphasymbol.create.length).to eq(32)
+      end
+    end
+
+    context 'json output type' do
+      it 'returns a secure random generated alphanumeric symbol password as JSON formatted String class object' do
+        expect(Polypass::AlphaSymbol.new(32, 'json').create).to be_kind_of(String)
+      end
+    end
+
+    context 'yaml output type' do
+      it 'returns a secure random generated alphanumeric symbol password as YAML formatted String class object' do
+        expect(Polypass::AlphaSymbol.new(32, 'yaml').create).to be_kind_of(String)
+      end
+    end
+  end
+end

data/spec/polypass_helpers_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'polypass'
+
+describe 'Polypass Helpers' do
+  before :all do
+    @polypass = Polypass.new
+  end
+
+  describe '.alphanumeric_chars' do
+    it 'returns 62 alphanumeric characters as an Array class object' do
+      expect(@polypass.alphanumeric_chars).to be_kind_of(Array)
+      expect(@polypass.alphanumeric_chars.length).to eq(62)
+    end
+  end
+
+  describe '.alphasymbol_chars' do
+    it 'returns 92 alphanumeric and symbol characters as an Array class object' do
+      expect(@polypass.alphasymbol_chars).to be_kind_of(Array)
+      expect(@polypass.alphasymbol_chars.length).to eq(92)
+    end
+  end
+
+  describe '.output_json' do
+    it 'should respond to 1 argument' do
+      expect(@polypass).to respond_to(:output_json).with(1).argument
+    end
+  end
+
+  describe '.output_yaml' do
+    it 'should respond to 1 argument' do
+      expect(@polypass).to respond_to(:output_yaml).with(1).argument
+    end
+  end
+
+  describe '.random_element' do
+    it 'should respond to 1 argument' do
+      expect(@polypass).to respond_to(:random_element).with(1).argument
+    end
+
+    it 'returns a secure random single element from an Array as a String class object' do
+      expect(@polypass.random_element(@polypass.alphanumeric_chars)).to be_kind_of(String)
+      expect(@polypass.random_element(@polypass.alphanumeric_chars).length).to eq(1)
+    end
+  end
+
+  describe '.random_number' do
+    it 'should respond to 1 argument' do
+      expect(@polypass).to respond_to(:random_element).with(1).argument
+    end
+
+    context 'default integer argument of 1000' do
+      it 'returns a secure random number less than or equal to 1101 as an Integer class object' do
+        expect(@polypass.random_number).to be_kind_of(Integer)
+        expect(@polypass.random_number).to be <= 1101
+      end
+    end
+
+    context 'integer argument of 10000' do
+      it 'returns a secure random number less than or equal to 10101 as an Integer class object' do
+        expect(@polypass.random_number).to be_kind_of(Integer)
+        expect(@polypass.random_number).to be <= 10101
+      end
+    end
+  end
+
+  describe '.random_sample_chars' do
+    it 'should respond to 2 arguments' do
+      expect(@polypass).to respond_to(:random_sample_chars).with(2).arguments
+    end
+
+    context 'random alphanumberic characters with default length' do
+      it 'returns a random sample of 32 characters as a String class object' do
+        expect(@polypass.random_sample_chars(@polypass.alphanumeric_chars)).to be_kind_of(String)
+        expect(@polypass.random_sample_chars(@polypass.alphanumeric_chars).length).to eq(32)
+      end
+    end
+
+    context 'random alphanumberic and symbol characters with default character length' do
+      it 'returns a random sample of 32 characters as a String class object' do
+        expect(@polypass.random_sample_chars(@polypass.alphasymbol_chars)).to be_kind_of(String)
+        expect(@polypass.random_sample_chars(@polypass.alphasymbol_chars).length).to eq(32)
+      end
+    end
+
+    context 'random alphanumberic and symbol characters with 128 character length' do
+      it 'returns a random sample of 32 characters as a String class object' do
+        expect(@polypass.random_sample_chars(@polypass.alphasymbol_chars)).to be_kind_of(String)
+        expect(@polypass.random_sample_chars(@polypass.alphasymbol_chars, 128).length).to eq(128)
+      end
+    end
+  end
+
+  describe '.random_sample_set' do
+    it 'should respond to 3 arguments' do
+      expect(@polypass).to respond_to(:random_sample_set).with(3).arguments
+    end
+
+    context 'given an alphanumeric character type with defult length of 32 and rounds of 1000' do
+      it 'should return a set of of less than or equal to 1101 random passwords as an Array class object' do
+        expect(@polypass.random_sample_set('alphanumeric')).to be_kind_of(Array)
+        expect(@polypass.random_sample_set('alphanumeric').length).to be <= 1101
+      end
+    end
+
+    context 'given an alphansymbol character type with defult length of 32 and rounds of 1000' do
+      it 'should return a set of of less than or equal to 1101 random passwords as an Array class object' do
+        expect(@polypass.random_sample_set('alphasymbol')).to be_kind_of(Array)
+        expect(@polypass.random_sample_set('alphasymbol').length).to be <= 1101
+      end
+    end
+
+    context 'given an invalid character type argument' do
+      it 'should raise an ArgumentError expection' do
+        expect { @polypass.random_sample_set('foobar') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end