encrypted_strings 0.2.1 → 0.3.0

data/CHANGELOG.rdoc

@@ -1,5 +1,9 @@
 == master
 
+== 0.3.0 / 2008-12-14
+
+* Remove the PluginAWeek namespace
+
 == 0.2.1 / 2008-12-04
 
 * Fix class-level defaults not working when inherited

data/README.rdoc

@@ -38,11 +38,11 @@ Asymmetric ciphers.
   >> encrypted_password.class
   => String
   >> encrypted_password.cipher
-  => #<PluginAWeek::EncryptedStrings::ShaCipher:0x2b9238889460 @salt="salt">
+  => #<EncryptedStrings::ShaCipher:0x2b9238889460 @salt="salt">
   >> encrypted_password == 'shhhh'
   => true
   >> encrypted_password.decrypt
-  NotImplementedError: Decryption is not supported using a(n) PluginAWeek::EncryptedStrings::ShaCipher
+  NotImplementedError: Decryption is not supported using a(n) EncryptedStrings::ShaCipher
           from ./script/../config/../config/../vendor/plugins/encrypted_strings/lib/encrypted_strings/cipher.rb:13:in `decrypt'
           from ./script/../config/../config/../vendor/plugins/encrypted_strings/lib/encrypted_strings/extensions/string.rb:52:in `decrypt'
           from (irb):40

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/contrib/sshpublisher'
 
 spec = Gem::Specification.new do |s|
   s.name              = 'encrypted_strings'
-  s.version           = '0.2.1'
+  s.version           = '0.3.0'
   s.platform          = Gem::Platform::RUBY
   s.summary           = 'Dead-simple string encryption/decryption syntax.'
   

data/lib/encrypted_strings/asymmetric_cipher.rb

@@ -1,187 +1,185 @@
-module PluginAWeek #:nodoc:
-  module EncryptedStrings
-    # Indicates no public key was found
-    class NoPublicKeyError < StandardError
+module EncryptedStrings
+  # Indicates no public key was found
+  class NoPublicKeyError < StandardError
+  end
+  
+  # Indicates no private key was found
+  class NoPrivateKeyError < StandardError
+  end
+  
+  # Encryption in which the keys used to encrypt/decrypt come in pairs.  Also
+  # known as public key encryption.  Anything that's encrypted using the
+  # public key can only be decrypted with the same algorithm and a matching
+  # private key.  Any message that is encrypted with the private key can only
+  # be decrypted with the matching public key.
+  # 
+  # Source: http://support.microsoft.com/kb/246071
+  # 
+  # == Encrypting 
+  # 
+  # To encrypt a string using an asymmetric cipher, the location of the
+  # public key file must be specified.  You can define the default for this
+  # value like so:
+  # 
+  #   EncryptedStrings::AsymmetricCipher.default_public_key_file = './public.key'
+  # 
+  # If these configuration options are not passed in to #encrypt, then the
+  # default values will be used.  You can override the default values like so:
+  # 
+  #   password = 'shhhh'
+  #   password.encrypt(:asymmetric, :public_key_file => './encrypted_public.key')  # => "INy95irZ8AlHmvc6ZAF/ARsTpbqPIB/4bEAKKOebjsayB7NYWtIzpswvzxqf\nNJ5yyuvxfMODrcg7RimEMFkFlg==\n"
+  # 
+  # An exception will be raised if either the public key file could not be
+  # found or the key could not decrypt the public key file.
+  # 
+  # == Decrypting
+  # 
+  # To decrypt a string using an asymmetric cipher, the location of the
+  # private key file must be specified.  If this file is itself encrypted, you
+  # must also specify the algorithm and password used to seed the symmetric
+  # algorithm that will decrypt the plublic key file.  You can define defaults
+  # for these values like so:
+  # 
+  #   EncryptedStrings::AsymmetricCipher.default_private_key_file = './private.key'
+  #   EncryptedStrings::SymmetricCipher.default_algorithm = 'DES-EDE3-CBC'
+  #   EncryptedStrings::SymmetricCipher.default_password = 'secret'
+  # 
+  # If these configuration options are not passed in to #decrypt, then the
+  # default values will be used.  You can override the default values like so:
+  # 
+  #   password = "INy95irZ8AlHmvc6ZAF/ARsTpbqPIB/4bEAKKOebjsayB7NYWtIzpswvzxqf\nNJ5yyuvxfMODrcg7RimEMFkFlg==\n"
+  #   password.decrypt(:asymmetric, :public_key_file => './encrypted_public.key', :password => 'secret') # => "shhhh"
+  # 
+  # An exception will be raised if either the private key file could not be
+  # found or the password could not decrypt the private key file.
+  class AsymmetricCipher < Cipher
+    class << self
+      # The default private key to use during encryption.  Default is nil.
+      attr_accessor :default_private_key_file
+      
+      # The default public key to use during encryption.  Default is nil.
+      attr_accessor :default_public_key_file
     end
     
-    # Indicates no private key was found
-    class NoPrivateKeyError < StandardError
-    end
+    # Private key used for decrypting data
+    attr_reader :private_key_file
     
-    # Encryption in which the keys used to encrypt/decrypt come in pairs.  Also
-    # known as public key encryption.  Anything that's encrypted using the
-    # public key can only be decrypted with the same algorithm and a matching
-    # private key.  Any message that is encrypted with the private key can only
-    # be decrypted with the matching public key.
-    # 
-    # Source: http://support.microsoft.com/kb/246071
-    # 
-    # == Encrypting 
-    # 
-    # To encrypt a string using an asymmetric cipher, the location of the
-    # public key file must be specified.  You can define the default for this
-    # value like so:
-    # 
-    #   PluginAWeek::EncryptedStrings::AsymmetricCipher.default_public_key_file = './public.key'
-    # 
-    # If these configuration options are not passed in to #encrypt, then the
-    # default values will be used.  You can override the default values like so:
-    # 
-    #   password = 'shhhh'
-    #   password.encrypt(:asymmetric, :public_key_file => './encrypted_public.key')  # => "INy95irZ8AlHmvc6ZAF/ARsTpbqPIB/4bEAKKOebjsayB7NYWtIzpswvzxqf\nNJ5yyuvxfMODrcg7RimEMFkFlg==\n"
-    # 
-    # An exception will be raised if either the public key file could not be
-    # found or the key could not decrypt the public key file.
-    # 
-    # == Decrypting
-    # 
-    # To decrypt a string using an asymmetric cipher, the location of the
-    # private key file must be specified.  If this file is itself encrypted, you
-    # must also specify the algorithm and password used to seed the symmetric
-    # algorithm that will decrypt the plublic key file.  You can define defaults
-    # for these values like so:
-    # 
-    #   PluginAWeek::EncryptedStrings::AsymmetricCipher.default_private_key_file = './private.key'
-    #   PluginAWeek::EncryptedStrings::SymmetricCipher.default_algorithm = 'DES-EDE3-CBC'
-    #   PluginAWeek::EncryptedStrings::SymmetricCipher.default_password = 'secret'
-    # 
-    # If these configuration options are not passed in to #decrypt, then the
-    # default values will be used.  You can override the default values like so:
-    # 
-    #   password = "INy95irZ8AlHmvc6ZAF/ARsTpbqPIB/4bEAKKOebjsayB7NYWtIzpswvzxqf\nNJ5yyuvxfMODrcg7RimEMFkFlg==\n"
-    #   password.decrypt(:asymmetric, :public_key_file => './encrypted_public.key', :password => 'secret') # => "shhhh"
+    # Public key used for encrypting data
+    attr_reader :public_key_file
+    
+    # The algorithm to use if the key files are encrypted themselves
+    attr_accessor :algorithm
+    
+    # The password used during symmetric decryption of the key files
+    attr_accessor :password
+    
+    # Creates a new cipher that uses an asymmetric encryption strategy.
     # 
-    # An exception will be raised if either the private key file could not be
-    # found or the password could not decrypt the private key file.
-    class AsymmetricCipher < Cipher
-      class << self
-        # The default private key to use during encryption.  Default is nil.
-        attr_accessor :default_private_key_file
-        
-        # The default public key to use during encryption.  Default is nil.
-        attr_accessor :default_public_key_file
-      end
+    # Configuration options:
+    # * +private_key_file+ - Encrypted private key file
+    # * +public_key_file+ - Public key file
+    # * +password+ - The password to use in the symmetric cipher
+    # * +algorithm+ - Algorithm to use symmetrically encrypted strings
+    def initialize(options = {})
+      invalid_options = options.keys - [:private_key_file, :public_key_file, :algorithm, :password]
+      raise ArgumentError, "Unknown key(s): #{invalid_options.join(", ")}" unless invalid_options.empty?
       
-      # Private key used for decrypting data
-      attr_reader :private_key_file
+      options = {
+        :private_key_file => AsymmetricCipher.default_private_key_file,
+        :public_key_file => AsymmetricCipher.default_public_key_file
+      }.merge(options)
       
-      # Public key used for encrypting data
-      attr_reader :public_key_file
+      @public_key = @private_key = nil
       
-      # The algorithm to use if the key files are encrypted themselves
-      attr_accessor :algorithm
+      self.private_key_file = options[:private_key_file]
+      self.public_key_file  = options[:public_key_file]
+      raise ArgumentError, 'At least one key file must be specified (:private_key_file or :public_key_file)' unless private_key_file || public_key_file
       
-      # The password used during symmetric decryption of the key files
-      attr_accessor :password
+      self.algorithm  = options[:algorithm]
+      self.password = options[:password]
       
-      # Creates a new cipher that uses an asymmetric encryption strategy.
-      # 
-      # Configuration options:
-      # * +private_key_file+ - Encrypted private key file
-      # * +public_key_file+ - Public key file
-      # * +password+ - The password to use in the symmetric cipher
-      # * +algorithm+ - Algorithm to use symmetrically encrypted strings
-      def initialize(options = {})
-        invalid_options = options.keys - [:private_key_file, :public_key_file, :algorithm, :password]
-        raise ArgumentError, "Unknown key(s): #{invalid_options.join(", ")}" unless invalid_options.empty?
-        
-        options = {
-          :private_key_file => AsymmetricCipher.default_private_key_file,
-          :public_key_file => AsymmetricCipher.default_public_key_file
-        }.merge(options)
-        
-        @public_key = @private_key = nil
-        
-        self.private_key_file = options[:private_key_file]
-        self.public_key_file  = options[:public_key_file]
-        raise ArgumentError, 'At least one key file must be specified (:private_key_file or :public_key_file)' unless private_key_file || public_key_file
-        
-        self.algorithm  = options[:algorithm]
-        self.password = options[:password]
-        
-        super()
-      end
-      
-      # Encrypts the given data. If no public key file has been specified, then
-      # a NoPublicKeyError will be raised.
-      def encrypt(data)
-        raise NoPublicKeyError, "Public key file: #{public_key_file}" unless public?
-        
-        encrypted_data = public_rsa.public_encrypt(data)
-        Base64.encode64(encrypted_data)
-      end
+      super()
+    end
+    
+    # Encrypts the given data. If no public key file has been specified, then
+    # a NoPublicKeyError will be raised.
+    def encrypt(data)
+      raise NoPublicKeyError, "Public key file: #{public_key_file}" unless public?
       
-      # Decrypts the given data. If no private key file has been specified, then
-      # a NoPrivateKeyError will be raised.
-      def decrypt(data)
-        raise NoPrivateKeyError, "Private key file: #{private_key_file}" unless private?
-        
-        decrypted_data = Base64.decode64(data)
-        private_rsa.private_decrypt(decrypted_data)
-      end
+      encrypted_data = public_rsa.public_encrypt(data)
+      Base64.encode64(encrypted_data)
+    end
+    
+    # Decrypts the given data. If no private key file has been specified, then
+    # a NoPrivateKeyError will be raised.
+    def decrypt(data)
+      raise NoPrivateKeyError, "Private key file: #{private_key_file}" unless private?
       
-      # Sets the location of the private key and loads it
-      def private_key_file=(file)
-        @private_key_file = file and load_private_key
-      end
+      decrypted_data = Base64.decode64(data)
+      private_rsa.private_decrypt(decrypted_data)
+    end
+    
+    # Sets the location of the private key and loads it
+    def private_key_file=(file)
+      @private_key_file = file and load_private_key
+    end
+    
+    # Sets the location of the public key and loads it
+    def public_key_file=(file)
+      @public_key_file = file and load_public_key
+    end
+    
+    # Does this cipher have a public key available?
+    def public?
+      return true if @public_key
       
-      # Sets the location of the public key and loads it
-      def public_key_file=(file)
-        @public_key_file = file and load_public_key
-      end
+      load_public_key
+      !@public_key.nil?
+    end
+    
+    # Does this cipher have a private key available?
+    def private?
+      return true if @private_key
       
-      # Does this cipher have a public key available?
-      def public?
-        return true if @public_key
+      load_private_key
+      !@private_key.nil?
+    end
+    
+    private
+      # Loads the private key from the configured file
+      def load_private_key
+        @private_rsa = nil
         
-        load_public_key
-        !@public_key.nil?
+        if private_key_file && File.file?(private_key_file)
+          @private_key = File.read(private_key_file)
+        end
       end
       
-      # Does this cipher have a private key available?
-      def private?
-        return true if @private_key
+      # Loads the public key from the configured file
+      def load_public_key
+        @public_rsa = nil
         
-        load_private_key
-        !@private_key.nil?
+        if public_key_file && File.file?(public_key_file)
+          @public_key = File.read(public_key_file)
+        end
       end
       
-      private
-        # Loads the private key from the configured file
-        def load_private_key
-          @private_rsa = nil
+      # Retrieves the private RSA from the private key
+      def private_rsa
+        if password
+          options = {:password => password}
+          options[:algorithm] = algorithm if algorithm
           
-          if private_key_file && File.file?(private_key_file)
-            @private_key = File.read(private_key_file)
-          end
+          private_key = @private_key.decrypt(:symmetric, options)
+          OpenSSL::PKey::RSA.new(private_key)
+        else
+          @private_rsa ||= OpenSSL::PKey::RSA.new(@private_key)
         end
-        
-        # Loads the public key from the configured file
-        def load_public_key
-          @public_rsa = nil
-          
-          if public_key_file && File.file?(public_key_file)
-            @public_key = File.read(public_key_file)
-          end
-        end
-        
-        # Retrieves the private RSA from the private key
-        def private_rsa
-          if password
-            options = {:password => password}
-            options[:algorithm] = algorithm if algorithm
-            
-            private_key = @private_key.decrypt(:symmetric, options)
-            OpenSSL::PKey::RSA.new(private_key)
-          else
-            @private_rsa ||= OpenSSL::PKey::RSA.new(@private_key)
-          end
-        end
-        
-        # Retrieves the public RSA
-        def public_rsa
-          @public_rsa ||= OpenSSL::PKey::RSA.new(@public_key)
-        end
-    end
+      end
+      
+      # Retrieves the public RSA
+      def public_rsa
+        @public_rsa ||= OpenSSL::PKey::RSA.new(@public_key)
+      end
   end
 end

data/lib/encrypted_strings/cipher.rb

@@ -1,19 +1,17 @@
-module PluginAWeek #:nodoc:
-  module EncryptedStrings
-    # Represents the base class for all ciphers.  By default, all ciphers are
-    # assumed to be able to decrypt strings.  Note, however, that certain
-    # encryption algorithms do not allow decryption.
-    class Cipher
-      # Can this string be decrypted?  Default is true.
-      def can_decrypt?
-        true
-      end
-      
-      # Attempts to decrypt the given data using the current configuration.  By
-      # default, decryption is not implemented.
-      def decrypt(data)
-        raise NotImplementedError, "Decryption is not supported using a(n) #{self.class.name}"
-      end
+module EncryptedStrings
+  # Represents the base class for all ciphers.  By default, all ciphers are
+  # assumed to be able to decrypt strings.  Note, however, that certain
+  # encryption algorithms do not allow decryption.
+  class Cipher
+    # Can this string be decrypted?  Default is true.
+    def can_decrypt?
+      true
+    end
+    
+    # Attempts to decrypt the given data using the current configuration.  By
+    # default, decryption is not implemented.
+    def decrypt(data)
+      raise NotImplementedError, "Decryption is not supported using a(n) #{self.class.name}"
     end
   end
 end

data/lib/encrypted_strings/extensions/string.rb

@@ -1,210 +1,208 @@
 require 'openssl'
 require 'base64'
 
-module PluginAWeek #:nodoc:
-  module EncryptedStrings
-    module Extensions #:nodoc:
-      # Adds support for in-place encryption/decryption of strings
-      module String
-        def self.included(base) #:nodoc:
-          base.class_eval do
-            attr_accessor :cipher
-            
-            alias_method :equals_without_encryption, :==
-            alias_method :==, :equals_with_encryption
-          end
-        end
-        
-        # Encrypts the current string using the specified cipher.  The default
-        # cipher is sha.
-        # 
-        # Configuration options are cipher-specific.  See each individual cipher
-        # class to find out the options available.
-        # 
-        # == Example
-        # 
-        # The following uses an SHA cipher to encrypt the string:
-        # 
-        #   password = 'shhhh'
-        #   password.encrypt  # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
-        # 
-        # == Custom encryption mode
-        # 
-        # The following uses Symmetric cipher (with a default password) to
-        # encrypt the string:
-        # 
-        #   PluginAWeek::EncryptedStrings::SymmetricCipher.default_password = 'secret'
-        #   password = 'shhhh'
-        #   password.encrypt(:symmetric)  # => "jDACXI5hMPI=\n"
-        # 
-        # == Custom encryption options
-        # 
-        # Some encryption modes also support additional configuration options
-        # that determine how to encrypt the string.  For example, SHA supports
-        # a salt which seeds the algorithm:
-        # 
-        #   password = 'shhhh'
-        #   password.encrypt(:sha, :salt => 'secret') # => "3b22cbe4acde873c3efc82681096f3ae69aff828"
-        def encrypt(*args)
-          cipher = cipher_from_args(*args)
-          encrypted_string = cipher.encrypt(self)
-          encrypted_string.cipher = cipher
-          
-          encrypted_string
-        end
-        
-        # Encrypts this string and replaces it with the encrypted value.  This
-        # takes the same parameters as #encrypt, but returns the same string
-        # instead of a different one.
-        # 
-        # == Example
-        # 
-        #   password = 'shhhh'
-        #   password.encrypt!(:symmetric, :password => 'secret')  # => "qSg8vOo6QfU=\n"
-        #   password                                              # => "qSg8vOo6QfU=\n"
-        def encrypt!(*args)
-          encrypted_string = encrypt(*args)
-          self.cipher = encrypted_string.cipher
+module EncryptedStrings
+  module Extensions #:nodoc:
+    # Adds support for in-place encryption/decryption of strings
+    module String
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          attr_accessor :cipher
           
-          replace(encrypted_string)
+          alias_method :equals_without_encryption, :==
+          alias_method :==, :equals_with_encryption
         end
+      end
+      
+      # Encrypts the current string using the specified cipher.  The default
+      # cipher is sha.
+      # 
+      # Configuration options are cipher-specific.  See each individual cipher
+      # class to find out the options available.
+      # 
+      # == Example
+      # 
+      # The following uses an SHA cipher to encrypt the string:
+      # 
+      #   password = 'shhhh'
+      #   password.encrypt  # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+      # 
+      # == Custom encryption mode
+      # 
+      # The following uses Symmetric cipher (with a default password) to
+      # encrypt the string:
+      # 
+      #   EncryptedStrings::SymmetricCipher.default_password = 'secret'
+      #   password = 'shhhh'
+      #   password.encrypt(:symmetric)  # => "jDACXI5hMPI=\n"
+      # 
+      # == Custom encryption options
+      # 
+      # Some encryption modes also support additional configuration options
+      # that determine how to encrypt the string.  For example, SHA supports
+      # a salt which seeds the algorithm:
+      # 
+      #   password = 'shhhh'
+      #   password.encrypt(:sha, :salt => 'secret') # => "3b22cbe4acde873c3efc82681096f3ae69aff828"
+      def encrypt(*args)
+        cipher = cipher_from_args(*args)
+        encrypted_string = cipher.encrypt(self)
+        encrypted_string.cipher = cipher
         
-        # Is this string encrypted?  This will return true if the string is the
-        # result of a call to #encrypt or #encrypt!.
-        # 
-        # == Example
-        # 
-        #   password = 'shhhh'
-        #   password.encrypted? # => false
-        #   password.encrypt!   # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
-        #   password.encrypted? # => true
-        def encrypted?
-          !cipher.nil?
-        end
+        encrypted_string
+      end
+      
+      # Encrypts this string and replaces it with the encrypted value.  This
+      # takes the same parameters as #encrypt, but returns the same string
+      # instead of a different one.
+      # 
+      # == Example
+      # 
+      #   password = 'shhhh'
+      #   password.encrypt!(:symmetric, :password => 'secret')  # => "qSg8vOo6QfU=\n"
+      #   password                                              # => "qSg8vOo6QfU=\n"
+      def encrypt!(*args)
+        encrypted_string = encrypt(*args)
+        self.cipher = encrypted_string.cipher
         
-        # Decrypts this string.  If this is not a string that was previously
-        # encrypted, the cipher must be specified in the same way that it is
-        # when encrypting a string.
-        # 
-        # == Example
-        # 
-        # Without being previously encrypted:
-        # 
-        #   password = "qSg8vOo6QfU=\n"
-        #   password.decrypt(:symmetric, :password => 'secret')   # => "shhhh"
-        # 
-        # After being previously encrypted:
-        # 
-        #   password = 'shhhh'
-        #   password.encrypt!(:symmetric, :password => 'secret')  # => "qSg8vOo6QfU=\n"
-        #   password.decrypt                                      # => "shhhh"
-        def decrypt(*args)
-          raise ArgumentError, 'Cipher cannot be inferred: must specify it as an argument' if args.empty? && !encrypted?
-          
-          cipher = args.empty? && self.cipher || cipher_from_args(*args)
-          encrypted_string = cipher.decrypt(self)
-          encrypted_string.cipher = nil
-          
-          encrypted_string
-        end
+        replace(encrypted_string)
+      end
+      
+      # Is this string encrypted?  This will return true if the string is the
+      # result of a call to #encrypt or #encrypt!.
+      # 
+      # == Example
+      # 
+      #   password = 'shhhh'
+      #   password.encrypted? # => false
+      #   password.encrypt!   # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+      #   password.encrypted? # => true
+      def encrypted?
+        !cipher.nil?
+      end
+      
+      # Decrypts this string.  If this is not a string that was previously
+      # encrypted, the cipher must be specified in the same way that it is
+      # when encrypting a string.
+      # 
+      # == Example
+      # 
+      # Without being previously encrypted:
+      # 
+      #   password = "qSg8vOo6QfU=\n"
+      #   password.decrypt(:symmetric, :password => 'secret')   # => "shhhh"
+      # 
+      # After being previously encrypted:
+      # 
+      #   password = 'shhhh'
+      #   password.encrypt!(:symmetric, :password => 'secret')  # => "qSg8vOo6QfU=\n"
+      #   password.decrypt                                      # => "shhhh"
+      def decrypt(*args)
+        raise ArgumentError, 'Cipher cannot be inferred: must specify it as an argument' if args.empty? && !encrypted?
         
-        # Decrypts this string and replaces it with the decrypted value  This
-        # takes the same parameters as #decrypt, but returns the same string
-        # instead of a different one.
-        # 
-        # For example,
-        # 
-        #   password = "qSg8vOo6QfU=\n"
-        #   password.decrypt!(:symmetric, :password => 'secret')  # => "shhhh"
-        #   password                                              # => "shhhh"
-        def decrypt!(*args)
-          value = replace(decrypt(*args))
-          self.cipher = nil
-          value
-        end
+        cipher = args.empty? && self.cipher || cipher_from_args(*args)
+        encrypted_string = cipher.decrypt(self)
+        encrypted_string.cipher = nil
         
-        # Can this string be decrypted?  Strings can only be decrypted if they
-        # have previously been decrypted *and* the cipher supports decryption.
-        # To determine whether or not the cipher supports decryption, see the
-        # api for the cipher.
-        def can_decrypt?
-          encrypted? && cipher.can_decrypt?
-        end
-        
-        # Tests whether the other object is equal to this one.  Encrypted strings
-        # will be tested not only on their encrypted strings, but also by
-        # decrypting them and running tests against the decrypted value.
-        # 
-        # == Equality with strings
-        # 
-        #   password = 'shhhh'
-        #   password.encrypt!   # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
-        #   password            # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
-        #   password == "shhhh" # => true
-        # 
-        # == Equality with encrypted strings
-        # 
-        #   password = 'shhhh'
-        #   password.encrypt!             # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
-        #   password                      # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
-        #   password == 'shhhh'           # => true
-        #   
-        #   another_password = 'shhhh'
-        #   another_password.encrypt!     # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
-        #   password == another_password  # => true
-        def equals_with_encryption(other)
-          if !(is_equal = equals_without_encryption(other)) && String === other
-            if encrypted?
-              if other.encrypted?
-                # We're both encrypted, so check if:
-                # (1) The other string is the encrypted value of this string
-                # (2) This string is the encrypted value of the other string
-                # (3) The other string is the encrypted value of this string, decrypted
-                # (4) This string is the encrypted value of the other string, decrypted
-                is_string_equal?(self, other) || is_string_equal?(other, self) || self.can_decrypt? && is_string_equal?(self.decrypt, other) || other.can_decrypt? && is_string_equal?(other.decrypt, self)
-              else
-                # Only we're encrypted
-                is_string_equal?(other, self)
-              end
+        encrypted_string
+      end
+      
+      # Decrypts this string and replaces it with the decrypted value  This
+      # takes the same parameters as #decrypt, but returns the same string
+      # instead of a different one.
+      # 
+      # For example,
+      # 
+      #   password = "qSg8vOo6QfU=\n"
+      #   password.decrypt!(:symmetric, :password => 'secret')  # => "shhhh"
+      #   password                                              # => "shhhh"
+      def decrypt!(*args)
+        value = replace(decrypt(*args))
+        self.cipher = nil
+        value
+      end
+      
+      # Can this string be decrypted?  Strings can only be decrypted if they
+      # have previously been decrypted *and* the cipher supports decryption.
+      # To determine whether or not the cipher supports decryption, see the
+      # api for the cipher.
+      def can_decrypt?
+        encrypted? && cipher.can_decrypt?
+      end
+      
+      # Tests whether the other object is equal to this one.  Encrypted strings
+      # will be tested not only on their encrypted strings, but also by
+      # decrypting them and running tests against the decrypted value.
+      # 
+      # == Equality with strings
+      # 
+      #   password = 'shhhh'
+      #   password.encrypt!   # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+      #   password            # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+      #   password == "shhhh" # => true
+      # 
+      # == Equality with encrypted strings
+      # 
+      #   password = 'shhhh'
+      #   password.encrypt!             # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+      #   password                      # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+      #   password == 'shhhh'           # => true
+      #   
+      #   another_password = 'shhhh'
+      #   another_password.encrypt!     # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+      #   password == another_password  # => true
+      def equals_with_encryption(other)
+        if !(is_equal = equals_without_encryption(other)) && String === other
+          if encrypted?
+            if other.encrypted?
+              # We're both encrypted, so check if:
+              # (1) The other string is the encrypted value of this string
+              # (2) This string is the encrypted value of the other string
+              # (3) The other string is the encrypted value of this string, decrypted
+              # (4) This string is the encrypted value of the other string, decrypted
+              is_string_equal?(self, other) || is_string_equal?(other, self) || self.can_decrypt? && is_string_equal?(self.decrypt, other) || other.can_decrypt? && is_string_equal?(other.decrypt, self)
             else
-              if other.encrypted?
-                # Only the other string is encrypted
-                is_string_equal?(self, other)
-              else
-                # Neither are encrypted and equality test didn't work before, so
-                # they can't be equal
-                false
-              end
+              # Only we're encrypted
+              is_string_equal?(other, self)
             end
           else
-            # The other value wasn't a string, so we can't check encryption equality
-            is_equal
-          end
-        end
-        
-        private
-          def is_string_equal?(value, encrypted_value) #:nodoc:
-            # If the encrypted value can be decrypted, then test against the decrypted value
-            if encrypted_value.can_decrypt?
-              encrypted_value.decrypt.equals_without_encryption(value)
+            if other.encrypted?
+              # Only the other string is encrypted
+              is_string_equal?(self, other)
             else
-              # Otherwise encrypt this value based on the cipher used on the encrypted value
-              # and test the equality of those strings
-              encrypted_value.equals_without_encryption(encrypted_value.cipher.encrypt(value))
+              # Neither are encrypted and equality test didn't work before, so
+              # they can't be equal
+              false
             end
           end
-          
-          # Builds the cipher to use from the given arguments
-          def cipher_from_args(*args) #:nodoc:
-            options = args.last.is_a?(Hash) ? args.pop : {}
-            name = (args.first || :sha).to_s.gsub(/(?:^|_)(.)/) {$1.upcase}
-            PluginAWeek::EncryptedStrings.const_get("#{name}Cipher").new(options)
-          end
+        else
+          # The other value wasn't a string, so we can't check encryption equality
+          is_equal
+        end
       end
+      
+      private
+        def is_string_equal?(value, encrypted_value) #:nodoc:
+          # If the encrypted value can be decrypted, then test against the decrypted value
+          if encrypted_value.can_decrypt?
+            encrypted_value.decrypt.equals_without_encryption(value)
+          else
+            # Otherwise encrypt this value based on the cipher used on the encrypted value
+            # and test the equality of those strings
+            encrypted_value.equals_without_encryption(encrypted_value.cipher.encrypt(value))
+          end
+        end
+        
+        # Builds the cipher to use from the given arguments
+        def cipher_from_args(*args) #:nodoc:
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          name = (args.first || :sha).to_s.gsub(/(?:^|_)(.)/) {$1.upcase}
+          EncryptedStrings.const_get("#{name}Cipher").new(options)
+        end
     end
   end
 end
 
 ::String.class_eval do
-  include PluginAWeek::EncryptedStrings::Extensions::String
+  include EncryptedStrings::Extensions::String
 end