personal_wordlist 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad270b79c7b8358f7bce982d8e5defc4136b8c5a
+  data.tar.gz: 309ec84e26bbb248e99635c8aaa6acab12cd9776
+SHA512:
+  metadata.gz: e41cc60360bf704cf4d540b23aac241e870f2502e9ef97a8e90f2ab755a4530574eb2213b56fdcf3c4c93f89b1f7e10f342648271bf0d82b5d120fb2bfa97d16
+  data.tar.gz: 64f036b8201f234344bbaa6d03ef0ffce62d117312bf05491e309aafad01c4a5a860281d263d222777bb569a288d60b69b9d25e960a9341997a01a8866ceb5cb

data/README.md

@@ -0,0 +1,98 @@
+# personal_wordlist
+
+**personal_wordlist** is a wordlist generator backend to create wordlists from the given personal data. It is originally designed for security purposes.
+
+personal_wordlist uses a simple DSL to create password patterns and those patterns are used to create password sequences.
+
+## Installation
+
+```shell
+gem install personal_wordlist
+```
+or add the following line to Gemfile:
+
+```ruby
+gem 'personal_wordlist'
+```
+and run `bundle install` from your shell.
+
+## Usage
+
+To start generating wordlists we need to use ```PersonalWordlist.generate``` method with a block.
+
+```ruby
+PersonalWordlist.generate(personal_data) do
+  # DSL here
+end
+
+```
+
+```.generate``` method takes a Hash argument and returns and Array of strings.
+
+### Partials
+
+```partial``` is a string pattern and can be used to combine more complex strings.
+
+```
+partial { first_name[0..1] }
+partial { '123' }
+partial { last_name[0].downcase }
+```
+Consider the data is ```{ first_name: 'John', last_name: 'Doe' }``` and the result will be _Jo123d_.
+
+### Sequences
+
+```sequence```s are like loops in programming languages. sequence method requires a ```Range``` variable and a block.
+
+```
+sequence(1998..2011) do |n|
+  # string manupulation here
+end
+```
+
+You can insert partials into sequences.
+
+```
+sequence(1998..2011) do |n|
+  partial { first_name.downcase }
+  partial { n.to_s }
+end
+```
+And result becomes: _['john1998', 'john1999', 'john2000', ... 'john2011']_
+
+When sequence is done iterating, the result is added to the returning array of strings. If you have multiple sequences, the results from each sequence will be concatenated.
+
+### Example
+```
+personal_data = { 
+	first_name: 'John', last_name: 'Doe', 
+	date_of_birth: '1980-01-01', favorite_team: 'Galatasaray'
+}
+
+PersonalWordlist.generate(personal_data) do
+  sequence(0..999) do |n|
+    partial { first_name[0..2].downcase }
+    partial { n.to_s }
+    partial { last_name[0] }
+  end
+  sequence(0..999) do |n|
+    partial { first_name[0..2].downcase }
+    partial { n.to_s }
+    partial { last_name[0] }
+  end
+end
+```
+
+## Future Plans
+
+- CLI, I see that as a must.
+- Input Data Adaptors, I am planning to create adaptors such as parsing yaml, xml, csv file to input hash format. 
+
+## Contribution
+
+Contributing to factory_girl:
+
+Fork the official repository.
+Make your changes in a topic branch.
+Send a pull request.
+## Licence

data/lib/personal_wordlist/dsl/partial.rb

@@ -0,0 +1,21 @@
+module PersonalWordlist
+  module DSL
+    # Evaluate of methods in `partial` blocks
+    class Partial
+      def initialize(personal_data, block)
+        @block = block
+        @personal_data = personal_data
+      end
+
+      def run!
+        instance_eval(&@block)
+      end
+
+      # Map unknown methods to known keys of the input hash
+      def method_missing(name)
+        return @personal_data[name.to_sym] if @personal_data.key?(name)
+        fail NoMethodError
+      end
+    end
+  end
+end

data/lib/personal_wordlist/dsl/sequence.rb

@@ -0,0 +1,25 @@
+module PersonalWordlist
+  module DSL
+    # Creates sequences within given patterns
+    class Sequence
+      include PersonalWordlist::DSL
+
+      def initialize(personal_data, block, range)
+        @block = block
+        @personal_data = personal_data
+        @current_password = ''
+        @range = range || (0..1)
+      end
+
+      def run!
+        passwords = []
+        @range.to_a.each do |n|
+          # Reset the state of current_password
+          @current_password = ''
+          passwords << instance_exec(n, &@block)
+        end
+        passwords
+      end
+    end
+  end
+end

data/lib/personal_wordlist/dsl.rb

@@ -0,0 +1,23 @@
+require 'personal_wordlist/dsl/partial'
+require 'personal_wordlist/dsl/sequence'
+
+module PersonalWordlist
+  # DSL Syntax Methods
+  module DSL
+    def partial(&block)
+      fail ArgumentError unless block_given?
+      @current_password += Partial.new(@personal_data, block).run!
+    end
+
+    def sequence(range, &block)
+      fail ArgumentError unless block_given?
+      @passwords.concat Sequence.new(@personal_data, block, range).run!
+    end
+
+    # Map unknown methods to known keys of the input hash
+    def method_missing(name)
+      return @personal_data[name.to_sym] if @personal_data.key?(name)
+      fail NoMethodError
+    end
+  end
+end

data/lib/personal_wordlist/version.rb

@@ -0,0 +1,3 @@
+module PersonalWordlist
+  VERSION = '0.1.0'
+end

data/lib/personal_wordlist.rb

@@ -0,0 +1,32 @@
+require 'personal_wordlist/version'
+require 'personal_wordlist/dsl'
+
+##
+# A wordlist generator. Uses simple DSL to define password generation rules.
+module PersonalWordlist
+  class PersonalWordlistError < StandardError; end
+  class InvalidTemplateError < PersonalWordlistError; end
+
+  class << self
+    include PersonalWordlist::DSL
+
+    attr_reader :current_password
+
+    ##
+    # PersonalWorlList.password
+    def generate(personal_data, &block)
+      fail ArgumentError unless block_given?
+
+      # Set class variables
+      @personal_data = personal_data
+      @block = block
+      @current_password = ''
+      @passwords = []
+
+      result = instance_eval(&block)
+
+      # Ensure that result is always an Array
+      result.instance_of?(Array) ? @passwords = result : @passwords << result
+    end
+  end
+end

data/personal_wordlist.gemspec

@@ -0,0 +1,22 @@
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+require 'personal_wordlist/version'
+
+Gem::Specification.new do |s|
+  s.name       = 'personal_wordlist'
+  s.version    = PersonalWordlist::VERSION
+  s.date       = '2015-01-18'
+  s.summary    = 'Create wordlists from personal data.'
+
+  s.authors    = ['Turhan Coskun']
+  s.email      = 'turhancoskun@gmail.com'
+
+  s.files = `git ls-files`.split("\n").reject { |path| path =~ /\.gitignore$/ }
+  s.test_files = `git ls-files -- Appraisals {spec,features,gemfiles}/*`
+    .split("\n")
+
+  s.require_paths = ['lib']
+  s.required_ruby_version = Gem::Requirement.new('>= 1.9.2')
+  s.add_development_dependency('rspec')
+
+  s.license   = 'MIT'
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+# Puppet class with minimum requirements to test the DSL
+class TestClass
+  attr_accessor :current_password, :passwords
+
+  include PersonalWordlist::DSL
+
+  def initialize(personal_data)
+    @personal_data = personal_data
+    @current_password = ''
+    @passwords = []
+  end
+end
+
+describe 'SocialWordlist::DSL' do
+  subject { TestClass.new(john_doe) }
+  describe '#partial' do
+    it 'should fail if block is not given' do
+      expect { subject.partial }.to raise_error ArgumentError
+    end
+    it 'should access class variables' do
+      expect do
+        subject.partial do
+          "#{first_name}A"
+        end
+      end.to change { subject.current_password }.from('').to('JohnA')
+      subject.current_password = '' # Reset Current Passoword
+      expect do
+        subject.partial do
+          "#{first_name[0]}123#{last_name[0]}xyz"
+        end
+      end.to change { subject.current_password }.from('').to('J123Dxyz')
+    end
+  end
+
+  describe '#sequence' do
+    it 'should create sequences' do
+      expect do
+        subject.sequence(1..3) do |n|
+          "#{first_name}#{n}"
+        end
+      end.to change { subject.passwords }.from([]).to %w(John1 John2 John3)
+    end
+  end
+end

data/spec/features_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe 'PersonalWordlist' do
+  context 'when everything is fine' do
+    it 'should work with multiple partial DSLs' do
+      passwords = PersonalWordlist.generate(john_doe) do
+        partial { "#{first_name[0..1]}" }
+        partial { '123' }
+        partial { "#{last_name[0]}" }
+      end
+      expect(passwords.first).to eq 'Jo123D'
+    end
+
+    it 'should combine sequences and partials' do
+      passwords = PersonalWordlist.generate(john_doe) do
+        sequence(1..5) do |n|
+          partial { n.to_s }
+          partial { first_name[0] }
+        end
+      end
+      expect(passwords).to eq %w(1J 2J 3J 4J 5J)
+    end
+
+    it 'should combine multiple sequences' do
+      passwords = PersonalWordlist.generate(john_doe) do
+        sequence(125..250) do |n|
+          partial { first_name.downcase }
+          partial { n.to_s }
+          partial { last_name[0].upcase }
+        end
+        sequence(1960..2000) do |n|
+          partial { last_name.downcase }
+          partial { n.to_s }
+        end
+        partial do
+          'Test Password'
+        end
+      end
+      expect(passwords.count).to eq 168
+    end
+  end
+
+  context 'when something went wrong' do
+    it 'gives an error when method is not recognized in DSL' do
+      expect do
+        PersonalWordlist.generate(john_doe) do
+          sequence(1..10) do |n|
+            partial { n.to_s + undefined_field }
+          end
+        end
+      end.to raise_error NoMethodError
+    end
+  end
+end

data/spec/personal_wordlist_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe PersonalWordlist do
+  describe '.password' do
+    it 'must have a block given' do
+      expect do
+        PersonalWordlist.generate(john_doe)
+      end.to raise_error ArgumentError
+    end
+    it 'should be an array' do
+      passwords = PersonalWordlist.generate(john_doe) do
+      end
+      expect(passwords).to be_kind_of(Array)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require 'personal_wordlist'
+require 'support/people_helper'
+
+include PeopleHelper
+include PersonalWordlist

data/spec/support/people_helper.rb

@@ -0,0 +1,5 @@
+module PeopleHelper
+  def john_doe
+    { first_name: 'John', last_name: 'Doe', date_of_birth: '01.01.1987' }
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: personal_wordlist
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Turhan Coskun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: turhancoskun@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/personal_wordlist.rb
+- lib/personal_wordlist/dsl.rb
+- lib/personal_wordlist/dsl/partial.rb
+- lib/personal_wordlist/dsl/sequence.rb
+- lib/personal_wordlist/version.rb
+- personal_wordlist.gemspec
+- spec/dsl_spec.rb
+- spec/features_spec.rb
+- spec/personal_wordlist_spec.rb
+- spec/spec_helper.rb
+- spec/support/people_helper.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Create wordlists from personal data.
+test_files:
+- spec/dsl_spec.rb
+- spec/features_spec.rb
+- spec/personal_wordlist_spec.rb
+- spec/spec_helper.rb
+- spec/support/people_helper.rb