sifar 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,24 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## Netbeans
+nbproject
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Suman Debnath
+
+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.rdoc

@@ -0,0 +1,33 @@
+= Sifar
+
+Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word.
+
+Sifar can also generate passwords that satisfy the same criteria.
+
+== Installation
+
+=== Requirements
+
+You need english-0.4.0. This is installed automatically if ActiveMerchantCcavenue is installed as a gem.
+
+More information on english can be found at http://rubyworks.github.com/english.
+
+=== As a gem (recommended)
+
+Install the gem:
+
+  > sudo gem install sifar
+
+To use the Sifar gem in a Rails application, add the following line in your environment.rb:
+
+  config.gem 'sifar'
+
+=== As a Rails plugin
+
+To add Sifar as a plugin in a Rails application, run the following command from your application root:
+
+  > ./script/plugin install git@github.com:meshbrain/sifar.git
+
+== Copyright
+
+Copyright (c) 2010 Suman Debnath. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+    require 'jeweler'
+    Jeweler::Tasks.new do |gem|
+        gem.name = 'sifar'
+        gem.summary = %Q{A library to generate strong passwords and check password strength.}
+        gem.description = %Q{Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word. Sifar can also generate passwords that satisfy the same criteria.}
+        gem.email = 'contact@meshbrain.com'
+        gem.homepage = 'http://github.com/meshbrain/sifar'
+        gem.authors = ['Suman Debnath']
+        gem.add_development_dependency 'rspec', '~> 1.2'
+        gem.add_dependency 'english', '= 0.4.0'
+    end
+    Jeweler::GemcutterTasks.new
+rescue LoadError
+    puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+    version = File.exist?('VERSION') ? File.read('VERSION') : ''
+
+    rdoc.rdoc_dir = 'rdoc'
+    rdoc.title = "sifar #{version}"
+    rdoc.rdoc_files.include('README*')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/init.rb

@@ -0,0 +1 @@
+require 'sifar'

data/lib/sifar.rb

@@ -0,0 +1,170 @@
+require 'rubygems'
+gem 'english', '= 0.4.0'
+
+class Sifar
+    attr_accessor :errors
+
+    def initialize
+        @checks = {
+            'L' => :check_length,
+            'D' => :check_dictionary,
+            'H' => :check_heterogeneity,
+            'W' => :check_word_blacklist,
+            'C' => :check_char_blacklist,
+            'P' => :check_phonetic,
+            'T' => :check_similarity,
+            'S' => :check_string
+        }
+    end
+
+    def check_password(password, name = '', options = {}, error_messages = {})
+        self.set_opt options, error_messages
+        @errors = []
+
+        self.check_strength(password)
+        self.check_against_name(password, name) unless name.empty?
+
+        1 > @errors.length
+    end
+
+    def generate_password(name = '', options = {}, error_messages = {})
+        self.set_opt options, error_messages
+    end
+
+    def check_strength(password)
+        @options[:password_check_type].each(''){|option| self.send(@checks[option], password)}
+    end
+
+    def check_against_name(password, name)
+        @options[:name_check_type].each(''){|option| self.send(@checks[option], password, name)}
+    end
+
+    def check_length(word)
+        @errors << @error_messages[:length] if word.length < @options[:minimum_length]
+    end
+
+    def check_heterogeneity(word)
+        num_chars = word.length
+        num = {}
+        num[:upper] = word.gsub(/[^[:upper:]]/, '').length
+        num[:lower] = word.gsub(/[^[:lower:]]/, '').length
+        num[:digit] = word.gsub(/[^[:digit:]]/, '').length
+        num[:special] = num_chars - (num[:upper] + num[:lower] + num[:digit])
+
+        max = 4 > num_chars ? 3 : num_chars - 3
+        num.each do |type, value|
+            if value > max
+                @errors << @error_messages[:heter]
+                return false
+            end
+        end
+
+        true
+    end
+
+    def check_dictionary(word)
+        if File.readable? @options[:dictionary]
+            @errors << @error_messages[:dict] if find_word_in_file(word, @options[:dictionary])
+        else
+            @errors << @error_messages[:config_blackword]
+        end
+    end
+
+    def check_word_blacklist(word)
+        if File.readable? @options[:word_blacklist]
+            @errors << @error_messages[:blackword] if find_word_in_file(word, @options[:word_blacklist])
+        else
+            @errors << @error_messages[:config_dict]
+        end
+    end
+
+    def check_char_blacklist(word)
+        if File.readable? @options[:char_blacklist]
+            File.open(@options[:char_blacklist]) do |f|
+                f.readlines.each do |char|
+                    char = char.strip
+                    if not(char.empty?) and word.include?(char)
+                        @errors << @error_messages[:blackchar]
+                        return false
+                    end
+                end
+            end
+        else
+            @errors << @error_messages[:config_blackchar]
+            return false
+        end
+        true
+    end
+
+    def check_phonetic(password, name)
+        require 'english/levenshtein'
+        require 'english/soundex'
+        unless 2 < English::Levenshtein.distance(password.soundex, name.soundex)
+            @errors << @error_messages[:phonetic]
+            return false
+        end
+        true
+    end
+
+    def check_similarity(password, name)
+        require 'english/similarity'
+        if 0.8 < password.similarity(name)
+            @errors << @error_messages[:similar]
+            return false
+        end
+        true
+    end
+
+    def check_string(password, name)
+        longer, shorter = password.size > name.size ? [password, name] : [name, password]
+        if longer.include?(shorter)
+            @errors << @error_messages[:similar]
+            return false
+        end
+        true
+    end
+
+    def find_word_in_file(word, file)
+        t = []
+        IO.popen("#{@options[:grep_path]} -ixs '#{word}' #{file}") {|io|
+            r = io.readlines
+            t << r unless r.empty?
+        }
+        not t.empty?
+    end
+
+    def set_opt(options = {}, error_messages = {})
+        @options = {
+            :minimum_length => 8,
+            :password_check_type => 'LD',
+            :name_check_type => 'S',
+            :dictionary => '',
+            :word_blacklist => '',
+            :char_blacklist => '',
+            :error_msg_hash => {},
+            :umlaut_hash => {},
+            :grep_path => '/bin/grep'
+        }.merge options
+        @options[:minimum_length] = 1 > @options[:minimum_length] ? 8 : @options[:minimum_length]
+        @options[:password_check_type] = @options[:password_check_type].gsub(/[^DLHWC]/, '').split('').sort.join
+        @options[:name_check_type] = @options[:name_check_type].gsub(/[^PTS]/, '').split('').sort.join
+
+        raise ArgumentError, 'grep not found' unless (File.stat(@options[:grep_path]).executable? rescue false)
+
+        @error_messages = {
+            :length => 'The password is too short!',
+            :similar => 'The password is too similar to the given name!',
+            :phonetic => 'The password sounds too similar to the given name!',
+            :dict => 'The password is based upon a dictionary word!',
+            :heter => 'The password is too homogeneous!',
+            :blackword => 'The password is based upon a blacklsited word!',
+            :blackchar => 'The password contains a blacklisted character!',
+            :similar_looking_chars => 'The password contains  similar looking  characters!',
+            :config_blackchar => 'Could not load a valid blacklisted character file!',
+            :config_blackword => 'Could not load a valid blacklisted word file!',
+            :config_dict => 'Could not load a valid dictionary file!',
+            :config_heter => 'Conflict in heterogeneity check and password generation configuration!',
+            :config_length => 'Generated password length cannot be less then specified minimum length!'
+        }.merge error_messages
+    end
+end

data/sifar.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sifar}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Suman Debnath"]
+  s.date = %q{2010-10-01}
+  s.description = %q{Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word. Sifar can also generate passwords that satisfy the same criteria.}
+  s.email = %q{contact@meshbrain.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/sifar.rb",
+     "sifar.gemspec",
+     "spec/sifar_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/meshbrain/sifar}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A library to generate strong passwords and check password strength.}
+  s.test_files = [
+    "spec/spec_helper.rb",
+     "spec/sifar_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 1.2"])
+      s.add_runtime_dependency(%q<english>, ["= 0.4.0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 1.2"])
+      s.add_dependency(%q<english>, ["= 0.4.0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 1.2"])
+    s.add_dependency(%q<english>, ["= 0.4.0"])
+  end
+end
+

data/spec/sifar_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Sifar" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sifar'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: sifar
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Suman Debnath
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-01 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: english
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id002
+description: Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word. Sifar can also generate passwords that satisfy the same criteria.
+email: contact@meshbrain.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- lib/sifar.rb
+- sifar.gemspec
+- spec/sifar_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/meshbrain/sifar
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A library to generate strong passwords and check password strength.
+test_files: 
+- spec/spec_helper.rb
+- spec/sifar_spec.rb