c7decrypt 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4c3a9b400ae6f576e417c8feab081a032749f22
-  data.tar.gz: 799c99315d7b7604c26b07d6707a221ee244f21f
+  metadata.gz: f70de5c1f93bf9ad137dea9dd3fa33db2a793fa0
+  data.tar.gz: 5a8f766cf0de4464adf4c87f09e8148b3d8326ec
 SHA512:
-  metadata.gz: 8d997d254c5ae60d1ead6a468abbb3a4ba7f4dc07ccc9cd8f2d86443377fc82d10315d2879be2cca2e95a5ac11f0f776fe140abeab7e4d9f5e5a72a32a153482
-  data.tar.gz: a490e626d751ba8bdd94fe925d39e2d548e48624a233b08da9d255056697bd0e3808c75aee380ac94bd286f197fe534e492e4c6d1d71270f161dc8529d8f4801
+  metadata.gz: c55ffa4cb4fa17dafd2c8e97758f057e92b3b65101c53b7c2eec05803792e5e5b32720d195c1633b4a74273a66fcf7284d9c00e8734d8210d0d7e958e6ee5543
+  data.tar.gz: 3de9b21375709c209da4fd865c33984c3700cee54df3d95d9be6c265c16c6992b6a6110f6b2f85a154c5aadd004192adcd71f520f4e59e196fd28c647f108b78

data/README.md

@@ -47,7 +47,7 @@ require 'c7decrypt'
 Decrypt A Single Encrypted Password
 
 ```ruby
->> C7Decrypt.decrypt("060506324F41")
+>> C7Decrypt::Type7.decrypt("060506324F41")
 => "cisco"
 ```
 
@@ -56,28 +56,28 @@ Decrypt Array of Encrypted Passwords
 ```ruby
 >> encrypted_hashes = ["060506324F41", "0822455D0A16"]
 => ["060506324F41", "0822455D0A16"]
->> C7Decrypt.decrypt_array(encrypted_hashes)
+>> C7Decrypt::Type7.decrypt_array(encrypted_hashes)
 => ["cisco", "cisco"]
 ```
 
 Decrypt Encrypted Passwords from Config
 
 ```ruby
->> C7Decrypt.decrypt_config("cisco_config.txt")
+>> C7Decrypt::Type7.decrypt_config("cisco_config.txt")
 => ["cisco", "Password1", "admin"]
 ```
 
 Encrypt A Single Plaintext Password
 
 ```ruby
->> C7Decrypt.encrypt("cisco")
+>> C7Decrypt::Type7.encrypt("cisco")
 => "02050D480809"
 ```
 
 Encrypt A Single Plaintext Password w/ Explicit Seed
 
 ```ruby
->> C7Decrypt.encrypt("cisco", 6)
+>> C7Decrypt::Type7.encrypt("cisco", 6)
 => "060506324F41"
 ```
 
@@ -86,7 +86,7 @@ Encrypt An Array of Plaintext Passwords
 ```ruby
 >> passwords = ["cisco", "password"]
 => ["cisco", "password"]
->> C7Decrypt.encrypt_array(passwords)
+>> C7Decrypt::Type7.encrypt_array(passwords)
 => ["02050D480809", "021605481811003348"]
 ```
 

data/bin/c7decrypt

@@ -48,11 +48,11 @@ if options.string.nil? &&
 end
 
 if options.string
-  puts C7Decrypt.decrypt(options.string)  
+  puts C7Decrypt::Type7.decrypt(options.string)  
 end
 
 if options.file &&
    File.exists?(options.file)
 
-  C7Decrypt.decrypt_config(options.file).each {|pw| puts pw }
+  C7Decrypt::Type7.decrypt_config(options.file).each {|pw| puts pw }
 end

data/c7decrypt.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |s|
   s.homepage = 'http://rubygems.org/gems/c7decrypt'
 
   s.add_development_dependency('fuzzbert')
-  s.add_development_dependency('rspec', '~> 2.14.1')
+  s.add_development_dependency('rspec', '~> 3.0.0')
+  s.add_development_dependency('rspec-its')
   s.add_development_dependency('rake')
 end

data/lib/c7decrypt.rb

@@ -1,2 +1,2 @@
 require 'c7decrypt/version'
-require 'c7decrypt/c7decrypt'
+require 'c7decrypt/type7'

data/lib/c7decrypt/type7.rb

@@ -0,0 +1,188 @@
+module C7Decrypt
+  module Type7
+    
+    module Constants
+      # Vigenere translation table (these are our key values for decryption)
+      VT_TABLE = [
+        0x64, 0x73, 0x66, 0x64, 0x3b, 0x6b, 0x66, 0x6f, 0x41, 0x2c, 0x2e,
+        0x69, 0x79, 0x65, 0x77, 0x72, 0x6b, 0x6c, 0x64, 0x4a, 0x4b, 0x44,
+        0x48, 0x53, 0x55, 0x42, 0x73, 0x67, 0x76, 0x63, 0x61, 0x36, 0x39,
+        0x38, 0x33, 0x34, 0x6e, 0x63, 0x78, 0x76, 0x39, 0x38, 0x37, 0x33,
+        0x32, 0x35, 0x34, 0x6b, 0x3b, 0x66, 0x67, 0x38, 0x37
+      ]
+
+      # Regexes for extracting hashes from configs
+      TYPE_7_REGEXES = [
+        /enable password 7 ([A-Z0-9]+)/,
+        /username [A-Z0-9]+ password 7 ([A-Z0-9]+)/,
+        /password 7 ([A-Z0-9]+)/
+      ]
+    end
+
+    class InvalidFirstCharacter < StandardError
+    end
+
+    class InvalidCharacter < StandardError
+    end
+
+    class OddNumberOfCharacters < StandardError
+    end
+
+    class InvalidEncryptionSeed < StandardError
+    end
+
+    # The Decryption Method for Cisco Type-7 Encrypted Strings
+    # @param [String] the Cisco Type-7 Encrypted String
+    # @raise [InvalidFirstCharacter, 
+    #         InvalidCharacter, 
+    #         OddNumberOfCharacters]
+    # @return [String] the Decrypted String
+    def self.decrypt(e_text)
+      check_type_7_errors(e_text)
+
+      d_text = ""
+      seed = nil
+
+      e_text.scan(/../).each_with_index do |char,i|
+        if i == 0
+          seed = char.to_i - 1
+        else
+          d_text += decrypt_char(char, i, seed)
+        end
+      end
+
+      return d_text
+    end
+
+    # The Encryption Method for Cisco Type-7 Encrypted Strings
+    # @param [String] the plaintext password
+    # @param [String] the seed for the encryption used
+    # @raise [InvalidEncryptionSeed,
+    #         InvalidFirstCharacter, 
+    #         InvalidCharacter, 
+    #         OddNumberOfCharacters]
+    # @return [String] the encrypted password
+    def self.encrypt(d_text, seed = 2)
+      check_seed(seed)
+    
+      e_text = sprintf("%02d", seed)
+
+      d_text.each_char.each_with_index do |d_char,i|
+        e_text += encrypt_char(d_char, i, seed)
+      end
+
+      check_type_7_errors(e_text)
+
+      return e_text
+    end
+
+    # The method for encrypting a single character
+    # @param [String] the plain text char
+    # @param [FixNum] the index of the char in plaintext string
+    # @param [FixNum] the seed used in the encryption process
+    # @return [String] the string of the encrypted char
+    def self.encrypt_char(char, i, seed)
+      sprintf("%02X", char.unpack('C')[0] ^ Constants::VT_TABLE[(i + seed) % 53])
+    end
+
+    # The method for decrypting a single character
+    # @param [String] the encrypted char
+    # @param [Integer] the index of the char pair in encrypted string
+    # @param [Integer] the seed used in the decryption process
+    # @return [String] the string of the decrypted char
+    def self.decrypt_char(char, i, seed)
+      (char.hex^Constants::VT_TABLE[(i + seed) % 53]).chr
+    end
+
+    # A helper method to decrypt an arracy of Cisco Type-7 Encrypted Strings
+    # @param [Array>String] an array of Cisco Type-7 Encrypted Strings
+    # @raise [InvalidFirstCharacter, 
+    #         InvalidCharacter, 
+    #         OddNumberOfCharacters]
+    # @return [Array>String] an array of Decrypted Strings
+    def self.decrypt_array(pw_array)
+      pw_array.collect {|pw| decrypt(pw)}
+    end
+
+    # A helper method to encrypt an arracy of passwords
+    # @param [Array>String] an array of plain-text passwords
+    # @raise [InvalidEncryptionSeed,
+    #         InvalidFirstCharacter, 
+    #         InvalidCharacter, 
+    #         OddNumberOfCharacters]
+    # @return [Array>String] an array of encrypted passwords
+    def self.encrypt_array(pt_array, seed = 2)
+      pt_array.collect {|pw| encrypt(pw, seed)}
+    end
+
+    # This method scans a raw config file for type 7 passwords and 
+    #   decrypts them
+    # @param [String] a string of the config file path that contains
+    #   Cisco Type-7 Encrypted Strings
+    # @raise [InvalidFirstCharacter, 
+    #         InvalidCharacter, 
+    #         OddNumberOfCharacters]
+    # @return [Array>String] an array of Decrypted Strings
+    def self.decrypt_config(file)
+      f = File.open(file, 'r').to_a
+      decrypt_array(f.collect {|line| type_7_matches(line)}.flatten)
+    end
+
+    # This method scans a config line for encrypted type-7 passwords and
+    #   returns an array of results
+    # @param [String] a line with potential encrypted type-7 passwords
+    # @return [Array>String] an array of Cisco type-7 encrypted Strings
+    def self.type_7_matches(string)
+      Constants::TYPE_7_REGEXES.collect {|regex| string.scan(regex)}.flatten.uniq
+    end
+
+    # This method determines if an encrypted hash is corrupted/invalid 
+    #   and throw a specific exeception
+    # @param [String] the Cisco Type-7 Encrypted String
+    # @raise [InvalidFirstCharacter, InvalidCharacter, OddNumberOfCharacters]
+    # @return [Nil]
+    def self.check_type_7_errors(e_text)
+      
+      valid_first_chars = (0..15).to_a.collect {|c| sprintf("%02d", c)}
+      first_char = e_text[0,2]
+
+      # Check for an invalid first character in the has
+      unless valid_first_chars.include? first_char
+        raise InvalidFirstCharacter, 
+          "'#{e_text}' hash contains an invalid first chracter (only '00' - '15' allowed)"
+      end
+
+      # Check for an invalid character in the hash
+      unless e_text.match(/^[A-Z0-9]+$/)
+        raise InvalidCharacter,
+          "'#{e_text}' hash contains an invalid character (only upper-alpha numeric allowed)"
+      end
+
+      # Check for an odd number of characters in the hash
+      unless e_text.size % 2 == 0
+        raise OddNumberOfCharacters,
+          "'#{e_text}' hash contains odd length of chars (only even number of chars allowed)"     
+      end
+
+      return nil
+
+    end
+
+    # This method determines if an encryption seed is valid or not
+    #   and throw a specific exeception
+    # @param [FixNum] the seed used in the encryption process
+    # @raise [InvalidEncryptionSeed] 
+    # @return [Nil]
+    def self.check_seed(seed)
+      if seed < 0 ||
+         seed > 15
+        
+        raise InvalidEncryptionSeed,
+          "'#{seed.to_s}' seed is not a valid seed (only 0 - 15 allowed)"
+      end
+
+      return nil
+    end
+
+  end
+end

data/lib/c7decrypt/version.rb

@@ -1,3 +1,3 @@
 module C7Decrypt
-  VERSION = '0.2.6'
+  VERSION = '0.3.0'
 end

data/spec/{c7decrypt_spec.rb → type7_spec.rb}

@@ -1,6 +1,7 @@
 require 'c7decrypt'
+require 'rspec/its'
 
-describe C7Decrypt do
+describe C7Decrypt::Type7 do
 
   before(:each) do
     @known_values = [
@@ -20,7 +21,7 @@ describe C7Decrypt do
   context "when decrypting single Cisco Type-7 hash using longhand" do 
     before(:each) do
       @encrypted_hash = "060506324F41"
-      @decrypted_hash = C7Decrypt.decrypt(@encrypted_hash)
+      @decrypted_hash = C7Decrypt::Type7.decrypt(@encrypted_hash)
     end
   
     subject{@decrypted_hash}
@@ -34,7 +35,7 @@ describe C7Decrypt do
         "060506324F41",
         "0822455D0A16"
       ]
-      @decrypted_hashes = C7Decrypt.decrypt_array(@encrypted_hashes)
+      @decrypted_hashes = C7Decrypt::Type7.decrypt_array(@encrypted_hashes)
     end
   
     subject{@decrypted_hashes}
@@ -47,7 +48,7 @@ describe C7Decrypt do
   context "when decrypting Cisco Type-7 hashes from a config" do 
     before(:each) do
       @config_file = "./spec/example_configs/simple_canned_example.txt"
-      @decrypted_hashes = C7Decrypt.decrypt_config(@config_file)
+      @decrypted_hashes = C7Decrypt::Type7.decrypt_config(@config_file)
     end
   
     subject{@decrypted_hashes}
@@ -64,7 +65,7 @@ describe C7Decrypt do
 
   context "when decrypting known Cisco Type-7 known value matches" do 
     before(:each) do
-      @decrypted_hashes = C7Decrypt.decrypt_array(
+      @decrypted_hashes = C7Decrypt::Type7.decrypt_array(
                             @known_values.map {|known_value| known_value[:ph]}
                           )
     end
@@ -77,7 +78,7 @@ describe C7Decrypt do
 
   context "when decrypting Cisco Type-7 with a seed greater than 9" do 
     before(:each) do
-      @decrypt_hash = C7Decrypt.decrypt("15000E010723382727")
+      @decrypt_hash = C7Decrypt::Type7.decrypt("15000E010723382727")
     end
 
     subject{@decrypt_hash}
@@ -95,7 +96,7 @@ describe C7Decrypt do
       }
 
       @known_config_lines.keys.each do |k,v|
-        @encrypted_hashes << C7Decrypt.type_7_matches(k)
+        @encrypted_hashes << C7Decrypt::Type7.type_7_matches(k)
       end
       @encrypted_hashes.flatten!
     end
@@ -109,7 +110,7 @@ describe C7Decrypt do
   context "when encrypting single Cisco Type-7 hash" do 
     before(:each) do
       @plaintext_hash = "cisco"
-      @encrypted_hash = C7Decrypt.encrypt(@plaintext_hash)
+      @encrypted_hash = C7Decrypt::Type7.encrypt(@plaintext_hash)
     end
 
     subject{@encrypted_hash}
@@ -121,7 +122,7 @@ describe C7Decrypt do
     before(:each) do
       @plaintext_hash = "cisco"
       @seed = 3
-      @encrypted_hash = C7Decrypt.encrypt(@plaintext_hash, @seed)
+      @encrypted_hash = C7Decrypt::Type7.encrypt(@plaintext_hash, @seed)
     end
 
     subject{@encrypted_hash}
@@ -129,7 +130,7 @@ describe C7Decrypt do
     it {should == "030752180500"}
 
     it "should decrypt back to the original plaintext hash" do
-      C7Decrypt.decrypt(@encrypted_hash).should == @plaintext_hash
+      C7Decrypt::Type7.decrypt(@encrypted_hash).should == @plaintext_hash
     end
   end
 
@@ -137,7 +138,7 @@ describe C7Decrypt do
     before(:each) do
       @plaintext_hash = "cisco"
       @seeds = 0..15
-      @encrypted_hashes = @seeds.map {|seed| C7Decrypt.encrypt(@plaintext_hash, seed)}
+      @encrypted_hashes = @seeds.map {|seed| C7Decrypt::Type7.encrypt(@plaintext_hash, seed)}
     end
 
     subject{@encrypted_hashes}
@@ -145,7 +146,7 @@ describe C7Decrypt do
 
     it "should decrypt back to the original plaintext hashes" do
       @encrypted_hashes.each do |encrypted_hash|
-        C7Decrypt.decrypt(encrypted_hash).should == @plaintext_hash
+        C7Decrypt::Type7.decrypt(encrypted_hash).should == @plaintext_hash
       end
     end
   end
@@ -154,7 +155,7 @@ describe C7Decrypt do
     before(:each) do
       @encrypted_hashes = []
       @known_values.each do |known_value|
-        @encrypted_hashes << C7Decrypt.encrypt(known_value[:pt], known_value[:seed])
+        @encrypted_hashes << C7Decrypt::Type7.encrypt(known_value[:pt], known_value[:seed])
       end
     end
 
@@ -167,19 +168,19 @@ describe C7Decrypt do
   context "when encrypting known value matches individually as an array" do 
     before(:each) do
       @plaintext_passwords = @known_values.map {|known_value| known_value[:pt]}.uniq
-      @encrypted_passwords = C7Decrypt.encrypt_array(@plaintext_passwords)
+      @encrypted_passwords = C7Decrypt::Type7.encrypt_array(@plaintext_passwords)
     end
 
     subject{@encrypted_passwords}
     its(:class) {should == ::Array}
     its(:size) {should == @plaintext_passwords.size}
-    it {should == @plaintext_passwords.map {|plaintext_password| C7Decrypt.encrypt(plaintext_password)}}
+    it {should == @plaintext_passwords.map {|plaintext_password| C7Decrypt::Type7.encrypt(plaintext_password)}}
   end
 
   context "when encrypting Cisco Type-7" do 
     before(:each) do
       @plaintext_hash = "remcisco"
-      @encrypted_hash = C7Decrypt.encrypt(@plaintext_hash)
+      @encrypted_hash = C7Decrypt::Type7.encrypt(@plaintext_hash)
     end
 
     subject{@encrypted_hash}
@@ -191,7 +192,7 @@ describe C7Decrypt do
     before(:each) do
       @plaintext_hash = "remcisco"
       @seed = 15
-      @encrypted_hash = C7Decrypt.encrypt(@plaintext_hash, @seed)
+      @encrypted_hash = C7Decrypt::Type7.encrypt(@plaintext_hash, @seed)
     end
 
     subject{@encrypted_hash}
@@ -201,31 +202,41 @@ describe C7Decrypt do
 
   context "when trying to decrypt a hash with an invalid first character" do
     it "should raise an InvalidFirstCharacter Exception" do
-      expect { C7Decrypt.decrypt("AA000E010723382727") }.to raise_error(C7Decrypt::InvalidFirstCharacter)
+      expect {
+        C7Decrypt::Type7.decrypt("AA000E010723382727")
+      }.to raise_error(C7Decrypt::Type7::InvalidFirstCharacter)
     end
   end
 
   context "when trying to decrypt a hash with an invalid character" do
     it "should raise an InvalidFirstCharacter Exception" do
-      expect { C7Decrypt.decrypt("06000**E010723382727") }.to raise_error(C7Decrypt::InvalidCharacter)
+      expect { 
+        C7Decrypt::Type7.decrypt("06000**E010723382727")
+      }.to raise_error(C7Decrypt::Type7::InvalidCharacter)
     end
   end
   
   context "when trying to decrypt a hash with an odd number of characters" do
     it "should raise an InvalidFirstCharacter Exception" do
-      expect { C7Decrypt.decrypt("06000E01723382727") }.to raise_error(C7Decrypt::OddNumberOfCharacters)
+      expect {
+        C7Decrypt::Type7.decrypt("06000E01723382727")
+      }.to raise_error(C7Decrypt::Type7::OddNumberOfCharacters)
     end
   end
 
   context "when trying to encrypt a hash with an invalid high encryption seed" do
     it "should raise an InvalidFirstCharacter Exception" do
-      expect { C7Decrypt.encrypt("bananas", 16) }.to raise_error(C7Decrypt::InvalidEncryptionSeed)
+      expect {
+        C7Decrypt::Type7.encrypt("bananas", 16)
+      }.to raise_error(C7Decrypt::Type7::InvalidEncryptionSeed)
     end
   end
 
   context "when trying to encrypt a hash with an invalid low encryption seed" do
     it "should raise an InvalidFirstCharacter Exception" do
-      expect { C7Decrypt.encrypt("bananas", -1) }.to raise_error(C7Decrypt::InvalidEncryptionSeed)
+      expect {
+        C7Decrypt::Type7.encrypt("bananas", -1)
+      }.to raise_error(C7Decrypt::Type7::InvalidEncryptionSeed)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: c7decrypt
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Jonathan Claudius
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-19 00:00:00.000000000 Z
+date: 2014-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fuzzbert
@@ -30,14 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -70,12 +84,12 @@ files:
 - bin/c7decrypt
 - c7decrypt.gemspec
 - lib/c7decrypt.rb
-- lib/c7decrypt/c7decrypt.rb
+- lib/c7decrypt/type7.rb
 - lib/c7decrypt/version.rb
-- spec/c7decrypt_spec.rb
 - spec/example_configs/bad_canned_example.txt
 - spec/example_configs/empty_example.txt
 - spec/example_configs/simple_canned_example.txt
+- spec/type7_spec.rb
 homepage: http://rubygems.org/gems/c7decrypt
 licenses: []
 metadata: {}

data/lib/c7decrypt/c7decrypt.rb

@@ -1,192 +0,0 @@
-module C7Decrypt
-  module Constants
-    # Vigenere translation table (these are our key values for decryption)
-    VT_TABLE = [
-      0x64, 0x73, 0x66, 0x64, 0x3b, 0x6b, 0x66, 0x6f, 0x41, 0x2c, 0x2e,
-      0x69, 0x79, 0x65, 0x77, 0x72, 0x6b, 0x6c, 0x64, 0x4a, 0x4b, 0x44,
-      0x48, 0x53, 0x55, 0x42, 0x73, 0x67, 0x76, 0x63, 0x61, 0x36, 0x39,
-      0x38, 0x33, 0x34, 0x6e, 0x63, 0x78, 0x76, 0x39, 0x38, 0x37, 0x33,
-      0x32, 0x35, 0x34, 0x6b, 0x3b, 0x66, 0x67, 0x38, 0x37
-    ]
-
-    # Regexes for extracting hashes from configs
-    TYPE_7_REGEXES = [
-      /enable password 7 ([A-Z0-9]+)/,
-      /username [A-Z0-9]+ password 7 ([A-Z0-9]+)/,
-      /password 7 ([A-Z0-9]+)/
-    ]
-  end
-
-  class InvalidFirstCharacter < StandardError
-  end
-
-  class InvalidCharacter < StandardError
-  end
-
-  class OddNumberOfCharacters < StandardError
-  end
-
-  class InvalidEncryptionSeed < StandardError
-  end
-
-  # The Decryption Method for Cisco Type-7 Encrypted Strings
-  # @param [String] the Cisco Type-7 Encrypted String
-  # @raise [InvalidFirstCharacter, 
-  #         InvalidCharacter, 
-  #         OddNumberOfCharacters]
-  # @return [String] the Decrypted String
-  def self.decrypt(e_text)
-    check_type_7_errors(e_text)
-
-    d_text = ""
-    seed = nil
-
-    e_text.scan(/../).each_with_index do |char,i|
-      if i == 0
-        seed = char.to_i - 1
-      else
-        d_text += decrypt_char(char, i, seed)
-      end
-    end
-
-    return d_text
-  end
-
-  # The Encryption Method for Cisco Type-7 Encrypted Strings
-  # @param [String] the plaintext password
-  # @param [String] the seed for the encryption used
-  # @raise [InvalidEncryptionSeed,
-  #         InvalidFirstCharacter, 
-  #         InvalidCharacter, 
-  #         OddNumberOfCharacters]
-  # @return [String] the encrypted password
-  def self.encrypt(d_text, seed = 2)
-    check_seed(seed)
-  
-    e_text = sprintf("%02d", seed)
-
-    d_text.each_char.each_with_index do |d_char,i|
-      e_text += encrypt_char(d_char, i, seed)
-    end
-
-    check_type_7_errors(e_text)
-
-    return e_text
-  end
-
-  # The method for encrypting a single character
-  # @param [String] the plain text char
-  # @param [FixNum] the index of the char in plaintext string
-  # @param [FixNum] the seed used in the encryption process
-  # @return [String] the string of the encrypted char
-  def self.encrypt_char(char, i, seed)
-    sprintf("%02X", char.unpack('C')[0] ^ Constants::VT_TABLE[(i + seed) % 53])
-  end
-
-  # The method for decrypting a single character
-  # @param [String] the encrypted char
-  # @param [Integer] the index of the char pair in encrypted string
-  # @param [Integer] the seed used in the decryption process
-  # @return [String] the string of the decrypted char
-  def self.decrypt_char(char, i, seed)
-    (char.hex^Constants::VT_TABLE[(i + seed) % 53]).chr
-  end
-
-  # A helper method to decrypt an arracy of Cisco Type-7 Encrypted Strings
-  # @param [Array>String] an array of Cisco Type-7 Encrypted Strings
-  # @raise [InvalidFirstCharacter, 
-  #         InvalidCharacter, 
-  #         OddNumberOfCharacters]
-  # @return [Array>String] an array of Decrypted Strings
-  def self.decrypt_array(pw_array)
-    pw_array.collect {|pw| decrypt(pw)}
-  end
-
-  # A helper method to encrypt an arracy of passwords
-  # @param [Array>String] an array of plain-text passwords
-  # @raise [InvalidEncryptionSeed,
-  #         InvalidFirstCharacter, 
-  #         InvalidCharacter, 
-  #         OddNumberOfCharacters]
-  # @return [Array>String] an array of encrypted passwords
-  def self.encrypt_array(pt_array, seed = 2)
-    pt_array.collect {|pw| encrypt(pw, seed)}
-  end
-
-  # This method scans a raw config file for type 7 passwords and 
-  #   decrypts them
-  # @param [String] a string of the config file path that contains
-  #   Cisco Type-7 Encrypted Strings
-  # @raise [InvalidFirstCharacter, 
-  #         InvalidCharacter, 
-  #         OddNumberOfCharacters]
-  # @return [Array>String] an array of Decrypted Strings
-  def self.decrypt_config(file)
-    f = File.open(file, 'r').to_a
-    decrypt_array(f.collect {|line| type_7_matches(line)}.flatten)
-  end
-
-  # This method scans a config line for encrypted type-7 passwords and
-  #   returns an array of results
-  # @param [String] a line with potential encrypted type-7 passwords
-  # @return [Array>String] an array of Cisco type-7 encrypted Strings
-  def self.type_7_matches(string)
-    Constants::TYPE_7_REGEXES.collect {|regex| string.scan(regex)}.flatten.uniq
-  end
-
-  # This method determines if an encrypted hash is corrupted/invalid 
-  #   and throw a specific exeception
-  # @param [String] the Cisco Type-7 Encrypted String
-  # @raise [InvalidFirstCharacter, InvalidCharacter, OddNumberOfCharacters]
-  # @return [Nil]
-  def self.check_type_7_errors(e_text)
-    
-    valid_first_chars = (0..15).to_a.collect {|c| sprintf("%02d", c)}
-    first_char = e_text[0,2]
-
-    # Check for an invalid first character in the has
-    unless valid_first_chars.include? first_char
-      raise InvalidFirstCharacter, 
-        "'#{e_text}' hash contains an invalid first chracter (only '00' - '15' allowed)"
-    end
-
-    # Check for an invalid character in the hash
-    unless e_text.match(/^[A-Z0-9]+$/)
-      raise InvalidCharacter,
-        "'#{e_text}' hash contains an invalid character (only upper-alpha numeric allowed)"
-    end
-
-    # Check for an odd number of characters in the hash
-    unless e_text.size % 2 == 0
-      raise OddNumberOfCharacters,
-        "'#{e_text}' hash contains odd length of chars (only even number of chars allowed)"     
-    end
-
-    return nil
-
-  end
-
-  # This method determines if an encryption seed is valid or not
-  #   and throw a specific exeception
-  # @param [FixNum] the seed used in the encryption process
-  # @raise [InvalidEncryptionSeed] 
-  # @return [Nil]
-  def self.check_seed(seed)
-    if seed < 0 ||
-       seed > 15
-      
-      raise InvalidEncryptionSeed,
-        "'#{seed.to_s}' seed is not a valid seed (only 0 - 15 allowed)"
-    end
-
-    return nil
-  end
-
-  #Definition of short-hand methods for the lazy
-  #alias :d :decrypt
-  #alias :e :encrypt
-  #alias :d_a :decrypt_array
-  #alias :e_a :encrypt_array
-  #alias :d_c :decrypt_config
-
-end