Embedding dependency :-(

(ActionItem1732)

Embedding dependency :-(
(ActionItem1732)
Antonio Terceiro
1 parent 73806727
Showing 50 changed files with 7375 additions and 0 deletions Show diff stats
lib/ezcrypto.rb
vendor/ezcrypto-0.7.2/._CHANGELOG
vendor/ezcrypto-0.7.2/._MIT-LICENSE
vendor/ezcrypto-0.7.2/._README.rdoc
vendor/ezcrypto-0.7.2/._README_ACTIVE_CRYPTO
vendor/ezcrypto-0.7.2/._rakefile
vendor/ezcrypto-0.7.2/CHANGELOG
vendor/ezcrypto-0.7.2/MIT-LICENSE
vendor/ezcrypto-0.7.2/README.rdoc
vendor/ezcrypto-0.7.2/README_ACTIVE_CRYPTO
vendor/ezcrypto-0.7.2/README_DIGITAL_SIGNATURES
vendor/ezcrypto-0.7.2/init.rb
vendor/ezcrypto-0.7.2/lib/._active_crypto.rb
vendor/ezcrypto-0.7.2/lib/._ezcrypto.rb
vendor/ezcrypto-0.7.2/lib/._ezsig.rb
vendor/ezcrypto-0.7.2/lib/._trusted.pem
vendor/ezcrypto-0.7.2/lib/active_crypto.rb
vendor/ezcrypto-0.7.2/lib/ezcrypto.rb
vendor/ezcrypto-0.7.2/lib/ezsig.rb
vendor/ezcrypto-0.7.2/lib/trusted.pem
@@ -0,0 +1 @@
+../vendor/ezcrypto-0.7.2/lib/ezcrypto.rb
 \ No newline at end of file
@@ -0,0 +1,85 @@
+0.7.2 March, 2009 support for base64 encrypted attributes in ActiveCrypto (Micah Wedemeyer)
+
+0.7 September 12th, 2006 PKYP services support
+
+Marking the release of http://pkyp.org a new no nonsense Public Key directory, this allows you register your public keys and certificates on a public server. If you have web applications with certificates or public keys you can point your users at http://pkyp.org/{key.digest} for more info about a certificate.
+
+Register a public key or certificate at PKYP with the new method register_with_pkyp like this:
+
+    signer=EzCrypto::Signer.generate
+    signer.verifier.register_with_pkyp
+    
+If you have the public key or certificate digest you can fetch the full public key or certificate like this:
+
+    verifier=EzCrypto::Verifier.from_pkyp "e93e18114cbefaaa89fda908b09df63d3662879a"
+    verifier.verify sig, request_text
+
+This allows a simpler way of transfering certificates. The idea of including certificates with every request is not really necessary in an online world. For example you could pass the digest in a HTTP header for a REST web services request.
+
+0.6.2 August 15th, 2006 Trust something release
+
+Now comes complete with a fairly trusted list of root certs as extracted from Apple's keystore. With the addition of CACerts and GoDaddy SSL Certs (Buy from http://widecert.net). If you feel any important ones are missing let me know.
+
+You can create a trust store from this with TrustStore.default_trusted. Note many of these CA's are useless and you shouldn't really trust them, but this makes it easy to emulate the browsers support.
+
+0.6.1 August 14th, 2006 Subject!=Issuer bug fix
+
+I discovered a not so little bug in the certificate handling. The issuer method of the Certificate mistakenly returned the subject.
+
+0.6   August 10th, 2006 Certified PKI release
+
+Finally I have had a good reason http://www.tractis.com to add Digital Signature support to EzCrypto. We have support for RSA and DSA private and public keys as well as basic X509 certificate support. All in typical EzCrypto simple Ruby like methods.
+
+KNOWN PROBLEM. The DSA Signer.public_key method has some sort of problem but will be fixed for 0.6.1.
+
+0.5   July 19th, 2006 Good citizen release
+
+I have cleaned up the ActiveCrypto namespaces. It now does not use ActiveRecord::Crypto, but ActiveCrypto::*, if you have called stuff directly please update your code. 
+
+The reason for this is to really be a good citizen in the world of rails and not unnecessarily pollute the ActiveRecord name space.
+
+I have also created much more thorough unit tests and refactored some things that did not work in version 0.4 that the world thankfully did not see.
+
+0.4   Flawed internal release
+
+0.3   February 25th, 2006 new encrypted file support by Dirk (dirk.barnikel@gmx.de) Thanks Dirk.
+
+* Added test case for the file-related stuff. file-stuff 
+  seems to work fine
+
+* Replaced hard coded IO buffersize (512) with class attribute
+  Key#block_size and default value.
+
+* Modification to create {De,En}crypters only via the factory methods
+  Key#{de,en}crypter.
+
+* Added Key#{de,en}crypt_file methods that take a file and de- or encrypts it. 
+
+* The methods are implemented to call the cipher with small chunks of data (512 bytes) to keep memory usage low.
+
+* By default, the original file is first overwritten and then removed.
+
+* This overwrite is not really safe but should make it harder to restore the data of the removed file from the filesystem.
+
+* Added Key#{store,load} methods that read and write Key data to/from files.
+
+* Added Key#safe_{create,delete,read} methods to encapsulate the handling of files inside EzCrypto.
+
+0.2.2 January 4th, 2006 Bug fixes and unit tests for active_crypto
+
+There were some serious problems with ActiveCrypto's support for having keys in associated classes. I also added unit tests to active_crypto. The support code was brutaly stolen from Rick Olson's acts_as_paranoid library. Unfortunately I disabled the schema stuff for now, but will add it in the next release, which hopefully is soon.
+
+0.2.1 November 2nd, 2005 New method in KeyHolder
+
+Added set_encoded_key(enc) to KeyHolder for setting a key with the Base64 encoded keyvalue.
+
+0.2 October 30th, 2005 Ruby on Rails integration
+
+As promised I have now included my first version of ActiveCrypto the crypto layer for ActiveRecord and Ruby on Rails.
+
+0.1.1 August 27, 2005 Minor fixes
+
+Thanks to Jason Vasquez mugatu at mugfu dot com for noticing that Key#to_s
+called the nonexistent encoded method. 
+
+I also made a few slight changes to the documentation.
@@ -0,0 +1,21 @@
+Copyright (c) 2004 David Heinemeier Hansson
+
+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.
+
@@ -0,0 +1,152 @@
+= EzCrypto - Easy to use Crypto for Ruby
+
+EzCrypto is an easy to use wrapper around the poorly documented OpenSSL ruby library.
+
+== Features
+
+* Defaults to AES 128 CBC
+* Will use the systems OpenSSL library for transparent hardware crypto support
+* Single class object oriented access to most commonly used features
+* Ruby like
+
+== Installation
+
+Download it from here:
+
+http://rubyforge.org/frs/?group_id=755
+
+or install it via Ruby Gems:
+
+	gem install ezcrypto
+
+== Simple examples
+
+==== To encrypt:
+
+Generate a key using a password and a salt. Use the keys encrypt method to encrypt a strings worth of data:
+
+  @key=EzCrypto::Key.with_password "password", "system salt"
+  @encrypted=@key.encrypt "Top secret should not be revealed"
+    
+==== To decrypt:
+
+Same procedure as encrypt. Generate a key using a password and a salt. Use the keys decrypt method to decrypt a strings worth of data:
+
+  @key=EzCrypto::Key.with_password "password", "system salt"
+  @key.decrypt @encrypted
+  
+==== One liners:
+
+These simple examples use one line each:
+
+  @encrypted=EzCrypto::Key.encrypt_with_password "password", @salt,"Top secret should not be revealed"
+  
+  EzCrypto::Key.decrypt_with_password "password", @salt,@encrypted
+
+== Keys
+
+The only class you need to know for most uses og EzCrypto is the Key class. You don't need understand ciphers or the encryption life cycle.
+
+==== Generating a random key
+
+The most secure type of key is the randomly generated key:
+
+  @key=EzCrypto::Key.generate
+  
+==== Initializing a key with raw key data
+
+If you already have a key from some other source, you simply have to call the constructor with the raw data:
+
+  @key=EzCrypto::Key.new @binarykey
+  
+==== Initializing a Key with a Base64 encoded key
+
+As seen above you can create a key from a password. This should be used if you don't want the key to be stored on disk for example:
+
+  @key=EzCrypto::Key.with_password "Secret password"
+
+==== Initializing a Key with a Base64 encoded key
+
+If you already have a key from some other source in the popular Base64 encoded format, you use the decode class method:
+
+  @key=EzCrypto::Key.decode @binarykey
+
+==== Exporting the key
+
+To export or save a key use the encode method (or to_s) method for a Base64 encoded key or raw as the raw binary data.
+
+  puts @key.encode
+  puts @key.raw
+  
+The raw method could be used for storing in a database using a tinyblob column.
+
+== Encryption and Decryption
+
+EzCrypto is optimized for simple encryption and decryption of strings. There are encrypt/decrypt pairs for normal binary use as well as for Base64 encoded use.
+
+==== Regular raw use
+
+Assuming you have generated a key using one of the above methods:
+
+  @encrypted=@key.encrypt("clear text")
+  @decrypted=@key.decrypt(@encrypted)
+  assert "clear text", @decrypted
+
+==== Base64 encoded use
+
+This uses the encrypt64 and decrypt64 methods. Otherwise it is all the same:
+
+  @encrypted=@key.encrypt64("clear text")
+  @decrypted=@key.decrypt64(@encrypted)
+  assert "clear text", @decrypted
+
+== FAQ
+
+=== What algorithm does this use?
+
+It uses as the default algorithm the AES 128 bit standard. This is a very fast and highly secure algorithm specified as the national standard in the US. For more information see:
+
+http://en.wikipedia.org/wiki/AES
+
+=== Only 128 bits. Is that enough?
+
+While it might sound like more would make it more secure, there is really no real security advantage for most commercial applications to use more than 128 bit AES.
+
+=== What is Base64 encoding?
+
+This is the most efficient and commonly used encoding scheme for binary data. This is used amongst other things for email attachments. It is also very common to use it for encrypted data.
+
+=== What is a Salt?
+
+A salt is just a piece of data we hash in with the password to create the key. If it is a server based application you could use store a salt within your source file. The salt must be the same for both encryption and decryption.
+
+
+== License
+
+EzCrypto and ActionCrypto is released under the MIT license.
+
+
+== Support
+
+To contact the author, send mail to pelle@stakeventures.com
+
+Also see my blogs at:
+http://stakeventures.com and
+http://blog.extraeagle.com
+
+This project was based on code used in my projects Agree2, WideWord and WideBlog.
+
+Agree2 lets you create legal business agreements instantly.
+
+https://agree2.com
+
+WideWord lets you collaboratively write and share documents that remain 100% encrypted on the server. Only you have the keys:
+
+http://wideword.net
+
+WideBlog is a secure private blogging system designed for private project blogs. It uses the same encryption technology as WideWord and is very easy to use:
+
+http://wideblog.net
+
+
+(C) 2005-2009 Pelle Braendgaard
@@ -0,0 +1,122 @@
+= ActiveCrypto - Easy to use Crypto for Ruby on Rails
+
+ActiveCrypto is based on EzCrypto and provides application oriented crypto support for Ruby on Rails applications.
+
+== Features
+
+* Transparent encryption/decryption
+* Ruby on Rails like domain language
+
+== Installation
+
+Download it from here:
+
+http://rubyforge.org/frs/?group_id=755
+
+or install it via Ruby Gems:
+
+	gem install ezruby
+
+
+== Simple examples
+
+==== A simple encrypted class
+
+You specify in your class which fields are encrypted:
+
+	class Document < ActiveRecord::Base
+		encrypt :title,:body
+	end
+
+Two encrypt it you need to enter a key. For ease of use there is a method called enter_password which sets the key based on a password of your choice.
+
+	doc=Document.new
+	doc.enter_password "This stuff is secret man!!!"
+	doc.title="Plan to take over the world"
+	doc.body="Write apps in Rails"
+	doc.save
+	
+This needs to be done as well if you want to read your document:
+
+	doc=Document.find 1
+	doc.enter_password "This stuff is secret man!!!"
+	puts doc.name
+	
+If you don't remember to set a key it will through a MissingKeyError.
+
+==== More realistic example with KeyHolder
+
+It probably isn't much use if each record needs its own key. The solution to this is the KeyHolder. A KeyHolder is an object that holds keys for use by other objects. A typical example would be a user.
+
+	class User < ActiveRecord::Base
+		has_many :documents
+		keyholder
+	end
+
+We use standard ActiveRecord associations to associate the User with his documents. We also need to specify that he is a keyholder. We now modify our Document class as follows:
+
+	class Document < ActiveRecord::Base
+		belongs_to :user
+		encrypt :title,:body,:key=>:user
+	end
+
+We have the standard associations going on here, but we have also added the option :key=>:user to the encrypt statement. Now we could do this:
+
+	@user=User.new
+	@user.enter_password "This stuff is secret man!!!"
+	@user.save
+	 
+	@doc=Document.new
+	@doc.user=@user 
+	@doc.title="Plan to take over the world"
+	@doc.body="Write apps in Rails"
+	@doc.save
+	
+You could also do ordinary rails like stuf such as:
+
+	@user.documents.each do |doc|
+		puts doc.name
+	end
+
+Decryption is done transparently.
+
+When doing this within a rails application, active_crypto automatically maintains a list of keys for each user session. Besides the 2 steps below you don't need to do anything special within your controller.
+
+1. When a user logs on with a password enter his password like this:
+
+	@user.enter_password @params['password']
+
+2. When a user logs off call the following
+
+	clear_session_keys
+	
+== Usage as a Rails plugin
+
+Just unpack it into your $MY_RAILS_PROJECTS/vendor/plugins folder to use it as a self contained plugin. Otherwise you can install it as a gem using:
+
+	$ gem install ezcrypto
+
+Then make sure to require "active_crypto.rb" at the end of your environment.rb file.
+
+== Database Schema issues
+
+ActiveCrypto doesn't really care about the schema, but that said you do need a schema that will accept and not mangle it's output. On MySQL I normally use TINYBLOB instead of VARCHAR and BLOB instead of TEXT.
+
+== License
+
+EzCrypto and ActionCrypto is released under the MIT license.
+
+
+== Support
+
+To contact the author, send mail to pelleb@gmail.com
+
+Also see my blogs at:
+http://stakeventures.com and
+http://neubia.com
+
+This project was based on code used in my projects WideWord where you can securely share documents and StakeItOut, where you can securely share web services with your partners.
+https://wideword.net
+https://stakeitout.com
+
+(C) 2005 Pelle Braendgaard
@@ -0,0 +1,55 @@
+= EzSig - Easy to use Digital Signatures for Ruby
+
+EzSig is based on OpenSSL and allows you to do create and verify digital signatures in Ruby without learning too much crypto goobledegook.
+
+== Features
+
+* Simple Signer class
+* Simple Verifier class
+* Certificate sub class of Verifier which lets you read the certificate data in clear ruby.
+
+== Installation
+
+Download it from here:
+
+http://rubyforge.org/frs/?group_id=755
+
+or install it via Ruby Gems:
+
+	gem install ezruby
+
+
+== Simple examples
+
+==== Load Private key and sign
+
+	signer=EzCrypto::Signer.from_file "testsigner.pem"
+	sig=signer.sign "hello"
+
+==== Load Certificate and verify
+
+	cert=EzCrypto::Verifier.from_file "testsigner.cert"
+	cert.verify( sig,"hello")
+
+==== Query Certificate for information
+	
+	assert_equal cert.email,"pelleb@gmail.com"
+	assert_equal cert.country,"DK"
+	assert_equal cert.state,"Denmark"
+	assert_equal cert.locality,"Copenhagen"
+
+== PKYP integration
+
+http://pkyp.org allows you register your public keys and certificates on a public server. If you have web applications with certificates or public keys you can point your users at http://pkyp.org/{key.digest} for more info about a certificate.
+
+Register a public key or certificate at PKYP with the new method register_with_pkyp like this:
+
+	signer=EzCrypto::Signer.generate
+	signer.verifier.register_with_pkyp
+
+If you have the public key or certificate digest you can fetch the full public key or certificate like this:
+
+	verifier=EzCrypto::Verifier.from_pkyp "e93e18114cbefaaa89fda908b09df63d3662879a"
+	verifier.verify sig, request_text
+
+This allows a simpler way of transfering certificates. The idea of including certificates with every request is not really necessary in an online world. For example you could pass the digest in a HTTP header for a REST web services request.
@@ -0,0 +1 @@
+require 'active_crypto.rb'
@@ -0,0 +1,325 @@
+require "ezcrypto.rb"
+module ActiveCrypto # :nodoc:
+    
+    def self.append_features(base)  #:nodoc:
+      super
+      base.extend(ClassMethods)
+    end
+    
+=begin rdoc
+
+Usage is very simple. You will generally only need the two class methods listed here in your ActiveRecord class model.
+
+== License
+
+ActiveCrypto and EzCrypto are released under the MIT license.
+
+
+== Support
+
+To contact the author, send mail to pelleb@gmail.com
+
+Also see my blogs at:
+http://stakeventures.com and
+http://neubia.com
+
+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
+https://stakeitout.com
+
+(C) 2005 Pelle Braendgaard
+
+=end
+    module ClassMethods
+      @@session_keys={}
+
+=begin rdoc
+Turn encryption on for this record. List all encrypted attributes
+
+  class Document < ActiveRecord::Base
+		encrypt :title,:body
+	end
+
+Options are:
+  <tt>key</tt> - to specify an external KeyHolder, which holds the key used for encrypting and decrypting
+  <tt>base64</tt> - set to true in order to base64 encode the encrypted attributes.  defaults to false
+
+  class Document < ActiveRecord::Base
+  	belongs_to :user
+  	encrypt :title,:body,:key=>:user, :base64 => true
+  end
+	
+=end
+      def encrypt(*attributes)        
+      	include ActiveCrypto::Encrypted
+      	before_save :encrypt_attributes
+      	after_save :decrypt_attributes
+        options=attributes.last.is_a?(Hash) ? attributes.pop : {}
+        keyholder
+        if options and options[:key]
+  				module_eval <<-"end;"				 
+  					def session_key
+  						(send :#{options[:key]} ).send :session_key
+  					end	 
+  					@@external_key=true
+  				end;
+        end
+
+        base64_encode = (options and options[:base64])
+        module_eval <<-"end;"
+          def self.ezcrypto_base64?
+            #{base64_encode.to_s}
+          end
+        end;
+        
+        self.encrypted_attributes=attributes
+      end   
+		
+=begin rdoc
+Creates support in this class for holding a key. Adds the following methods:
+
+* enter_password(password,salt="onetwothree")
+* set_session_key(key)
+* session_key
+
+Use it as follows:
+
+  class User < ActiveRecord::Base
+  	has_many :documents
+  	keyholder
+  end
+
+=end        
+      def keyholder()
+      	include ActiveCrypto::AssociationKeyHolder   
+      	after_create :save_session_key       
+      end
+
+=begin rdoc
+Clears the session_key array. Generally this is handled automatically as a filter in ActionController. Only use these if you need to
+do something out of the ordinary.
+=end
+      def clear_session_keys() #:nodoc:
+        @@session_keys.clear
+      end 
+      
+=begin rdoc
+Sets the session_keys array. Only use these if you need to
+do something out of the ordinary, as it is handled
+=end
+      def session_keys=(keys) #:nodoc:
+        @@session_keys=keys
+      end
+      
+      def session_keys() #:nodoc:
+        @@session_keys
+      end
+      
+    end
+
+=begin rdoc
+This module handles all standard key management features.
+=end
+    module KeyHolder   
+
+=begin rdoc
+Creates a key for object based on given password and an optional salt.
+=end
+      def enter_password(password,salt="onetwothree")
+        set_session_key(EzCrypto::Key.with_password(password, salt))
+      end
+
+=begin rdoc
+Decodes the Base64 encoded key and uses it as it's session key
+=end
+      def set_encoded_key(enc)
+        set_session_key(EzCrypto::Key.decode(enc))
+      end
+=begin rdoc
+Sets a session key for the object. This should be a EzCrypto::Key instance.
+=end
+      def set_session_key(key)    
+        @session_key=key
+        self.decrypt_attributes if self.class.include? Encrypted
+      end      
+
+=begin rdoc
+Returns the session_key
+=end
+      def session_key
+        @session_key
+      end
+      
+    end
+
+    module AssociationKeyHolder   
+      include ActiveCrypto::KeyHolder
+      
+      
+      def save_session_key
+        ActiveRecord::Base.session_keys[session_key_id]=@session_key if @session_key
+      end
+=begin rdoc
+Sets a session key for the object. This should be a EzCrypto::Key instance.
+=end
+      def set_session_key(key)    
+        if self.new_record?
+          @session_key=key
+        else
+          ActiveRecord::Base.session_keys[session_key_id]=key
+        end
+        decrypt_attributes if self.class.include? Encrypted #if respond_to?(:decrypt_attributes)
+        
+      end      
+
+=begin rdoc
+Returns the session_key
+=end
+      def session_key
+        if self.new_record?
+          @session_key
+        else
+          ActiveRecord::Base.session_keys[session_key_id]
+        end
+      end
+        
+      
+
+      def session_key_id
+        "#{self.class.to_s}:#{id}"
+      end      
+      
+    end
+
+    module Encrypted    #:nodoc:
+      def self.append_features(base)  #:nodoc:
+        super
+        base.extend ClassAccessors
+      end
+      
+      module ClassAccessors
+        def encrypted_attributes
+          @encrypted_attributes||=[]
+        end
+
+        def encrypted_attributes=(attrs)
+          @encrypted_attributes=attrs
+        end
+        
+      end
+    
+      protected
+
+      def encrypt_attributes
+        if !is_encrypted?
+          self.class.encrypted_attributes.each do |key|
+            value=read_attribute(key)
+            write_attribute(key,_encrypt(value)) if value
+          end
+          @is_encrypted=true
+        end
+        true
+      end
+    
+      def decrypt_attributes
+        if is_encrypted?
+          self.class.encrypted_attributes.each do |key|
+            value=read_attribute(key)
+            write_attribute(key,_decrypt(value)) if value
+          end
+          @is_encrypted=false
+        end
+        true
+      end
+      
+      def after_find
+        @is_encrypted=true
+        decrypt_attributes unless session_key.nil?
+      end
+      
+      private
+      def is_encrypted?
+        @is_encrypted
+      end
+      
+      def _decrypt(data)
+        if session_key.nil?
+          raise MissingKeyError
+        else
+          if data
+            self.class.ezcrypto_base64? ? session_key.decrypt64(data) : session_key.decrypt(data)
+          else
+            nil
+          end
+        end
+      end
+    
+      def _encrypt(data)
+        if session_key.nil?
+          raise MissingKeyError
+        else 
+          if data
+            self.class.ezcrypto_base64? ? session_key.encrypt64(data) : session_key.encrypt(data)
+          else
+            nil
+          end
+        end
+      end
+               
+    end
+  
+
+module ActionController # :nodoc:
+=begin rdoc
+This includes some basic support in the ActionController for handling session keys. It creates two filters one before the action and one after.
+These do the following:
+  
+If the users session already has a 'session_keys' value it loads it into the ActiveRecord::Base.session_keys class field. If not it 
+clears any existing session_keys.
+
+Leaving the action it stores any session_keys in the corresponding session variable.
+
+These filters are automatically enabled. You do not have to do anything.
+  
+To manually clear the session keys call clear_session_keys. This should be done for example as part of a session log off action.
+=end      
+    def self.append_features(base) #:nodoc:
+      super
+      base.send :prepend_before_filter, :load_session_keys
+      base.send :prepend_after_filter, :save_session_keys      
+    end
+
+=begin rdoc
+Clears the session keys. Call this when a user logs of.
+=end
+    def clear_session_keys
+      ActiveRecord::Base.clear_session_keys
+    end
+    
+    
+    private
+    def load_session_keys
+      if session['session_keys']
+        ActiveRecord::Base.session_keys=session['session_keys']
+      else
+        ActiveRecord::Base.clear_session_keys
+      end
+    end
+
+    def save_session_keys
+      if ActiveRecord::Base.session_keys.size>0
+        session['session_keys']=ActiveRecord::Base.session_keys
+      else
+        session['session_keys']=nil
+      end
+    end
+    
+
+end
+
+class MissingKeyError < RuntimeError
+end 
+end
+ActiveRecord::Base.send :include, ActiveCrypto
+require 'actionpack'
+require 'action_controller'
+ActionController::Base.send :include, ActiveCrypto::ActionController
@@ -0,0 +1,612 @@
+require 'openssl'
+require 'digest/sha2'
+require 'digest/sha1'
+require 'base64'
+
+module EzCrypto #:nodoc:
+
+
+=begin rdoc
+The Key is the only class you need to understand for simple use.
+
+=== Algorithms
+
+The crypto algorithms default to aes-128-cbc however on any of the class methods you can change it to one of the standard openssl cipher names using the
+optional <tt>:algorithm=>alg name</tt> parameter.
+
+Eg. 
+    Key.new @raw, :algorithm=>"des"
+    Key.generate :algorithm=>"blowfish"
+    Key.with_password @pwd,@salt,:algorithm=>"aes256"    
+
+
+== License
+
+ActiveCrypto and EzCrypto are released under the MIT license.
+
+
+== Support
+
+To contact the author, send mail to pelleb@gmail.com
+
+Also see my blogs at:
+http://stakeventures.com and
+http://neubia.com
+
+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
+https://stakeitout.com
+
+(C) 2005 Pelle Braendgaard
+
+=end
+
+  class Key
+
+    attr_reader :raw, :algorithm
+
+    @@block_size = 512
+
+=begin rdoc
+Set the block-size for IO-operations (default: 512 bytes)
+=end
+    def self.block_size=(size)
+      @@block_size = size
+    end
+
+=begin rdoc
+Return the block-size for IO-operations.
+=end
+    def self.block_size
+      @@block_size
+    end
+
+
+=begin rdoc
+Initialize the key with raw unencoded binary key data. This needs to be at least
+16 bytes long for the default aes-128 algorithm.
+=end
+    def initialize(raw,options = {})
+      @raw=raw
+      @algorithm=options[:algorithm]||"aes-128-cbc"
+    end
+
+=begin rdoc
+Generate random key.
+=end
+    def self.generate(options = {})
+      Key.new(EzCrypto::Digester.generate_key(calculate_key_size(options[:algorithm])),options)
+    end
+
+=begin rdoc
+Create key generated from the given password and salt
+=end
+    def self.with_password(password,salt,options = {})
+      Key.new(EzCrypto::Digester.get_key(password,salt,calculate_key_size(options[:algorithm])),options)
+    end
+
+=begin rdoc
+Initialize the key with Base64 encoded key data.
+=end
+    def self.decode(encoded,options = {})
+      Key.new(Base64.decode64(encoded),options)
+    end
+
+=begin rdoc
+Encrypts the data with the given password and a salt. Short hand for:
+
+  key=Key.with_password(password,salt,options)
+  key.encrypt(data)
+
+=end
+    def self.encrypt_with_password(password,salt,data,options = {})
+      key=Key.with_password(password,salt,options)
+      key.encrypt(data)
+    end
+
+=begin rdoc
+Decrypts the data with the given password and a salt. Short hand for:
+
+  key=Key.with_password(password,salt,options)
+  key.decrypt(data)
+
+
+=end
+    def self.decrypt_with_password(password,salt,data,options = {})
+      key=Key.with_password(password,salt,options)
+      key.decrypt(data)
+    end
+
+=begin rdoc
+Given an algorithm this calculates the keysize. This is used by both
+the generate and with_password methods. This is not yet 100% complete.
+=end
+    def self.calculate_key_size(algorithm)
+      if !algorithm.nil?
+        algorithm=~/^([[:alnum:]]+)(-(\d+))?/
+        if $3
+          size=($3.to_i)/8
+        else
+          case $1
+            when "bf"
+              size = 16
+            when "blowfish"
+              size = 16
+            when "des"
+              size = 8
+            when "des3"
+              size = 24
+            when "aes128"
+              size = 16
+            when "aes192"
+              size = 24
+            when "aes256"
+              size = 32
+            when "rc2"
+              size = 16
+            when "rc4"
+              size = 16
+            else
+              size = 16
+            end
+        end
+      end
+      if size.nil?
+        size = 16
+      end
+
+      size
+    end
+
+=begin rdoc
+returns the Base64 encoded key.
+=end
+    def encode
+      Base64.encode64(@raw).chop
+    end
+
+=begin rdoc
+returns the Base64 encoded key. Synonym for encode.
+=end
+    def to_s
+      encode
+    end
+
+=begin rdoc
+Encrypts the data and returns it in encrypted binary form.
+=end
+    def encrypt(data)
+      if data==nil || data==""
+        nil
+      else
+        encrypter("")
+        @cipher.encrypt(data)
+      end
+    end
+
+=begin rdoc
+Encrypts the data and returns it in encrypted Base64 encoded form.
+=end
+    def encrypt64(data)
+      Base64.encode64(encrypt(data))
+    end
+
+=begin rdoc
+Decrypts the data passed to it in binary format.
+=end
+    def decrypt(data)
+      if data==nil || data==""
+        nil
+      else
+        decrypter("")
+        @cipher.gulp(data)
+      end
+#    rescue
+#      puts @algorithm
+#      puts self.encode
+#      puts data.size
+#      throw $!
+    end
+
+=begin rdoc
+Decrypts a Base64 formatted string
+=end
+    def decrypt64(data)
+      decrypt(Base64.decode64(data))
+    end
+    
+=begin rdoc
+Allows keys to be marshalled
+=end
+    def marshal_dump
+       "#{self.algorithm}$$$#{self.encode}"
+    end
+    
+=begin rdoc
+Allows keys to be unmarshalled
+=end
+    def marshal_load(s) 
+       a, r = s.split '$$$'
+       @algorithm = a
+       @raw = Base64.decode64(r)
+    end
+
+=begin rdoc
+Create a file with minimal permissions, and yield
+it to a block. By default only the owner may read it.
+=end
+    def safe_create(file, mod=0400, mask=0066)
+      begin
+        old_umask = File.umask
+        File.umask(mask)
+        File.open(file, File::CREAT | File::EXCL | File::WRONLY) do |f|
+          yield(f) if block_given?
+        end
+      ensure
+        File.umask(old_umask)
+      end
+      File.chmod(mod, file) if File.exists?(file)
+      File.size(file)
+    end
+
+
+=begin rdoc
+Overwrite a file with zero values before removing it's filesystem inode.
+This is not very safe :-)
+=end
+    def safe_delete(file)
+      begin
+        to_clear = File.size(file)
+        zeroes   = Array.new(Key.block_size, "\0").join
+        File.chmod(0600, file)
+        File.open(file, File::WRONLY) do |f|
+          f.rewind
+          while to_clear > 0
+            f.write(zeroes)
+            to_clear -= Key.block_size
+          end
+          f.flush
+        end
+      ensure
+        File.delete(file) if File.exists?(file)
+      end
+      return !File.exists?(file)
+    end
+
+
+=begin rdoc
+Open a file readonly and yield it to a block.
+=end
+    def safe_read(file)
+      File.open(file, File::RDONLY) do |i|
+        yield(i) if block_given?
+      end
+    end
+
+    private :safe_create, :safe_read, :safe_delete
+
+=begin rdoc
+Load a key from a yaml_file generated via Key#store.
+=end
+    def self.load(filename)
+      require 'yaml'
+      hash = YAML::load_file(filename)
+      req = proc { |k| hash[k] or raise "Missing element #{k} in #{filename}" }
+      key = self.new Base64.decode64(req.call(:key)) , :algorithm => req.call(:algorithm)
+      return key
+    end
+
+
+=begin rdoc
+Save the key data into a file, try to do this in a secure manner.
+NOTE: YAML::store & friends are not used to encance control over
+the generated file format.
+=end
+    def store(filename)
+      safe_create(filename) do |f|
+        selfenc = self.encode
+        f.puts "---"
+        f.puts ":EZCRYPTO KEY FILE: KEEP THIS SECURE !"
+        f.puts ":created: #{Time.now}"
+        f.puts ":algorithm: #{@algorithm}"
+        f.puts ":key: #{selfenc}"
+      end
+    end
+
+
+=begin rdoc
+Get a Encrypter object. You have to call #final on it by yourself!
+=end
+    def encrypter(target='')
+      @cipher = EzCrypto::Encrypter.new(self,target,@algorithm)
+    end
+
+
+=begin rdoc
+Get a Decrypter object. You have to call #final on it by yourself!
+=end
+    def decrypter(target='')
+      @cipher = EzCrypto::Decrypter.new(self,target,@algorithm)
+    end
+
+=begin rdoc
+Create a Decrypter object and yield it to a block.
+You must *not* call #final by yourself, the method
+does this.
+=end
+    def on_decrypter(target='', &block)
+      decrypter(target)
+      on_cipher(&block)
+    end
+
+=begin rdoc
+Create an Encrypter object and yield it to a block.
+You must *not* call #final by yourself, the method
+does this.
+=end
+    def on_encrypter(target='', &block)
+      encrypter(target)
+      on_cipher(&block)
+    end
+
+
+=begin rdoc
+Helper method, yields the current cipher to a block.
+=end
+    def on_cipher(&block)
+      begin
+        block.call @cipher
+      ensure
+        @cipher.final
+      end
+    end
+
+    private :on_cipher
+
+
+=begin rdoc
+Encrypt a file 'inplace' and add a suffix
+see #cipher_file.
+IMPORTANT: The inputfile will be deleted by default.
+=end
+    def encrypt_file(src, tgt=nil, options = {} )
+      options = { :suffix => '.ez', :autoclean => 'true' }.update(options)
+      tgt = "#{src}#{options[:suffix]}" unless tgt
+      cipher_file :on_encrypter, src, tgt, options[:autoclean]
+    end
+
+
+=begin rdoc
+Decrypt a file 'inplace' and remove a suffix
+see #cipher_file
+IMPORTANT: The inputfile will be deleted by default.
+=end
+    def decrypt_file(src, tgt=nil, options = {} )
+      options = { :suffix => '.ez', :autoclean => 'true' }.update(options)
+      unless tgt
+        tgt = src
+        tgt = tgt.gsub(/#{options[:suffix]}$/, '')
+      end
+      cipher_file :on_decrypter, src, tgt, options[:autoclean]
+    end
+
+
+=begin rdoc
+uses either  #on_decrypter or #on_encrypter to transform a given sourcefile
+to a targetfile. the sourcefile is deleted after sucessful transformation
+the delete_source is 'true'.
+=end
+    def cipher_file(method, sourcefile, targetfile, delete_source)
+      raise(ArgumentError, "source == target #{sourcefile}") if sourcefile == targetfile
+      safe_create(targetfile,0600) do |o|
+        self.send(method, o) do |c|
+          safe_read(sourcefile) do |i|
+            loop do
+              buffer = i.read(Key.block_size) or break
+              c << buffer
+            end
+          end
+        end
+      end
+      safe_delete(sourcefile) if delete_source && File.exists?(targetfile)
+      return targetfile
+    end
+    
+    private :cipher_file
+    
+  end
+  
+=begin rdoc
+Abstract Wrapper around OpenSSL's Cipher object. Extended by Encrypter and Decrypter.
+  
+You probably should be using the Key class instead.
+
+Warning! The interface may change.
+
+=end
+  class CipherWrapper #:nodoc:
+
+=begin rdoc
+  
+=end
+    def initialize(key,target,mode,algorithm)
+      @cipher = OpenSSL::Cipher::Cipher.new(algorithm)  
+      if mode
+        @cipher.encrypt
+      else
+        @cipher.decrypt
+      end
+      @cipher.key=key.raw
+      @cipher.padding=1
+      @target=target
+      @finished=false
+    end
+    
+    
+    def to_target(data)
+      return data
+    end
+    
+=begin rdoc
+Process the givend data with the cipher.
+=end
+    def update(data)
+      reset if @finished
+      @target<< to_target(@cipher.update(data))
+    end
+
+=begin rdoc
+  
+=end
+    def <<(data)
+      update(data)
+    end
+    
+=begin rdoc
+Finishes up any last bits of data in the cipher and returns the final result.
+=end
+    def final
+      @target<< to_target(@cipher.final)
+      @finished=true
+      @target
+    end
+    
+=begin rdoc
+Processes the entire data string using update and performs a final on it returning the data.
+=end
+    def gulp(data)
+      update(data)
+      final 
+#    rescue
+#      breakpoint
+    end  
+
+=begin rdoc
+  
+=end
+    def reset(target="")
+      @target=target
+      @finished=false
+    end
+  end
+
+=begin rdoc
+Wrapper around OpenSSL Cipher for Encryption use.
+
+You probably should be using Key instead.
+
+Warning! The interface may change.
+
+=end
+  class Encrypter<EzCrypto::CipherWrapper #:nodoc:
+
+=begin rdoc
+  
+=end
+    def initialize(key,target="",algorithm="aes-128-cbc")
+      super(key,target,true,algorithm)
+    end
+    
+=begin rdoc
+  
+=end    
+    def encrypt(data)    
+      gulp(data)
+    end
+  end
+
+=begin rdoc
+Wrapper around OpenSSL Cipher for Decryption use.
+
+You probably should be using Key instead.
+
+Warning! The interface may change.
+=end
+  class Decrypter<EzCrypto::CipherWrapper #:nodoc:
+=begin rdoc
+  
+=end
+    def initialize(key,target="",algorithm="aes-128-cbc")
+      super(key,target,false,algorithm)
+    end
+    
+=begin rdoc
+  
+=end    
+    def decrypt(data)
+      gulp(data)
+    end
+  end
+
+=begin rdoc
+
+=end
+  class Digester    
+=begin rdoc
+Various handy Digest methods. 
+
+Warning! The interface may change.
+=end
+    def self.get_key(password,salt,size)
+        digest(salt+password,size)
+    end
+  
+=begin rdoc
+  
+=end
+    def self.generate_key(size=16)
+        key=OpenSSL::Random.random_bytes(size)
+        digest(key,size)
+    end
+  
+=begin rdoc
+  
+=end
+    def self.generate_key64(size=32)
+        key=OpenSSL::Random.random_bytes(size)
+        digest64(key,size)
+    end   
+=begin rdoc
+
+=end
+    def self.generate_hexkey(size=40)
+        key=OpenSSL::Random.random_bytes(size)
+        hexdigest(key,size)
+    end   
+    
+=begin rdoc
+  
+=end
+    def self.digest(data,size=16)
+      if size==0
+        ""
+      elsif size<=16
+        Digest::SHA1.digest(data)[0..(size-1)]
+      else
+        Digest::SHA256.digest(data)[0..(size-1)]
+      end
+    end
+
+=begin rdoc
+
+=end
+    def self.hexdigest(data,size=40)
+      if size==0
+        ""
+      elsif size<=40
+        Digest::SHA1.hexdigest(data)[0..(size-1)]
+      else
+        Digest::SHA256.hexdigest(data)[0..(size-1)]
+      end
+    end
+    
+=begin rdoc
+  
+=end
+    def self.digest64(data,size=16)
+      Base64.encode64(digest(data,size))
+    end
+	end
+
+end
+
+
@@ -0,0 +1,535 @@
+require 'ezcrypto'
+require 'net/http'
+=begin rdoc
+
+These modules provides a simple ruby like way to create and verify digital signatures.
+
+== License
+
+ActiveCrypto and EzCrypto are released under the MIT license.
+
+
+== Support
+
+To contact the author, send mail to pelleb@gmail.com
+
+Also see my blogs at:
+http://stakeventures.com and
+http://neubia.com
+
+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
+https://stakeitout.com
+
+(C) 2005 Pelle Braendgaard
+
+=end
+module EzCrypto
+
+=begin rdoc
+  The signer is used for signing stuff. It encapsulates the functionality of a private key.
+=end
+  class Signer
+=begin rdoc
+  Initialize a Signer with a OpenSSL Private Key. You generally should not call new directly. 
+  Unless you are interfacing with your own underlying OpenSSL code.
+=end
+    def initialize(priv,options = {})
+      @priv=priv
+    end
+  
+=begin rdoc
+  Generate a new keypair. Defaults to 2048 bit RSA.
+=end
+    def self.generate(strength=2048,type=:rsa)
+      key_class=case type
+      when :dsa
+        OpenSSL::PKey::DSA
+      else
+        OpenSSL::PKey::RSA
+      end
+      EzCrypto::Signer.new(key_class.generate(strength))
+    end
+    
+=begin rdoc
+  Decode a PEM encoded Private Key  and return a signer. Takes an optional password
+=end  
+    def self.decode(encoded,password=nil)
+      begin
+        EzCrypto::Signer.new(OpenSSL::PKey::RSA.new( encoded,password))
+      rescue
+        EzCrypto::Signer.new(OpenSSL::PKey::DSA.new( encoded,password))
+      end
+    end
+  
+=begin rdoc
+  Decode a PEM encoded Private Key file and return a signer. Takes an optional password
+=end  
+    def self.from_file(filename,password=nil)
+      file = File.read( filename )
+      decode(file,password)
+    end
+
+=begin rdoc
+  Returns the OpenSSL Public Key object. You normally do not need to use this.
+=end
+    def public_key
+      @priv.public_key
+    end
+
+=begin rdoc
+  Returns the corresponding Verifier object.
+=end    
+    def verifier
+      Verifier.new(public_key)
+    end
+    
+=begin rdoc
+  Returns the OpenSSL Private Key object. You normally do not need to use this.
+=end  
+    def private_key
+      @priv
+    end
+
+=begin rdoc
+  signs data using the private key and the corresponding digest function. SHA1 for RSA and DSS1 for DSA.
+  99% of signing use these parameters. 
+  Email a request or send me a patch if you have other requirements.
+=end  
+    def sign(data)
+      if rsa?
+        @priv.sign(OpenSSL::Digest::SHA1.new,data)
+      elsif dsa?
+        @priv.sign(OpenSSL::Digest::DSS1.new,data)
+      end
+    end
+    
+=begin rdoc
+  Returns true if it is a RSA private key
+=end
+    def rsa?
+      @priv.is_a? OpenSSL::PKey::RSA
+    end
+    
+=begin rdoc
+  Returns true if it is a DSA private key
+=end    
+    def dsa?
+      @priv.is_a? OpenSSL::PKey::DSA
+    end
+
+  end
+
+=begin rdoc
+  The Verifier is used for verifying signatures. If you use the decode or 
+  from_file methods you can use either raw PEM encoded public keys or certificate.
+=end
+  class Verifier
+=begin rdoc
+  Initializes a Verifier using a OpenSSL public key object.
+=end
+    def initialize(pub)
+      @pub=pub
+    end
+
+=begin rdoc
+  Decodes a PEM encoded Certificate or Public Key and returns a Verifier object.
+=end  
+    def self.decode(encoded)
+      case encoded
+      when /-----BEGIN CERTIFICATE-----/
+        EzCrypto::Certificate.new(OpenSSL::X509::Certificate.new( encoded))
+      else
+        begin
+          EzCrypto::Verifier.new(OpenSSL::PKey::RSA.new( encoded))
+        rescue
+          EzCrypto::Verifier.new(OpenSSL::PKey::DSA.new( encoded))
+        end
+      end
+    end
+  
+=begin rdoc
+  Decodes a PEM encoded Certificate or Public Key from a file and returns a Verifier object.
+=end  
+    def self.from_file(filename)
+      file = File.read( filename )
+      decode(file)
+    end
+
+=begin rdoc
+  Load a certificate or public key from PKYP based on it's hex digest
+=end  
+    def self.from_pkyp(digest)
+      digest=digest.strip.downcase
+      if digest=~/[0123456789abcdef]{40}/
+#        Net::HTTP.start("localhost", 9000) do |query|
+        Net::HTTP.start("pkyp.org", 80) do |query|
+          response=query.get "/#{digest}.pem"
+          if response.code=="200"
+            decode(response.body)
+          else
+            raise "Error occured (#{response.code}): #{response.body}"      
+          end
+        end
+      else
+        raise "Invalid digest"
+      end
+    end
+
+=begin rdoc
+  Decodes all certificates or public keys in a file and returns an array.
+=end
+    def self.load_all_from_file(filename)
+      file = File.read( filename )
+      certs=[]
+      count=0
+      file.split( %q{-----BEGIN}).each do |pem|
+        if pem and pem!=""
+            pem="-----BEGIN#{pem}\n"
+              cert=decode(pem)
+              if cert.is_a? EzCrypto::Verifier
+                certs<<cert
+              end
+        end
+      end
+      certs
+    end
+
+=begin rdoc
+  Is the Verifier a Certificate or not.
+=end  
+    def cert?
+      false
+    end
+
+=begin rdoc
+  Returns the OpenSSL public key object. You would normally not need to use this.
+=end        
+    def public_key
+      @pub
+    end
+
+=begin rdoc
+  Returns the SHA1 hexdigest of the DER encoded public key. This can be used as a unique key identifier.
+=end
+    def digest
+      Digest::SHA1.hexdigest(@pub.to_der)
+    end
+=begin rdoc
+  Is this a RSA key?
+=end
+    def rsa?
+      @pub.is_a? OpenSSL::PKey::RSA
+    end
+=begin rdoc
+  Is this a DSA key?
+=end    
+    def dsa?
+      @pub.is_a? OpenSSL::PKey::DSA
+    end
+
+
+=begin rdoc
+  Returns true if the public key signed the given data.
+=end  
+    def verify(sig,data)
+      if rsa?
+        @pub.verify( OpenSSL::Digest::SHA1.new, sig, data )
+      elsif dsa?
+        @pub.verify( OpenSSL::Digest::DSS1.new, sig, data )
+      else
+        false
+      end
+    end
+
+=begin rdoc
+  Register the public key or certificate at PKYP
+=end
+    def register_with_pkyp
+      send_to_pkyp(@pub.to_s)
+    end
+    
+    protected
+    
+    def send_to_pkyp(pem)
+#      Net::HTTP.start("localhost", 9000) do |query|
+      Net::HTTP.start("pkyp.org", 80) do |query|
+        output=URI.escape(pem).gsub("+","%2b")
+        response=query.post "/register","body="+output
+        if response.code=="302"
+          response["Location"]=~/([0123456789abcdef]{40}$)/
+          $1
+        else
+          raise "Error occured (#{response.code}): #{response.body}"      
+        end
+      end
+    end
+
+  end
+
+=begin rdoc
+  Certificate provides functionality to make it easy to extract information from a Certificate. 
+  This also provides all the same functionality as a Verifier.
+=end  
+  class Certificate < Verifier
+
+=begin rdoc
+  Intialize with a OpenSSL cert object.
+=end
+    def initialize(cert)
+      super(cert.public_key)
+      @cert=cert
+    end
+
+=begin rdoc
+  Returns true
+=end    
+    def cert?
+      true
+    end
+
+=begin rdoc
+  Register the certificate at PKYP
+=end
+    def register_with_pkyp
+      send_to_pkyp(@cert.to_s)
+    end
+
+=begin rdoc
+  Returns the SHA1 hex digest of a the DER encoded certificate. This is useful as a unique identifier.
+=end    
+    def cert_digest
+      Digest::SHA1.hexdigest(@cert.to_der)
+    end
+
+=begin rdoc
+  Returns a Name object containt the subject of the certificate. The subject in X509 speak is the details of the certificate owner.
+=end    
+    def subject
+      @subject=EzCrypto::Name.new(@cert.subject) unless @subject
+      @subject
+    end
+
+=begin rdoc
+  Returns a Name object containt the issuer of the certificate. 
+=end        
+    def issuer
+      @issuer=EzCrypto::Name.new(@cert.issuer) unless @issuer
+      @issuer
+    end
+    
+=begin rdoc
+  Returns the issuers serial number for this certificate
+=end
+    def serial
+      @cert.serial
+    end
+
+=begin rdoc
+  Returns the OpenSSL Certificate object
+=end    
+    def cert
+      @cert
+    end
+
+=begin rdoc
+  Returns the certificates valid not before date.
+=end    
+    def not_before
+      @cert.not_before
+    end
+    
+=begin rdoc
+  Returns the certificates valid not after date.
+=end
+    def not_after
+      @cert.not_after
+    end
+
+=begin rdoc
+  Is this certificate valid at this point in time. Note this only checks if it is valid with respect to time.
+  It is important to realize that it does not check with any CRL or OCSP services to see if the certificate was 
+  revoked.
+=end    
+    def valid?(time=Time.now.utc)
+      time>not_before && time<self.not_after
+    end
+
+=begin rdoc
+  Returns the hash of extensions available in the certificate. These are not always present.
+=end    
+    def extensions
+      unless @extensions
+        @extensions={}
+        cert.extensions.each {|e| @extensions[e.oid]=e.value} if cert.extensions
+      end
+      @extensions
+    end
+
+=begin rdoc
+  Any methods defined in Name can be used here. This means you can do cert.email rather than cert.subject.email.
+=end    
+    def method_missing(method)
+      subject.send method
+    end
+    
+  end
+
+=begin rdoc
+  A handy ruby wrapper around OpenSSL's Name object. This was created to make it really easy to extract information out of the certificate.
+=end
+  class Name
+=begin rdoc
+  Initializes the Name object with the underlying OpenSSL Name object. You generally do not need to use this. 
+  Rather use the Certificates subject or issuer methods. 
+=end
+    def initialize(name)
+      @name=name
+      @attributes={}
+      name.to_s.split(/\//).each do |field| 
+        key, val = field.split(/=/,2)
+        if key
+          @attributes[key.to_sym]=val
+        end
+      end  
+    end
+
+=begin rdoc
+  Returns the full name object in classic horrible X500 format.
+=end
+    def to_s
+      @name.to_s
+    end
+
+=begin rdoc
+  Returns the email if present in the name
+=end    
+    def email
+      self[:emailAddress]
+    end
+=begin rdoc
+  The 2 letter country code of the name
+=end
+    def country
+      self[:C]
+    end
+    alias_method :c,:country
+=begin rdoc
+  The state or province code
+=end
+    def state
+      self[:ST]
+    end
+    alias_method :st,:state
+    alias_method :province,:state
+
+=begin rdoc
+  The locality
+=end    
+    def locality
+      self[:L]
+    end
+    alias_method :l,:locality
+
+=begin rdoc
+  The Organizational Unit
+=end    
+    def organizational_unit
+      self[:OU]
+    end
+    alias_method :ou,:organizational_unit
+    alias_method :organisational_unit,:organizational_unit
+
+=begin rdoc
+  The Organization
+=end    
+    def organization
+      self[:O]
+    end
+    alias_method :o,:organization
+    alias_method :organisation,:organization
+
+=begin rdoc
+  The common name. For SSL this means the domain name. For personal certificates it is the name.
+=end    
+    def common_name
+      self[:CN]
+    end
+    alias_method :name,:common_name
+    alias_method :cn,:common_name
+
+=begin rdoc
+  Lookup fields in the certificate.
+=end    
+    def [](attr_key)
+      @attributes[attr_key.to_sym]
+    end
+    
+    def method_missing(method)
+      self[method]
+    end
+    
+  end
+
+=begin rdoc
+  Wraps around the OpenSSL trust store. This allows you to decide which certificates you trust.
+  
+  You can either point it at a path which contains a OpenSSL trust store (see OpenSSL for more) or build it up manually.
+  
+  For a certificate to verify you need the issuer and the issuers issuers certs added to the Trust store.
+  
+  NOTE: Currently this does not support CRL's or OCSP. We may add support for this later.
+=end  
+  class TrustStore
+    
+=begin rdoc
+  Create a trust store of normally trusted root certificates as found in a browser. Extracted from Safari.
+=end
+    def self.default_trusted
+      load_from_file(File.dirname(__FILE__) + "/trusted.pem")
+    end
+=begin rdoc
+  Create a trust store from a list of certificates in a pem file.
+  These certificates should just be listed one after each other.
+=end    
+    def self.load_from_file(file)
+      store=TrustStore.new
+      EzCrypto::Verifier.load_all_from_file(file).each do |cert|
+        store.add cert
+      end
+      store
+    end
+=begin rdoc
+  Create trust store with an optional list of paths of openssl trust stores.
+=end
+    def initialize(*paths)
+      @store=OpenSSL::X509::Store.new
+#      @store.set_default_path paths.shift if paths.length>0
+      paths.each {|path| @store.add_path path}
+    end
+
+=begin rdoc
+  Add either a EzCrypto::Certificate or a OpenSSL::X509::Cert object to the TrustStore. This should be a trusted certificate such as a CA's issuer certificate.
+=end
+    def add(obj)
+      if obj.kind_of?(EzCrypto::Certificate)
+        @store.add_cert obj.cert
+      elsif obj.kind_of?(OpenSSL::X509::Certificate)
+        @store.add_cert obj
+      else 
+        raise "unsupported object type"
+      end
+    end
+=begin rdoc
+  Returns true if either the EzCrypto::Certificate or OpenSSL::X509::Cert object is verified using issuer certificates in the trust store.
+=end
+    def verify(cert)
+      if cert.kind_of?(EzCrypto::Certificate)
+        @store.verify cert.cert
+      elsif cert.kind_of?(OpenSSL::X509::Certificate)
+        @store.verify cert
+      else 
+        false
+      end
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,2363 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb
+MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
+GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj
+YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM
+GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua
+BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe
+3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4
+YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR
+rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm
+ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU
+oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF
+MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v
+QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t
+b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF
+AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q
+GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz
+Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2
+G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi
+l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3
+smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEGDCCAwCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQGEwJTRTEU
+MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3
+b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwHhcNMDAwNTMw
+MTAzODMxWhcNMjAwNTMwMTAzODMxWjBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChML
+QWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYD
+VQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUA
+A4IBDwAwggEKAoIBAQCWltQhSWDia+hBBwzexODcEyPNwTXH+9ZOEQpnXvUGW2ul
+CDtbKRY654eyNAbFvAWlA3yCyykQruGIgb3WntP+LVbBFc7jJp0VLhD7Bo8wBN6n
+tGO0/7Gcrjyvd7ZWxbWroulpOj0OM3kyP3CCkplhbY0wCI9xP6ZIVxn4JdxLZlyl
+dI+Yrsj5wAYi56xz36Uu+1LcsRVlIPo1Zmne3yzxbrww2ywkEtvrNTVokMsAsJch
+PXQhI2U0K7t4WaPW4XY5mqRJjox0r26kmqPZm9I4XJuiGMx1I4S+6+JNM3GOGvDC
++Mcdoq0Dlyz4zyXG9rgkMbFjXZJ/Y/AlyVMuH79NAgMBAAGjgdIwgc8wHQYDVR0O
+BBYEFJWxtPCUtr3H2tERCSG+wa9J/RB7MAsGA1UdDwQEAwIBBjAPBgNVHRMBAf8E
+BTADAQH/MIGPBgNVHSMEgYcwgYSAFJWxtPCUtr3H2tERCSG+wa9J/RB7oWmkZzBl
+MQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFk
+ZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENB
+IFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBACxtZBsfzQ3duQH6lmM0MkhHma6X
+7f1yFqZzR1r0693p9db7RcwpiURdv0Y5PejuvE1Uhh4dbOMXJ0PhiVYrqW9yTkkz
+43J8KiOavD7/KCrto/8cI7pDVwlnTUtiBi34/2ydYB7YHEt9tTEv2dB8Xfjea4MY
+eDdXL+gzB2ffHsdrKpV2ro9Xo/D0UrSpUwjP4E/TelOL/bscVjby/rK25Xa71SJl
+pz/+0WatC7xrmYbvP33zGDLKe8bjq2RGlfgmadlVg3sslgf/WSxEo8bl6ancoWOA
+WiFeIc9TVPC6b4nbqKqVz4vjccweGyBECMB6tkD9xOQ14R0WHNC8K47Wcdk=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU
+MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs
+IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290
+MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux
+FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h
+bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v
+dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt
+H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9
+uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX
+mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX
+a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN
+E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0
+WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD
+VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0
+Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU
+cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx
+IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN
+AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH
+YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5
+6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC
+Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX
+c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a
+mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEFTCCAv2gAwIBAgIBATANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJTRTEU
+MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3
+b3JrMSAwHgYDVQQDExdBZGRUcnVzdCBQdWJsaWMgQ0EgUm9vdDAeFw0wMDA1MzAx
+MDQxNTBaFw0yMDA1MzAxMDQxNTBaMGQxCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtB
+ZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIDAeBgNV
+BAMTF0FkZFRydXN0IFB1YmxpYyBDQSBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOC
+AQ8AMIIBCgKCAQEA6Rowj4OIFMEg2Dybjxt+A3S72mnTRqX4jsIMEZBRpS9mVEBV
+6tsfSlbunyNu9DnLoblv8n75XYcmYZ4c+OLspoH4IcUkzBEMP9smcnrHAZcHF/nX
+GCwwfQ56HmIexkvA/X1id9NEHif2P0tEs7c42TkfYNVRknMDtABp4/MUTu7R3AnP
+dzRGULD4EfL+OHn3Bzn+UZKXC1sIXzSGAa2Il+tmzV7R/9x98oTaunet3IAIx6eH
+1lWfl2royBFkuucZKT8Rs3iQhCBSWxHveNCD9tVIkNAwHM+A+WD+eeSI8t0A65RF
+62WUaUC6wNW0uLp9BBGo6zEFlpROWCGOn9Bg/QIDAQABo4HRMIHOMB0GA1UdDgQW
+BBSBPjfYkrAfd59ctKtzquf2NGAv+jALBgNVHQ8EBAMCAQYwDwYDVR0TAQH/BAUw
+AwEB/zCBjgYDVR0jBIGGMIGDgBSBPjfYkrAfd59ctKtzquf2NGAv+qFopGYwZDEL
+MAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQLExRBZGRU
+cnVzdCBUVFAgTmV0d29yazEgMB4GA1UEAxMXQWRkVHJ1c3QgUHVibGljIENBIFJv
+b3SCAQEwDQYJKoZIhvcNAQEFBQADggEBAAP3FUr4JNojVhaTdt02KLmuG7jD8WS6
+IBh4lSknVwW8fCr0uVFV2ocC3g8WFzH4qnkuCRO7r7IgGRLlk/lL+YPoRNWyQSW/
+iHVv/xD8SlTQX/D67zZzfRs2RcYhbbQVuE7PnFylPVoAjgbjPGsye/Kf8Lb93/Ao
+GEjwxrzQvzSAlsJKsW2Ox5BF3i9nrEUEo3rcVZLJR2bYGozH7ZxOmuASu7VqTITh
+4SINhwBk/ox9Yjllpu9CtoAlEmEBqCQTcAARJl/6NVDFSMwGR+gn2HCNX2TmoUQm
+XiLsks3/QppEIW1cxeMiHV9HEufOX1362KqxMy3ZdvJOOjMMK7MtkAY=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEHjCCAwagAwIBAgIBATANBgkqhkiG9w0BAQUFADBnMQswCQYDVQQGEwJTRTEU
+MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3
+b3JrMSMwIQYDVQQDExpBZGRUcnVzdCBRdWFsaWZpZWQgQ0EgUm9vdDAeFw0wMDA1
+MzAxMDQ0NTBaFw0yMDA1MzAxMDQ0NTBaMGcxCzAJBgNVBAYTAlNFMRQwEgYDVQQK
+EwtBZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIzAh
+BgNVBAMTGkFkZFRydXN0IFF1YWxpZmllZCBDQSBSb290MIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA5B6a/twJWoekn0e+EV+vhDTbYjx5eLfpMLXsDBwq
+xBb/4Oxx64r1EW7tTw2R0hIYLUkVAcKkIhPHEWT/IhKauY5cLwjPcWqzZwFZ8V1G
+87B4pfYOQnrjfxvM0PC3KP0q6p6zsLkEqv32x7SxuCqg+1jxGaBvcCV+PmlKfw8i
+2O+tCBGaKZnhqkRFmhJePp1tUvznoD1oL/BLcHwTOK28FSXx1s6rosAx1i+f4P8U
+WfyEk9mHfExUE+uf0S0R+Bg6Ot4l2ffTQO2kBhLEO+GRwVY18BTcZTYJbqukB8c1
+0cIDMzZbdSZtQvESa0NvS3GU+jQd7RNuyoB/mC9suWXY6QIDAQABo4HUMIHRMB0G
+A1UdDgQWBBQ5lYtii1zJ1IC6WA+XPxUIQ8yYpzALBgNVHQ8EBAMCAQYwDwYDVR0T
+AQH/BAUwAwEB/zCBkQYDVR0jBIGJMIGGgBQ5lYtii1zJ1IC6WA+XPxUIQ8yYp6Fr
+pGkwZzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQL
+ExRBZGRUcnVzdCBUVFAgTmV0d29yazEjMCEGA1UEAxMaQWRkVHJ1c3QgUXVhbGlm
+aWVkIENBIFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBABmrder4i2VhlRO6aQTv
+hsoToMeqT2QbPxj2qC0sVY8FtzDqQmodwCVRLae/DLPt7wh/bDxGGuoYQ992zPlm
+hpwsaPXpF/gxsxjE1kh9I0xowX67ARRvxdlu3rsEQmr49lx95dr6h+sNNVJn0J6X
+dgWTP5XHAeZpVTh/EGGZyeNfpso+gmNIquIISD6q8rKFYqa0p9m9N5xotS1WfbC3
+P6CxB9bpT9zeRXEwMn8bLgn5v1Kh7sKAPgZcLlVAwRv1cEWw3F369nJad9Jjzc9Y
+iQBCYz95OdBEsIJuQRno3eDBiFrRHnGTHyQwdOUeqN48Jzd/g66ed8/wMLH/S5no
+xqE=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDpDCCAoygAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEc
+MBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UEAxMtQW1lcmljYSBP
+bmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAxMB4XDTAyMDUyODA2
+MDAwMFoXDTM3MTExOTIwNDMwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft
+ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3Qg
+Q2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBAKgv6KRpBgNHw+kqmP8ZonCaxlCyfqXfaE0bfA+2l2h9LaaLl+lk
+hsmj76CGv2BlnEtUiMJIxUo5vxTjWVXlGbR0yLQFOVwWpeKVBeASrlmLojNoWBym
+1BW32J/X3HGrfpq/m44zDyL9Hy7nBzbvYjnF3cu6JRQj3gzGPTzOggjmZj7aUTsW
+OqMFf6Dch9Wc/HKpoH145LcxVR5lu9RhsCFg7RAycsWSJR74kEoYeEfffjA3PlAb
+2xzTa5qGUwew76wGePiEmf4hjUyAtgyC9mZweRrTT6PP8c9GsEsPPt2IYriMqQko
+O3rHl+Ee5fSfwMCuJKDIodkP1nsmgmkyPacCAwEAAaNjMGEwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQUAK3Zo/Z59m50qX8zPYEX10zPM94wHwYDVR0jBBgwFoAU
+AK3Zo/Z59m50qX8zPYEX10zPM94wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB
+BQUAA4IBAQB8itEfGDeC4Liwo+1WlchiYZwFos3CYiZhzRAW18y0ZTTQEYqtqKkF
+Zu90821fnZmv9ov761KyBZiibyrFVL0lvV+uyIbqRizBs73B6UlwGBaXCBOMIOAb
+LjpHyx7kADCVW/RFo8AasAFOq73AI25jP4BKxQft3OJvx8Fi8eNy1gTIdGcL+oir
+oQHIb/AUr9KZzVGTfu0uOMe9zkZQPXLjeSWdm4grECDdpbgyn43gKd8hdIaC2y+C
+MMbHNYaz+ZZfRtsMRf3zUMNvxsNIrUam4SdHCh0Om7bCd39j8uB9Gr784N/Xx6ds
+sPmuujz9dLQR6FgNgLzTqIA6me11zEZ7
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFpDCCA4ygAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEc
+MBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UEAxMtQW1lcmljYSBP
+bmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAyMB4XDTAyMDUyODA2
+MDAwMFoXDTM3MDkyOTE0MDgwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft
+ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3Qg
+Q2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIP
+ADCCAgoCggIBAMxBRR3pPU0Q9oyxQcngXssNt79Hc9PwVU3dxgz6sWYFas14tNwC
+206B89enfHG8dWOgXeMHDEjsJcQDIPT/DjsS/5uN4cbVG7RtIuOx238hZK+GvFci
+KtZHgVdEglZTvYYUAQv8f3SkWq7xuhG1m1hagLQ3eAkzfDJHA1zEpYNI9FdWboE2
+JxhP7JsowtS013wMPgwr38oE18aO6lhOqKSlGBxsRZijQdEt0sdtjRnxrXm3gT+9
+BoInLRBYBbV4Bbkv2wxrkJB+FFk4u5QkE+XRnRTf04JNRvCAOVIyD+OEsnpD8l7e
+Xz8d3eOyG6ChKiMDbi4BFYdcpnV1x5dhvt6G3NRI270qv0pV2uh9UPu0gBe4lL8B
+PeraunzgWGcXuVjgiIZGZ2ydEEdYMtA1fHkqkKJaEBEjNa0vzORKW6fIJ/KD3l67
+Xnfn6KVuY8INXWHQjNJsWiEOyiijzirplcdIz5ZvHZIlyMbGwcEMBawmxNJ10uEq
+Z8A9W6Wa6897GqidFEXlD6CaZd4vKL3Ob5Rmg0gp2OpljK+T2WSfVVcmv2/LNzGZ
+o2C7HK2JNDJiuEMhBnIMoVxtRsX6Kc8w3onccVvdtjc+31D1uAclJuW8tf48ArO3
++L5DwYcRlJ4jbBeKuIonDFRH8KmzwICMoCfrHRnjB453cMor9H124HhnAgMBAAGj
+YzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFE1FwWg4u3OpaaEg5+31IqEj
+FNeeMB8GA1UdIwQYMBaAFE1FwWg4u3OpaaEg5+31IqEjFNeeMA4GA1UdDwEB/wQE
+AwIBhjANBgkqhkiG9w0BAQUFAAOCAgEAZ2sGuV9FOypLM7PmG2tZTiLMubekJcmn
+xPBUlgtk87FYT15R/LKXeydlwuXK5w0MJXti4/qftIe3RUavg6WXSIylvfEWK5t2
+LHo1YGwRgJfMqZJS5ivmae2p+DYtLHe/YUjRYwu5W1LtGLBDQiKmsXeu3mnFzccc
+obGlHBD7GL4acN3Bkku+KVqdPzW+5X1R+FXgJXUjhx5c3LqdsKyzadsXg8n33gy8
+CNyRnqjQ1xU3c6U1uPx+xURABsPr+CKAXEfOAuMRn0T//ZoyzH1kUQ7rVyZ2OuMe
+IjzCpjbdGe+n/BLzJsBZMYVMnNjP36TMzCmT/5RtdlwTCJfy7aULTd3oyWgOZtMA
+DjMSW7yV5TKQqLPGbIOtd+6Lfn6xqavT4fG2wLHqiMDn05DpKJKUe2h7lyoKZy2F
+AjgQ5ANh1NolNscIWC2hp1GvMApJ9aZphwctREZ2jirlmjvXGKL8nDgQzMY70rUX
+Om/9riW99XJZZLF0KjhfGEzfz3EEWjbUvy+ZnOjZurGV5gJLIaFb1cFPj65pbVPb
+AZO1XB4Y3WRayhgoPmMEEf0cjQAPuDffZ4qdZqkCapH/E8ovXYO8h5Ns3CRRFgQl
+Zvqz2cK6Kb6aSDiCmfS/O0oxGfm/jiEzFMpPVF/7zvuPcX/9XhmgD0uRuMRUvAaw
+RY8mkaKO/qk=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIID5jCCAs6gAwIBAgIBATANBgkqhkiG9w0BAQUFADCBgzELMAkGA1UEBhMCVVMx
+HTAbBgNVBAoTFEFPTCBUaW1lIFdhcm5lciBJbmMuMRwwGgYDVQQLExNBbWVyaWNh
+IE9ubGluZSBJbmMuMTcwNQYDVQQDEy5BT0wgVGltZSBXYXJuZXIgUm9vdCBDZXJ0
+aWZpY2F0aW9uIEF1dGhvcml0eSAxMB4XDTAyMDUyOTA2MDAwMFoXDTM3MTEyMDE1
+MDMwMFowgYMxCzAJBgNVBAYTAlVTMR0wGwYDVQQKExRBT0wgVGltZSBXYXJuZXIg
+SW5jLjEcMBoGA1UECxMTQW1lcmljYSBPbmxpbmUgSW5jLjE3MDUGA1UEAxMuQU9M
+IFRpbWUgV2FybmVyIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMTCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJnej8Mlo2k06AX3dLm/WpcZuS+U
+0pPlLYnKhHw/EEMbjIt8hFj4JHxIzyr9wBXZGH6EGhfT257XyuTZ16pYUYfw8ItI
+TuLCxFlpMGK2MKKMCxGZYTVtfu/FsRkGIBKOQuHfD5YQUqjPnF+VFNivO3ULMSAf
+RC+iYkGzuxgh28pxPIzstrkNn+9R7017EvILDOGsQI93f7DKeHEMXRZxcKLXwjqF
+zQ6axOAAsNUl6twr5JQtOJyJQVdkKGUZHLZEtMgxa44Be3ZZJX8VHIQIfHNlIAqh
+BC4aMqiaILGcLCFZ5/vP7nAtCMpjPiybkxlqpMKX/7eGV4iFbJ4VFitNLLMCAwEA
+AaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoTYwFsuGkABFgFOxj8jY
+PXy+XxIwHwYDVR0jBBgwFoAUoTYwFsuGkABFgFOxj8jYPXy+XxIwDgYDVR0PAQH/
+BAQDAgGGMA0GCSqGSIb3DQEBBQUAA4IBAQCKIBilvrMvtKaEAEAwKfq0FHNMeUWn
+9nDg6H5kHgqVfGphwu9OH77/yZkfB2FK4V1Mza3u0FIy2VkyvNp5ctZ7CegCgTXT
+Ct8RHcl5oIBN/lrXVtbtDyqvpxh1MwzqwWEFT2qaifKNuZ8u77BfWgDrvq2g+EQF
+Z7zLBO+eZMXpyD8Fv8YvBxzDNnGGyjhmSs3WuEvGbKeXO/oTLW4jYYehY0KswsuX
+n2Fozy1MBJ3XJU8KDk2QixhWqJNIV9xvrr2eZ1d3iVCzvhGbRWeDhhmH05i9CBoW
+H1iCC+GWaQVLjuyDUTEH1dSf/1l7qG6Fz9NLqUmwX7A5KGgOc90lmt4S
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAyygAwIBAgIBADANBgkqhkiG9w0BAQQFADCBmDELMAkGA1UEBhMCQVQx
+EDAOBgNVBAgTB0F1c3RyaWExDzANBgNVBAcTBlZpZW5uYTFCMEAGA1UEChM5QXJn
+ZSBEYXRlbiBPZXN0ZXJyZWljaGlzY2hlIEdlc2VsbHNjaGFmdCBmdWVyIERhdGVu
+c2NodXR6MSIwIAYJKoZIhvcNAQkBFhNhLWNlcnRAYXJnZWRhdGVuLmF0MB4XDTAx
+MDIxMjExMzAzMFoXDTA5MDIxMjExMzAzMFowgZgxCzAJBgNVBAYTAkFUMRAwDgYD
+VQQIEwdBdXN0cmlhMQ8wDQYDVQQHEwZWaWVubmExQjBABgNVBAoTOUFyZ2UgRGF0
+ZW4gT2VzdGVycmVpY2hpc2NoZSBHZXNlbGxzY2hhZnQgZnVlciBEYXRlbnNjaHV0
+ejEiMCAGCSqGSIb3DQEJARYTYS1jZXJ0QGFyZ2VkYXRlbi5hdDCBnzANBgkqhkiG
+9w0BAQEFAAOBjQAwgYkCgYEAwgsHqoNtmmrJ86+e1I4hOVBaL4kokqKN2IPOIL+1
+XwY8vfOOUfPEdhWpaC0ldt7VYrksgDiUccgH0FROANWK2GkfKMDzjjXHysR04uEb
+Om7Kqjqn0nproOGkFG+QvBZgs+Ws+HXNFJA6V76fU4+JXq4452LSK4Lr5YcBquu3
+NJECAwEAAaOCARkwggEVMB0GA1UdDgQWBBQ0j59zH/G31zRjgK1y2P//tSAWZjCB
+xQYDVR0jBIG9MIG6gBQ0j59zH/G31zRjgK1y2P//tSAWZqGBnqSBmzCBmDELMAkG
+A1UEBhMCQVQxEDAOBgNVBAgTB0F1c3RyaWExDzANBgNVBAcTBlZpZW5uYTFCMEAG
+A1UEChM5QXJnZSBEYXRlbiBPZXN0ZXJyZWljaGlzY2hlIEdlc2VsbHNjaGFmdCBm
+dWVyIERhdGVuc2NodXR6MSIwIAYJKoZIhvcNAQkBFhNhLWNlcnRAYXJnZWRhdGVu
+LmF0ggEAMAwGA1UdEwQFMAMBAf8wCwYDVR0PBAQDAgEGMBEGCWCGSAGG+EIBAQQE
+AwICBDANBgkqhkiG9w0BAQQFAAOBgQBFuJYncqMYB6gXQS3eDOI90BEHfFTKy/dV
+AV+K7QdAYikWmqgBheRdPKddJdccPy/Zl/p3ZT7GhDyC5f3wZjcuu8AJ27BNwbCA
+x54dgxgCNcyPm79nY8MRtEdEpoRGdSsFKJemz6hpXM++MWFciyrRWIIA44XB0Gv3
+US0spjsDPQ==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ
+RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD
+VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX
+DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y
+ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy
+VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr
+mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr
+IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK
+mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu
+XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy
+dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye
+jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1
+BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3
+DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92
+9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx
+jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0
+Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz
+ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS
+R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDlDCCAnygAwIBAgIQWAsFbFMk27JQVxhf+eWmUDANBgkqhkiG9w0BAQUFADAn
+MQswCQYDVQQGEwJCRTEYMBYGA1UEAxMPQmVsZ2l1bSBSb290IENBMB4XDTAzMDEy
+NjIzMDAwMFoXDTE0MDEyNjIzMDAwMFowJzELMAkGA1UEBhMCQkUxGDAWBgNVBAMT
+D0JlbGdpdW0gUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+AMihcekcRkJ5eHFvna6pqKsot03HIOswkVp19eLSz8hMFJhCWK3HEcVAQGpa+XQS
+J4fpnOVxTiIs0RIYqjBeoiG52bv/9nTrMQHnO35YD5EWTXaJqAFPrSJmcPpLHZXB
+MFjqvNll2Jq0iOtJRlLf0lMVdssUXRlJsW9q09P9vMIt7EU/CT9YvvzU7wCMgTVy
+v/cY6pZifSsofxVsY9LKyn0FrMhtB20yvmi4BUCuVJhWPmbxMOjvxKuTXgfeMo8S
+dKpbNCNUwOpszv42kqgJF+qhLc9s44Qd3ocuMws8dOIhUDiVLlzg5cYx+dtA+mqh
+pIqTm6chBocdJ9PEoclMsG8CAwEAAaOBuzCBuDAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zBCBgNVHSAEOzA5MDcGBWA4AQEBMC4wLAYIKwYBBQUHAgEW
+IGh0dHA6Ly9yZXBvc2l0b3J5LmVpZC5iZWxnaXVtLmJlMB0GA1UdDgQWBBQQ8AxW
+m2HqVzq2NZdtn925FI7b5jARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAU
+EPAMVpth6lc6tjWXbZ/duRSO2+YwDQYJKoZIhvcNAQEFBQADggEBAMhtIlGKYfgP
+lm7VILKB+MbcoxYA2s1q52sq+llIp0xJN9dzoWoBZV4yveeX09AuPHPTjHuD79ZC
+wT+oqV0PN7p20kC9zC0/00RBSZz9Wyn0AiMiW3Ebv1jZKE4tRfTa57VjRUQRDSp/
+M382SbTObqkCMa5c/ciJv0J71/Fg8teH9lcuen5qE4Ad3OPQYx49cTGxYNSeCMqr
+8JTHSHVUgfMbrXec6LKP24OsjzRr6L/D2fVDw2RV6xq9NoY2uiGMlxoh1OotO6y6
+7Kcdq765Sps1LxxcHVGnH1TtEpf/8m6HfUbJdNbv6z195lluBpQE5KJVhzgoaiJe
+4r50ErAEQyo=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFLDCCBBSgAwIBAgIEOU99hzANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJX
+VzESMBAGA1UEChMJYmVUUlVTVGVkMRswGQYDVQQDExJiZVRSVVNUZWQgUm9vdCBD
+QXMxGjAYBgNVBAMTEWJlVFJVU1RlZCBSb290IENBMB4XDTAwMDYyMDE0MjEwNFoX
+DTEwMDYyMDEzMjEwNFowWjELMAkGA1UEBhMCV1cxEjAQBgNVBAoTCWJlVFJVU1Rl
+ZDEbMBkGA1UEAxMSYmVUUlVTVGVkIFJvb3QgQ0FzMRowGAYDVQQDExFiZVRSVVNU
+ZWQgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANS0c3oT
+CjhVAb6JVuGUntS+WutKNHUbYSnE4a0IYCF4SP+00PpeQY1hRIfo7clY+vyTmt9P
+6j41ffgzeubx181vSUs9Ty1uDoM6GHh3o8/n9E1z2Jo7Gh2+lVPPIJfCzz4kUmwM
+jmVZxXH/YgmPqsWPzGCgc0rXOD8Vcr+il7dw6K/ifhYGTPWqZCZyByWtNfwYsSbX
+2P8ZDoMbjNx4RWc0PfSvHI3kbWvtILNnmrRhyxdviTX/507AMhLn7uzf/5cwdO2N
+R47rtMNE5qdMf1ZD6Li8tr76g5fmu/vEtpO+GRg+jIG5c4gW9JZDnGdzF5DYCW5j
+rEq2I8QBoa2k5MUCAwEAAaOCAfgwggH0MA8GA1UdEwEB/wQFMAMBAf8wggFZBgNV
+HSAEggFQMIIBTDCCAUgGCisGAQQBsT4BAAAwggE4MIIBAQYIKwYBBQUHAgIwgfQa
+gfFSZWxpYW5jZSBvbiB0aGlzIGNlcnRpZmljYXRlIGJ5IGFueSBwYXJ0eSBhc3N1
+bWVzIGFjY2VwdGFuY2Ugb2YgdGhlIHRoZW4gYXBwbGljYWJsZSBzdGFuZGFyZCB0
+ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB1c2UsIGFuZCBjZXJ0aWZpY2F0aW9uIHBy
+YWN0aWNlIHN0YXRlbWVudCwgd2hpY2ggY2FuIGJlIGZvdW5kIGF0IGJlVFJVU1Rl
+ZCdzIHdlYiBzaXRlLCBodHRwczovL3d3dy5iZVRSVVNUZWQuY29tL3ZhdWx0L3Rl
+cm1zMDEGCCsGAQUFBwIBFiVodHRwczovL3d3dy5iZVRSVVNUZWQuY29tL3ZhdWx0
+L3Rlcm1zMDQGA1UdHwQtMCswKaAnoCWkIzAhMRIwEAYDVQQKEwliZVRSVVNUZWQx
+CzAJBgNVBAYTAldXMB0GA1UdDgQWBBQquZtpLjub2M3eKjEENGvKBxirZzAfBgNV
+HSMEGDAWgBQquZtpLjub2M3eKjEENGvKBxirZzAOBgNVHQ8BAf8EBAMCAf4wDQYJ
+KoZIhvcNAQEFBQADggEBAHlh26Nebhax6nZR+csVm8tpvuaBa58oH2U+3RGFktTo
+Qb9+M70j5/Egv6S0phkBxoyNNXxlpE8JpNbYIxUFE6dDea/bow6be3ga8wSGWsb2
+jCBHOElQBp1yZzrwmAOtlmdE/D8QDYZN5AA7KXvOOzuZhmElQITcE2K3+spZ1gMe
+1lMBzW1MaFVA4e5rxyoAAEiCswoBw2AqDPeCNe5IhpbkdNQ96gFxugR1QKepfzk5
+mlWXKWWuGVUlBXJH0+gY3Ljpr0NzARJ0o+FcXxVdJPP55PS2Z2cS52QiivalQaYc
+tmBjRYoQtLpGEK5BV2VsPyMQPyEQWbfkQN0mDCP2qq4=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDczCCAlugAwIBAgIQMDAwMDk3Mzc1NzM4NjAwMDANBgkqhkiG9w0BAQUFADBV
+MQswCQYDVQQGEwJGUjETMBEGA1UEChMKQ2VydGlOb21pczEcMBoGA1UECxMTQUMg
+UmFjaW5lIC0gUm9vdCBDQTETMBEGA1UEAxMKQ2VydGlOb21pczAeFw0wMDExMDkw
+MDAwMDBaFw0xMjExMDkwMDAwMDBaMFUxCzAJBgNVBAYTAkZSMRMwEQYDVQQKEwpD
+ZXJ0aU5vbWlzMRwwGgYDVQQLExNBQyBSYWNpbmUgLSBSb290IENBMRMwEQYDVQQD
+EwpDZXJ0aU5vbWlzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA8SWb
+4mS5RXB3ENSIcfrEzCj/TRUQuT1tMCU0YUfXFSgcPdWglIzCv3kvh07QoB+8xMl+
+fQHvSSduAxnNewz0GBY9rApCPKlP6CcnJr74OSVZIiWt9wLfl4wwhNhZOiikIpZp
+EdOXWqRc84P5cUlN3Lwmr1sjCWmHfTSS4cAKxfDbFLfE61etosyoFZUTQbIhb1Bf
+JL5xRXAUZudQiU42n/yAoSUrN4FLUfPQNlOe1AB81pIgX8g2ojwxDjfgqSs1JmBF
+uLKJ45uVLEenQBPmQCGjL3maV86IRmR3a9UGlgvKAk0NBdh8mrQyQvcUlLBIQBCm
+l7wppt6maQHUNEPQSwIDAQABoz8wPTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQU+F4ho6ijFeb4tRG7/kIEXU2OgnowDQYJKoZIhvcNAQEF
+BQADggEBACe9FJayK6bXkJQrilBFMh75QPdFOks9PJuo86OMUlBDZGYFTCh9Arex
+N3KYCnAEzazYIALwr7eASJJDIQMu1Q+pkx/7ACde4kP47F27M2rm+v5HnGooCLz2
+s7Fe/WUycTQqgwF5lNp03m1ce/TvovgkEZeVN5wM/7+SsZLJGDigXGeq48j2g2hn
+8OckX9Ciyo0U3/1IVeigNBisiaOlsHSZOEPBZQRiZULob+NVbXVPo8nM1OyP3aHI
+LQex1yYcCr9m93nOiZyKkur3Uedf1yMTBe+fflnPFKGYnVqvTGXCKVdHzQBfpILA
+AuaC+5ykZhSiSMf8nmL2oPMcLO7YQw4=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICPTCCAaYCEQDNun9W8N/kvFT+IqyzcqpVMA0GCSqGSIb3DQEBAgUAMF8xCzAJ
+BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE3MDUGA1UECxMuQ2xh
+c3MgMSBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05
+NjAxMjkwMDAwMDBaFw0yODA4MDEyMzU5NTlaMF8xCzAJBgNVBAYTAlVTMRcwFQYD
+VQQKEw5WZXJpU2lnbiwgSW5jLjE3MDUGA1UECxMuQ2xhc3MgMSBQdWJsaWMgUHJp
+bWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCBnzANBgkqhkiG9w0BAQEFAAOB
+jQAwgYkCgYEA5Rm/baNWYS2ZSHH2Z965jeu3noaACpEO+jglr0aIguVzqKCbJF0N
+H8xlbgyw0FaEGIeaBpsQoXPftFg5a27B9hXVqKg/qhIGjTGsf7A01480Z4gJzRQR
+4k5FVmkfeAKA2txHkSm7NsljXMXg1y2He6G3MrB7MLoqLzGq7qNn2tsCAwEAATAN
+BgkqhkiG9w0BAQIFAAOBgQBMP7iLxmjf7kMzDl3ppssHhE16M/+SG/Q2rdiVIjZo
+EWx8QszznC7EBz8UsA9P/5CSdvnivErpj82ggAr3xSnxgiJduLHdgSOjeyUVRjB5
+FvjqBUuUfx3CHMjjt/QQQDwTw18fU+hI5Ia0e6E1sHslurjTjqs/OJ0ANACY89Fx
+lA==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDAjCCAmsCEEzH6qqYPnHTkxD4PTqJkZIwDQYJKoZIhvcNAQEFBQAwgcExCzAJ
+BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh
+c3MgMSBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy
+MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp
+emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X
+DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw
+FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMSBQdWJsaWMg
+UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo
+YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5
+MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB
+AQUAA4GNADCBiQKBgQCq0Lq+Fi24g9TK0g+8djHKlNgdk4xWArzZbxpvUjZudVYK
+VdPfQ4chEWWKfo+9Id5rMj8bhDSVBZ1BNeuS65bdqlk/AVNtmU/t5eIqWpDBucSm
+Fc/IReumXY6cPvBkJHalzasab7bYe1FhbqZ/h8jit+U03EGI6glAvnOSPWvndQID
+AQABMA0GCSqGSIb3DQEBBQUAA4GBAKlPww3HZ74sy9mozS11534Vnjty637rXC0J
+h9ZrbWB85a7FkCMMXErQr7Fd88e2CtvgFZMN3QO8x3aKtd1Pw5sTdbgBwObJW2ul
+uIncrKTdcu1OofdPvAbT6shkdHvClUGcZXNY8ZCaPGqxmMnEh7zPRW1F4m4iP/68
+DzFc6PLZ
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICPDCCAaUCEC0b/EoXjaOR6+f/9YtFvgswDQYJKoZIhvcNAQECBQAwXzELMAkG
+A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz
+cyAyIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2
+MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV
+BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAyIFB1YmxpYyBQcmlt
+YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN
+ADCBiQKBgQC2WoujDWojg4BrzzmH9CETMwZMJaLtVRKXxaeAufqDwSCg+i8VDXyh
+YGt+eSz6Bg86rvYbb7HS/y8oUl+DfUvEerf4Zh+AVPy3wo5ZShRXRtGak75BkQO7
+FYCTXOvnzAhsPz6zSvz/S2wj1VCCJkQZjiPDceoZJEcEnnW/yKYAHwIDAQABMA0G
+CSqGSIb3DQEBAgUAA4GBAIobK/o5wXTXXtgZZKJYSi034DNHD6zt96rbHuSLBlxg
+J8pFUs4W7z8GZOeUaHxgMxURaa+dYo2jA1Rrpr7l7gUYYAS/QoD90KioHgE796Nc
+r6Pc5iaAIzy4RHT3Cq5Ji2F4zCS/iIqnDupzGUH9TQPwiNHleI2lKk/2lw0Xd8rY
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDAzCCAmwCEQC5L2DMiJ+hekYJuFtwbIqvMA0GCSqGSIb3DQEBBQUAMIHBMQsw
+CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xPDA6BgNVBAsTM0Ns
+YXNzIDIgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH
+MjE6MDgGA1UECxMxKGMpIDE5OTggVmVyaVNpZ24sIEluYy4gLSBGb3IgYXV0aG9y
+aXplZCB1c2Ugb25seTEfMB0GA1UECxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazAe
+Fw05ODA1MTgwMDAwMDBaFw0yODA4MDEyMzU5NTlaMIHBMQswCQYDVQQGEwJVUzEX
+MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xPDA6BgNVBAsTM0NsYXNzIDIgUHVibGlj
+IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBHMjE6MDgGA1UECxMx
+KGMpIDE5OTggVmVyaVNpZ24sIEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s
+eTEfMB0GA1UECxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazCBnzANBgkqhkiG9w0B
+AQEFAAOBjQAwgYkCgYEAp4gBIXQs5xoD8JjhlzwPIQjxnNuX6Zr8wgQGE75fUsjM
+HiwSViy4AWkszJkfrbCWrnkE8hM5wXuYuggs6MKEEyyqaekJ9MepAqRCwiNPStjw
+DqL7MWzJ5m+ZJwf15vRMeJ5t60aG+rmGyVTyssSv1EYcWskVMP8NbPUtDm3Of3cC
+AwEAATANBgkqhkiG9w0BAQUFAAOBgQByLvl/0fFx+8Se9sVeUYpAmLho+Jscg9ji
+nb3/7aHmZuovCfTK1+qlK5X2JGCGTUQug6XELaDTrnhpb3LabK4I8GOSN+a7xDAX
+rXfMSTWqz9iP0b63GJZHc2pUIjRkLbYWm1lbtFFZOrMLFPQS32eg9K0yZF6xRnIn
+jBJ7xUS0rg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG
+A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz
+cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2
+MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV
+BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt
+YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN
+ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE
+BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is
+I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G
+CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do
+lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc
+AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDAjCCAmsCEH3Z/gfPqB63EHln+6eJNMYwDQYJKoZIhvcNAQEFBQAwgcExCzAJ
+BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh
+c3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy
+MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp
+emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X
+DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw
+FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMyBQdWJsaWMg
+UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo
+YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5
+MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB
+AQUAA4GNADCBiQKBgQDMXtERXVxp0KvTuWpMmR9ZmDCOFoUgRm1HP9SFIIThbbP4
+pO0M8RcPO/mn+SXXwc+EY/J8Y8+iR/LGWzOOZEAEaMGAuWQcRXfH2G71lSk8UOg0
+13gfqLptQ5GVj0VXXn7F+8qkBOvqlzdUMG+7AUcyM83cV5tkaWH4mx0ciU9cZwID
+AQABMA0GCSqGSIb3DQEBBQUAA4GBAFFNzb5cy5gZnBWyATl4Lk0PZ3BwmcYQWpSk
+U01UbSuvDV1Ai2TT1+7eVmGSX6bEHRBhNtMsJzzoKQm5EWR0zLVznxxIqbxhAe7i
+F6YM40AIOw7n60RzKprxaZLvcRTDOaxxp5EJb+RxBrO6WVcmeQD2+A2iMzAo1KpY
+oJ2daZH9
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDAjCCAmsCEDKIjprS9esTR/h/xCA3JfgwDQYJKoZIhvcNAQEFBQAwgcExCzAJ
+BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh
+c3MgNCBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy
+MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp
+emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X
+DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw
+FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgNCBQdWJsaWMg
+UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo
+YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5
+MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB
+AQUAA4GNADCBiQKBgQC68OTP+cSuhVS5B1f5j8V/aBH4xBewRNzjMHPVKmIquNDM
+HO0oW369atyzkSTKQWI8/AIBvxwWMZQFl3Zuoq29YRdsTjCG8FE3KlDHqGKB3FtK
+qsGgtG7rL+VXxbErQHDbWk2hjh+9Ax/YA9SPTJlxvOKCzFjomDqG04Y48wApHwID
+AQABMA0GCSqGSIb3DQEBBQUAA4GBAIWMEsGnuVAVess+rLhDityq3RS6iYF+ATwj
+cSGIL4LcY/oCRaxFWdcqWERbt5+BO5JoPeI3JPV7bI92NZYJqFmduc4jq3TWg/0y
+cyfYaT5DdPauxYma51N86Xv2S/PBZYPejYqcPIiNOVn8qj8ijaHBZlCBckztImRP
+T8qAkbYp
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICZzCCAdCgAwIBAgIBBDANBgkqhkiG9w0BAQUFADBhMQswCQYDVQQGEwJVUzEY
+MBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsT
+A1BLSTEcMBoGA1UEAxMTRG9EIENMQVNTIDMgUm9vdCBDQTAeFw0wMDA1MTkxMzEz
+MDBaFw0yMDA1MTQxMzEzMDBaMGExCzAJBgNVBAYTAlVTMRgwFgYDVQQKEw9VLlMu
+IEdvdmVybm1lbnQxDDAKBgNVBAsTA0RvRDEMMAoGA1UECxMDUEtJMRwwGgYDVQQD
+ExNEb0QgQ0xBU1MgMyBSb290IENBMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
+gQC1MP5kvurMbe2BLPd/6Rm6DmlqKOGpqcuVWB/x5pppU+CIP5HFUbljl6jmIYwT
+XjY8qFf6+HAsTGrLvzCnTBbkMlz4ErBR+BZXjS+0TfouqJToKmHUVw1Hzm4sL36Y
+Z8wACKu2lhY1woWR5VugCsdmUmLzYXWVF668KlYppeArUwIDAQABoy8wLTAdBgNV
+HQ4EFgQUbJyl8FyPbUGNxBc7kFfCD6PNbf4wDAYDVR0TBAUwAwEB/zANBgkqhkiG
+9w0BAQUFAAOBgQCvcUT5lyPMaGmMQwdBuoggsyIAQciYoFUczT9usZNcrfoYmrsc
+c2/9JEKPh59Rz76Gn+nXikhPCNlplKw/5g8tlw8ok3ZPYt//oM1h+KaGDDE0INx/
+L6j7Ob6V7jhZAmLB3mwVT+DfnbvkeXMk/WNklfdKqJkfSGWVx3u/eDLneg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICZzCCAdCgAwIBAgIBGjANBgkqhkiG9w0BAQUFADBhMQswCQYDVQQGEwJVUzEY
+MBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsT
+A1BLSTEcMBoGA1UEAxMTRG9EIFBLSSBNZWQgUm9vdCBDQTAeFw05ODA4MDYxNTAx
+MDBaFw0wODA4MDcxNTAxMDBaMGExCzAJBgNVBAYTAlVTMRgwFgYDVQQKEw9VLlMu
+IEdvdmVybm1lbnQxDDAKBgNVBAsTA0RvRDEMMAoGA1UECxMDUEtJMRwwGgYDVQQD
+ExNEb0QgUEtJIE1lZCBSb290IENBMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
+gQC5arG1dp5gWLAG69GfVnf0laK3aCAXLKGE65A72UGYsJQ3ENGaE9lW/JoDaLV8
+wrjQIL87bVC34jTvJs2aPjd7oeUaUXjeddt8bYjwRV/fwXl/oUoGx9umpJUuNvEW
+1H9P6xJFyzB9jpm+HGW+Oid3wtWKqNq1xsSuMByHlpoXtwIDAQABoy8wLTAdBgNV
+HQ4EFgQUxVnSzvGYlVBmqG3eMkvWYTXiRrMwDAYDVR0TBAUwAwEB/zANBgkqhkiG
+9w0BAQUFAAOBgQAyPjGMqsgKSbKHr38GlCT6WmkKtCWX6YX/3S3vaf39asluzJX6
+3sTcMByqi0jy7BLYbgKzPvxmuW3yVUlLl6rV6YrId62ezjPmaIqkDI8snEM0BWSW
+2ousTPara2J0xvzdC5lj/+ke6LHrO9yhSLRFMk8quccSXtFW6H5ei0+sGg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDOzCCAiOgAwIBAgIRANAeRlAAACmMAAAAAgAAAAIwDQYJKoZIhvcNAQEFBQAw
+PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD
+Ew5EU1QgUm9vdCBDQSBYNDAeFw0wMDA5MTMwNjIyNTBaFw0yMDA5MTMwNjIyNTBa
+MD8xJDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRydXN0IENvLjEXMBUGA1UE
+AxMORFNUIFJvb3QgQ0EgWDQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+AQCthX3OFEYY8gSeIYur0O4ypOT68HnDrjLfIutL5PZHRwQGjzCPb9PFo/ihboJ8
+RvfGhBAqpQCo47zwYEhpWm1jB+L/OE/dBBiyn98krfU2NiBKSom2J58RBeAwHGEy
+cO+lewyjVvbDDLUy4CheY059vfMjPAftCRXjqSZIolQb9FdPcAoa90mFwB7rKniE
+J7vppdrUScSS0+eBrHSUPLdvwyn4RGp+lSwbWYcbg5EpSpE0GRJdchic0YDjvIoC
+YHpe7Rkj93PYRTQyU4bhC88ck8tMqbvRYqMRqR+vobbkrj5LLCOQCHV5WEoxWh+0
+E2SpIFe7RkV++MmpIAc0h1tZAgMBAAGjMjAwMA8GA1UdEwEB/wQFMAMBAf8wHQYD
+VR0OBBYEFPCD6nPIP1ubWzdf9UyPWvf0hki9MA0GCSqGSIb3DQEBBQUAA4IBAQCE
+G85wl5eEWd7adH6XW/ikGN5salvpq/Fix6yVTzE6CrhlP5LBdkf6kx1bSPL18M45
+g0rw2zA/MWOhJ3+S6U+BE0zPGCuu8YQaZibR7snm3HiHUaZNMu5c8D0x0bcMxDjY
+AVVcHCoNiL53Q4PLW27nbY6wwG0ffFKmgV3blxrYWfuUDgGpyPwHwkfVFvz9qjaV
+mf12VJffL6W8omBPtgteb6UaT/k1oJ7YI0ldGf+ngpVbRhD+LC3cUtT6GO/BEPZu
+8YTV/hbiDH5v3khVqMIeKT6o8IuXGG7F6a6vKwP1F1FwTXf4UC/ivhme7vdUH7B/
+Vv4AEbT8dNfEeFxrkDbh
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIID2DCCAsACEQDQHkCLAAACfAAAAAIAAAABMA0GCSqGSIb3DQEBBQUAMIGpMQsw
+CQYDVQQGEwJ1czENMAsGA1UECBMEVXRhaDEXMBUGA1UEBxMOU2FsdCBMYWtlIENp
+dHkxJDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRydXN0IENvLjERMA8GA1UE
+CxMIRFNUQ0EgWDExFjAUBgNVBAMTDURTVCBSb290Q0EgWDExITAfBgkqhkiG9w0B
+CQEWEmNhQGRpZ3NpZ3RydXN0LmNvbTAeFw05ODEyMDExODE4NTVaFw0wODExMjgx
+ODE4NTVaMIGpMQswCQYDVQQGEwJ1czENMAsGA1UECBMEVXRhaDEXMBUGA1UEBxMO
+U2FsdCBMYWtlIENpdHkxJDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRydXN0
+IENvLjERMA8GA1UECxMIRFNUQ0EgWDExFjAUBgNVBAMTDURTVCBSb290Q0EgWDEx
+ITAfBgkqhkiG9w0BCQEWEmNhQGRpZ3NpZ3RydXN0LmNvbTCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBANLGJrbnpT3BxGjVUG9TxW9JEwm4ryxIjRRqoxdf
+WvnTLnUv2Chi0ZMv/E3Uq4flCMeZ55I/db3rJbQVwZsZPdJEjdd0IG03Ao9pk1uK
+xBmd9LIO/BZsubEFkoPRhSxglD5FVaDZqwgh5mDoO3TymVBRaNADLbGAvqPYUrBE
+zUNKcI5YhZXhTizWLUFv1oTnyJhEykfbLCSlaSbPa7gnYsP0yXqSI+0TZ4KuRS5F
+5X5yP4WdlGIQ5jyRoa13AOAV7POEgHJ6jm5gl8ckWRA0g1vhpaRptlc1HHhZxtMv
+OnNn7pTKBBMFYgZwI7P0fO5F2WQLW0mqpEPOJsREEmy43XkCAwEAATANBgkqhkiG
+9w0BAQUFAAOCAQEAojeyP2n714Z5VEkxlTMr89EJFEliYIalsBHiUMIdBlc+Legz
+ZL6bqq1fG03UmZWii5rJYnK1aerZWKs17RWiQ9a2vAd5ZWRzfdd5ynvVWlHG4VME
+lo04z6MXrDlxawHDi1M8Y+nuecDkvpIyZHqzH5eUYr3qsiAVlfuX8ngvYzZAOONG
+Dx3drJXK50uQe7FLqdTF65raqtWjlBRGjS0f8zrWkzr2Pnn86Oawde3uPclwx12q
+gUtGJRzHbBXjlU4PqjI3lAoXJJIThFjSY28r9+ZbYgsTF7ANUkz+/m9c4pFuHf2k
+Ytdo+o56T9II2pPc8JIRetDccpMMc5NihWjQ9A==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIID2DCCAsACEQDQHkCLAAB3bQAAAAEAAAAEMA0GCSqGSIb3DQEBBQUAMIGpMQsw
+CQYDVQQGEwJ1czENMAsGA1UECBMEVXRhaDEXMBUGA1UEBxMOU2FsdCBMYWtlIENp
+dHkxJDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRydXN0IENvLjERMA8GA1UE
+CxMIRFNUQ0EgWDIxFjAUBgNVBAMTDURTVCBSb290Q0EgWDIxITAfBgkqhkiG9w0B
+CQEWEmNhQGRpZ3NpZ3RydXN0LmNvbTAeFw05ODExMzAyMjQ2MTZaFw0wODExMjcy
+MjQ2MTZaMIGpMQswCQYDVQQGEwJ1czENMAsGA1UECBMEVXRhaDEXMBUGA1UEBxMO
+U2FsdCBMYWtlIENpdHkxJDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRydXN0
+IENvLjERMA8GA1UECxMIRFNUQ0EgWDIxFjAUBgNVBAMTDURTVCBSb290Q0EgWDIx
+ITAfBgkqhkiG9w0BCQEWEmNhQGRpZ3NpZ3RydXN0LmNvbTCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBANx18IzAdZaawGIfJvfE4Zrq4FZzW5nNAUSoCLbV
+p9oaBBg5kkp4o4HC9Xd6ULRw/5qrxsfKboNPQpj7Jgva3G3WqZlVUmfpKAOS3OWw
+BZoPFflrWXJW8vo5/Kpo7g8fEIMv/J36F5bdguPmRX3AS4BEH+0s4IT9kVySVGkl
+5WJp3OXuAFK9MwutdQKFp2RQLcUZGTDAJtvJ0/0uma1ZtQtN1EGuhUhDWdy3qOKi
+3sOP17ihYqZoUFLkzzGnlIXan0YyF1bl8utmPRL/Q9uY73fPy4GNNLHGUEom0eQ+
+QVCvbK4iNC7Va26Dunm4dmVI2gkpZGMiuftHdoWMhkTLCdsCAwEAATANBgkqhkiG
+9w0BAQUFAAOCAQEAtTYOXeFhKFoRZcA/gwN5Tb4opgsHAlKFzfiR0BBstWogWxyQ
+2TA8xkieil5k+aFxd+8EJx8H6+Qm93N0yUQYGmbT4EOvkTvRyyzYdFQ6HE3K1GjN
+I3wdEJ5F6fYAbqbNGf9PLCmPV03Ed5K+4EwJ+11EhmYhqLkyolbV6YyDfFk/xPEL
+553snr2cGA4+wjl5KLcDDQjLxufZATdQEOzMYRZA1K8xdHv8PzGn0EdzMzkbzE5q
+10mDEQb+64JYMzJM8FasHpwvVpp7wUocpf1VNs78lk30sPDst2yC7S8xmUJMqbIN
+uBVd8d+6ybVK1GSYsyapMMj9puyrliGtf8J4tg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEXDCCA0SgAwIBAgIEOGO5ZjANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML
+RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp
+bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5
+IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0xOTEy
+MjQxODIwNTFaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3
+LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp
+YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG
+A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq
+K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe
+sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX
+MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT
+XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/
+HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH
+4QIDAQABo3QwcjARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAUVeSB0RGA
+vtiJuQijMfmhJAkWuXAwHQYDVR0OBBYEFFXkgdERgL7YibkIozH5oSQJFrlwMB0G
+CSqGSIb2fQdBAAQQMA4bCFY1LjA6NC4wAwIEkDANBgkqhkiG9w0BAQUFAAOCAQEA
+WUesIYSKF8mciVMeuoCFGsY8Tj6xnLZ8xpJdGGQC49MGCBFhfGPjK50xA3B20qMo
+oPS7mmNz7W3lKtvtFKkrxjYR0CvrB4ul2p5cGZ1WEvVUKcgF7bISKo30Axv/55IQ
+h7A6tcOdBTcSo8f0FbnVpDkWm1M6I5HxqIKiaohowXkCIryqptau37AUX7iH0N18
+f3v/rxzP5tsHrV7bhZ3QKw0z2wTR5klAEyt2+z7pnIkPFc4YsIV4IU9rTw76NmfN
+B/L/CNDi3tm/Kq+4h4YhPATKt5Rof8886ZjXOP/swNlQ8C5LWK5Gb9Auw2DaclVy
+vUxFnmG6v4SBkgPR0ml8xQ==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIE7TCCBFagAwIBAgIEOAOR7jANBgkqhkiG9w0BAQQFADCByTELMAkGA1UEBhMC
+VVMxFDASBgNVBAoTC0VudHJ1c3QubmV0MUgwRgYDVQQLFD93d3cuZW50cnVzdC5u
+ZXQvQ2xpZW50X0NBX0luZm8vQ1BTIGluY29ycC4gYnkgcmVmLiBsaW1pdHMgbGlh
+Yi4xJTAjBgNVBAsTHChjKSAxOTk5IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNV
+BAMTKkVudHJ1c3QubmV0IENsaWVudCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe
+Fw05OTEwMTIxOTI0MzBaFw0xOTEwMTIxOTU0MzBaMIHJMQswCQYDVQQGEwJVUzEU
+MBIGA1UEChMLRW50cnVzdC5uZXQxSDBGBgNVBAsUP3d3dy5lbnRydXN0Lm5ldC9D
+bGllbnRfQ0FfSW5mby9DUFMgaW5jb3JwLiBieSByZWYuIGxpbWl0cyBsaWFiLjEl
+MCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEGA1UEAxMq
+RW50cnVzdC5uZXQgQ2xpZW50IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGdMA0G
+CSqGSIb3DQEBAQUAA4GLADCBhwKBgQDIOpleMRffrCdvkHvkGf9FozTC28GoT/Bo
+6oT9n3V5z8GKUZSvx1cDR2SerYIbWtp/N3hHuzeYEpbOxhN979IMMFGpOZ5V+Pux
+5zDeg7K6PvHViTs7hbqqdCz+PzFur5GVbgbUB01LLFZHGARS2g4Qk79jkJvh34zm
+AqTmT173iwIBA6OCAeAwggHcMBEGCWCGSAGG+EIBAQQEAwIABzCCASIGA1UdHwSC
+ARkwggEVMIHkoIHhoIHepIHbMIHYMQswCQYDVQQGEwJVUzEUMBIGA1UEChMLRW50
+cnVzdC5uZXQxSDBGBgNVBAsUP3d3dy5lbnRydXN0Lm5ldC9DbGllbnRfQ0FfSW5m
+by9DUFMgaW5jb3JwLiBieSByZWYuIGxpbWl0cyBsaWFiLjElMCMGA1UECxMcKGMp
+IDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEGA1UEAxMqRW50cnVzdC5uZXQg
+Q2xpZW50IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMCyg
+KqAohiZodHRwOi8vd3d3LmVudHJ1c3QubmV0L0NSTC9DbGllbnQxLmNybDArBgNV
+HRAEJDAigA8xOTk5MTAxMjE5MjQzMFqBDzIwMTkxMDEyMTkyNDMwWjALBgNVHQ8E
+BAMCAQYwHwYDVR0jBBgwFoAUxPucKXuXzUyW/O5bs8qZdIuV6kwwHQYDVR0OBBYE
+FMT7nCl7l81MlvzuW7PKmXSLlepMMAwGA1UdEwQFMAMBAf8wGQYJKoZIhvZ9B0EA
+BAwwChsEVjQuMAMCBJAwDQYJKoZIhvcNAQEEBQADgYEAP66K8ddmAwWePvrqHEa7
+pFuPeJoSSJn59DXeDDYHAmsQOokUgZwxpnyyQbJq5wcBoUv5nyU7lsqZwz6hURzz
+wy5E97BnRqqS5TvaHBkUODDV4qIxJS7x7EU47fgGWANzYrAQMY9Av2TgXD7FTx/a
+EkP/TOYGJqibGapEPHayXOw=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEgzCCA+ygAwIBAgIEOJ725DANBgkqhkiG9w0BAQQFADCBtDEUMBIGA1UEChML
+RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9HQ0NBX0NQUyBp
+bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAyMDAw
+IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENsaWVu
+dCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wMDAyMDcxNjE2NDBaFw0yMDAy
+MDcxNjQ2NDBaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3
+LmVudHJ1c3QubmV0L0dDQ0FfQ1BTIGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp
+YWIuKTElMCMGA1UECxMcKGMpIDIwMDAgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG
+A1UEAxMqRW50cnVzdC5uZXQgQ2xpZW50IENlcnRpZmljYXRpb24gQXV0aG9yaXR5
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCTdLS25MVL1qFof2LV7PdRV7Ny
+Spj10InJrWPNTTVRaoTUrcloeW+46xHbh65cJFET8VQlhK8pK5/jgOLZy93GRUk0
+iJBeAZfv6lOm3fzB3ksqJeTpNfpVBQbliXrqpBFXO/x8PTbNZzVtpKklWb1m9fkn
+5JVn1j+SgF7yNH0rhQIDAQABo4IBnjCCAZowEQYJYIZIAYb4QgEBBAQDAgAHMIHd
+BgNVHR8EgdUwgdIwgc+ggcyggcmkgcYwgcMxFDASBgNVBAoTC0VudHJ1c3QubmV0
+MUAwPgYDVQQLFDd3d3cuZW50cnVzdC5uZXQvR0NDQV9DUFMgaW5jb3JwLiBieSBy
+ZWYuIChsaW1pdHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMjAwMCBFbnRydXN0Lm5l
+dCBMaW1pdGVkMTMwMQYDVQQDEypFbnRydXN0Lm5ldCBDbGllbnQgQ2VydGlmaWNh
+dGlvbiBBdXRob3JpdHkxDTALBgNVBAMTBENSTDEwKwYDVR0QBCQwIoAPMjAwMDAy
+MDcxNjE2NDBagQ8yMDIwMDIwNzE2NDY0MFowCwYDVR0PBAQDAgEGMB8GA1UdIwQY
+MBaAFISLdP3FjcD/J20gN0V8/i3OutN9MB0GA1UdDgQWBBSEi3T9xY3A/ydtIDdF
+fP4tzrrTfTAMBgNVHRMEBTADAQH/MB0GCSqGSIb2fQdBAAQQMA4bCFY1LjA6NC4w
+AwIEkDANBgkqhkiG9w0BAQQFAAOBgQBObzWAO9GK9Q6nIMstZVXQkvTnhLUGJoMS
+hAusO7JE7r3PQNsgDrpuFOow4DtifH+La3xKp9U1PL6oXOpLu5OOgGarDyn9TS2/
+GpsKkMWr2tGzhtQvJFJcem3G8v7lTRowjJDyutdKPkN+1MhQGof4T4HHdguEOnKd
+zmVml64mXg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIE2DCCBEGgAwIBAgIEN0rSQzANBgkqhkiG9w0BAQUFADCBwzELMAkGA1UEBhMC
+VVMxFDASBgNVBAoTC0VudHJ1c3QubmV0MTswOQYDVQQLEzJ3d3cuZW50cnVzdC5u
+ZXQvQ1BTIGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMc
+KGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDE6MDgGA1UEAxMxRW50cnVzdC5u
+ZXQgU2VjdXJlIFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05OTA1
+MjUxNjA5NDBaFw0xOTA1MjUxNjM5NDBaMIHDMQswCQYDVQQGEwJVUzEUMBIGA1UE
+ChMLRW50cnVzdC5uZXQxOzA5BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5j
+b3JwLiBieSByZWYuIChsaW1pdHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBF
+bnRydXN0Lm5ldCBMaW1pdGVkMTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUg
+U2VydmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGdMA0GCSqGSIb3DQEBAQUA
+A4GLADCBhwKBgQDNKIM0VBuJ8w+vN5Ex/68xYMmo6LIQaO2f55M28Qpku0f1BBc/
+I0dNxScZgSYMVHINiC3ZH5oSn7yzcdOAGT9HZnuMNSjSuQrfJNqc1lB5gXpa0zf3
+wkrYKZImZNHkmGw6AIr1NJtl+O3jEP/9uElY3KDegjlrgbEWGWG5VLbmQwIBA6OC
+AdcwggHTMBEGCWCGSAGG+EIBAQQEAwIABzCCARkGA1UdHwSCARAwggEMMIHeoIHb
+oIHYpIHVMIHSMQswCQYDVQQGEwJVUzEUMBIGA1UEChMLRW50cnVzdC5uZXQxOzA5
+BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5jb3JwLiBieSByZWYuIChsaW1p
+dHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBFbnRydXN0Lm5ldCBMaW1pdGVk
+MTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUgU2VydmVyIENlcnRpZmljYXRp
+b24gQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMCmgJ6AlhiNodHRwOi8vd3d3LmVu
+dHJ1c3QubmV0L0NSTC9uZXQxLmNybDArBgNVHRAEJDAigA8xOTk5MDUyNTE2MDk0
+MFqBDzIwMTkwNTI1MTYwOTQwWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAU8Bdi
+E1U9s/8KAGv7UISX8+1i0BowHQYDVR0OBBYEFPAXYhNVPbP/CgBr+1CEl/PtYtAa
+MAwGA1UdEwQFMAMBAf8wGQYJKoZIhvZ9B0EABAwwChsEVjQuMAMCBJAwDQYJKoZI
+hvcNAQEFBQADgYEAkNwwAvpkdMKnCqV8IY00F6j7Rw7/JXyNEwr75Ji174z4xRAN
+95K+8cPV1ZVqBLssziY2ZcgxxufuP+NXdYR6Ee9GTxj005i7qIcyunL2POI9n9cd
+2cNgQ4xYDiKWL2KjLB+6rQXvqzJ4h6BUcxm1XAX5Uj5tLUUL9wqT6u0G+bI=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIElTCCA/6gAwIBAgIEOJsRPDANBgkqhkiG9w0BAQQFADCBujEUMBIGA1UEChML
+RW50cnVzdC5uZXQxPzA9BgNVBAsUNnd3dy5lbnRydXN0Lm5ldC9TU0xfQ1BTIGlu
+Y29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMcKGMpIDIwMDAg
+RW50cnVzdC5uZXQgTGltaXRlZDE6MDgGA1UEAxMxRW50cnVzdC5uZXQgU2VjdXJl
+IFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wMDAyMDQxNzIwMDBa
+Fw0yMDAyMDQxNzUwMDBaMIG6MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDE/MD0GA1UE
+CxQ2d3d3LmVudHJ1c3QubmV0L1NTTF9DUFMgaW5jb3JwLiBieSByZWYuIChsaW1p
+dHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMjAwMCBFbnRydXN0Lm5ldCBMaW1pdGVk
+MTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUgU2VydmVyIENlcnRpZmljYXRp
+b24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDHwV9OcfHO
+8GCGD9JYf9Mzly0XonUwtZZkJi9ow0SrqHXmAGc0V55lxyKbc+bT3QgON1WqJUaB
+bL3+qPZ1V1eMkGxKwz6LS0MKyRFWmponIpnPVZ5h2QLifLZ8OAfc439PmrkDQYC2
+dWcTC5/oVzbIXQA23mYU2m52H083jIITiQIDAQABo4IBpDCCAaAwEQYJYIZIAYb4
+QgEBBAQDAgAHMIHjBgNVHR8EgdswgdgwgdWggdKggc+kgcwwgckxFDASBgNVBAoT
+C0VudHJ1c3QubmV0MT8wPQYDVQQLFDZ3d3cuZW50cnVzdC5uZXQvU1NMX0NQUyBp
+bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAyMDAw
+IEVudHJ1c3QubmV0IExpbWl0ZWQxOjA4BgNVBAMTMUVudHJ1c3QubmV0IFNlY3Vy
+ZSBTZXJ2ZXIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxDTALBgNVBAMTBENSTDEw
+KwYDVR0QBCQwIoAPMjAwMDAyMDQxNzIwMDBagQ8yMDIwMDIwNDE3NTAwMFowCwYD
+VR0PBAQDAgEGMB8GA1UdIwQYMBaAFMtswGvjuz7L/CKc/vuLkpyw8m4iMB0GA1Ud
+DgQWBBTLbMBr47s+y/winP77i5KcsPJuIjAMBgNVHRMEBTADAQH/MB0GCSqGSIb2
+fQdBAAQQMA4bCFY1LjA6NC4wAwIEkDANBgkqhkiG9w0BAQQFAAOBgQBi24GRzsia
+d0Iv7L0no1MPUBvqTpLwqa+poLpIYcvvyQbvH9X07t9WLebKahlzqlO+krNQAraF
+JnJj2HVQYnUUt7NQGj/KEQALhUVpbbalrlHhStyCP2yMNLJ3a9kC9n8O6mUE8c1U
+yrrJzOCE98g+EZfTYAkYvAX/bIkz8OwVDw==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV
+UzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2Vy
+dGlmaWNhdGUgQXV0aG9yaXR5MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1
+MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVx
+dWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0B
+AQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6f
+BeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+A
+cJkVV5MW8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kC
+AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQ
+MA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlm
+aWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTgw
+ODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvSspXXR9gj
+IBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQF
+MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA
+A4GBAFjOKer89961zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y
+7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh
+1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee9570+sB3c4
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICgjCCAeugAwIBAgIBBDANBgkqhkiG9w0BAQQFADBTMQswCQYDVQQGEwJVUzEc
+MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEmMCQGA1UEAxMdRXF1aWZheCBT
+ZWN1cmUgZUJ1c2luZXNzIENBLTEwHhcNOTkwNjIxMDQwMDAwWhcNMjAwNjIxMDQw
+MDAwWjBTMQswCQYDVQQGEwJVUzEcMBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5j
+LjEmMCQGA1UEAxMdRXF1aWZheCBTZWN1cmUgZUJ1c2luZXNzIENBLTEwgZ8wDQYJ
+KoZIhvcNAQEBBQADgY0AMIGJAoGBAM4vGbwXt3fek6lfWg0XTzQaDJj0ItlZ1MRo
+RvC0NcWFAyDGr0WlIVFFQesWWDYyb+JQYmT5/VGcqiTZ9J2DKocKIdMSODRsjQBu
+WqDZQu4aIZX5UkxVWsUPOE9G+m34LjXWHXzr4vCwdYDIqROsvojvOm6rXyo4YgKw
+Env+j6YDAgMBAAGjZjBkMBEGCWCGSAGG+EIBAQQEAwIABzAPBgNVHRMBAf8EBTAD
+AQH/MB8GA1UdIwQYMBaAFEp4MlIR21kWNl7fwRQ2QGpHfEyhMB0GA1UdDgQWBBRK
+eDJSEdtZFjZe38EUNkBqR3xMoTANBgkqhkiG9w0BAQQFAAOBgQB1W6ibAxHm6VZM
+zfmpTMANmvPMZWnmJXbMWbfWVMMdzZmsGd20hdXgPfxiIKeES1hl8eL5lSE/9dR+
+WB5Hh1Q+WKG1tfgq73HnvMP2sUlG4tega+VWeponmHxGYhTnyfxuAxJ5gDgdSIKN
+/Bf+KpYrtWKmpj29f5JZzVoqgrI3eQ==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDIDCCAomgAwIBAgIEN3DPtTANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV
+UzEXMBUGA1UEChMORXF1aWZheCBTZWN1cmUxJjAkBgNVBAsTHUVxdWlmYXggU2Vj
+dXJlIGVCdXNpbmVzcyBDQS0yMB4XDTk5MDYyMzEyMTQ0NVoXDTE5MDYyMzEyMTQ0
+NVowTjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDkVxdWlmYXggU2VjdXJlMSYwJAYD
+VQQLEx1FcXVpZmF4IFNlY3VyZSBlQnVzaW5lc3MgQ0EtMjCBnzANBgkqhkiG9w0B
+AQEFAAOBjQAwgYkCgYEA5Dk5kx5SBhsoNviyoynF7Y6yEb3+6+e0dMKP/wXn2Z0G
+vxLIPw7y1tEkshHe0XMJitSxLJgJDR5QRrKDpkWNYmi7hRsgcDKqQM2mll/EcTc/
+BPO3QSQ5BxoeLmFYoBIL5aXfxavqN3HMHMg3OrmXUqesxWoklE6ce8/AatbfIb0C
+AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEX
+MBUGA1UEChMORXF1aWZheCBTZWN1cmUxJjAkBgNVBAsTHUVxdWlmYXggU2VjdXJl
+IGVCdXNpbmVzcyBDQS0yMQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTkw
+NjIzMTIxNDQ1WjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUUJ4L6q9euSBIplBq
+y/3YIHqngnYwHQYDVR0OBBYEFFCeC+qvXrkgSKZQasv92CB6p4J2MAwGA1UdEwQF
+MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA
+A4GBAAyGgq3oThr1jokn4jVYPSm0B482UJW/bsGe68SQsoWou7dC4A8HOd/7npCy
+0cE+U58DRLB+S/Rv5Hwf5+Kx5Lia78O9zt4LMjTZ3ijtM2vE1Nc9ElirfQkty3D1
+E4qUoSek1nDFbZS1yX2doNLGCEnZZpum0/QL3MUmV+GRMOrN
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICkDCCAfmgAwIBAgIBATANBgkqhkiG9w0BAQQFADBaMQswCQYDVQQGEwJVUzEc
+MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEtMCsGA1UEAxMkRXF1aWZheCBT
+ZWN1cmUgR2xvYmFsIGVCdXNpbmVzcyBDQS0xMB4XDTk5MDYyMTA0MDAwMFoXDTIw
+MDYyMTA0MDAwMFowWjELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0VxdWlmYXggU2Vj
+dXJlIEluYy4xLTArBgNVBAMTJEVxdWlmYXggU2VjdXJlIEdsb2JhbCBlQnVzaW5l
+c3MgQ0EtMTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAuucXkAJlsTRVPEnC
+UdXfp9E3j9HngXNBUmCbnaEXJnitx7HoJpQytd4zjTov2/KaelpzmKNc6fuKcxtc
+58O/gGzNqfTWK8D3+ZmqY6KxRwIP1ORROhI8bIpaVIRw28HFkM9yRcuoWcDNM50/
+o5brhTMhHD4ePmBudpxnhcXIw2ECAwEAAaNmMGQwEQYJYIZIAYb4QgEBBAQDAgAH
+MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUvqigdHJQa0S3ySPY+6j/s1dr
+aGwwHQYDVR0OBBYEFL6ooHRyUGtEt8kj2Puo/7NXa2hsMA0GCSqGSIb3DQEBBAUA
+A4GBADDiAVGqx+pf2rnQZQ8w1j7aDRRJbpGTJxQx78T3LUX47Me/okENI7SS+RkA
+Z70Br83gcfxaz2TE4JaY0KNA4gGK7ycH8WUBikQtBmV1UsCGECAhX2xrD2yuCRyv
+8qIYNMR1pHMc8Y3c7635s3a0kr/clRAevsvIO1qEYBlWlKlV
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT
+MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i
+YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG
+EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg
+R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9
+9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq
+fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv
+iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU
+1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+
+bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW
+MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA
+ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l
+uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn
+Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS
+tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF
+PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un
+hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV
+5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDIzCCAgugAwIBAgIQMDAwMTAwMDQ0ODczMzAwMDANBgkqhkiG9w0BAQUFADAf
+MQswCQYDVQQGEwJGUjEQMA4GA1UEChMHR0lQLUNQUzAeFw0wMTA2MjYwMDAwMDBa
+Fw0xMDEyMzEwMDAwMDBaMB8xCzAJBgNVBAYTAkZSMRAwDgYDVQQKEwdHSVAtQ1BT
+MIIBITANBgkqhkiG9w0BAQEFAAOCAQ4AMIIBCQKCAQBvz+ogB2ovWM18JmOtizrL
+Y2KgEZ8TpU6H7zu+r6cT1Q8xgLm8BPOfeW3eI/e0PLmZN+Sp+LZ4wyFMecJmp/FT
+M9/9Gp23vpMePge/tJctwu0mihabVcUHFoIMtpKgSJ2+Xlywk16AjsHN3DONcWBa
+xV4wa4Tt/BtaEkf9148pDn074lZZ2mKmANu9zNDm/buSgRkqqS1eVCbLxkRaMBSp
+dwGAjsBYEqPjmI4So915ab3Eqqz5zawQwC4T+O41wRgpD9bDTo+9xAFiZz8PqYs9
+pc2tHOKhIlRxJbQqcWQW+St9I7Y+rRx2lTMrt6DD7CMoxrt1TuGzxdN777w1GSfx
+AgMBAAGjXDBaMA4GA1UdDwEB/wQEAwICBDASBgNVHRMBAf8ECDAGAQH/AgEBMB0G
+A1UdDgQWBBTnqP2NPQkWlq78dWMnkCN5XlvZtDAVBgNVHSAEDjAMMAoGCCqBegFH
+AwcDMA0GCSqGSIb3DQEBBQUAA4IBAQAc9sFFWGgFJ14VGI91Cf1h9KYuuh1m2y2u
+xF/mVb58IYBDE0fwG371XwpOHd6d9cM3ANSpK51V5EOmwgFDGkNGtDYcPXR+Ndli
+rhD8aSq0Yv2p3h78o5O6y4GMRycFPsTfWpE9h7fGmsfZXWnYJGRAGM2iKYn7x3f7
++kOrtbVj+XAvws7PqO2lLh/HjWCek4efnU9EaG6SDqu7srTuhyILFRBJ+sfOr68t
+5bwyjufk391dbPBYcQ1AK9CQrnaorhPo+S7iNekX1e5iJShETVrZJkH/AAido34c
+3ohHWmmZPyNW+5CpxZlRL6J6mlcAxIDqkXXsxj/r5zxGrW/jGwxo
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDdTCCAl2gAwIBAgILAgAAAAAA1ni3lAUwDQYJKoZIhvcNAQEEBQAwVzELMAkG
+A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
+b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
+MDBaFw0xNDAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
+YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
+aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
+jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
+xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
+1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
+snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
+U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
+9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIABjAdBgNVHQ4EFgQU
+YHtmGkUNl8qJUC99BM00qP/8/UswDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0B
+AQQFAAOCAQEArqqf/LfSyx9fOSkoGJ40yWxPbxrwZKJwSk8ThptgKJ7ogUmYfQq7
+5bCdPTbbjwVR/wkxKh/diXeeDy5slQTthsu0AD+EAk2AaioteAuubyuig0SDH81Q
+gkwkr733pbTIWg/050deSY43lv6aiAU62cDbKYfmGZZHpzqmjIs8d/5GY6dT2iHR
+rH5Jokvmw2dZL7OKDrssvamqQnw1wdh/1acxOk5jQzmvCLBhNIzTmKlDNPYPhyk7
+ncJWWJh3w/cbrPad+D6qp1RF8PX51TFl/mtYnHGzHtdS6jIX/EBgHcl5JLL2bP2o
+Zg6C3ZjL2sJETy6ge/L3ayx2EYRGinij4w==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh
+MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE
+YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3
+MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo
+ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg
+MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN
+ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA
+PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w
+wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi
+EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY
+avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+
+YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE
+sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h
+/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5
+IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
+ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy
+OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P
+TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ
+HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER
+dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf
+ReYNnyicsbkqWletNw+vHX/bvZ8=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICWjCCAcMCAgGlMA0GCSqGSIb3DQEBBAUAMHUxCzAJBgNVBAYTAlVTMRgwFgYD
+VQQKEw9HVEUgQ29ycG9yYXRpb24xJzAlBgNVBAsTHkdURSBDeWJlclRydXN0IFNv
+bHV0aW9ucywgSW5jLjEjMCEGA1UEAxMaR1RFIEN5YmVyVHJ1c3QgR2xvYmFsIFJv
+b3QwHhcNOTgwODEzMDAyOTAwWhcNMTgwODEzMjM1OTAwWjB1MQswCQYDVQQGEwJV
+UzEYMBYGA1UEChMPR1RFIENvcnBvcmF0aW9uMScwJQYDVQQLEx5HVEUgQ3liZXJU
+cnVzdCBTb2x1dGlvbnMsIEluYy4xIzAhBgNVBAMTGkdURSBDeWJlclRydXN0IEds
+b2JhbCBSb290MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVD6C28FCc6HrH
+iM3dFw4usJTQGz0O9pTAipTHBsiQl8i4ZBp6fmw8U+E3KHNgf7KXUwefU/ltWJTS
+r41tiGeA5u2ylc9yMcqlHHK6XALnZELn+aks1joNrI1CqiQBOeacPwGFVw1Yh0X4
+04Wqk2kmhXBIgD8SFcd5tB8FLztimQIDAQABMA0GCSqGSIb3DQEBBAUAA4GBAG3r
+GwnpXtlR22ciYaQqPEh346B8pt5zohQDhT37qw4wxYMWM4ETCJ57NE7fQMh017l9
+3PR2VX2bY1QY6fDq81yx2YtCHrnAlU66+tXifPVoYb+O7AWXX1uw16OFNMQkpw0P
+lZPvy5TYnh+dXIVtx6quTx8itc2VrbqnzPmrC3p/
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0
+IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz
+BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y
+aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG
+9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMTk1NFoXDTE5MDYy
+NjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y
+azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw
+Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl
+cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOOnHK5avIWZJV16vY
+dA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVCCSRrCl6zfN1SLUzm1NZ9
+WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7RfZHM047QS
+v4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9v
+UJSZSWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTu
+IYEZoDJJKPTEjlbVUjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwC
+W/POuZ6lcg5Ktz885hZo+L7tdEy8W9ViH0Pd
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0
+IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz
+BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y
+aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG
+9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNTIyMjM0OFoXDTE5MDYy
+NTIyMjM0OFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y
+azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw
+Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl
+cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDYWYJ6ibiWuqYvaG9Y
+LqdUHAZu9OqNSLwxlBfw8068srg1knaw0KWlAdcAAxIiGQj4/xEjm84H9b9pGib+
+TunRf50sQB1ZaG6m+FiwnRqP0z/x3BkGgagO4DrdyFNFCQbmD3DD+kCmDuJWBQ8Y
+TfwggtFzVXSNdnKgHZ0dwN0/cQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFBoPUn0
+LBwGlN+VYH+Wexf+T3GtZMjdd9LvWVXoP+iOBSoh8gfStadS/pyxtuJbdxdA6nLW
+I8sogTLDAHkY7FkXicnGah5xyf23dKUlRWnFSKsZ4UWKJWsZ7uW7EvV/96aNUcPw
+nXS3qT6gpf+2SQMT2iLM7XGCK5nPOrf1LXLI
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0
+IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz
+BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y
+aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG
+9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMjIzM1oXDTE5MDYy
+NjAwMjIzM1owgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y
+azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw
+Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl
+cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDjmFGWHOjVsQaBalfD
+cnWTq8+epvzzFlLWLU2fNUSoLgRNB0mKOCn1dzfnt6td3zZxFJmP3MKS8edgkpfs
+2Ejcv8ECIMYkpChMMFp2bbFc893enhBxoYjHW5tBbcqwuI4V7q0zK89HBFx1cQqY
+JJgpp0lZpd34t0NiYfPT4tBVPwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFa7AliE
+Zwgs3x/be0kz9dNnnfS0ChCzycUs4pJqcXgn8nCDQtM+z6lU9PHYkhaM0QTLS6vJ
+n0WuPIqpsHEzXcjFV9+vqDWzf4mH6eglkrh/hXqu1rweN1gqZ8mRzyqBPu3GOd/A
+PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICtzCCAiACAQAwDQYJKoZIhvcNAQEEBQAwgaMxCzAJBgNVBAYTAkVTMRIwEAYD
+VQQIEwlCQVJDRUxPTkExEjAQBgNVBAcTCUJBUkNFTE9OQTEZMBcGA1UEChMQSVBT
+IFNlZ3VyaWRhZCBDQTEYMBYGA1UECxMPQ2VydGlmaWNhY2lvbmVzMRcwFQYDVQQD
+Ew5JUFMgU0VSVklET1JFUzEeMBwGCSqGSIb3DQEJARYPaXBzQG1haWwuaXBzLmVz
+MB4XDTk4MDEwMTIzMjEwN1oXDTA5MTIyOTIzMjEwN1owgaMxCzAJBgNVBAYTAkVT
+MRIwEAYDVQQIEwlCQVJDRUxPTkExEjAQBgNVBAcTCUJBUkNFTE9OQTEZMBcGA1UE
+ChMQSVBTIFNlZ3VyaWRhZCBDQTEYMBYGA1UECxMPQ2VydGlmaWNhY2lvbmVzMRcw
+FQYDVQQDEw5JUFMgU0VSVklET1JFUzEeMBwGCSqGSIb3DQEJARYPaXBzQG1haWwu
+aXBzLmVzMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCsT1J0nznqjtwlxLyY
+XZhkJAk8IbPMGbWOlI6H0fg3PqHILVikgDVboXVsHUUMH2Fjal5vmwpMwci4YSM1
+gf/+rHhwLWjhOgeYlQJU3c0jt4BT18g3RXIGJBK6E2Ehim51KODFDzT9NthFf+G4
+Nu+z4cYgjui0OLzhPvYR3oydAQIDAQABMA0GCSqGSIb3DQEBBAUAA4GBACzzw3lY
+JN7GO9HgQmm47mSzPWIBubOE3yN93ZjPEKn+ANgilgUTB1RXxafey9m4iEL2mdsU
+dx+2/iU94aI+A6mB0i1sR/WWRowiq8jMDQ6XXotBtDvECgZAHd1G9AHduoIuPD14
+cJ58GNCr+Lh3B0Zx8coLY1xq+XKU1QFPoNtC
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICeTCCAeKgAwIBAgIBBDANBgkqhkiG9w0BAQUFADBqMQswCQYDVQQGEwJVUzEY
+MBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsT
+A1BLSTElMCMGA1UEAxMcSklUQyBEb0QgUEtJIENsYXNzIDMgUm9vdCBDQTAeFw0w
+MDAzMjExODU4NDBaFw0xMDAzMTkxODU4NDBaMGoxCzAJBgNVBAYTAlVTMRgwFgYD
+VQQKEw9VLlMuIEdvdmVybm1lbnQxDDAKBgNVBAsTA0RvRDEMMAoGA1UECxMDUEtJ
+MSUwIwYDVQQDExxKSVRDIERvRCBQS0kgQ2xhc3MgMyBSb290IENBMIGfMA0GCSqG
+SIb3DQEBAQUAA4GNADCBiQKBgQDRUOCEGYuPE/hkf/1670GY5DbacmoHjcfVOUNC
+HvEYvrUbF/V62q+oY63BWDeAMWoVSjsTYFGLW9VPLhpDh0QeKhBNrpjOhTGEsJE0
+ijKnolTQx/LsR00ZIWyZBGsQH0s3cu4QsM8uWKiBBuV9C5sMmJXFwMlarhfJToAg
+/ViPKQIDAQABoy8wLTAdBgNVHQ4EFgQUa5/49j2w6Ko9iPJjHSDv3Gwbd04wDAYD
+VR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOBgQCU8gI7V8QVwl4lMkGPJ3SaEqZB
+g2p/aFqmAYoRjZoun2CYUl6Zy/dJMYaWIC8lVedDui2u9v6/4JNmx8yU6JtpDjGW
+/HpLAwEuZjiWPIm+Wqiuz9LWDGXCLSS7XraHliW6YgPkgxeGoZllwdwFLZQ/j5fX
+UxtL7uDwQbYehVaw4g==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDdjCCAl6gAwIBAgIEOhsEBTANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJE
+SzEMMAoGA1UEChMDS01EMQ8wDQYDVQQLEwZLTUQtQ0ExIzAhBgNVBAMTGktNRC1D
+QSBLdmFsaWZpY2VyZXQgUGVyc29uMB4XDTAwMTEyMTIzMjQ1OVoXDTE1MTEyMjIz
+MjQ1OVowUTELMAkGA1UEBhMCREsxDDAKBgNVBAoTA0tNRDEPMA0GA1UECxMGS01E
+LUNBMSMwIQYDVQQDExpLTUQtQ0EgS3ZhbGlmaWNlcmV0IFBlcnNvbjCCASIwDQYJ
+KoZIhvcNAQEBBQADggEPADCCAQoCggEBANriF4Xd6yD7ZlBE317UBDObn+vRMVc6
+p3wNQODdEDJe2z1ncCz9NJvhoLGdOJhyg7VVPh0P2c+KZ9WI9mWOKZI2bp2WkLju
+jCcxbhTrurY3Wfc6gwLBqqFV8wWgaZKmvVWizjw9Kyi25f3yX4fOho6Qq2lvVbub
+tvVFXAd51GJ+/2Yed+a4Or2bz2RcqHS81B3pywsD4mgJR5xREv5jqPfwNP+V7bkc
+X+pfO4kVhZ/V+8MSPdQHgcV/iB3wP2mwgWyIBNc1reBidGTiz8unnWu55hcNfsvt
+LJbTs9OHhsR7naRuy+S402nDnD5vnONOFEsiHn46w+T0rtu7h6j4OvkCAwEAAaNW
+MFQwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUeWLqmhI42Jxj7DifDsW+
+DlQhKD0wHwYDVR0jBBgwFoAUeWLqmhI42Jxj7DifDsW+DlQhKD0wDQYJKoZIhvcN
+AQEFBQADggEBANML/P42OuJ9aUV/0fItuIyc1JhqWvSqn5bXj+9eyEegcp8bHLHY
+42D1O+z0lNipdjYPSdMJ0wZOEUhr+150SdDQ1P/zQL8AUaLEBkRt7ZdzXPVH3PER
+qnf9IrpYBknZKfCAoVchA6Rr9WU3Sd8bMoRfMLKg8c0M8G6EPwCTcOFriSkbtvNG
+zd8r8I+WfUYIN/p8DI9JT9qfjVODnYPRMUm6KPvq27TsrGruKrqyaV94kWc8co8A
+v3zFLeCtghvUiRBdx+8Q7m5t4CkuSr0WINrqjIPFW2QrM1r82y09Fd16RkqL4LOg
+Lh6vB5KnTApv62rWdw7zWwYnjY6/vXYY1Aw=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDWjCCAkKgAwIBAgIEO8rJUjANBgkqhkiG9w0BAQUFADBmMQswCQYDVQQGEwJE
+SzEMMAoGA1UEChMDS01EMQ8wDQYDVQQLEwZLTUQtQ0ExFjAUBgNVBAMTDUtNRC1D
+QSBTZXJ2ZXIxIDAeBgoJkiaJk/IsZAEDFBBpbmZvY2FAa21kLWNhLmRrMB4XDTk4
+MTAxNjE5MTkyMVoXDTE4MTAxMjE5MTkyMVowZjELMAkGA1UEBhMCREsxDDAKBgNV
+BAoTA0tNRDEPMA0GA1UECxMGS01ELUNBMRYwFAYDVQQDEw1LTUQtQ0EgU2VydmVy
+MSAwHgYKCZImiZPyLGQBAxQQaW5mb2NhQGttZC1jYS5kazCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBAJsLpbSgFxQ7IhFgf5f+RfBxnbCkx5C7yTjfCZvp
+/BP2LBD3OKjgLRwvASoCU3I5NMhccho6uhZVf1HC+Ac5HmXUUd+v92a7gDnohPPy
+Rgv8c6f/+R2fFen37SBemYFDtZveamVXZ2To7xAxNiMKgPTPs/Rl7F6LDsYgv1bD
+36FrjahNoSTmTbYRoK21eIOVwrZeNSzo9w3W8fj0n+V2IB1jsOh+AvjXkjbvAVky
+0/57GMlyBNKP7JIGP7LXqwWfrBXuAph1DUMz467KlHZOMkPwCjTZOab7CcLQXCCY
+12s5c5QAkwpf35hQRuOaNo6d/XFM6J9mofiWlGTT3Px1EX0CAwEAAaMQMA4wDAYD
+VR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAPlA6VZ2C2cJbsI0SBIe9v+M9
+GxI45QI7P0D7QGyrqM7oNqGq7hJdN6NFb0LyPcF3/pVzmtYVJzaGKF6spaxOEveB
+9ki1xRoXUKpaCxSweBpTzEktWa43OytRy0sbryEmHJCQkz8MPufWssf2yXHzgFFo
+XMQpcMyT7JwxPlfYVvab9Kp+nW7fIyDOG0wdmBerZ+GEQJxJEkri1HskjigxhGze
+ziocJatBuOWgqw5KRylgGIQjUGRTCbODVta+Kmqb9d+cB7FStbYtt2HebOXzBIY3
+XUM5KtGC++We7DqgU5Firek7brw8i2XsHPLKJTceb6Xo6DsSxLfBAWV6+8DCkQ==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFTzCCBLigAwIBAgIBaDANBgkqhkiG9w0BAQQFADCBmzELMAkGA1UEBhMCSFUx
+ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0
+b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMTQwMgYDVQQD
+EytOZXRMb2NrIEV4cHJlc3N6IChDbGFzcyBDKSBUYW51c2l0dmFueWtpYWRvMB4X
+DTk5MDIyNTE0MDgxMVoXDTE5MDIyMDE0MDgxMVowgZsxCzAJBgNVBAYTAkhVMREw
+DwYDVQQHEwhCdWRhcGVzdDEnMCUGA1UEChMeTmV0TG9jayBIYWxvemF0Yml6dG9u
+c2FnaSBLZnQuMRowGAYDVQQLExFUYW51c2l0dmFueWtpYWRvazE0MDIGA1UEAxMr
+TmV0TG9jayBFeHByZXNzeiAoQ2xhc3MgQykgVGFudXNpdHZhbnlraWFkbzCBnzAN
+BgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA6+ywbGGKIyWvYCDj2Z/8kwvbXY2wobNA
+OoLO/XXgeDIDhlqGlZHtU/qdQPzm6N3ZW3oDvV3zOwzDUXmbrVWg6dADEK8KuhRC
+2VImESLH0iDMgqSaqf64gXadarfSNnU+sYYJ9m5tfk63euyucYT2BDMIJTLrdKwW
+RMbkQJMdf60CAwEAAaOCAp8wggKbMBIGA1UdEwEB/wQIMAYBAf8CAQQwDgYDVR0P
+AQH/BAQDAgAGMBEGCWCGSAGG+EIBAQQEAwIABzCCAmAGCWCGSAGG+EIBDQSCAlEW
+ggJNRklHWUVMRU0hIEV6ZW4gdGFudXNpdHZhbnkgYSBOZXRMb2NrIEtmdC4gQWx0
+YWxhbm9zIFN6b2xnYWx0YXRhc2kgRmVsdGV0ZWxlaWJlbiBsZWlydCBlbGphcmFz
+b2sgYWxhcGphbiBrZXN6dWx0LiBBIGhpdGVsZXNpdGVzIGZvbHlhbWF0YXQgYSBO
+ZXRMb2NrIEtmdC4gdGVybWVrZmVsZWxvc3NlZy1iaXp0b3NpdGFzYSB2ZWRpLiBB
+IGRpZ2l0YWxpcyBhbGFpcmFzIGVsZm9nYWRhc2FuYWsgZmVsdGV0ZWxlIGF6IGVs
+b2lydCBlbGxlbm9yemVzaSBlbGphcmFzIG1lZ3RldGVsZS4gQXogZWxqYXJhcyBs
+ZWlyYXNhIG1lZ3RhbGFsaGF0byBhIE5ldExvY2sgS2Z0LiBJbnRlcm5ldCBob25s
+YXBqYW4gYSBodHRwczovL3d3dy5uZXRsb2NrLm5ldC9kb2NzIGNpbWVuIHZhZ3kg
+a2VyaGV0byBheiBlbGxlbm9yemVzQG5ldGxvY2submV0IGUtbWFpbCBjaW1lbi4g
+SU1QT1JUQU5UISBUaGUgaXNzdWFuY2UgYW5kIHRoZSB1c2Ugb2YgdGhpcyBjZXJ0
+aWZpY2F0ZSBpcyBzdWJqZWN0IHRvIHRoZSBOZXRMb2NrIENQUyBhdmFpbGFibGUg
+YXQgaHR0cHM6Ly93d3cubmV0bG9jay5uZXQvZG9jcyBvciBieSBlLW1haWwgYXQg
+Y3BzQG5ldGxvY2submV0LjANBgkqhkiG9w0BAQQFAAOBgQAQrX/XDDKACtiG8XmY
+ta3UzbM2xJZIwVzNmtkFLp++UOv0JhQQLdRmF/iewSf98e3ke0ugbLWrmldwpu2g
+pO0u9f38vf5NNwgMvOOWgyL1SRt/Syu0VMGAfJlOHdCM7tCs5ZL6dVb+ZKATj7i4
+Fp1hBWeAyNDYpQcCNJgEjTME1A==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFSzCCBLSgAwIBAgIBaTANBgkqhkiG9w0BAQQFADCBmTELMAkGA1UEBhMCSFUx
+ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0
+b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMTIwMAYDVQQD
+EylOZXRMb2NrIFV6bGV0aSAoQ2xhc3MgQikgVGFudXNpdHZhbnlraWFkbzAeFw05
+OTAyMjUxNDEwMjJaFw0xOTAyMjAxNDEwMjJaMIGZMQswCQYDVQQGEwJIVTERMA8G
+A1UEBxMIQnVkYXBlc3QxJzAlBgNVBAoTHk5ldExvY2sgSGFsb3phdGJpenRvbnNh
+Z2kgS2Z0LjEaMBgGA1UECxMRVGFudXNpdHZhbnlraWFkb2sxMjAwBgNVBAMTKU5l
+dExvY2sgVXpsZXRpIChDbGFzcyBCKSBUYW51c2l0dmFueWtpYWRvMIGfMA0GCSqG
+SIb3DQEBAQUAA4GNADCBiQKBgQCx6gTsIKAjwo84YM/HRrPVG/77uZmeBNwcf4xK
+gZjupNTKihe5In+DCnVMm8Bp2GQ5o+2So/1bXHQawEfKOml2mrriRBf8TKPV/riX
+iK+IA4kfpPIEPsgHC+b5sy96YhQJRhTKZPWLgLViqNhr1nGTLbO/CVRY7QbrqHvc
+Q7GhaQIDAQABo4ICnzCCApswEgYDVR0TAQH/BAgwBgEB/wIBBDAOBgNVHQ8BAf8E
+BAMCAAYwEQYJYIZIAYb4QgEBBAQDAgAHMIICYAYJYIZIAYb4QgENBIICURaCAk1G
+SUdZRUxFTSEgRXplbiB0YW51c2l0dmFueSBhIE5ldExvY2sgS2Z0LiBBbHRhbGFu
+b3MgU3pvbGdhbHRhdGFzaSBGZWx0ZXRlbGVpYmVuIGxlaXJ0IGVsamFyYXNvayBh
+bGFwamFuIGtlc3p1bHQuIEEgaGl0ZWxlc2l0ZXMgZm9seWFtYXRhdCBhIE5ldExv
+Y2sgS2Z0LiB0ZXJtZWtmZWxlbG9zc2VnLWJpenRvc2l0YXNhIHZlZGkuIEEgZGln
+aXRhbGlzIGFsYWlyYXMgZWxmb2dhZGFzYW5hayBmZWx0ZXRlbGUgYXogZWxvaXJ0
+IGVsbGVub3J6ZXNpIGVsamFyYXMgbWVndGV0ZWxlLiBBeiBlbGphcmFzIGxlaXJh
+c2EgbWVndGFsYWxoYXRvIGEgTmV0TG9jayBLZnQuIEludGVybmV0IGhvbmxhcGph
+biBhIGh0dHBzOi8vd3d3Lm5ldGxvY2submV0L2RvY3MgY2ltZW4gdmFneSBrZXJo
+ZXRvIGF6IGVsbGVub3J6ZXNAbmV0bG9jay5uZXQgZS1tYWlsIGNpbWVuLiBJTVBP
+UlRBTlQhIFRoZSBpc3N1YW5jZSBhbmQgdGhlIHVzZSBvZiB0aGlzIGNlcnRpZmlj
+YXRlIGlzIHN1YmplY3QgdG8gdGhlIE5ldExvY2sgQ1BTIGF2YWlsYWJsZSBhdCBo
+dHRwczovL3d3dy5uZXRsb2NrLm5ldC9kb2NzIG9yIGJ5IGUtbWFpbCBhdCBjcHNA
+bmV0bG9jay5uZXQuMA0GCSqGSIb3DQEBBAUAA4GBAATbrowXr/gOkDFOzT4JwG06
+sPgzTEdM43WIEJessDgVkcYplswhwG08pXTP2IKlOcNl40JwuyKQ433bNXbhoLXa
+n3BukxowOR0w2y7jfLKRstE3Kfq51hdcR0/jHTjrn9V7lagonhVK0dHQKwCXoOKS
+NitjrFgBazMpUIaD8QFI
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEajCCA1KgAwIBAgIBATANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJKUDEN
+MAsGA1UECgwESlBLSTEpMCcGA1UECwwgUHJlZmVjdHVyYWwgQXNzb2NpYXRpb24g
+Rm9yIEpQS0kxETAPBgNVBAsMCEJyaWRnZUNBMB4XDTAzMTIyNzA1MDgxNVoXDTEz
+MTIyNjE0NTk1OVowWjELMAkGA1UEBhMCSlAxDTALBgNVBAoMBEpQS0kxKTAnBgNV
+BAsMIFByZWZlY3R1cmFsIEFzc29jaWF0aW9uIEZvciBKUEtJMREwDwYDVQQLDAhC
+cmlkZ2VDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANTnUmg7K3m8
+52vd77kwkq156euwoWm5no8E8kmaTSc7x2RABPpqNTlMKdZ6ttsyYrqREeDkcvPL
+yF7yf/I8+innasNtsytcTAy8xY8Avsbd4JkCGW9dyPjk9pzzc3yLQ64Rx2fujRn2
+agcEVdPCr/XpJygX8FD5bbhkZ0CVoiASBmlHOcC3YpFlfbT1QcpOSOb7o+VdKVEi
+MMfbBuU2IlYIaSr/R1nO7RPNtkqkFWJ1/nKjKHyzZje7j70qSxb+BTGcNgTHa1YA
+UrogKB+UpBftmb4ds+XlkEJ1dvwokiSbCDaWFKD+YD4B2s0bvjCbw8xuZFYGhNyR
+/2D5XfN1s2MCAwEAAaOCATkwggE1MA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
+BTADAQH/MG0GA1UdHwRmMGQwYqBgoF6kXDBaMQswCQYDVQQGEwJKUDENMAsGA1UE
+CgwESlBLSTEpMCcGA1UECwwgUHJlZmVjdHVyYWwgQXNzb2NpYXRpb24gRm9yIEpQ
+S0kxETAPBgNVBAsMCEJyaWRnZUNBMIGDBgNVHREEfDB6pHgwdjELMAkGA1UEBhMC
+SlAxJzAlBgNVBAoMHuWFrOeahOWAi+S6uuiqjeiovOOCteODvOODk+OCuTEeMBwG
+A1UECwwV6YO96YGT5bqc55yM5Y2U6K2w5LyaMR4wHAYDVQQLDBXjg5bjg6rjg4Pj
+grjoqo3oqLzlsYAwHQYDVR0OBBYEFNQXMiCqQNkR2OaZmQgLtf8mR8p8MA0GCSqG
+SIb3DQEBBQUAA4IBAQATjJo4reTNPC5CsvAKu1RYT8PyXFVYHbKsEpGt4GR8pDCg
+HEGAiAhHSNrGh9CagZMXADvlG0gmMOnXowriQQixrtpkmx0TB8tNAlZptZWkZC+R
+8TnjOkHrk2nFAEC3ezbdK0R7MR4tJLDQCnhEWbg50rf0wZ/aF8uAaVeEtHXa6W0M
+Xq3dSe0XAcrLbX4zZHQTaWvdpLAIjl6DZ3SCieRMyoWUL+LXaLFdTP5WBCd+No58
+IounD9X4xxze2aeRVaiV/WnQ0OSPNS7n7YXy6xQdnaOU4KRW/Lne1EDf5IfWC/ih
+bVAmhZMbcrkWWcsR6aCPG+2mV3zTD6AUzuKPal8Y
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICXDCCAcWgAwIBAgIQCgEBAQAAAnwAAAALAAAAAjANBgkqhkiG9w0BAQUFADA6
+MRkwFwYDVQQKExBSU0EgU2VjdXJpdHkgSW5jMR0wGwYDVQQLExRSU0EgU2VjdXJp
+dHkgMTAyNCBWMzAeFw0wMTAyMjIyMTAxNDlaFw0yNjAyMjIyMDAxNDlaMDoxGTAX
+BgNVBAoTEFJTQSBTZWN1cml0eSBJbmMxHTAbBgNVBAsTFFJTQSBTZWN1cml0eSAx
+MDI0IFYzMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDV3f5mCc8kPD6ugU5O
+isRpgFtZO9+5TUzKtS3DJy08rwBCbbwoppbPf9dYrIMKo1W1exeQFYRMiu4mmdxY
+78c4pqqv0I5CyGLXq6yp+0p9v+r+Ek3d/yYtbzZUaMjShFbuklNhCbM/OZuoyZu9
+zp9+1BlqFikYvtc6adwlWzMaUQIDAQABo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAfBgNVHSMEGDAWgBTEwBykB5T9zU0B1FTapQxf3q4FWjAd
+BgNVHQ4EFgQUxMAcpAeU/c1NAdRU2qUMX96uBVowDQYJKoZIhvcNAQEFBQADgYEA
+Py1q4yZDlX2Jl2X7deRyHUZXxGFraZ8SmyzVWujAovBDleMf6XbN3Ou8k6BlCsdN
+T1+nr6JGFLkM88y9am63nd4lQtBU/55oc2PcJOsiv6hy8l4A4Q1OOkNumU4/iXgD
+mMrzVcydro7BqkWY+o8aoI2II/EVQQ2lRj6RP4vr93E=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDYTCCAkmgAwIBAgIQCgEBAQAAAnwAAAAKAAAAAjANBgkqhkiG9w0BAQUFADA6
+MRkwFwYDVQQKExBSU0EgU2VjdXJpdHkgSW5jMR0wGwYDVQQLExRSU0EgU2VjdXJp
+dHkgMjA0OCBWMzAeFw0wMTAyMjIyMDM5MjNaFw0yNjAyMjIyMDM5MjNaMDoxGTAX
+BgNVBAoTEFJTQSBTZWN1cml0eSBJbmMxHTAbBgNVBAsTFFJTQSBTZWN1cml0eSAy
+MDQ4IFYzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt49VcdKA3Xtp
+eafwGFAyPGJn9gqVB93mG/Oe2dJBVGutn3y+Gc37RqtBaB4Y6lXIL5F4iSj7Jylg
+/9+PjDvJSZu1pJTOAeo+tWN7fyb9Gd3AIb2E0S1PRsNO3Ng3OTsor8udGuorryGl
+wSMiuLgbWhOHV4PR8CDn6E8jQrAApX2J6elhc5SYcSa8LWrg903w8bYqODGBDSnh
+AMFRD0xS+ARaqn1y07iHKrtjEAMqs6FPDVpeRrc9DvV07Jmf+T0kgYim3WBU6JU2
+PcYJk5qjEoAAVZkZR73QpXzDuvsf9/UP+Ky5tfQ3mBMY3oVbtwyCO4dvlTlYMNpu
+AWgXIszACwIDAQABo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAfBgNVHSMEGDAWgBQHw1EwpKrpRa41JPr/JCwz0LGdjDAdBgNVHQ4EFgQUB8NR
+MKSq6UWuNST6/yQsM9CxnYwwDQYJKoZIhvcNAQEFBQADggEBAF8+hnZuuDU8TjYc
+HnmYv/3VEhF5Ug7uMYm83X/50cYVIeiKAVQNOvtUudZj1LGqlk2iQk3UUx+LEN5/
+Zb5gEydxiKRz44Rj0aRV4VCT5hsOedBnvEbIvz8XDZXmxpBp3ue0L96VfdASPz0+
+f00/FGj1EVDVwfSQpQgdMWD/YIwjVAqv/qFuxdF6Kmh4zx6CCiC0H63lhbJqaHVO
+rSU3lIW+vaHU6rcMSzyd6BIA8F+sDeGscGNz9395nzIlQnQFgCi/vcEkllgVsRch
+6YlL2weIZ/QVrXA+L02FO8K32/6YaCOJ4XQP3vTFhGMpG8zLB8kApKnXwiJPZ9d3
+7CAFYd4=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEPzCCAyegAwIBAgIBATANBgkqhkiG9w0BAQUFADB+MQswCQYDVQQGEwJHQjEb
+MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
+GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEkMCIGA1UEAwwbU2VjdXJlIENlcnRp
+ZmljYXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVow
+fjELMAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
+A1UEBwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxJDAiBgNV
+BAMMG1NlY3VyZSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBAMBxM4KK0HDrc4eCQNUd5MvJDkKQ+d40uaG6EfQlhfPM
+cm3ye5drswfxdySRXyWP9nQ95IDC+DwN879A6vfIUtFyb+/Iq0G4bi4XKpVpDM3S
+HpR7LZQdqnXXs5jLrLxkU0C8j6ysNstcrbvd4JQX7NFc0L/vpZXJkMWwrPsbQ996
+CF23uPJAGysnnlDOXmWCiIxe004MeuoIkbY2qitC++rCoznl2yY4rYsK7hljxxwk
+3wN42ubqwUcaCwtGCd0C/N7Lh1/XMGNooa7cMqG6vv5Eq2i2pRcV/b3Vp6ea5EQz
+6YiO/O1R65NxTq0B50SOqy3LqP4BSUjwwN3HaNiS/j0CAwEAAaOBxzCBxDAdBgNV
+HQ4EFgQUPNiTiMLAggnMAZkGkyDpnnAJY08wDgYDVR0PAQH/BAQDAgEGMA8GA1Ud
+EwEB/wQFMAMBAf8wgYEGA1UdHwR6MHgwO6A5oDeGNWh0dHA6Ly9jcmwuY29tb2Rv
+Y2EuY29tL1NlY3VyZUNlcnRpZmljYXRlU2VydmljZXMuY3JsMDmgN6A1hjNodHRw
+Oi8vY3JsLmNvbW9kby5uZXQvU2VjdXJlQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmww
+DQYJKoZIhvcNAQEFBQADggEBAIcBbSMdflsXfcFhMs+P5/OKlFlm4J4oqF7Tt/Q0
+5qo5spcWxYJvMqTpjOev/e/C6LlLqqP05tqNZSH7uoDrJiiFGv45jN5bBAS0VPmj
+Z55B+glSzAVIqMk/IQQezkhr/IXownuvf7fM+F86/TXGDe+X3EyrEeFryzHRbPtI
+gKvcnDe4IRRLDXE97IMzbtFuMhbsmMcWi1mmNKsFVy2T96oTy9IT4rcuO81rUBcJ
+aD61JlfutuC23bkpgHl9j6PwpCikFcSF9CfUa7/lXORlAnZUtOM3ZiTTGWHIUhDl
+izeauan5Hb/qmZJhlv8BzaFfDbxxvA6sCx1HRR3B7Hzs/Sk=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICNDCCAaECEAKtZn5ORf5eV288mBle3cAwDQYJKoZIhvcNAQECBQAwXzELMAkG
+A1UEBhMCVVMxIDAeBgNVBAoTF1JTQSBEYXRhIFNlY3VyaXR5LCBJbmMuMS4wLAYD
+VQQLEyVTZWN1cmUgU2VydmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk0
+MTEwOTAwMDAwMFoXDTEwMDEwNzIzNTk1OVowXzELMAkGA1UEBhMCVVMxIDAeBgNV
+BAoTF1JTQSBEYXRhIFNlY3VyaXR5LCBJbmMuMS4wLAYDVQQLEyVTZWN1cmUgU2Vy
+dmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGbMA0GCSqGSIb3DQEBAQUAA4GJ
+ADCBhQJ+AJLOesGugz5aqomDV6wlAXYMra6OLDfO6zV4ZFQD5YRAUcm/jwjiioII
+0haGN1XpsSECrXZogZoFokvJSyVmIlZsiAeP94FZbYQHZXATcXY+m3dM41CJVphI
+uR2nKRoTLkoRWZweFdVJVCxzOmmCsZc5nG1wZ0jl3S3WyB57AgMBAAEwDQYJKoZI
+hvcNAQECBQADfgBl3X7hsuyw4jrg7HFGmhkRuNPHoLQDQCYCPgmc4RKz0Vr2N6W3
+YQO2WxZpO8ZECAyIUwxrl0nHPjXcbLm7qt9cuzovk2C2qUtN8iD3zV9/ZHuO3ABc
+1/p3yjkWWW8O6tO1g39NTUJWdrTJXwT4OPjr0l91X817/OWOgHz8UA==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIID+zCCAuOgAwIBAgIENuWNnjANBgkqhkiG9w0BAQUFADCBtDELMAkGA1UEBhMC
+VVkxKzApBgNVBAoTIkFETUlOSVNUUkFDSU9OIE5BQ0lPTkFMIERFIENPUlJFT1Mx
+HzAdBgNVBAsTFlNFUlZJQ0lPUyBFTEVDVFJPTklDT1MxLDAqBgNVBAMTI1NFUlZJ
+Q0lPUyBERSBDRVJUSUZJQ0FDSU9OIC0gQS5OLkMuMSkwJwYKCZImiZPyLGQBAxQZ
+Y29ycmVvX2NlcnRAY29ycmVvLmNvbS51eTAeFw05OTAzMDkyMTA4MDdaFw0wOTAz
+MDkyMTA4MDdaMIG0MQswCQYDVQQGEwJVWTErMCkGA1UEChMiQURNSU5JU1RSQUNJ
+T04gTkFDSU9OQUwgREUgQ09SUkVPUzEfMB0GA1UECxMWU0VSVklDSU9TIEVMRUNU
+Uk9OSUNPUzEsMCoGA1UEAxMjU0VSVklDSU9TIERFIENFUlRJRklDQUNJT04gLSBB
+Lk4uQy4xKTAnBgoJkiaJk/IsZAEDFBljb3JyZW9fY2VydEBjb3JyZW8uY29tLnV5
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsiov7CtZakOTiUYqiuXs
++gX64sjeQWuvA9sAWu9IN89XifvdyZIQ3ncDlRyQPse2ZyU7VZjv2Tz+JuSKO0Sp
+dDeDCncndLipca3dlxPSyqIuuLqdyb5Z6Nly8oqFZhxHXrSHgtYP32cmpr02sfNd
+kFBRdjIsOy+qX2Fe41TVEl3/DY0Rx4J6Nt/hTBbEdN0tau/QsfAzp/6/N2dDEi55
+SpSvhPsHEQhOMJN16QFUzsXeFIbwrq6bciUPRHfi82yveZwuSceemHYyFpq8AN7g
+tCAFkRfdgBUU7jZBxCGP7tkAShnGcWGlEV0AO+SndGw6Sm6D4HoxXCFl+AiHQodn
+5QIDAQABoxMwETAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQCZ
+H0kiXPhlf4NukGYvAs+09lY6Zjaht5INNsNFWDZL5szxWsxzMp6aqK7Tduvv/oAs
+4xA0skefHCVq6ES1j0y+gfPQwMELzQMWoEJVVk7B47QgrV+btlVfSBAS7ySzVnzM
+BRuyySqpaBGSfi/pP0Tx0MaQG0vd92Ei7GmGFUCz4qVqd/Oz8lQn2kkqZBn0Od58
+dobZnHJXCjT19S/QOWgb20WlGOOAVDuTEJAUwhQBqqV2LX0P5Fbz/3Mqb47B2ID7
+u5AdGxpJnARjxEId82+7s0lK3UftSboCLSqMxwNWueJo0MGwhrWMSzqujRyIhEz9
+UK+ZJnYIwoCtKHlV0y3m
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDIDCCAgigAwIBAgIBJDANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP
+MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MxIENBMB4XDTAx
+MDQwNjEwNDkxM1oXDTIxMDQwNjEwNDkxM1owOTELMAkGA1UEBhMCRkkxDzANBgNV
+BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMSBDQTCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBALWJHytPZwp5/8Ue+H887dF+2rDNbS82rDTG
+29lkFwhjMDMiikzujrsPDUJVyZ0upe/3p4zDq7mXy47vPxVnqIJyY1MPQYx9EJUk
+oVqlBvqSV536pQHydekfvFYmUk54GWVYVQNYwBSujHxVX3BbdyMGNpfzJLWaRpXk
+3w0LBUXl0fIdgrvGE+D+qnr9aTCU89JFhfzyMlsy3uhsXR/LpCJ0sICOXZT3BgBL
+qdReLjVQCfOAl/QMF6452F/NM8EcyonCIvdFEu1eEpOdY6uCLrnrQkFEy0oaAIIN
+nvmLVz5MxxftLItyM19yejhW1ebZrgUaHXVFsculJRwSVzb9IjcCAwEAAaMzMDEw
+DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQIR+IMi/ZTiFIwCwYDVR0PBAQDAgEG
+MA0GCSqGSIb3DQEBBQUAA4IBAQCLGrLJXWG04bkruVPRsoWdd44W7hE928Jj2VuX
+ZfsSZ9gqXLar5V7DtxYvyOirHYr9qxp81V9jz9yw3Xe5qObSIjiHBxTZ/75Wtf0H
+DjxVyhbMp6Z3N/vbXB9OWQaHowND9Rart4S9Tu+fMTfwRvFAttEMpWT4Y14h21VO
+TzF2nBBhjrZTOqMRvq9tfB69ri3iDGnHhVNoomG6xT60eVR4ngrHAr5i0RGCS2Uv
+kVrCqIexVmiUefkl98HVrhq4uz2PqYo4Ffdz0Fpg0YCw8NzVUM1O7pJIae2yIx4w
+zMiUyLb1O4Z/P6Yun/Y+LLWSlj7fLJOK/4GMDw9ZIRlXvVWa
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDIDCCAgigAwIBAgIBHTANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP
+MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MyIENBMB4XDTAx
+MDQwNjA3Mjk0MFoXDTIxMDQwNjA3Mjk0MFowOTELMAkGA1UEBhMCRkkxDzANBgNV
+BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMiBDQTCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAJAXSjWdyvANlsdE+hY3/Ei9vX+ALTU74W+o
+Z6m/AxxNjG8yR9VBaKQTBME1DJqEQ/xcHf+Js+gXGM2RX/uJ4+q/Tl18GybTdXnt
+5oTjV+WtKcT0OijnpXuENmmz/V52vaMtmdOQTiMofRhj8VQ7Jp12W5dCsv+u8E7s
+3TmVToMGf+dJQMjFAbJUWmYdPfz56TwKnoG4cPABi+QjVHzIrviQHgCWctRUz2Ej
+vOr7nQKV0ba5cTppCD8PtOFCx4j1P5iop7oc4HFx71hXgVB6XGt0Rg6DA5jDjqhu
+8nYybieDwnPz3BjotJPqdURrBGAgcVeHnfO+oJAjPYok4doh28MCAwEAAaMzMDEw
+DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQISqCqWITTXjwwCwYDVR0PBAQDAgEG
+MA0GCSqGSIb3DQEBBQUAA4IBAQBazof5FnIVV0sd2ZvnoiYw7JNn39Yt0jSv9zil
+zqsWuasvfDXLrNAPtEwr/IDva4yRXzZ299uzGxnq9LIR/WFxRL8oszodv7ND6J+/
+3DEIcbCdjdY0RzKQxmUk96BKfARzjzlvF4xytb1LyHr4e4PDKE6cCepnP7JnBBvD
+FNr450kkkdAdavphOe9r5yF1BgfYErQhIHBCcYHaPJo2vqZbDWpsmh+Re/n570K6
+Tk6ezAyNlNzZRZxe7EJQY670XcSxEtzKO6gunRRaBXW37Ndj4ro1tgQIkejanZz2
+ZrUYrAqmVCY0M9IbwdR/GjqOC6oybtv8TyWf2TLHllpwrN9M
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl
+MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp
+U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw
+NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE
+ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp
+ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3
+DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf
+8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN
++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0
+X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa
+K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA
+1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G
+A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR
+zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0
+YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD
+bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w
+DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3
+L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D
+eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl
+xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp
+VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY
+WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDXDCCAsWgAwIBAgICA+kwDQYJKoZIhvcNAQEEBQAwgbwxCzAJBgNVBAYTAkRF
+MRAwDgYDVQQIEwdIYW1idXJnMRAwDgYDVQQHEwdIYW1idXJnMTowOAYDVQQKEzFU
+QyBUcnVzdENlbnRlciBmb3IgU2VjdXJpdHkgaW4gRGF0YSBOZXR3b3JrcyBHbWJI
+MSIwIAYDVQQLExlUQyBUcnVzdENlbnRlciBDbGFzcyAxIENBMSkwJwYJKoZIhvcN
+AQkBFhpjZXJ0aWZpY2F0ZUB0cnVzdGNlbnRlci5kZTAeFw05ODAzMDkxMTU5NTla
+Fw0xMTAxMDExMTU5NTlaMIG8MQswCQYDVQQGEwJERTEQMA4GA1UECBMHSGFtYnVy
+ZzEQMA4GA1UEBxMHSGFtYnVyZzE6MDgGA1UEChMxVEMgVHJ1c3RDZW50ZXIgZm9y
+IFNlY3VyaXR5IGluIERhdGEgTmV0d29ya3MgR21iSDEiMCAGA1UECxMZVEMgVHJ1
+c3RDZW50ZXIgQ2xhc3MgMSBDQTEpMCcGCSqGSIb3DQEJARYaY2VydGlmaWNhdGVA
+dHJ1c3RjZW50ZXIuZGUwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALAp67R2
+s67Xtlu0Xue947GcSQRXW6Gr2X8TG/26YavY53HfLQCUXVFIfSPvdWKEkDwKH1kR
+dC+OgKX9MAI9KVLNchpJIZy8y1KOSKFjlsgQhTBpV3RFwFqGxtU94GhXfTFqJI1F
+lz4xfmhmMm4kbewyNslByvAxRMijYcoboDYfAgMBAAGjazBpMA8GA1UdEwEB/wQF
+MAMBAf8wDgYDVR0PAQH/BAQDAgGGMDMGCWCGSAGG+EIBCAQmFiRodHRwOi8vd3d3
+LnRydXN0Y2VudGVyLmRlL2d1aWRlbGluZXMwEQYJYIZIAYb4QgEBBAQDAgAHMA0G
+CSqGSIb3DQEBBAUAA4GBAE+ZWYXIZFaCxW892EYJLzxRwadwWIGSEur01BYAll5y
+KOfWNl8anK8fwoMatAVVmaZYXDco8lce612/sdNFD3IcA9IAxyxV2v5fiXaL4tR3
+9U0JF6/EuqswK0+4HerZ/1nwUHRGul7qNrDrknsPWNoy4VK9IzcP9fMASq6wXt5u
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDXDCCAsWgAwIBAgICA+owDQYJKoZIhvcNAQEEBQAwgbwxCzAJBgNVBAYTAkRF
+MRAwDgYDVQQIEwdIYW1idXJnMRAwDgYDVQQHEwdIYW1idXJnMTowOAYDVQQKEzFU
+QyBUcnVzdENlbnRlciBmb3IgU2VjdXJpdHkgaW4gRGF0YSBOZXR3b3JrcyBHbWJI
+MSIwIAYDVQQLExlUQyBUcnVzdENlbnRlciBDbGFzcyAyIENBMSkwJwYJKoZIhvcN
+AQkBFhpjZXJ0aWZpY2F0ZUB0cnVzdGNlbnRlci5kZTAeFw05ODAzMDkxMTU5NTla
+Fw0xMTAxMDExMTU5NTlaMIG8MQswCQYDVQQGEwJERTEQMA4GA1UECBMHSGFtYnVy
+ZzEQMA4GA1UEBxMHSGFtYnVyZzE6MDgGA1UEChMxVEMgVHJ1c3RDZW50ZXIgZm9y
+IFNlY3VyaXR5IGluIERhdGEgTmV0d29ya3MgR21iSDEiMCAGA1UECxMZVEMgVHJ1
+c3RDZW50ZXIgQ2xhc3MgMiBDQTEpMCcGCSqGSIb3DQEJARYaY2VydGlmaWNhdGVA
+dHJ1c3RjZW50ZXIuZGUwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANo46O0y
+AClxgwENv4wB3NrGrTmkqYov1YtcaF9QxmL1Zr3KkSLsqh1R1z2zUbKDTl3LSbDw
+TFXlay3HhQswHJJOgtTKAu33b77c4OMUuAVT8pr0VotanoWT0bSCVq5Nu6hLVxa8
+/vhYnvgpjbB7zXjJT6yLZwzxnPv8V5tXXE8NAgMBAAGjazBpMA8GA1UdEwEB/wQF
+MAMBAf8wDgYDVR0PAQH/BAQDAgGGMDMGCWCGSAGG+EIBCAQmFiRodHRwOi8vd3d3
+LnRydXN0Y2VudGVyLmRlL2d1aWRlbGluZXMwEQYJYIZIAYb4QgEBBAQDAgAHMA0G
+CSqGSIb3DQEBBAUAA4GBAIRS+yjf/x91AbwBvgRWl2p0QiQxg/lGsQaKic+WLDO/
+jLVfenKhhQbOhvgFjuj5Jcrag4wGrOs2bYWRNAQ29ELw+HkuCkhcq8xRT3h2oNms
+Gb0q0WkEKJHKNhAngFdb0lz1wlurZIFjdFH0l7/NEij3TWZ/p/AcASZ4smZHcFFk
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDXDCCAsWgAwIBAgICA+swDQYJKoZIhvcNAQEEBQAwgbwxCzAJBgNVBAYTAkRF
+MRAwDgYDVQQIEwdIYW1idXJnMRAwDgYDVQQHEwdIYW1idXJnMTowOAYDVQQKEzFU
+QyBUcnVzdENlbnRlciBmb3IgU2VjdXJpdHkgaW4gRGF0YSBOZXR3b3JrcyBHbWJI
+MSIwIAYDVQQLExlUQyBUcnVzdENlbnRlciBDbGFzcyAzIENBMSkwJwYJKoZIhvcN
+AQkBFhpjZXJ0aWZpY2F0ZUB0cnVzdGNlbnRlci5kZTAeFw05ODAzMDkxMTU5NTla
+Fw0xMTAxMDExMTU5NTlaMIG8MQswCQYDVQQGEwJERTEQMA4GA1UECBMHSGFtYnVy
+ZzEQMA4GA1UEBxMHSGFtYnVyZzE6MDgGA1UEChMxVEMgVHJ1c3RDZW50ZXIgZm9y
+IFNlY3VyaXR5IGluIERhdGEgTmV0d29ya3MgR21iSDEiMCAGA1UECxMZVEMgVHJ1
+c3RDZW50ZXIgQ2xhc3MgMyBDQTEpMCcGCSqGSIb3DQEJARYaY2VydGlmaWNhdGVA
+dHJ1c3RjZW50ZXIuZGUwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALa0wTUF
+Lg2N7KBAahwOJ6ZQkmtQGwfeLud2zODa/ISoXoxjaitN2U4CdhHBC/KNecoAtvGw
+Dtf7pBc9r6tpepYnv68zoZoqWarEtTcI8hKlMbZD9TKWcSgoq40oht+77uMMfTDW
+w1Krj10nnGvAo+cFa1dJRLNu6mTP0o56UHd3AgMBAAGjazBpMA8GA1UdEwEB/wQF
+MAMBAf8wDgYDVR0PAQH/BAQDAgGGMDMGCWCGSAGG+EIBCAQmFiRodHRwOi8vd3d3
+LnRydXN0Y2VudGVyLmRlL2d1aWRlbGluZXMwEQYJYIZIAYb4QgEBBAQDAgAHMA0G
+CSqGSIb3DQEBBAUAA4GBABY9xs3Bu4VxhUafPiCPUSiZ7C1FIWMjWwS7TJC4iJIE
+Tb19AaM/9uzO8d7+feXhPrvGq14L3T2WxMup1Pkm5gZOngylerpuw3yCGdHHsbHD
+2w2Om0B8NwvxXej9H5CIpQ5ON2QhqE6NtJ/x3kit1VYYUimLRzQSCdS7kjXvD9s0
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDXDCCAsWgAwIBAgICA+wwDQYJKoZIhvcNAQEEBQAwgbwxCzAJBgNVBAYTAkRF
+MRAwDgYDVQQIEwdIYW1idXJnMRAwDgYDVQQHEwdIYW1idXJnMTowOAYDVQQKEzFU
+QyBUcnVzdENlbnRlciBmb3IgU2VjdXJpdHkgaW4gRGF0YSBOZXR3b3JrcyBHbWJI
+MSIwIAYDVQQLExlUQyBUcnVzdENlbnRlciBDbGFzcyA0IENBMSkwJwYJKoZIhvcN
+AQkBFhpjZXJ0aWZpY2F0ZUB0cnVzdGNlbnRlci5kZTAeFw05ODAzMDkxMTU5NTla
+Fw0xMTAxMDExMTU5NTlaMIG8MQswCQYDVQQGEwJERTEQMA4GA1UECBMHSGFtYnVy
+ZzEQMA4GA1UEBxMHSGFtYnVyZzE6MDgGA1UEChMxVEMgVHJ1c3RDZW50ZXIgZm9y
+IFNlY3VyaXR5IGluIERhdGEgTmV0d29ya3MgR21iSDEiMCAGA1UECxMZVEMgVHJ1
+c3RDZW50ZXIgQ2xhc3MgNCBDQTEpMCcGCSqGSIb3DQEJARYaY2VydGlmaWNhdGVA
+dHJ1c3RjZW50ZXIuZGUwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAL8vY9Y2
+e7IN01X1ZGzmJV3GtMgUuiU4g+tWYqVVqWWj9COZwku50M1UZ6ajoKOpMyt25L2t
+d7LtXBJ0w8W2D1KacpNDkGJmFQ9Fpd3g3bhvQG5XwXlyo2CqunYdEolTWvwCvuEJ
+E8VKL9w9ixmt14skRftM9M1cNR0pTFHz8mxVAgMBAAGjazBpMA8GA1UdEwEB/wQF
+MAMBAf8wDgYDVR0PAQH/BAQDAgGGMDMGCWCGSAGG+EIBCAQmFiRodHRwOi8vd3d3
+LnRydXN0Y2VudGVyLmRlL2d1aWRlbGluZXMwEQYJYIZIAYb4QgEBBAQDAgAHMA0G
+CSqGSIb3DQEBBAUAA4GBAHIR5ZVBRTK6HPiAFPtmt+uums51g1HAroq7F9Eo53Yf
+E8YrRnGmFXcEmedespEkbwMMc+cjnnbKvgzFy8SQGPxtOm7gVoAbw9+MNhNH+WXB
+g1LVXFy92UJm4TUhaBIQpGCQPj+B6MOMobAVBFrO6yxUVkv5BHktneqMWS+teb1I
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDQzCCAqygAwIBAgICA/EwDQYJKoZIhvcNAQEEBQAwgcExCzAJBgNVBAYTAkRF
+MRAwDgYDVQQIEwdIYW1idXJnMRAwDgYDVQQHEwdIYW1idXJnMTowOAYDVQQKEzFU
+QyBUcnVzdENlbnRlciBmb3IgU2VjdXJpdHkgaW4gRGF0YSBOZXR3b3JrcyBHbWJI
+MSgwJgYDVQQLEx9UQyBUcnVzdENlbnRlciBUaW1lIFN0YW1waW5nIENBMSgwJgYD
+VQQDEx9UQyBUcnVzdENlbnRlciBUaW1lIFN0YW1waW5nIENBMB4XDTk4MDMwOTEx
+NTk1OVoXDTExMDEwMTExNTk1OVowgcExCzAJBgNVBAYTAkRFMRAwDgYDVQQIEwdI
+YW1idXJnMRAwDgYDVQQHEwdIYW1idXJnMTowOAYDVQQKEzFUQyBUcnVzdENlbnRl
+ciBmb3IgU2VjdXJpdHkgaW4gRGF0YSBOZXR3b3JrcyBHbWJIMSgwJgYDVQQLEx9U
+QyBUcnVzdENlbnRlciBUaW1lIFN0YW1waW5nIENBMSgwJgYDVQQDEx9UQyBUcnVz
+dENlbnRlciBUaW1lIFN0YW1waW5nIENBMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB
+iQKBgQC2S+Q2apwDjOkZb76H+fcwjD4vGE1U3ujMLAg9fEYvhAyd6+/7EZRj5+y0
+zRP9mvYwZcWKfciC0aO9EXsefr8v3GeBBFtwS+rhs7aYPbW+cNM+eV0LN5hYisP6
+mSiPAQRjHoB/d3LEXX//T1f/qslWd0Ot/BY3ajgvdEEZN6f/wwIDAQABo0gwRjAP
+BgNVHRMBAf8EBTADAQH/MDMGCWCGSAGG+EIBCAQmFiRodHRwOi8vd3d3LnRydXN0
+Y2VudGVyLmRlL2d1aWRlbGluZXMwDQYJKoZIhvcNAQEEBQADgYEALqyPthmgpIxe
+AbsJadYuBft2K2k118hvBqgb8tVfC8xL88FT9JW/nI5ss197C8bmnKfQLAM+1Tnh
+nG7rQfjJZEO4PaJK4R5PhZLXG0duPxfar+wWPo4aiS1BidZpL0OqXS7y6NBU7g0W
+xdpw2BJ0RK4WS3TtjAurNQpIaOxpAyk=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEKzCCAxOgAwIBAgIEOsylTDANBgkqhkiG9w0BAQUFADBDMQswCQYDVQQGEwJE
+SzEVMBMGA1UEChMMVERDIEludGVybmV0MR0wGwYDVQQLExRUREMgSW50ZXJuZXQg
+Um9vdCBDQTAeFw0wMTA0MDUxNjMzMTdaFw0yMTA0MDUxNzAzMTdaMEMxCzAJBgNV
+BAYTAkRLMRUwEwYDVQQKEwxUREMgSW50ZXJuZXQxHTAbBgNVBAsTFFREQyBJbnRl
+cm5ldCBSb290IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxLhA
+vJHVYx/XmaCLDEAedLdInUaMArLgJF/wGROnN4NrXceO+YQwzho7+vvOi20jxsNu
+Zp+Jpd/gQlBn+h9sHvTQBda/ytZO5GhgbEaqHF1j4QeGDmUApy6mcca8uYGoOn0a
+0vnRrEvLznWv3Hv6gXPU/Lq9QYjUdLP5Xjg6PEOo0pVOd20TDJ2PeAG3WiAfAzc1
+4izbSysseLlJ28TQx5yc5IogCSEWVmb/Bexb4/DPqyQkXsN/cHoSxNK1EKC2IeGN
+eGlVRGn1ypYcNIUXJXfi9i8nmHj9eQY6otZaQ8H/7AQ77hPv01ha/5Lr7K7a8jcD
+R0G2l8ktCkEiu7vmpwIDAQABo4IBJTCCASEwEQYJYIZIAYb4QgEBBAQDAgAHMGUG
+A1UdHwReMFwwWqBYoFakVDBSMQswCQYDVQQGEwJESzEVMBMGA1UEChMMVERDIElu
+dGVybmV0MR0wGwYDVQQLExRUREMgSW50ZXJuZXQgUm9vdCBDQTENMAsGA1UEAxME
+Q1JMMTArBgNVHRAEJDAigA8yMDAxMDQwNTE2MzMxN1qBDzIwMjEwNDA1MTcwMzE3
+WjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUbGQBx/2FbazI2p5QCIUItTxWqFAw
+HQYDVR0OBBYEFGxkAcf9hW2syNqeUAiFCLU8VqhQMAwGA1UdEwQFMAMBAf8wHQYJ
+KoZIhvZ9B0EABBAwDhsIVjUuMDo0LjADAgSQMA0GCSqGSIb3DQEBBQUAA4IBAQBO
+Q8zR3R0QGwZ/t6T609lN+yOfI1Rb5osvBCiLtSdtiaHsmGnc540mgwV5dOy0uaOX
+wTUA/RXaOYE6lTGQ3pfphqiZdwzlWqCE/xIWrG64jcN7ksKsLtB9KOy282A4aW8+
+2ARVPp7MVdK6/rtHBNcK2RYKNCn1WBPVT8+PVkuzHu7TmHnaCB4Mb7j4Fifvwm89
+9qNLPg7kbWzbO0ESm70NRyN/PErQr8Cv9u8btRXE64PECV90i9kR+8JWsTz4cMo0
+jUNAE4z9mQNUecYu6oah9jrUCbz0vGbMPVjQV0kK7iXiQe4T+Zs4NNEA9X7nlB38
+aQNiuJkFBT1reBK9sG9l
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFGTCCBAGgAwIBAgIEPki9xDANBgkqhkiG9w0BAQUFADAxMQswCQYDVQQGEwJE
+SzEMMAoGA1UEChMDVERDMRQwEgYDVQQDEwtUREMgT0NFUyBDQTAeFw0wMzAyMTEw
+ODM5MzBaFw0zNzAyMTEwOTA5MzBaMDExCzAJBgNVBAYTAkRLMQwwCgYDVQQKEwNU
+REMxFDASBgNVBAMTC1REQyBPQ0VTIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEArGL2YSCyz8DGhdfjeebM7fI5kqSXLmSjhFuHnEz9pPPEXyG9VhDr
+2y5h7JNp46PMvZnDBfwGuMo2HP6QjklMxFaaL1a8z3sM8W9Hpg1DTeLpHTk0zY0s
+2RKY+ePhwUp8hjjEqcRhiNJerxomTdXkoCJHhNlktxmW/OwZ5LKXJk5KTMuPJItU
+GBxIYXvViGjaXbXqzRowwYCDdlCqT9HU3Tjw7xb04QxQBr/q+3pJoSgrHPb8FTKj
+dGqPqcNiKXEx5TukYBdedObaE+3pHx8b0bJoc8YQNHVGEBDjkAB2QMuLt0MJIf+r
+TpPGWOmlgtt3xDqZsXKVSQTwtyv6e1mO3QIDAQABo4ICNzCCAjMwDwYDVR0TAQH/
+BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwgewGA1UdIASB5DCB4TCB3gYIKoFQgSkB
+AQEwgdEwLwYIKwYBBQUHAgEWI2h0dHA6Ly93d3cuY2VydGlmaWthdC5kay9yZXBv
+c2l0b3J5MIGdBggrBgEFBQcCAjCBkDAKFgNUREMwAwIBARqBgUNlcnRpZmlrYXRl
+ciBmcmEgZGVubmUgQ0EgdWRzdGVkZXMgdW5kZXIgT0lEIDEuMi4yMDguMTY5LjEu
+MS4xLiBDZXJ0aWZpY2F0ZXMgZnJvbSB0aGlzIENBIGFyZSBpc3N1ZWQgdW5kZXIg
+T0lEIDEuMi4yMDguMTY5LjEuMS4xLjARBglghkgBhvhCAQEEBAMCAAcwgYEGA1Ud
+HwR6MHgwSKBGoESkQjBAMQswCQYDVQQGEwJESzEMMAoGA1UEChMDVERDMRQwEgYD
+VQQDEwtUREMgT0NFUyBDQTENMAsGA1UEAxMEQ1JMMTAsoCqgKIYmaHR0cDovL2Ny
+bC5vY2VzLmNlcnRpZmlrYXQuZGsvb2Nlcy5jcmwwKwYDVR0QBCQwIoAPMjAwMzAy
+MTEwODM5MzBagQ8yMDM3MDIxMTA5MDkzMFowHwYDVR0jBBgwFoAUYLWF7FZkfhIZ
+J2cdUBVLc647+RIwHQYDVR0OBBYEFGC1hexWZH4SGSdnHVAVS3OuO/kSMB0GCSqG
+SIb2fQdBAAQQMA4bCFY2LjA6NC4wAwIEkDANBgkqhkiG9w0BAQUFAAOCAQEACrom
+JkbTc6gJ82sLMJn9iuFXehHTuJTXCRBuo7E4A9G28kNBKWKnctj7fAXmMXAnVBhO
+inxO5dHKjHiIzxvTkIvmI/gLDjNDfZziChmPyQE+dF10yYscA+UYyAFMP8uXBV2Y
+caaYb7Z8vTd/vuGTJW1v8AqtFxjhA7wHKcitJuj4YfD9IQl+mo6paH1IYnK9AOoB
+mbgGglGBTvH1tJFUuSN6AJqfXY3gPGS5GhKSKseCRHI53OI8xthV9RVOyAUO28bQ
+YqbsFbS1AoLbrIyigfCbmTH1ICCoiGEKB5+U/NDXG8wuF/MEJ3Zn61SD/aSQfgY9
+BKNDLdr8C2LqL19iUw==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDITCCAoqgAwIBAgIBADANBgkqhkiG9w0BAQQFADCByzELMAkGA1UEBhMCWkEx
+FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMRowGAYD
+VQQKExFUaGF3dGUgQ29uc3VsdGluZzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBT
+ZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhhd3RlIFBlcnNvbmFsIEJhc2lj
+IENBMSgwJgYJKoZIhvcNAQkBFhlwZXJzb25hbC1iYXNpY0B0aGF3dGUuY29tMB4X
+DTk2MDEwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgcsxCzAJBgNVBAYTAlpBMRUw
+EwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEaMBgGA1UE
+ChMRVGhhd3RlIENvbnN1bHRpbmcxKDAmBgNVBAsTH0NlcnRpZmljYXRpb24gU2Vy
+dmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQZXJzb25hbCBCYXNpYyBD
+QTEoMCYGCSqGSIb3DQEJARYZcGVyc29uYWwtYmFzaWNAdGhhd3RlLmNvbTCBnzAN
+BgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAvLyTU23AUE+CFeZIlDWmWr5vQvoPR+53
+dXLdjUmbllegeNTKP1GzaQuRdhciB5dqxFGTS+CN7zeVoQxN2jSQHReJl+A1OFdK
+wPQIcOk8RHtQfmGakOMj04gRRif1CwcOu93RfyAKiLlWCy4cgNrx454p7xS9CkT7
+G1sY0b8jkyECAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQQF
+AAOBgQAt4plrsD16iddZopQBHyvdEktTwq1/qqcAXJFAVyVKOKqEcLnZgA+le1z7
+c8a914phXAPjLSeoF+CEhULcXpvGt7Jtu3Sv5D/Lp7ew4F2+eIMllNLbgQ95B21P
+9DkVWlIBe94y1k049hJcBlDfBVu9FEuh3ym6O0GN92NWod8isQ==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDLTCCApagAwIBAgIBADANBgkqhkiG9w0BAQQFADCB0TELMAkGA1UEBhMCWkEx
+FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMRowGAYD
+VQQKExFUaGF3dGUgQ29uc3VsdGluZzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBT
+ZXJ2aWNlcyBEaXZpc2lvbjEkMCIGA1UEAxMbVGhhd3RlIFBlcnNvbmFsIEZyZWVt
+YWlsIENBMSswKQYJKoZIhvcNAQkBFhxwZXJzb25hbC1mcmVlbWFpbEB0aGF3dGUu
+Y29tMB4XDTk2MDEwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgdExCzAJBgNVBAYT
+AlpBMRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEa
+MBgGA1UEChMRVGhhd3RlIENvbnN1bHRpbmcxKDAmBgNVBAsTH0NlcnRpZmljYXRp
+b24gU2VydmljZXMgRGl2aXNpb24xJDAiBgNVBAMTG1RoYXd0ZSBQZXJzb25hbCBG
+cmVlbWFpbCBDQTErMCkGCSqGSIb3DQEJARYccGVyc29uYWwtZnJlZW1haWxAdGhh
+d3RlLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA1GnX1LCUZFtx6UfY
+DFG26nKRsIRefS0Nj3sS34UldSh0OkIsYyeflXtL734Zhx2G6qPduc6WZBrCFG5E
+rHzmj+hND3EfQDimAKOHePb5lIZererAXnbr2RSjXW56fAylS1V/Bhkpf56aJtVq
+uzgkCGqYx7Hao5iR/Xnb5VrEHLkCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zAN
+BgkqhkiG9w0BAQQFAAOBgQDH7JJ+Tvj1lqVnYiqk8E0RYNBvjWBYYawmu1I1XAjP
+MPuoSpaKH2JCI4wXD/S6ZJwXrEcp352YXtJsYHFcoqzceePnbgBHH7UNKOgCneSa
+/RP0ptl8sfjcXyMmCZGAc9AUG95DqYMl8uacLxXK/qarigd1iwzdUYRr5PjRznei
+gQ==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDKTCCApKgAwIBAgIBADANBgkqhkiG9w0BAQQFADCBzzELMAkGA1UEBhMCWkEx
+FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMRowGAYD
+VQQKExFUaGF3dGUgQ29uc3VsdGluZzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBT
+ZXJ2aWNlcyBEaXZpc2lvbjEjMCEGA1UEAxMaVGhhd3RlIFBlcnNvbmFsIFByZW1p
+dW0gQ0ExKjAoBgkqhkiG9w0BCQEWG3BlcnNvbmFsLXByZW1pdW1AdGhhd3RlLmNv
+bTAeFw05NjAxMDEwMDAwMDBaFw0yMDEyMzEyMzU5NTlaMIHPMQswCQYDVQQGEwJa
+QTEVMBMGA1UECBMMV2VzdGVybiBDYXBlMRIwEAYDVQQHEwlDYXBlIFRvd24xGjAY
+BgNVBAoTEVRoYXd0ZSBDb25zdWx0aW5nMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9u
+IFNlcnZpY2VzIERpdmlzaW9uMSMwIQYDVQQDExpUaGF3dGUgUGVyc29uYWwgUHJl
+bWl1bSBDQTEqMCgGCSqGSIb3DQEJARYbcGVyc29uYWwtcHJlbWl1bUB0aGF3dGUu
+Y29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDJZtn4B0TPuYwu8KHvE0Vs
+Bd/eJxZRNkERbGw77f4QfRKe5ZtCmv5gMcNmt3M6SK5O0DI3lIi1DbbZ8/JE2dWI
+Et12TfIa/G8jHnrx2JhFTgcQ7xZC0EN1bUre4qrJMf8fAHB8Zs8QJQi6+u4A6UYD
+ZicRFTuqW/KY3TZCstqIdQIDAQABoxMwETAPBgNVHRMBAf8EBTADAQH/MA0GCSqG
+SIb3DQEBBAUAA4GBAGk2ifc0KjNyL2071CKyuG+axTZmDhs8obF1Wub9NdP4qPIH
+b4Vnjt4rueIXsDqg8A6iAJrf8xQVbrvIhVqYgPn/vnQdPfP+MCXRNzRn+qVxeTBh
+KXLA4CxM+1bkOqhv5TJZUtt1KFBZDPgLGeSs2a+WjS9Q2wfD6h+rM+D1KzGJ
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDJzCCApCgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBzjELMAkGA1UEBhMCWkEx
+FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD
+VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv
+biBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhhd3RlIFByZW1pdW0gU2Vy
+dmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNlcnZlckB0aGF3dGUuY29t
+MB4XDTk2MDgwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgc4xCzAJBgNVBAYTAlpB
+MRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEdMBsG
+A1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRp
+b24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNl
+cnZlciBDQTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNv
+bTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2aovXwlue2oFBYo847kkE
+VdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560ZXUCTe/LCaIhUdib0GfQ
+ug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j+ao6hnO2RlNYyIkFvYMR
+uHM/qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG
+9w0BAQQFAAOBgQAmSCwWwlj66BZ0DKqqX1Q/8tfJeGBeXm43YyJ3Nn6yF8Q0ufUI
+hfzJATj/Tb7yFkJD57taRvvBxhEf8UqwKEbJw8RCfbz6q1lu1bdRiBHjpIUZa4JM
+pAwSremkrj/xw0llmozFyD4lt5SZu5IycQfwhl7tUCemDaYj+bvLpgcUQg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDEzCCAnygAwIBAgIBATANBgkqhkiG9w0BAQQFADCBxDELMAkGA1UEBhMCWkEx
+FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD
+VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv
+biBTZXJ2aWNlcyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEm
+MCQGCSqGSIb3DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wHhcNOTYwODAx
+MDAwMDAwWhcNMjAxMjMxMjM1OTU5WjCBxDELMAkGA1UEBhMCWkExFTATBgNVBAgT
+DFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYDVQQKExRUaGF3
+dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNl
+cyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEmMCQGCSqGSIb3
+DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQAD
+gY0AMIGJAoGBANOkUG7I/1Zr5s9dtuoMaHVHoqrC2oQl/Kj0R1HahbUgdJSGHg91
+yekIYfUGbTBuFRkC6VLAYttNmZ7iagxEOM3+vuNkCXDF/rFrKbYvScg71CcEJRCX
+L+eQbcAoQpnXTEPew/UhbVSfXcNY4cDk2VuwuNy0e982OsK1ZiIS1ocNAgMBAAGj
+EzARMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEAB/pMaVz7lcxG
+7oWDTSEwjsrZqG9JGubaUeNgcGyEYRGhGshIPllDfU+VPaGLtwtimHp1it2ITk6e
+QNuozDJ0uW8NxuOzRAvZim+aKZuZGCg70eNAKJpaPNW15yAbi8qkq43pUdniTCxZ
+qdq5snUb9kLy78fyGPmJvKP/iiMucEc=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEQzCCAyugAwIBAgIBATANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJHQjEb
+MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
+GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDElMCMGA1UEAwwcVHJ1c3RlZCBDZXJ0
+aWZpY2F0ZSBTZXJ2aWNlczAeFw0wNDAxMDEwMDAwMDBaFw0yODEyMzEyMzU5NTla
+MH8xCzAJBgNVBAYTAkdCMRswGQYDVQQIDBJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO
+BgNVBAcMB1NhbGZvcmQxGjAYBgNVBAoMEUNvbW9kbyBDQSBMaW1pdGVkMSUwIwYD
+VQQDDBxUcnVzdGVkIENlcnRpZmljYXRlIFNlcnZpY2VzMIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA33FvNlhTWvI2VFeAxHQIIO0Yfyod5jWaHiWsnOWW
+fnJSoBVC21ndZHoa0Lh73TkVvFVIxO06AOoxEbrycXQaZ7jPM8yoMa+j49d/vzMt
+TGo87IvDktJTdyR0nAducPy9C1t2ul/y/9c3S0pgePfw+spwtOpZqqPOSC+pw7IL
+fhdyFgymBwwbOM/JYrc/oJOlh0Hyt3BAd9i+FHzjqMB6juljatEPmsbS9Is6FARW
+1O24zG71++IsWL1/T2sr92AkWCTOJu80kTrV44HQsvAEAtdbtz6SrGsSivnkBbA7
+kUlcsutT6vifR4buv5XAwAaf0lteERv0xwQ1KdJVXOTt6wIDAQABo4HJMIHGMB0G
+A1UdDgQWBBTFe1i97doladL3WRaoszLAeydb9DAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zCBgwYDVR0fBHwwejA8oDqgOIY2aHR0cDovL2NybC5jb21v
+ZG9jYS5jb20vVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMuY3JsMDqgOKA2hjRo
+dHRwOi8vY3JsLmNvbW9kby5uZXQvVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMu
+Y3JsMA0GCSqGSIb3DQEBBQUAA4IBAQDIk4E7ibSvuIQSTI3S8NtwuleGFTQQuS9/
+HrCoiWChisJ3DFBKmwCL2Iv0QeLQg4pKHBQGsKNoBXAxMKdTmw7pSqBYaWcOrp32
+pSxBvzwGa+RZzG0Q8ZZvH9/0BAKkn0U+yNj6NkZEUD+Cl5EfKNsYEYwq5GWDVxIS
+jBc/lDb+XbDABHcTuPQV1T84zJQ6VdCsmPW6AF/ghhmBeC8owH7TzEIK9a5QoNE+
+xqFx7D+gIIxmOom0jtTYsU0lR+4viMi14QVFwL4Ucd56/Y57fU0IlqUSc/Atyjcn
+dBInTMu2l+nZrghtWjlA3QVHdWpaIbOjGM9O9y5Xt5hwXsjEeLBi
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEXjCCA0agAwIBAgIQRL4Mi1AAIbQR0ypoBqmtaTANBgkqhkiG9w0BAQUFADCB
+kzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
+Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
+dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xGzAZBgNVBAMTElVUTiAtIERBVEFDb3Jw
+IFNHQzAeFw05OTA2MjQxODU3MjFaFw0xOTA2MjQxOTA2MzBaMIGTMQswCQYDVQQG
+EwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYD
+VQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cu
+dXNlcnRydXN0LmNvbTEbMBkGA1UEAxMSVVROIC0gREFUQUNvcnAgU0dDMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3+5YEKIrblXEjr8uRgnn4AgPLit6
+E5Qbvfa2gI5lBZMAHryv4g+OGQ0SR+ysraP6LnD43m77VkIVni5c7yPeIbkFdicZ
+D0/Ww5y0vpQZY/KmEQrrU0icvvIpOxboGqBMpsn0GFlowHDyUwDAXlCCpVZvNvlK
+4ESGoE1O1kduSUrLZ9emxAW5jh70/P/N5zbgnAVssjMiFdC04MwXwLLA9P4yPykq
+lXvY8qdOD1R8oQ2AswkDwf9c3V6aPryuvEeKaq5xyh+xKrhfQgUL7EYw0XILyulW
+bfXv33i+Ybqypa4ETLyorGkVl73v67SMvzX41MPRKA5cOp9wGDMgd8SirwIDAQAB
+o4GrMIGoMAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRT
+MtGzz3/64PGgXYVOktKeRR20TzA9BgNVHR8ENjA0MDKgMKAuhixodHRwOi8vY3Js
+LnVzZXJ0cnVzdC5jb20vVVROLURBVEFDb3JwU0dDLmNybDAqBgNVHSUEIzAhBggr
+BgEFBQcDAQYKKwYBBAGCNwoDAwYJYIZIAYb4QgQBMA0GCSqGSIb3DQEBBQUAA4IB
+AQAnNZcAiosovcYzMB4p/OL31ZjUQLtgyr+rFywJNn9Q+kHcrpY6CiM+iVnJowft
+Gzet/Hy+UUla3joKVAgWRcKZsYfNjGjgaQPpxE6YsjuMFrMOoAyYUJuTqXAJyCyj
+j98C5OBxOvG0I3KgqgHf35g+FFCgMSa9KOlaMCZ1+XtgHI3zzVAmbQQnmt/VDUVH
+KWss5nbZqSl9Mt3JNjy9rjXxEZ4du5A/EkdOjtd+D2JzHVImOBwYSf0wdJrE5SIv
+2MCN7ZF6TACPcn9d2t0bi0Vr591pl6jFVkwPDPafepE39peC4N1xaf92P2BNPM/3
+mfnGV/TJVTl4uix5yaaIK/QI
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEojCCA4qgAwIBAgIQRL4Mi1AAJLQR0zYlJWfJiTANBgkqhkiG9w0BAQUFADCB
+rjELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
+Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
+dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xNjA0BgNVBAMTLVVUTi1VU0VSRmlyc3Qt
+Q2xpZW50IEF1dGhlbnRpY2F0aW9uIGFuZCBFbWFpbDAeFw05OTA3MDkxNzI4NTBa
+Fw0xOTA3MDkxNzM2NThaMIGuMQswCQYDVQQGEwJVUzELMAkGA1UECBMCVVQxFzAV
+BgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5l
+dHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cudXNlcnRydXN0LmNvbTE2MDQGA1UE
+AxMtVVROLVVTRVJGaXJzdC1DbGllbnQgQXV0aGVudGljYXRpb24gYW5kIEVtYWls
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsjmFpPJ9q0E7YkY3rs3B
+YHW8OWX5ShpHornMSMxqmNVNNRm5pELlzkniii8efNIxB8dOtINknS4p1aJkxIW9
+hVE1eaROaJB7HHqkkqgX8pgV8pPMyaQylbsMTzC9mKALi+VuG6JG+ni8om+rWV6l
+L8/K2m2qL+usobNqqrcuZzWLeeEeaYji5kbNoKXqvgvOdjp6Dpvq/NonWz1zHyLm
+SGHGTPNpsaguG7bUMSAsvIKKjqQOpdeJQ/wWWq8dcdcRWdq6hw2v+vPhwvCkxWeM
+1tZUOt4KpLoDd7NlyP0e03RiqhjKaJMeoYV+9Udly/hNVyh00jT/MLbu9mIwFIws
+6wIDAQABo4G5MIG2MAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
+DgQWBBSJgmd9xJ0mcABLtFBIfN49rgRufTBYBgNVHR8EUTBPME2gS6BJhkdodHRw
+Oi8vY3JsLnVzZXJ0cnVzdC5jb20vVVROLVVTRVJGaXJzdC1DbGllbnRBdXRoZW50
+aWNhdGlvbmFuZEVtYWlsLmNybDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUH
+AwQwDQYJKoZIhvcNAQEFBQADggEBALFtYV2mGn98q0rkMPxTbyUkxsrt4jFcKw7u
+7mFVbwQ+zznexRtJlOTrIEy05p5QLnLZjfWqo7NK2lYcYJeA3IKirUq9iiv/Cwm0
+xtcgBEXkzYABurorbs6q15L+5K/r9CYdFip/bDCVNy8zEqx/3cfREYxRmLLQo5HQ
+rfafnoOTHh1CuEava2bwm3/q4wMC5QJRwarVNZ1yQAOJujEdxRBoUp7fooXFXAim
+eOZTT7Hot9MUnpOmw2TjrH5xzbyf6QMbzPvprDHBr3wVdAKZw7JHpsIyYdfHb0gk
+USeh1YdV8nuPmD0Wnu51tvjQjvLzxq4oW6fw8zYX/MMF08oDSlQ=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEdDCCA1ygAwIBAgIQRL4Mi1AAJLQR0zYq/mUK/TANBgkqhkiG9w0BAQUFADCB
+lzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
+Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
+dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3Qt
+SGFyZHdhcmUwHhcNOTkwNzA5MTgxMDQyWhcNMTkwNzA5MTgxOTIyWjCBlzELMAkG
+A1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEe
+MBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8v
+d3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3QtSGFyZHdh
+cmUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx98M4P7Sof885glFn
+0G2f0v9Y8+efK+wNiVSZuTiZFvfgIXlIwrthdBKWHTxqctU8EGc6Oe0rE81m65UJ
+M6Rsl7HoxuzBdXmcRl6Nq9Bq/bkqVRcQVLMZ8Jr28bFdtqdt++BxF2uiiPsA3/4a
+MXcMmgF6sTLjKwEHOG7DpV4jvEWbe1DByTCP2+UretNb+zNAHqDVmBe8i4fDidNd
+oI6yqqr2jmmIBsX6iSHzCJ1pLgkzmykNRg+MzEk0sGlRvfkGzWitZky8PqxhvQqI
+DsjfPe58BEydCl5rkdbux+0ojatNh4lz0G6k0B4WixThdkQDf2Os5M1JnMWS9Ksy
+oUhbAgMBAAGjgbkwgbYwCwYDVR0PBAQDAgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYD
+VR0OBBYEFKFyXyYbKJhDlV0HN9WFlp1L0sNFMEQGA1UdHwQ9MDswOaA3oDWGM2h0
+dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9VVE4tVVNFUkZpcnN0LUhhcmR3YXJlLmNy
+bDAxBgNVHSUEKjAoBggrBgEFBQcDAQYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEF
+BQcDBzANBgkqhkiG9w0BAQUFAAOCAQEARxkP3nTGmZev/K0oXnWO6y1n7k57K9cM
+//bey1WiCuFMVGWTYGufEpytXoMs61quwOQt9ABjHbjAbPLPSbtNk28Gpgoiskli
+CE7/yMgUsogWXecB5BKV5UU0s4tpvc+0hY91UZ59Ojg6FEgSxvunOxqNDYJAB+gE
+CJChicsZUN/KHAG8HQQZexB2lzvukJDKxA4fFm517zP4029bHpbj4HR3dHuKom4t
+3XbWOTCC8KucUvIqx69JXn7HaOWCgchqJ/kniCrVWFCVH/A7HFe7fRQ5YiuayZSS
+KqMiDP+JJn1fIytH1xUdqWqeUQ0qUZ6B+dQ7XnASfxAynB67nfhmqA==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEZDCCA0ygAwIBAgIQRL4Mi1AAJLQR0zYwS8AzdzANBgkqhkiG9w0BAQUFADCB
+ozELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
+Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
+dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xKzApBgNVBAMTIlVUTi1VU0VSRmlyc3Qt
+TmV0d29yayBBcHBsaWNhdGlvbnMwHhcNOTkwNzA5MTg0ODM5WhcNMTkwNzA5MTg1
+NzQ5WjCBozELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0
+IExha2UgQ2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYD
+VQQLExhodHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xKzApBgNVBAMTIlVUTi1VU0VS
+Rmlyc3QtTmV0d29yayBBcHBsaWNhdGlvbnMwggEiMA0GCSqGSIb3DQEBAQUAA4IB
+DwAwggEKAoIBAQCz+5Gh5DZVhawGNFugmliy+LUPBXeDrjKxdpJo7CNKyXY/45y2
+N3kDuatpjQclthln5LAbGHNhSuh+zdMvZOOmfAz6F4CjDUeJT1FxL+78P/m4FoCH
+iZMlIJpDgmkkdihZNaEdwH+DBmQWICzTSaSFtMBhf1EI+GgVkYDLpdXuOzr0hARe
+YFmnjDRy7rh4xdE7EkpvfmUnuaRVxblvQ6TFHSyZwFKkeEwVs0CYCGtDxgGwenv1
+axwiP8vv/6jQOkt2FZ7S0cYu49tXGzKiuG/ohqY/cKvlcJKrRB5AUPuco2LkbG6g
+yN7igEL66S/ozjIEj3yNtxyjNTwV3Z7DrpelAgMBAAGjgZEwgY4wCwYDVR0PBAQD
+AgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFPqGydvguul49Uuo1hXf8NPh
+ahQ8ME8GA1UdHwRIMEYwRKBCoECGPmh0dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9V
+VE4tVVNFUkZpcnN0LU5ldHdvcmtBcHBsaWNhdGlvbnMuY3JsMA0GCSqGSIb3DQEB
+BQUAA4IBAQCk8yXM0dSRgyLQzDKrm5ZONJFUICU0YV8qAhXhi6r/fWRRzwr/vH3Y
+IWp4yy9Rb/hCHTO967V7lMPDqaAt39EpHx3+jz+7qEUqf9FuVSTiuwL7MT++6Lzs
+QCv4AdRWOOTKRIK1YSAhZ2X28AvnNPilwpyjXEAfhZOVBt5P1CeptqX8Fs1zMT+4
+ZSfP1FMa8Kxun08FDAOBp4QpxFq9ZFdyrTvPNximmMatBrTcCKME1SmklpoSZ0qM
+YEWd8SOasACcaLWYUNPvji6SZbFIPiG+FTAqDbUMo2s/rn9X9R+WfN9v3YIwLGUb
+QErNaLly7HF27FSOH4UMAWr6pjisH8SE
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEZjCCA06gAwIBAgIQRL4Mi1AAJLQR0zYt4LNfGzANBgkqhkiG9w0BAQUFADCB
+lTELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
+Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
+dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHTAbBgNVBAMTFFVUTi1VU0VSRmlyc3Qt
+T2JqZWN0MB4XDTk5MDcwOTE4MzEyMFoXDTE5MDcwOTE4NDAzNlowgZUxCzAJBgNV
+BAYTAlVTMQswCQYDVQQIEwJVVDEXMBUGA1UEBxMOU2FsdCBMYWtlIENpdHkxHjAc
+BgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEhMB8GA1UECxMYaHR0cDovL3d3
+dy51c2VydHJ1c3QuY29tMR0wGwYDVQQDExRVVE4tVVNFUkZpcnN0LU9iamVjdDCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6qgT+jo2F4qjEAVZURnicP
+HxzfOpuCaDDASmEd8S8O+r5596Uj71VRloTN2+O5bj4x2AogZ8f02b+U60cEPgLO
+KqJdhwQJ9jCdGIqXsqoc/EHSoTbL+z2RuufZcDX65OeQw5ujm9M89RKZd7G3CeBo
+5hy485RjiGpq/gt2yb70IuRnuasaXnfBhQfdDWy/7gbHd2pBnqcP1/vulBe3/IW+
+pKvEHDHd17bR5PDv3xaPslKT16HUiaEHLr/hARJCHhrh2JU022R5KP+6LhHC5ehb
+kkj7RwvCbNqtMoNB86XlQXD9ZZBt+vpRxPm9lisZBCzTbafc8H9vg2XiaquHhnUC
+AwEAAaOBrzCBrDALBgNVHQ8EBAMCAcYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
+FgQU2u1kdBScFDyr3ZmpvVsoTYs8ydgwQgYDVR0fBDswOTA3oDWgM4YxaHR0cDov
+L2NybC51c2VydHJ1c3QuY29tL1VUTi1VU0VSRmlyc3QtT2JqZWN0LmNybDApBgNV
+HSUEIjAgBggrBgEFBQcDAwYIKwYBBQUHAwgGCisGAQQBgjcKAwQwDQYJKoZIhvcN
+AQEFBQADggEBAAgfUrE3RHjb/c652pWWmKpVZIC1WkDdIaXFwfNfLEzIR1pp6ujw
+NTX00CXzyKakh0q9G7FzCL3Uw8q2NbtZhncxzaeAFK4T7/yxSPlrJSUtUbYsbUXB
+mMiKVl0+7kNOPmsnjtA6S4ULX9Ptaqd1y9Fahy85dRNacrACgZ++8A+EVCBibGnU
+4U3GDZlDAQ0Slox4nb9QorFEqmrPF3rPbw/U+CRVX/A0FklmPlBGyWNxODFiuGK5
+81OtbLUrohKqGU8J2l7nk8aOFAj+8DCAGKCGhU3IfdeLA/5u1fedFqySLKAj5ZyR
+Uh+U3xeUc8OzwcFxBSAAeL0TUh2oPs0AH8g=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEGjCCAwICEQCLW3VWhFSFCwDPrzhIzrGkMA0GCSqGSIb3DQEBBQUAMIHKMQsw
+CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl
+cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu
+LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT
+aWduIENsYXNzIDEgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp
+dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD
+VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT
+aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ
+bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu
+IENsYXNzIDEgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg
+LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN2E1Lm0+afY8wR4
+nN493GwTFtl63SRRZsDHJlkNrAYIwpTRMx/wgzUfbhvI3qpuFU5UJ+/EbRrsC+MO
+8ESlV8dAWB6jRx9x7GD2bZTIGDnt/kIYVt/kTEkQeE4BdjVjEjbdZrwBBDajVWjV
+ojYJrKshJlQGrT/KFOCsyq0GHZXi+J3x4GD/wn91K0zM2v6HmSHquv4+VNfSWXjb
+PG7PoBMAGrgnoeS+Z5bKoMWznN3JdZ7rMJpfo83ZrngZPyPpXNspva1VyBtUjGP2
+6KbqxzcSXKMpHgLZ2x87tNcPVkeBFQRKr4Mn0cVYiMHd9qqnoxjaaKptEVHhv2Vr
+n5Z20T0CAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAq2aN17O6x5q25lXQBfGfMY1a
+qtmqRiYPce2lrVNWYgFHKkTp/j90CxObufRNG7LRX7K20ohcs5/Ny9Sn2WCVhDr4
+wTcdYcrnsMXlkdpUpqwxga6X3s0IrLjAl4B/bnKk52kTlWUfxJM8/XmPBNQ+T+r3
+ns7NZ3xPZQL/kYVUc8f/NveGLezQXk//EZ9yBta4GvFMDSZl4kSAHsef493oCtrs
+pSCAaWihT37ha88HQfqDjrw43bAuEbFrskLMmrz5SCJ5ShkPshw+IHTZasO+8ih4
+E1Z5T21Q6huwtVexN2ZYI/PcD98Kh8TvhgXVOBRgmaNL3gaWcSzy27YfpO8/7g==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEGTCCAwECEGFwy0mMX5hFKeewptlQW3owDQYJKoZIhvcNAQEFBQAwgcoxCzAJ
+BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UECxMWVmVy
+aVNpZ24gVHJ1c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDE5OTkgVmVyaVNpZ24s
+IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVyaVNp
+Z24gQ2xhc3MgMiBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0
+eSAtIEczMB4XDTk5MTAwMTAwMDAwMFoXDTM2MDcxNjIzNTk1OVowgcoxCzAJBgNV
+BAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UECxMWVmVyaVNp
+Z24gVHJ1c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDE5OTkgVmVyaVNpZ24sIElu
+Yy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVyaVNpZ24g
+Q2xhc3MgMiBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAt
+IEczMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArwoNwtUs22e5LeWU
+J92lvuCwTY+zYVY81nzD9M0+hsuiiOLh2KRpxbXiv8GmR1BeRjmL1Za6tW8UvxDO
+JxOeBUebMXoT2B/Z0wI3i60sR/COgQanDTAM6/c8DyAd3HJG7qUCyFvDyVZpTMUY
+wZF7C9UTAJu878NIPkZgIIUq1ZC2zYugzDLdt/1AVbJQHFauzI13TccgTacxdu9o
+koqQHgiBVrKtaaNS0MscxCM9H5n+TOgWY47GCI72MfbS+uV23bUckqNJzc0BzWjN
+qWm6o+sdDZykIKbBoMXRRkwXbdKsZj+WjOCE1Db/IlnF+RFgqF8EffIa9iVCYQ/E
+Srg+iQIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQA0JhU8wI1NQ0kdvekhktdmnLfe
+xbjQ5F1fdiLAJvmEOjr5jLX77GDx6M4EsMjdpwOPMPOY36TmpDHf0xwLRtxyID+u
+7gU8pDM/CzmscHhzS5kr3zDCVLCoO1Wh/hYozUK9dG6A2ydEp85EXdQbkJgNHkKU
+sQAsBNB0owIFImNjzYO1+8FtYmtpdf1dcEG59b98377BMnMiIYtYgXsVkXq642RI
+sH/7NiXaldDxJBQX3RiAa0YjOVT1jmIJBB2UkKab5iXiQkWquJCtvgiPqQtCGJTP
+cjnhsUPgKM+351psE2tJs//jGHyJizNdrDPXp/naOlXJWBD5qu9ats9LS98q
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw
+CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl
+cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu
+LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT
+aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp
+dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD
+VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT
+aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ
+bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu
+IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg
+LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b
+N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t
+KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu
+kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm
+CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ
+Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu
+imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te
+2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe
+DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC
+/Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p
+F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt
+TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEGjCCAwICEQDsoKeLbnVqAc/EfMwvlF7XMA0GCSqGSIb3DQEBBQUAMIHKMQsw
+CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl
+cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu
+LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT
+aWduIENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp
+dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD
+VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT
+aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ
+bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu
+IENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg
+LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK3LpRFpxlmr8Y+1
+GQ9Wzsy1HyDkniYlS+BzZYlZ3tCD5PUPtbut8XzoIfzk6AzufEUiGXaStBO3IFsJ
++mGuqPKljYXCKtbeZjbSmwL0qJJgfJxptI8kHtCGUvYynEFYHiK9zUVilQhu0Gbd
+U6LM8BDcVHOLBKFGMzNcF0C5nk3T875Vg+ixiY5afJqWIpA7iCXy0lOIAgwLePLm
+NxdLMEYH5IBtptiWLugs+BGzOA1mppvqySNb247i8xOOGlktqgLw7KSHZtzBP/XY
+ufTsgsbSPZUd5cBPhMnZo0QoBmrXRazwa2rvTl/4EYIeOGM0ZlDUPpNz+jDDZq3/
+ky2X7wMCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAj/ola09b5KROJ1WrIhVZPMq1
+CtRK26vdoV9TxaBXOcLORyu+OshWv8LZJxA6sQU8wHcxuzrTBXttmhwwjIDLk5Mq
+g6sFUYICABFna/OIYUdfA5PVWw3g8dShMjWFsjrbsIKr0csKvE+MW8VLADsfKoKm
+fjaF3H48ZwC15DtS4KjrXRX5xm3wrR0OhbepmnMUWluPQSjA1egtTaRezarZ7c7c
+2NU8Qh0XwRJdRTjDOPP8hS6DRkiy1yBfkjaP53kPmF6Z6PDQpLv1U70qzlmwr25/
+bLvSHgCwIe34QWKCudiyxLtGUPMxxY8BqHTr9Xgn2uf3ZkPznoM+IKrDNWCRzg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDojCCAoqgAwIBAgIQE4Y1TR0/BvLB+WUF1ZAcYjANBgkqhkiG9w0BAQUFADBr
+MQswCQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRl
+cm5hdGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNv
+bW1lcmNlIFJvb3QwHhcNMDIwNjI2MDIxODM2WhcNMjIwNjI0MDAxNjEyWjBrMQsw
+CQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRlcm5h
+dGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNvbW1l
+cmNlIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvV95WHm6h
+2mCxlCfLF9sHP4CFT8icttD0b0/Pmdjh28JIXDqsOTPHH2qLJj0rNfVIsZHBAk4E
+lpF7sDPwsRROEW+1QK8bRaVK7362rPKgH1g/EkZgPI2h4H3PVz4zHvtH8aoVlwdV
+ZqW1LS7YgFmypw23RuwhY/81q6UCzyr0TP579ZRdhE2o8mCP2w4lPJ9zcc+U30rq
+299yOIzzlr3xF7zSujtFWsan9sYXiwGd/BmoKoMWuDpI/k4+oKsGGelT84ATB+0t
+vz8KPFUgOSwsAGl0lUq8ILKpeeUYiZGo3BxN77t+Nwtd/jmliFKMAGzsGHxBvfaL
+dXe6YJ2E5/4tAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMB0GA1UdDgQWBBQVOIMPPyw/cDMezUb+B4wg4NfDtzANBgkqhkiG9w0BAQUF
+AAOCAQEAX/FBfXxcCLkr4NWSR/pnXKUTwwMhmytMiUbPWU3J/qVAtmPN3XEolWcR
+zCSs00Rsca4BIGsDoo8Ytyk6feUWYFN4PMCvFYP3j1IzJL1kk5fui/fbGKhtcbP3
+LBfQdCVp9/5rPJS+TUtBjE7ic9DjkCJzQ83z7+pzzkWKsKZJ/0x9nXGIxHYdkFsd
+7v3M9+79YKWxehZx0RbQfBI8bGmX265fOZpwLwU8GUYEmSA20GBuYQa7FkKMcPcw
+++DbZqMAAb3mLNqRX6BGi01qnD093QVG/na/oAo85ADmJ7f/hC3euiInlhBx6yLt
+398znM/jra6O1I7mT1GvFpLgXPYHDw==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIID5TCCAs2gAwIBAgIEOeSXnjANBgkqhkiG9w0BAQUFADCBgjELMAkGA1UEBhMC
+VVMxFDASBgNVBAoTC1dlbGxzIEZhcmdvMSwwKgYDVQQLEyNXZWxscyBGYXJnbyBD
+ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEvMC0GA1UEAxMmV2VsbHMgRmFyZ28gUm9v
+dCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMDAxMDExMTY0MTI4WhcNMjEwMTE0
+MTY0MTI4WjCBgjELMAkGA1UEBhMCVVMxFDASBgNVBAoTC1dlbGxzIEZhcmdvMSww
+KgYDVQQLEyNXZWxscyBGYXJnbyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEvMC0G
+A1UEAxMmV2VsbHMgRmFyZ28gUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDVqDM7Jvk0/82bfuUER84A4n13
+5zHCLielTWi5MbqNQ1mXx3Oqfz1cQJ4F5aHiidlMuD+b+Qy0yGIZLEWukR5zcUHE
+SxP9cMIlrCL1dQu3U+SlK93OvRw6esP3E48mVJwWa2uv+9iWsWCaSOAlIiR5NM4O
+JgALTqv9i86C1y8IcGjBqAr5dE8Hq6T54oN+J3N0Prj5OEL8pahbSCOz6+MlsoCu
+ltQKnMJ4msZoGK43YjdeUXWoWGPAUe5AeH6orxqg4bB4nVCMe+ez/I4jsNtlAHCE
+AQgAFG5Uhpq6zPk3EPbg3oQtnaSFN9OH4xXQwReQfhkhahKpdv0SAulPIV4XAgMB
+AAGjYTBfMA8GA1UdEwEB/wQFMAMBAf8wTAYDVR0gBEUwQzBBBgtghkgBhvt7hwcB
+CzAyMDAGCCsGAQUFBwIBFiRodHRwOi8vd3d3LndlbGxzZmFyZ28uY29tL2NlcnRw
+b2xpY3kwDQYJKoZIhvcNAQEFBQADggEBANIn3ZwKdyu7IvICtUpKkfnRLb7kuxpo
+7w6kAOnu5+/u9vnldKTC2FJYxHT7zmu1Oyl5GFrvm+0fazbuSCUlFLZWohDo7qd/
+0D+j0MNdJu4HzMPBJCGHHt8qElNvQRbn7a6U+oxy+hNH8Dx+rn0ROhPs7fpvcmR7
+nX1/Jv16+yWt6j4pf0zjAFcysLPp7VMX2YuyFA4w6OXVE8Zkr8QA1dhYJPz1j+zx
+x32l2w8n0cbyQIjmH/ZhqPRCyLk306m+LFZ4wnKbWV01QIroTmMatukgalHizqSQ
+33ZwmVxwQ023tqcZZE6St8WRPH9IFmV7Fv3L/PvZ1dZPIWU7Sn9Ho/s=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB
+gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk
+MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY
+UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx
+NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3
+dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy
+dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB
+dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6
+38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP
+KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q
+DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4
+qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa
+JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi
+PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P
+BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs
+jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0
+eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD
+ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR
+vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt
+qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa
+IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy
+i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ
+O+7ETPTsJ3xCwnR8gooJybQDJbw=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEQTCCA6qgAwIBAgICAQQwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1Zh
+bGlDZXJ0IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIElu
+Yy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24g
+QXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAe
+BgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTA0MDExNDIxMDUyMVoX
+DTI0MDEwOTIxMDUyMVowgewxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25h
+MRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVjaG5v
+bG9naWVzLCBJbmMuMTAwLgYDVQQLEydodHRwOi8vd3d3LnN0YXJmaWVsZHRlY2gu
+Y29tL3JlcG9zaXRvcnkxMTAvBgNVBAMTKFN0YXJmaWVsZCBTZWN1cmUgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkxKjAoBgkqhkiG9w0BCQEWG3ByYWN0aWNlc0BzdGFy
+ZmllbGR0ZWNoLmNvbTCBnTANBgkqhkiG9w0BAQEFAAOBiwAwgYcCgYEA2xFDa9zR
+aXhZSehudBQIdBFsfrcqqCLYQjx6z59QskaupmcaIyK+D7M0+6yskKpbKMJw9raK
+gCrgm5xS4JGocqAW4cROfREJs5651POyUMRtSAi9vCqXDG2jimo8ms9KNNwe3upa
+JsChooKpSvuGIhKQOrKC1JKRn6lFn8Ok2/sCAQOjggEhMIIBHTAMBgNVHRMEBTAD
+AQH/MAsGA1UdDwQEAwIBBjBKBgNVHR8EQzBBMD+gPaA7hjlodHRwOi8vY2VydGlm
+aWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkvcm9vdC5jcmwwTwYD
+VR0gBEgwRjBEBgtghkgBhvhFAQcXAzA1MDMGCCsGAQUFBwIBFidodHRwOi8vd3d3
+LnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkwOQYIKwYBBQUHAQEELTArMCkG
+CCsGAQUFBzABhh1odHRwOi8vb2NzcC5zdGFyZmllbGR0ZWNoLmNvbTAdBgNVHQ4E
+FgQUrFXet+oT6/yYaOJTYB7xJT6M7ucwCQYDVR0jBAIwADANBgkqhkiG9w0BAQUF
+AAOBgQB+HJi+rQONJYXufJCIIiv+J/RCsux/tfxyaAWkfZHvKNF9IDk7eQg3aBhS
+1Y8D0olPHhHR6aV0S/xfZ2WEcYR4WbfWydfXkzXmE6uUPI6TQImMwNfy5wdS0XCP
+mIzroG3RNlOQoI8WMB7ew79/RqWVKvnI3jvbd/TyMrEzYaIwNQ==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFEjCCBHugAwIBAgICAQwwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1Zh
+bGlDZXJ0IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIElu
+Yy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24g
+QXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAe
+BgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTA0MDYyOTE3MzkxNloX
+DTI0MDYyOTE3MzkxNlowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0YXJmaWVs
+ZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBDbGFzcyAy
+IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0A
+MIIBCAKCAQEAtzLI/ulxpgSFrQwRZN/OTe/IAxiHP6Gr+zymn/DDodrU2G4rU5D7
+JKQ+hPCe6F/s5SdE9SimP3ve4CrwyK9TL57KBQGTHo9mHDmnTfpatnMEJWbrd3/n
+WcZKmSUUVOsmx/N/GdUwcI+vsEYq/63rKe3Xn6oEh6PU+YmlNF/bQ5GCNtlmPLG4
+uYL9nDo+EMg77wZlZnqbGRg9/3FRPDAuX749d3OyXQZswyNWmiuFJpIcpwKz5D8N
+rwh5grg2Peqc0zWzvGnK9cyd6P1kjReAM25eSl2ZyR6HtJ0awNVuEzUjXt+bXz3v
+1vd2wuo+u3gNHEJnawTY+Nbab4vyRKABqwIBA6OCAfMwggHvMB0GA1UdDgQWBBS/
+X7fRzt0fhvRbVazc1xDCDqmI5zCB0gYDVR0jBIHKMIHHoYHBpIG+MIG7MSQwIgYD
+VQQHExtWYWxpQ2VydCBWYWxpZGF0aW9uIE5ldHdvcmsxFzAVBgNVBAoTDlZhbGlD
+ZXJ0LCBJbmMuMTUwMwYDVQQLEyxWYWxpQ2VydCBDbGFzcyAyIFBvbGljeSBWYWxp
+ZGF0aW9uIEF1dGhvcml0eTEhMB8GA1UEAxMYaHR0cDovL3d3dy52YWxpY2VydC5j
+b20vMSAwHgYJKoZIhvcNAQkBFhFpbmZvQHZhbGljZXJ0LmNvbYIBATAPBgNVHRMB
+Af8EBTADAQH/MDkGCCsGAQUFBwEBBC0wKzApBggrBgEFBQcwAYYdaHR0cDovL29j
+c3Auc3RhcmZpZWxkdGVjaC5jb20wSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2Nl
+cnRpZmljYXRlcy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5L3Jvb3QuY3Js
+MFEGA1UdIARKMEgwRgYEVR0gADA+MDwGCCsGAQUFBwIBFjBodHRwOi8vY2VydGlm
+aWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkwDgYDVR0PAQH/BAQD
+AgEGMA0GCSqGSIb3DQEBBQUAA4GBAKVi8afCXSWlcD284ipxs33kDTcdVWptobCr
+mADkhWBKIMuh8D1195TaQ39oXCUIuNJ9MxB73HZn8bjhU3zhxoNbKXuNSm8uf0So
+GkVrMgfHeMpkksK0hAzc3S1fTbvdiuo43NlmouxBulVtWmQ9twPMHOKRUJ7jCUSV
+FxdzPcwl
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFBzCCA++gAwIBAgICAgEwDQYJKoZIhvcNAQEFBQAwaDELMAkGA1UEBhMCVVMx
+JTAjBgNVBAoTHFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsT
+KVN0YXJmaWVsZCBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2
+MTExNjAxMTU0MFoXDTI2MTExNjAxMTU0MFowgdwxCzAJBgNVBAYTAlVTMRAwDgYD
+VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy
+ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTkwNwYDVQQLEzBodHRwOi8vY2VydGlm
+aWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkxMTAvBgNVBAMTKFN0
+YXJmaWVsZCBTZWN1cmUgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxETAPBgNVBAUT
+CDEwNjg4NDM1MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4qddo+1m
+72ovKzYf3Y3TBQKgyg9eGa44cs8W2lRKy0gK9KFzEWWFQ8lbFwyaK74PmFF6YCkN
+bN7i6OUVTVb/kNGnpgQ/YAdKym+lEOez+FyxvCsq3AF59R019Xoog/KTc4KJrGBt
+y8JIwh3UBkQXPKwBR6s+cIQJC7ggCEAgh6FjGso+g9I3s5iNMj83v6G3W1/eXDOS
+zz4HzrlIS+LwVVAv+HBCidGTlopj2WYN5lhuuW2QvcrchGbyOY5bplhVc8tibBvX
+IBY7LFn1y8hWMkpQJ7pV06gBy3KpdIsMrTrlFbYq32X43or174Q7+edUZQuAvUdF
+pfBE2FM7voDxLwIDAQABo4IBRDCCAUAwHQYDVR0OBBYEFElLUifRG7zyoSFqYntR
+QnqK19VWMB8GA1UdIwQYMBaAFL9ft9HO3R+G9FtVrNzXEMIOqYjnMBIGA1UdEwEB
+/wQIMAYBAf8CAQAwOQYIKwYBBQUHAQEELTArMCkGCCsGAQUFBzABhh1odHRwOi8v
+b2NzcC5zdGFyZmllbGR0ZWNoLmNvbTBMBgNVHR8ERTBDMEGgP6A9hjtodHRwOi8v
+Y2VydGlmaWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkvc2Zyb290
+LmNybDBRBgNVHSAESjBIMEYGBFUdIAAwPjA8BggrBgEFBQcCARYwaHR0cDovL2Nl
+cnRpZmljYXRlcy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5MA4GA1UdDwEB
+/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAhlK6sx+mXmuQpmQq/EWyrp8+s2Kv
+2x9nxL3KoS/HnA0hV9D4NiHOOiU+eHaz2d283vtshF8Mow0S6xE7cV+AHvEfbQ5f
+wezUpfdlux9MlQETsmqcC+sfnbHn7RkNvIV88xe9WWOupxoFzUfjLZZiUTIKCGhL
+Indf90XcYd70yysiKUQl0p8Ld3qhJnxK1w/C0Ty6DqeVmlsFChD5VV/Bl4t0zF4o
+aRN+0AqNnQ9gVHrEjBs1D3R6cLKCzx214orbKsayUWm/EheSYBeqPVsJ+IdlHaek
+KOUiAgOCRJo0Y577KM/ozS4OUiDtSss4fJ2ubnnXlSyokfOGASGRS7VApA==
+-----END CERTIFICATE-----
@@ -0,0 +1,200 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'ezcrypto'
+PKG_VERSION   = '0.7.2' + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "ezcrypto"
+RUBY_FORGE_USER    = "pelleb"
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+Rake::TestTask.new { |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+}
+
+
+# Genereate the RDoc documentation
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "EzCrypto - Simplified Crypto Library"
+#  rdoc.options << '--line-numbers --inline-source --main README #--template=jamis'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('README_ACTIVE_CRYPTO')
+  rdoc.rdoc_files.include('README_DIGITAL_SIGNATURES')
+  rdoc.rdoc_files.include('CHANGELOG')
+  rdoc.rdoc_files.include('lib/*.rb')
+}
+
+
+# Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.summary = "Simplified encryption library."
+  s.description = %q{Makes it easier and safer to write crypto code.}
+  s.version = PKG_VERSION
+
+  s.author = "Pelle Braendgaard"
+  s.email = "pelle@stakeventures.com"
+  s.rubyforge_project = "ezcrypto"
+  s.homepage = "http://ezcrypto.rubyforge.org"
+
+
+  s.has_rdoc = true
+  s.requirements << 'none'
+  s.require_path = 'lib'
+
+  s.files = [ "rakefile", "README.rdoc", "README_ACTIVE_CRYPTO", "README_DIGITAL_SIGNATURES", "MIT-LICENSE","CHANGELOG","init.rb" ]
+  ["lib","test"].each do |dir|
+  		s.files = s.files + Dir.glob( "#{dir}/*" )
+  end
+  s.extra_rdoc_files = ["CHANGELOG", "README.rdoc","README_ACTIVE_CRYPTO","README_DIGITAL_SIGNATURES"]
+  s.test_files = Dir.glob("test/*")
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+
+desc "Publish the GEM"
+task :pgem => [:package] do 
+  Rake::SshFilePublisher.new("pelleb@rubyforge.org", "/var/www/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  Rake::SshDirPublisher.new("pelleb@rubyforge.org", "/var/www/gforge-projects/ezcrypto", "doc").upload
+end
+
+desc "Publish the release files to RubyForge."
+task :rubyforge_upload => :package do
+  files = %w(gem tgz zip).map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+
+  if RUBY_FORGE_PROJECT then
+    require 'net/http'
+    require 'open-uri'
+
+    project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
+    project_data = open(project_uri) { |data| data.read }
+    group_id = project_data[/[?&]group_id=(\d+)/, 1]
+    raise "Couldn't get group id" unless group_id
+
+    # This echos password to shell which is a bit sucky
+    if ENV["RUBY_FORGE_PASSWORD"]
+      password = ENV["RUBY_FORGE_PASSWORD"]
+    else
+      print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
+      password = STDIN.gets.chomp
+    end
+
+    login_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+      data = [
+        "login=1",
+        "form_loginname=#{RUBY_FORGE_USER}",
+        "form_pw=#{password}"
+      ].join("&")
+      http.post("/account/login.php", data)
+    end
+
+    cookie = login_response["set-cookie"]
+    raise "Login failed" unless cookie
+    headers = { "Cookie" => cookie }
+
+    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
+    release_data = open(release_uri, headers) { |data| data.read }
+    package_id = release_data[/[?&]package_id=(\d+)/, 1]
+    raise "Couldn't get package id" unless package_id
+
+    first_file = true
+    release_id = ""
+
+    files.each do |filename|
+      basename  = File.basename(filename)
+      file_ext  = File.extname(filename)
+      file_data = File.open(filename, "rb") { |file| file.read }
+
+      puts "Releasing #{basename}..."
+
+      release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+        release_date = Time.now.strftime("%Y-%m-%d %H:%M")
+        type_map = {
+          ".zip"    => "3000",
+          ".tgz"    => "3110",
+          ".gz"     => "3110",
+          ".gem"    => "1400"
+        }; type_map.default = "9999"
+        type = type_map[file_ext]
+        boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
+
+        query_hash = if first_file then
+          {
+            "group_id" => group_id,
+            "package_id" => package_id,
+            "release_name" => PKG_FILE_NAME,
+            "release_date" => release_date,
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "release_notes" => "",
+            "release_changes" => "",
+            "preformatted" => "1",
+            "submit" => "1"
+          }
+        else
+          {
+            "group_id" => group_id,
+            "release_id" => release_id,
+            "package_id" => package_id,
+            "step2" => "1",
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "submit" => "Add This File"
+          }
+        end
+
+        query = "?" + query_hash.map do |(name, value)|
+          [name, URI.encode(value)].join("=")
+        end.join("&")
+
+        data = [
+          "--" + boundary,
+          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
+          "Content-Type: application/octet-stream",
+          "Content-Transfer-Encoding: binary",
+          "", file_data, ""
+          ].join("\x0D\x0A")
+
+        release_headers = headers.merge(
+          "Content-Type" => "multipart/form-data; boundary=#{boundary}"
+        )
+
+        target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
+        http.post(target + query, data, release_headers)
+      end
+
+      if first_file then
+        release_id = release_response.body[/release_id=(\d+)/, 1]
+        raise("Couldn't get release id") unless release_id
+      end
+
+      first_file = false
+    end
+  end
+end
@@ -0,0 +1,211 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'test/unit'
+require 'active_crypto'
+
+
+class User < ActiveRecord::Base
+	has_many :secrets
+	has_many :groups
+	keyholder
+end
+
+class Secret < ActiveRecord::Base
+	encrypt :name,:email, :key=>:user, :base64=>true
+	belongs_to :user
+	has_many :children
+end
+
+class Child < ActiveRecord::Base
+	encrypt :email, :key=>:secret, :base64=>true
+	belongs_to :secret
+end
+
+class Asset<ActiveRecord::Base
+  encrypt :title, :base64=>true
+  has_many :caps,:dependent=>:destroy
+  
+  def self.create(title,email)
+    asset=Asset.new
+    asset.set_session_key(EzCrypto::Key.generate)
+    asset.title=title
+    if asset.save
+      asset.share(email)
+    else
+      nil
+    end
+  end
+
+  def share(email=nil)
+    Cap.create_for_asset(self,email)
+  end
+  
+end
+
+class AssetRaw<ActiveRecord::Base
+  set_table_name "assets"
+end
+
+class Cap < ActiveRecord::Base
+  belongs_to :asset
+  encrypt :shared_key, :base64=>true
+  
+  def self.find_by_key(cap_key)
+    cap_key.chop
+    hash=Digest::SHA1.hexdigest(cap_key)
+    if (cap_key.length>=20) # Sanity check
+      cap=self.find_by_key_hash(hash)
+      if cap
+        cap.set_encoded_key(cap_key)
+        cap.asset.set_encoded_key(cap.shared_key)
+        cap
+      end
+    else
+      nil
+    end
+  end
+  
+  def self.create_for_asset(asset,email=nil)
+    cap=Cap.new
+    cap.email=email if email
+    cap.asset=asset
+    if cap.save
+      cap.set_session_key(EzCrypto::Key.generate)
+      cap_key=cap.session_key.encode
+      cap.key_hash=Digest::SHA1.hexdigest(cap_key)
+      cap.shared_key=asset.session_key.encode
+      cap.save
+      cap_key
+    else
+      nil
+    end
+  end
+  
+end
+
+class Group < ActiveRecord::Base
+	belongs_to :user
+	has_many :group_secrets
+	
+	encrypt :name,:group_key, :key=>:user	, :base64=>true
+end
+
+class GroupSecret < ActiveRecord::Base
+	belongs_to :group
+	
+	encrypt :title,:body, :key=>:group, :base64=>true
+	
+end
+
+class ActiveCryptoTest < Test::Unit::TestCase
+ 
+  def setup
+  end
+    
+  def test_key_holder_in_record
+    user=User.new
+    user.name="bob"
+    user.save
+  	assert user.kind_of?(ActiveCrypto::KeyHolder)
+  	assert user.kind_of?(ActiveRecord::Base)
+  	assert user.kind_of?(User)
+    assert_nil user.session_key
+  	user.enter_password "shhcccc"
+  	assert_not_nil user.session_key
+  	assert_not_nil user.session_key.encrypt("test")    
+  end
+  
+  def test_encrypted_child
+    user=User.new
+    user.save
+    assert_nil user.session_key
+  	user.enter_password "shhcccc"
+  	assert_not_nil user.session_key
+  	assert user.kind_of?(ActiveCrypto::KeyHolder)
+  	assert user.kind_of?(ActiveRecord::Base)
+  	assert user.kind_of?(User)
+  	
+  	jill=user.secrets.create
+  	
+  	assert_not_nil jill
+  	assert jill.kind_of?(ActiveCrypto::AssociationKeyHolder)
+  	assert jill.kind_of?(ActiveCrypto::KeyHolder)
+  	assert jill.kind_of?(ActiveCrypto::Encrypted)
+  	assert jill.kind_of?(ActiveRecord::Base)
+  	assert jill.kind_of?(Secret)
+  	
+  	assert jill.respond_to?(:session_key)
+  	
+    assert_not_nil jill.user
+    assert_not_nil jill.user.session_key
+  	
+  	
+    assert_not_nil jill.session_key
+    assert_equal user.session_key,jill.session_key
+
+    jill.name="jill"
+    jill.save
+
+
+    assert_equal "jill",jill.name
+    
+    jill=user.secrets.first
+    assert_not_nil jill.session_key
+    assert_equal user.session_key,jill.session_key
+    assert_equal "jill",jill.name
+    
+    child=jill.children.create
+    child.email="pelle@neubia.com"
+    child.save
+
+    assert_not_nil child.secret
+    assert_not_nil child.secret.session_key
+
+
+    assert_not_nil child.session_key
+    assert_equal user.session_key,child.session_key
+
+    assert_equal "pelle@neubia.com",child.email
+
+    child=jill.children.first
+
+    assert_not_nil child.secret
+    assert_not_nil child.secret.session_key
+
+
+    assert_not_nil child.session_key
+    assert_equal user.session_key,child.session_key
+
+    assert_equal "pelle@neubia.com",child.email
+
+  end
+
+  def test_caps
+    key=Asset.create("title","pelle@neubia.com")
+    assert_not_nil key
+    cap=Cap.find_by_key key
+    assert_not_nil cap
+    assert_not_nil cap.asset
+    
+    assert_equal "title",cap.asset.title
+    assert_equal "title",cap.asset["title"]
+    assert_equal "pelle@neubia.com",cap.email
+    assert_equal "pelle@neubia.com",cap["email"]
+    
+    # Non decrypting version
+    raw=AssetRaw.find cap.asset.id
+    assert_not_equal "title",raw.title
+    assert_not_equal "title",raw["title"]
+    
+    bob_key=cap.asset.share("bob@bob.com")
+    bob_cap=Cap.find_by_key bob_key
+    
+    assert_not_equal key,bob_key
+    assert_not_nil bob_cap
+    assert_not_nil bob_cap.asset
+    assert_equal "title",bob_cap.asset.title
+    assert_equal "bob@bob.com",bob_cap.email
+  end
+end
+
+
@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFIzCCBAugAwIBAgIEdjTPCDANBgkqhkiG9w0BAQUFADCB3DELMAkGA1UEBhMC
+VVMxEDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNV
+BAoTHFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOTA3BgNVBAsTMGh0dHA6
+Ly9jZXJ0aWZpY2F0ZXMuc3RhcmZpZWxkdGVjaC5jb20vcmVwb3NpdG9yeTExMC8G
+A1UEAxMoU3RhcmZpZWxkIFNlY3VyZSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTER
+MA8GA1UEBRMIMTA2ODg0MzUwHhcNMDkwMzEwMTUyMzQ1WhcNMTAwMzExMjAzNzE0
+WjB6MQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEWMBQGA1UEBxMN
+U2FuIEZyYW5jaXNjbzEYMBYGA1UEChMPRXh0cmEgRWFnbGUgTExDMQ8wDQYDVQQL
+EwZBZ3JlZTIxEzARBgNVBAMTCmFncmVlMi5jb20wgZ8wDQYJKoZIhvcNAQEBBQAD
+gY0AMIGJAoGBAPNfoI6m+NIm69qkuOgOwlRI64W6SmJ+xlxz/fduK/0XtqRlANL9
+aENxkAEvJz6tpsinNOAry96ucajZP9WUMWfy+wmXkTWLQN1jVPZUJs2mBBw6ajgm
+8xLgPWn3czRve0Q34poWGLFb+CZdcZScbnHcn6Dkt8SwMsFFBhLB0FM/AgMBAAGj
+ggHQMIIBzDAPBgNVHRMBAf8EBTADAQEAMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggr
+BgEFBQcDAjAOBgNVHQ8BAf8EBAMCBaAwOAYDVR0fBDEwLzAtoCugKYYnaHR0cDov
+L2NybC5zdGFyZmllbGR0ZWNoLmNvbS9zZnMyLTAuY3JsMFkGA1UdIARSMFAwTgYL
+YIZIAYb9bgEHFwIwPzA9BggrBgEFBQcCARYxaHR0cDovL2NlcnRpZmljYXRlcy5z
+dGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5LzCBjQYIKwYBBQUHAQEEgYAwfjAq
+BggrBgEFBQcwAYYeaHR0cDovL29jc3Auc3RhcmZpZWxkdGVjaC5jb20vMFAGCCsG
+AQUFBzAChkRodHRwOi8vY2VydGlmaWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3Jl
+cG9zaXRvcnkvc2ZfaW50ZXJtZWRpYXRlLmNydDAfBgNVHSMEGDAWgBRJS1In0Ru8
+8qEhamJ7UUJ6itfVVjAlBgNVHREEHjAcggphZ3JlZTIuY29tgg53d3cuYWdyZWUy
+LmNvbTAdBgNVHQ4EFgQU8U68CbJHeGRhPSl2LRtx9IaocA4wDQYJKoZIhvcNAQEF
+BQADggEBACFngInbvv6YmtiwHFWZswcY7eoqMpUggXC2jmX9ZT+w9CcdgVlygow6
+jeR2HY7FPSKkm0YaDEAYYIoYeFHwaG6E4B6ykGvw5OQ4FESsQT/lxVlbeF0J1ERh
+YEpvwrVrVK/ppRd5En2hvl6kKvRyqjTcHKT/MKZ2xQXUZ6JEVKIME3HLS+IHR/Sc
+uo1aH3dXS73lFmWLH4P12KIfqnzQ938FDynW875bvKgl4HAzJj66wnMOoL5INOuK
+d+r9xUBD/uWXJPaXLzC8vuORHInLWNE4M2cpNeVNsU8siX4c9mC/Hj+Ss1nYBW0D
+4b8GcJ+tY+2Y+ODBKJn/s0qhB6TXoKM=
+-----END CERTIFICATE-----
+
@@ -0,0 +1,38 @@
+require 'key_holder_test'
+
+class User < ActiveRecord::Base
+  keyholder
+end
+
+class AssociationKeyHolderTest < KeyHolderTest
+  def setup
+    @key_holder=User.create
+  end
+  
+  def test_should_retain_session_key_on_reload
+    key=EzCrypto::Key.generate
+    key_holder.set_session_key key
+    assert_not_nil key_holder.session_key
+    assert_equal key.raw,key_holder.session_key.raw
+    
+    reloaded=User.find key_holder.id
+    assert_not_nil reloaded.session_key
+    assert_equal key.raw,reloaded.session_key.raw    
+  end
+  
+  def test_should_retain_session_key_on_reload_for_record_with_key_set_before_create
+    key=EzCrypto::Key.generate
+    key_holder=User.new
+    assert_nil key_holder.session_key
+    
+    key_holder.set_session_key key
+    assert_not_nil key_holder.session_key
+    
+    assert_equal key.raw,key_holder.session_key.raw
+    key_holder.save
+    
+    reloaded=User.find key_holder.id
+    assert_not_nil reloaded.session_key
+    assert_equal key.raw,reloaded.session_key.raw    
+  end
+end
@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: crypto_test.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: crypto_test.sqlite3.db
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: crypto_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: crypto_test
 \ No newline at end of file
@@ -0,0 +1,51 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'test/unit'
+require 'ezcrypto'
+require 'base64'
+require 'digest/sha1'
+
+class DigestTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_digest
+    ["hello","","test"].each do |data|
+      assert_equal Digest::SHA1.digest(data)[0..15],EzCrypto::Digester.digest(data)
+    end
+  end
+  
+  def test_digest64
+    ["hello","","test"].each do |data|
+      assert_equal Base64.encode64(Digest::SHA1.digest(data)[0..15]),EzCrypto::Digester.digest64(data)
+    end    
+  end
+  
+  def test_hexdigest
+    ["hello","","test"].each do |data|
+      assert_equal Digest::SHA1.hexdigest(data)[0..40],EzCrypto::Digester.hexdigest(data)
+    end
+  end
+  
+  def test_generate_key
+    key=EzCrypto::Digester.generate_key
+    assert 16,key.size
+  end
+  
+  def test_generate_key64
+    key=EzCrypto::Digester.generate_key64
+    assert 24,key.size
+    
+  end
+  
+  def test_generate_hexkey
+    key=EzCrypto::Digester.generate_hexkey
+    assert 40,key.size
+    
+  end
+  
+  def test_get_key
+    
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,12 @@
+-----BEGIN DSA PRIVATE KEY-----
+MIIBugIBAAKBgQCGwFYmCsY6XeXmC2vB2VwGy7N4jV0vjwTh22VAXLlMtKrjJJ0k
+WW/QI7wYWqttUIDQ1//ETRlW5+uV9E9WF1EtMo/Dv48LU/c1YCDjA5EAp2Wu/CnU
+Qgd6ibLNTvkzSDdiZhryuq3nv0s1hLR6cysMOWg/l6usiwU5jgWDXrMK2wIVAJS8
+gadASb6W8ZL6Ua4EqIFdYCdbAoGAWzwV5WF157O/oZeOmNv6IuV8MLD0m3JkJNkZ
+DrY0G0M7YIVryCkmvCOuu8PLu7M+GGp9hEKV/wrpWJgiOlWAz0C0yxwxMyz3GFbx
+ipqEL0CqKkl4QVMpKAhL1h2iIL+yI7p/8whcfeMnQXb0iIMD7AVvF++AJ/LAzulb
+zZXdfP8CgYApedgToseniE9KWVrV3CMXrkwf3Er5CgcVF2JJWAfBbm8/PI2wX5GU
+zT5++k+2sPISPQV3RFZiVKwdFNdft41KNNdfFPEC/4KhgHbK4nCJ3ReLiy2+MkHi
+msgzvxAg8WRc+0aZKNFlNyqsIezE6ufs8e9YvKZJ2d30ggOqCHTBtgIUZ6jIgX60
+PmOeqfRh32svQkP1p/E=
+-----END DSA PRIVATE KEY-----
@@ -0,0 +1,12 @@
+-----BEGIN PUBLIC KEY-----
+MIIBtjCCASsGByqGSM44BAEwggEeAoGBAIbAViYKxjpd5eYLa8HZXAbLs3iNXS+P
+BOHbZUBcuUy0quMknSRZb9AjvBhaq21QgNDX/8RNGVbn65X0T1YXUS0yj8O/jwtT
+9zVgIOMDkQCnZa78KdRCB3qJss1O+TNIN2JmGvK6ree/SzWEtHpzKww5aD+Xq6yL
+BTmOBYNeswrbAhUAlLyBp0BJvpbxkvpRrgSogV1gJ1sCgYBbPBXlYXXns7+hl46Y
+2/oi5XwwsPSbcmQk2RkOtjQbQztghWvIKSa8I667w8u7sz4Yan2EQpX/CulYmCI6
+VYDPQLTLHDEzLPcYVvGKmoQvQKoqSXhBUykoCEvWHaIgv7Ijun/zCFx94ydBdvSI
+gwPsBW8X74An8sDO6VvNld18/wOBhAACgYApedgToseniE9KWVrV3CMXrkwf3Er5
+CgcVF2JJWAfBbm8/PI2wX5GUzT5++k+2sPISPQV3RFZiVKwdFNdft41KNNdfFPEC
+/4KhgHbK4nCJ3ReLiy2+MkHimsgzvxAg8WRc+0aZKNFlNyqsIezE6ufs8e9YvKZJ
+2d30ggOqCHTBtg==
+-----END PUBLIC KEY-----
@@ -0,0 +1,288 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'test/unit'
+require 'fileutils'
+require 'ezsig'
+require 'base64'
+
+class EzCryptoTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def _test_generate_key #very slow so not run by default
+    signer=EzCrypto::Signer.generate
+    assert signer.rsa?
+    assert !signer.dsa?
+    
+    assert_signer(signer)
+  end
+  
+  def test_from_file
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/testsigner.pem"
+    assert signer.rsa?
+    assert !signer.dsa?
+    assert_signer(signer)
+  end
+
+  def test_dsa_from_file
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/dsakey.pem"
+    assert signer.dsa?
+    assert !signer.rsa?
+    assert_signer(signer)
+  end
+
+  def test_from_password_protected_file
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/protectedsigner.pem","secret"
+    assert signer.rsa?
+    assert !signer.dsa?
+    assert_signer(signer)
+  end
+  
+  def test_public_key_read
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/testsigner.pem"
+    verifier=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testpub.pem"
+    assert verifier
+    sig=signer.sign "test this rsa"
+    assert sig
+    assert verifier.verify( sig,"test this rsa")
+
+    assert !verifier.cert?
+    assert_equal signer.public_key.to_s, verifier.public_key.to_s
+  end
+  
+  def test_dsa_public_key_read
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/dsakey.pem"
+    verifier=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/dsapubkey.pem"
+    
+    assert verifier
+    sig=signer.sign "test this dsa"
+    assert sig
+    assert verifier.verify( sig,"test this dsa")
+
+    assert !verifier.cert?
+    
+    # This fails as it seems like it returns an incorrect public key
+#    assert_equal signer.public_key.to_s, verifier.public_key.to_s
+  end
+  
+  def test_certificate_reader
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/testsigner.pem"
+    cert=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testsigner.cert"
+    assert cert
+    assert cert.cert?
+    assert_instance_of EzCrypto::Certificate, cert
+    assert_equal signer.public_key.to_s, cert.public_key.to_s
+    
+    sig=signer.sign "hello"
+    assert sig
+    assert cert.verify( sig,"hello")
+    
+    assert_equal "/C=DK/ST=Denmark/L=Copenhagen/O=EzCrypto Test Certificate/OU=testing/CN=EzCrypto Testing/emailAddress=pelleb@gmail.com",cert.subject.to_s
+    assert_equal "/C=DK/ST=Denmark/L=Copenhagen/O=EzCrypto Test Certificate/OU=testing/CN=EzCrypto Testing/emailAddress=pelleb@gmail.com",cert.issuer.to_s
+    
+    assert_kind_of EzCrypto::Name,cert.issuer
+    assert_kind_of EzCrypto::Name,cert.subject
+    assert cert.serial
+    assert cert.not_after
+    assert cert.not_before
+    assert cert.valid?
+    
+    
+    assert_equal cert.subject[:emailAddress],"pelleb@gmail.com"
+    assert_equal cert.subject[:C],"DK"
+    assert_equal cert.subject[:ST],"Denmark"
+    assert_equal cert.subject[:L],"Copenhagen"
+    assert_equal cert.subject[:OU],"testing"
+    assert_equal cert.subject[:O],"EzCrypto Test Certificate"
+    assert_equal cert.subject[:CN],"EzCrypto Testing"
+
+    assert_equal cert.subject.emailAddress,"pelleb@gmail.com"
+    assert_equal cert.subject.C,"DK"
+    assert_equal cert.subject.ST,"Denmark"
+    assert_equal cert.subject.L,"Copenhagen"
+    assert_equal cert.subject.OU,"testing"
+    assert_equal cert.subject.O,"EzCrypto Test Certificate"
+    assert_equal cert.subject.CN,"EzCrypto Testing"
+
+    assert_equal cert.subject.email,"pelleb@gmail.com"
+    assert_equal cert.subject.c,"DK"
+    assert_equal cert.subject.st,"Denmark"
+    assert_equal cert.subject.l,"Copenhagen"
+    assert_equal cert.subject.ou,"testing"
+    assert_equal cert.subject.o,"EzCrypto Test Certificate"
+    assert_equal cert.subject.cn,"EzCrypto Testing"
+
+    assert_equal cert.subject.country,"DK"
+    assert_equal cert.subject.state,"Denmark"
+    assert_equal cert.subject.locality,"Copenhagen"
+    assert_equal cert.subject.organisational_unit,"testing"
+    assert_equal cert.subject.organisation,"EzCrypto Test Certificate"
+    assert_equal cert.subject.organizational_unit,"testing"
+    assert_equal cert.subject.organization,"EzCrypto Test Certificate"
+    assert_equal cert.subject.name,"EzCrypto Testing"
+    assert_equal cert.subject.common_name,"EzCrypto Testing"
+
+    assert_equal cert.emailAddress,"pelleb@gmail.com"
+    assert_equal cert.C,"DK"
+    assert_equal cert.ST,"Denmark"
+    assert_equal cert.L,"Copenhagen"
+    assert_equal cert.OU,"testing"
+    assert_equal cert.O,"EzCrypto Test Certificate"
+    assert_equal cert.CN,"EzCrypto Testing"
+                     
+    assert_equal cert.email,"pelleb@gmail.com"
+    assert_equal cert.c,"DK"
+    assert_equal cert.st,"Denmark"
+    assert_equal cert.l,"Copenhagen"
+    assert_equal cert.ou,"testing"
+    assert_equal cert.o,"EzCrypto Test Certificate"
+    assert_equal cert.cn,"EzCrypto Testing"
+                     
+    assert_equal cert.country,"DK"
+    assert_equal cert.state,"Denmark"
+    assert_equal cert.locality,"Copenhagen"
+    assert_equal cert.organisational_unit,"testing"
+    assert_equal cert.organisation,"EzCrypto Test Certificate"
+    assert_equal cert.organizational_unit,"testing"
+    assert_equal cert.organization,"EzCrypto Test Certificate"
+    assert_equal cert.name,"EzCrypto Testing"
+    assert_equal cert.common_name,"EzCrypto Testing"
+
+    assert_equal cert.issuer[:emailAddress],"pelleb@gmail.com"
+    assert_equal cert.issuer[:C],"DK"
+    assert_equal cert.issuer[:ST],"Denmark"
+    assert_equal cert.issuer[:L],"Copenhagen"
+    assert_equal cert.issuer[:OU],"testing"
+    assert_equal cert.issuer[:O],"EzCrypto Test Certificate"
+    assert_equal cert.issuer[:CN],"EzCrypto Testing"
+
+    assert_equal cert.issuer.emailAddress,"pelleb@gmail.com"
+    assert_equal cert.issuer.C,"DK"
+    assert_equal cert.issuer.ST,"Denmark"
+    assert_equal cert.issuer.L,"Copenhagen"
+    assert_equal cert.issuer.OU,"testing"
+    assert_equal cert.issuer.O,"EzCrypto Test Certificate"
+    assert_equal cert.issuer.CN,"EzCrypto Testing"
+
+    assert_equal cert.issuer.email,"pelleb@gmail.com"
+    assert_equal cert.issuer.c,"DK"
+    assert_equal cert.issuer.st,"Denmark"
+    assert_equal cert.issuer.l,"Copenhagen"
+    assert_equal cert.issuer.ou,"testing"
+    assert_equal cert.issuer.o,"EzCrypto Test Certificate"
+    assert_equal cert.issuer.cn,"EzCrypto Testing"
+    assert_equal cert.issuer.country,"DK"
+    assert_equal cert.issuer.state,"Denmark"
+    assert_equal cert.issuer.locality,"Copenhagen"
+    assert_equal cert.issuer.organisational_unit,"testing"
+    assert_equal cert.issuer.organisation,"EzCrypto Test Certificate"
+    assert_equal cert.issuer.organizational_unit,"testing"
+    assert_equal cert.issuer.organization,"EzCrypto Test Certificate"
+    assert_equal cert.issuer.name,"EzCrypto Testing"
+    assert_equal cert.issuer.common_name,"EzCrypto Testing"
+    
+    ## Extensions
+    
+    assert cert.extensions
+    
+  end
+  
+  def test_in_memory_store
+    trust=EzCrypto::TrustStore.new
+    cert=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testsigner.cert"
+    assert !trust.verify(cert)
+    trust.add cert
+    assert trust.verify(cert)
+    
+    sf_root=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf-class2-root.crt"
+    assert !trust.verify(sf_root)
+    starfield=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf_intermediate.crt"
+    assert !trust.verify(starfield)
+    agree2=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+    assert !trust.verify(agree2)
+    
+    trust.add sf_root
+    assert trust.verify(sf_root)
+    assert trust.verify(starfield)
+    assert !trust.verify(agree2)
+    
+    trust.add starfield
+    assert trust.verify(agree2)
+  end
+  
+  def test_disk_store
+    trust=EzCrypto::TrustStore.new File.dirname(__FILE__) + "/store"
+    sf_root=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf-class2-root.crt"
+    trust.add(sf_root)
+    assert trust.verify(sf_root)
+    starfield=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf_intermediate.crt"
+    assert trust.verify(starfield)
+    trust.add(starfield)
+    agree2=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+    assert trust.verify(agree2)
+    
+    cert=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testsigner.cert"
+    assert !trust.verify(cert)
+    trust.add cert
+    assert trust.verify(cert)
+  end
+  
+  def test_load_combined
+    certs=EzCrypto::Verifier.load_all_from_file File.dirname(__FILE__) + "/../lib/trusted.pem"
+    assert certs.is_a?( Array)
+    assert certs.size>1
+    certs.each do |cert|
+      assert_instance_of EzCrypto::Certificate, cert
+    end
+  end
+  
+  def test_load_trusted_truststore
+    trust=EzCrypto::TrustStore.default_trusted
+    sf_root=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf-class2-root.crt"
+    assert trust.verify(sf_root)
+    starfield=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf_intermediate.crt"
+    assert trust.verify(starfield)
+    agree2=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+    assert trust.verify(agree2)
+    
+    cert=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testsigner.cert"
+    assert !trust.verify(cert)
+    trust.add cert
+    assert trust.verify(cert)  
+  end
+
+# Disabling these until pkyp is back up  
+#  def test_public_key_load_from_pkyp
+#    verifier=EzCrypto::Verifier.from_pkyp "e93e18114cbefaaa89fda908b09df63d3662879a"
+#    agree2=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+#    assert_equal agree2.cert.to_s,verifier.cert.to_s
+#    assert verifier
+#  end
+#
+#  def test_register_public_key_at_pkyp
+#    pub=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+#    assert_equal pub.digest,pub.register_with_pkyp
+#  end
+#  
+#  def test_create_register_and_fetch_public_key
+#    signer=EzCrypto::Signer.generate
+#    assert_equal signer.verifier.digest,signer.verifier.register_with_pkyp
+#    verifier=EzCrypto::Verifier.from_pkyp signer.verifier.digest
+#    sig=signer.sign "hello"
+#    assert sig
+#    assert verifier.verify( sig,"hello")    
+#  end
+#  
+  
+  def assert_signer(signer)
+    assert signer
+    assert signer.public_key
+    
+    sig=signer.sign "hello"
+    assert sig
+    assert signer.verifier
+    assert signer.verifier.verify( sig,"hello")
+  end
+  
+end
 \ No newline at end of file
@@ -0,0 +1,41 @@
+require 'association_key_holder_test'
+
+class EncUser < ActiveRecord::Base
+  set_table_name "users"
+  encrypt :name, :base64=>true
+end
+
+class RawUser < ActiveRecord::Base
+  set_table_name "users"
+end
+
+class EncryptTest < AssociationKeyHolderTest
+  def setup
+    @key_holder=EncUser.create 
+  end
+  
+  def test_should_be_base64
+    assert EncUser.ezcrypto_base64?
+  end
+  
+  def test_should_retain_session_key_on_reload
+    key=EzCrypto::Key.generate
+    key_holder.set_session_key key
+    assert_not_nil key_holder.session_key
+    assert_equal key.raw,key_holder.session_key.raw
+    
+    key_holder.name="bob"
+    key_holder.save
+    
+    assert_equal "bob",key_holder.name
+    
+    found=EncUser.find key_holder.id
+    assert_equal key_holder.name,found.name
+    
+    raw=RawUser.find key_holder.id
+    assert_not_nil raw.name
+    assert_not_equal key_holder.name,raw.name
+    
+  end
+  
+end
@@ -0,0 +1,212 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'test/unit'
+require 'fileutils'
+require 'ezcrypto'
+require 'base64'
+
+class EzCryptoTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_generate_alg_key
+    assert_generate_alg_key "aes-128-cbc",16
+    assert_generate_alg_key "aes-192-cbc",24
+    assert_generate_alg_key "aes-256-cbc",32    
+    assert_generate_alg_key "rc2-40-cbc",5 
+    assert_generate_alg_key "rc2-64-cbc",8
+    assert_generate_alg_key "rc4-64" ,8
+    assert_generate_alg_key "blowfish" ,16
+    assert_generate_alg_key "des" ,8
+  end
+  
+  def test_with_password
+      assert_with_password "","secret","aes-128-cbc",16
+      assert_with_password "test","secret","aes-128-cbc",16
+      assert_with_password "password","secret","aes-128-cbc",16
+      assert_with_password "a�sldfad8q5�34j2�l4j24l6j2456","secret","aes-128-cbc",16
+      
+      assert_with_password "","secret","aes-192-cbc",24
+      assert_with_password "test","secret","aes-192-cbc",24
+      assert_with_password "password","secret","aes-192-cbc",24
+      assert_with_password "a�sldfad8q5�34j2�l4j24l6j2456","secret","aes-192-cbc",24
+
+      assert_with_password "","secret","aes-256-cbc",32
+      assert_with_password "test","secret","aes-256-cbc",32
+      assert_with_password "password","secret","aes-256-cbc",32
+      assert_with_password "a�sldfad8q5�34j2�l4j24l6j2456","secret","aes-256-cbc",32
+
+  end
+
+  def test_encoded
+    0.upto 32 do |size|
+      assert_encoded_keys size
+    end
+  end
+  
+  def test_encrypt    
+    0.upto(CLEAR_TEXT.size-1) do |size|
+      assert_encrypt CLEAR_TEXT[0..size]
+    end  
+  end
+  
+  def test_decrypt    
+    0.upto(CLEAR_TEXT.size) do |size|
+      assert_decrypt CLEAR_TEXT[0..size]
+    end  
+  end
+
+  def test_decrypt64
+    0.upto(CLEAR_TEXT.size) do |size|
+      assert_decrypt64 CLEAR_TEXT[0..size]
+    end  
+  end
+    
+  def test_keyfile_store_load
+
+    algo, size = "aes-256-cbc", 32   
+    keyfile = 'ezcrypto-test.key'
+    
+    FileUtils.rm [keyfile], :force => true
+    key = EzCrypto::Key.generate :algorithm => algo    
+    assert_file_not_exists keyfile    
+    key.store keyfile    
+    assert_file_exists keyfile    
+    assert_file_permissions keyfile, 0100400    
+    
+    key2 = EzCrypto::Key.load(keyfile)    
+    assert_equal key.raw, key2.raw
+    
+    FileUtils.rm [keyfile], :force => true    
+  end
+  
+  def test_filestuff_with_defaults      
+
+    clearfile = 'lorem_ipsum.txt'
+    keyfile = 'lorem_ipsum.key'
+    algo, size = "aes-256-cbc", 32
+    
+    File.open(clearfile, 'w') { |f| f.write(CLEAR_TEXT) }
+    assert_file_contains clearfile, CLEAR_TEXT    
+
+    key = EzCrypto::Key.generate :algorithm => algo    
+
+    # default behaviour: remove clearfile, append '.ez' suffix  
+    cryptfile = key.encrypt_file(clearfile)    
+    assert_equal cryptfile, clearfile + ".ez"
+    assert_file_not_exists clearfile
+    assert_file_exists cryptfile 
+    assert_file_contains cryptfile, key.encrypt(CLEAR_TEXT)    
+
+    # default behaviour: unlink cryptfile and remove suffix from filename
+    clearfile = key.decrypt_file cryptfile
+    assert_file_exists clearfile
+    assert_file_not_exists cryptfile
+    assert_file_contains clearfile, CLEAR_TEXT    
+    FileUtils.rm [keyfile, clearfile, cryptfile], :force => true
+  end
+  
+  def test_filestuff_with_options
+  
+    clearfile = 'lorem_ipsum.txt'
+    keyfile = 'lorem_ipsum.key'
+    algo, size = "aes-256-cbc", 32    
+
+    File.open(clearfile, 'w') { |f| f.write(CLEAR_TEXT) }
+    assert_file_contains clearfile, CLEAR_TEXT
+    
+    key = EzCrypto::Key.generate :algorithm => algo      
+    
+    # with options: keep the original file, auto-create a 
+    # new filename with a user-defined suffix        
+    cryptfile = key.encrypt_file(clearfile, nil, :autoclean => false, :suffix => '.Encrypted')
+    assert_equal cryptfile, clearfile + ".Encrypted", 'suffix was added'
+    assert_file_exists clearfile
+    assert_file_exists cryptfile    
+    assert_file_permissions cryptfile, 0100600
+    
+    assert_raises(Errno::EEXIST, "the original file would not be overwritten") { 
+      key.decrypt_file(cryptfile, nil, :autoclean => false, :suffix => '.Encrypted')
+    } 
+    FileUtils.rm [clearfile], :force => true    
+
+    clearfile = key.decrypt_file(cryptfile, nil, :autoclean => false, :suffix => '.Encrypted')
+    assert_equal cryptfile, clearfile + ".Encrypted", 'suffix was removed'    
+    assert_file_exists clearfile
+    assert_file_exists cryptfile
+    assert_file_permissions cryptfile, 0100600    
+    assert_file_contains clearfile, CLEAR_TEXT    
+
+    FileUtils.rm [keyfile, clearfile, cryptfile], :force => true        
+  end
+    
+  def assert_file_permissions(filename, mode, msg='')
+    fmode = File.stat(filename).mode
+    assert_equal fmode, mode, msg 
+  end
+  
+  def assert_file_exists(filename)
+    assert File.exists?(filename)
+  end
+
+  def assert_file_not_exists(filename)
+    assert !File.exists?(filename)
+  end
+  
+  def assert_file_contains(filename, expected)
+    assert_file_exists(filename)
+    content = File.open(filename,'r').read
+    assert_equal expected, content
+  end
+  
+  def assert_key_size(size,key)
+    assert_equal size,key.raw.size      
+  end
+  
+  def assert_generate_alg_key(algorithm,size)
+    key=EzCrypto::Key.generate :algorithm=>algorithm
+    assert_key_size size,key 
+  end
+ 
+  def assert_with_password(password,salt,algorithm,size)
+    key=EzCrypto::Key.with_password password,salt,:algorithm=>algorithm
+    assert_key_size size,key
+    assert_equal key.raw,EzCrypto::Key.with_password( password,salt,:algorithm=>algorithm).raw
+  end
+  
+  def assert_encoded_keys(size)
+    key=EzCrypto::Key.generate size
+    key2=EzCrypto::Key.decode(key.encode)
+    assert_equal key.raw, key2.raw    
+  end
+  
+  def assert_encrypt(clear)
+    ALGORITHMS.each do |alg|
+      key=EzCrypto::Key.generate :algorithm=>alg
+      encrypted=key.encrypt clear
+      assert_not_nil encrypted    
+    end
+  end
+  
+  def assert_decrypt(clear)
+    ALGORITHMS.each do |alg|
+      key=EzCrypto::Key.generate :algorithm=>alg
+      encrypted=key.encrypt clear
+      assert_not_nil encrypted
+      assert_equal clear,key.decrypt(encrypted)
+    end
+  end
+  
+  def assert_decrypt64(clear)
+    key=EzCrypto::Key.generate
+    encrypted=key.encrypt64 clear
+    assert_not_nil encrypted
+    assert_equal clear,key.decrypt64(encrypted)
+  end
+  
+  ALGORITHMS=["aes128","bf","blowfish","des","des3","rc4","rc2"]
+  CLEAR_TEXT="Lorem ipsum dolor sit amet, suspendisse id interdum mus leo id. Sapien tempus consequat nullam, platea vitae sociis sed elementum et fermentum, vel praesent eget. Sed blandit augue, molestie mus sed habitant, semper voluptatibus neque, nullam a augue. Aptent imperdiet curabitur, quam quis laoreet. Dolor magna. Quis vestibulum amet eu arcu fringilla nibh, mi urna sunt dictumst nulla, elit quisque purus eros, sem hendrerit. Vulputate tortor rhoncus ac nonummy tortor nulla. Nunc id nunc luctus ligula."
+end
+
+
@@ -0,0 +1,44 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'test/unit'
+require 'active_crypto'
+class KeyHolderSubject
+  include ActiveCrypto::KeyHolder
+end
+
+class KeyHolderTest < Test::Unit::TestCase
+  
+  attr :key_holder
+  
+  def setup
+    @key_holder=KeyHolderSubject.new
+  end
+  
+  def test_session_key_should_not_be_set_on_new
+    assert_nil key_holder.session_key
+  end
+  
+  def test_set_session_key_should_set_session_key
+    key=EzCrypto::Key.generate
+    key_holder.set_session_key key
+    assert_not_nil key_holder.session_key
+    assert_equal key.raw,key_holder.session_key.raw
+  end
+  
+  def test_set_encoded_key_should_set_session_key
+    key=EzCrypto::Key.generate
+    key_holder.set_encoded_key key.encode
+    assert_not_nil key_holder.session_key
+    assert_equal key.raw,key_holder.session_key.raw
+  end
+  
+  def test_enter_password_should_set_session_key
+    key=EzCrypto::Key.with_password "test","onetwothree"
+    key_holder.enter_password "test"
+    assert_not_nil key_holder.session_key
+    assert_equal key.raw,key_holder.session_key.raw
+  end
+  
+    
+end
+
@@ -0,0 +1,12 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,C730C2D8284C5EC8
+
+DU3RsKWpbDaiFA4DUu+5VBCbF5FQvNxQJXZ9s7qw8Odk/gTbI3WFWygaZSS1FGxr
+lFYz04hQB6Zm31EKqwBlvhJdEkDlpWAI1VCTOHFjfzA/fmiv1W5v0Cj7jm3KHQqo
+lmmDyIT9fbUKgiHBb9oCLn0N34DhbqQ4lSsGzwI9bTl+CWd593f+SFqq2SLAZ+gw
+wfaedG0PSjdylXMyUuLQtOe5T1F0Y+MfFmVE4CvBYlKl/qnVz3nn8iL1RkdQkvHB
+Z/JZEhjtu/FD0AvjCZD8frO+Le1vBxBCO+vx+tKiDeFpJTxWZM6kLBHvvFYtdvce
+ktQhyLLn40LiP4lj7Dq/IbqW+OWEge91ioC8uOAACTqmxLVyKPE9IiOHqoDb3gfw
+jCgYGLJdDhYdnD/f/8nuDJErflhKyAHh6OdbqREMRMg=
+-----END RSA PRIVATE KEY-----
@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl
+MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp
+U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw
+NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE
+ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp
+ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3
+DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf
+8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN
++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0
+X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa
+K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA
+1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G
+A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR
+zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0
+YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD
+bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w
+DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3
+L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D
+eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl
+xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp
+VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY
+WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q=
+-----END CERTIFICATE-----
@@ -0,0 +1,29 @@
+-----BEGIN CERTIFICATE-----
+MIIFBzCCA++gAwIBAgICAgEwDQYJKoZIhvcNAQEFBQAwaDELMAkGA1UEBhMCVVMx
+JTAjBgNVBAoTHFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsT
+KVN0YXJmaWVsZCBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2
+MTExNjAxMTU0MFoXDTI2MTExNjAxMTU0MFowgdwxCzAJBgNVBAYTAlVTMRAwDgYD
+VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy
+ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTkwNwYDVQQLEzBodHRwOi8vY2VydGlm
+aWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkxMTAvBgNVBAMTKFN0
+YXJmaWVsZCBTZWN1cmUgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxETAPBgNVBAUT
+CDEwNjg4NDM1MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4qddo+1m
+72ovKzYf3Y3TBQKgyg9eGa44cs8W2lRKy0gK9KFzEWWFQ8lbFwyaK74PmFF6YCkN
+bN7i6OUVTVb/kNGnpgQ/YAdKym+lEOez+FyxvCsq3AF59R019Xoog/KTc4KJrGBt
+y8JIwh3UBkQXPKwBR6s+cIQJC7ggCEAgh6FjGso+g9I3s5iNMj83v6G3W1/eXDOS
+zz4HzrlIS+LwVVAv+HBCidGTlopj2WYN5lhuuW2QvcrchGbyOY5bplhVc8tibBvX
+IBY7LFn1y8hWMkpQJ7pV06gBy3KpdIsMrTrlFbYq32X43or174Q7+edUZQuAvUdF
+pfBE2FM7voDxLwIDAQABo4IBRDCCAUAwHQYDVR0OBBYEFElLUifRG7zyoSFqYntR
+QnqK19VWMB8GA1UdIwQYMBaAFL9ft9HO3R+G9FtVrNzXEMIOqYjnMBIGA1UdEwEB
+/wQIMAYBAf8CAQAwOQYIKwYBBQUHAQEELTArMCkGCCsGAQUFBzABhh1odHRwOi8v
+b2NzcC5zdGFyZmllbGR0ZWNoLmNvbTBMBgNVHR8ERTBDMEGgP6A9hjtodHRwOi8v
+Y2VydGlmaWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkvc2Zyb290
+LmNybDBRBgNVHSAESjBIMEYGBFUdIAAwPjA8BggrBgEFBQcCARYwaHR0cDovL2Nl
+cnRpZmljYXRlcy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5MA4GA1UdDwEB
+/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAhlK6sx+mXmuQpmQq/EWyrp8+s2Kv
+2x9nxL3KoS/HnA0hV9D4NiHOOiU+eHaz2d283vtshF8Mow0S6xE7cV+AHvEfbQ5f
+wezUpfdlux9MlQETsmqcC+sfnbHn7RkNvIV88xe9WWOupxoFzUfjLZZiUTIKCGhL
+Indf90XcYd70yysiKUQl0p8Ld3qhJnxK1w/C0Ty6DqeVmlsFChD5VV/Bl4t0zF4o
+aRN+0AqNnQ9gVHrEjBs1D3R6cLKCzx214orbKsayUWm/EheSYBeqPVsJ+IdlHaek
+KOUiAgOCRJo0Y577KM/ozS4OUiDtSss4fJ2ubnnXlSyokfOGASGRS7VApA==
+-----END CERTIFICATE-----
 \ No newline at end of file
@@ -0,0 +1,35 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'rubygems'
+require 'action_pack'
+require 'active_record'
+#require 'active_support/binding_of_caller'
+#require 'active_support/breakpoint'
+
+
+unless defined?(RAILS_ROOT)
+  root_path = File.join(File.dirname(__FILE__), '..')
+  unless RUBY_PLATFORM =~ /mswin32/
+    require 'pathname'
+    root_path = Pathname.new(root_path).cleanpath.to_s
+  end
+  RAILS_ROOT = root_path
+end
+
+
+require 'active_record/fixtures'
+require 'initializer'
+
+Rails::Initializer.run(:set_load_path)
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(
+    :adapter  => "mysql",
+    :host     => "localhost",
+    :username => "root",
+    :password => "",
+    :database => "crypto_test"
+  )
+#load(File.dirname(__FILE__) + "/schema.rb")
+
@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQC6tQ2LfDcjyqlOLodJUUux+l4Gw/jkacpW6kwhfvV03QJzRaz8
+OrGkf+WKLPfQnCLma40aL2hpleTTd7SEiLSd3d77hySJ842rcYFlBfj0ldFyf9D3
+PUf1qpK/9f24C19bQwcSIDHBJOj7vlaW8rWtk0J5YOfRCTKD+tqTA400eQIDAQAB
+AoGBAJWqgxQYW78mOvfAFpSwRWSDVZJI0CCRqTBpGuQS+MJYVBmBdfyvNC2wlJli
+GLkyIEvjVTXzYNia3tahc6R2TYmL/9vQxXfoOOgbhJ0VgNofvXsU0vEcuomqDhHS
+ZeH1EJnM27/Yk5o2/WOY3iexRY1urjrpBMNWLiH7wizfmM9tAkEA5x0ViHInGzv5
+X2GB3TpJNhE2+5Kxw+keuBWsEiyBjOarJfHOPMHGBlssIIKM0k24pDOPuyhc5N6h
+F4XOMPdLXwJBAM7P2v0d2cVJTENi8OK7DjbBu/YBv/AHPyC5bz7cHySlUeNewWYy
+HXYBdSnpdVHJizMYjajjO+TQ+9BKsYHi5ycCQDm/0rmdjJgJjG6A9upIvjJ8arjC
+FxlVDxAAmlaQOG701J9OpLIZ2VmNPqGA/Z8vPIwLNkcV9uBZoPc3wCYMJRECQQDJ
+1rBaIjz8P4oPpkuEbJz1seRYtuJ1Rw1ESdYZmklGwZYG+t5zd+uq1MddTTyzwqh5
+CLiQoJ0+tvtcENnm8uU3AkEA2EIbaxJaadxUO71+banckjCFmv8H2fKAA391ev1/
+HTI088ych8V3sIUIAELhEo2K83fticAGgIdf7nPhDVgdpQ==
+-----END RSA PRIVATE KEY-----
@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIBujCCASMCAQAwejELMAkGA1UEBhMCREsxEDAOBgNVBAgTB0Rlbm1hcmsxEzAR
+BgNVBAcTCkNvcGVuaGFnZW4xETAPBgNVBAoTCEV6Q3J5cHRvMRAwDgYDVQQLEwdU
+ZXN0aW5nMR8wHQYDVQQDExZUZXN0IENoaWxkIENlcnRpZmljYXRlMIGfMA0GCSqG
+SIb3DQEBAQUAA4GNADCBiQKBgQC6tQ2LfDcjyqlOLodJUUux+l4Gw/jkacpW6kwh
+fvV03QJzRaz8OrGkf+WKLPfQnCLma40aL2hpleTTd7SEiLSd3d77hySJ842rcYFl
+Bfj0ldFyf9D3PUf1qpK/9f24C19bQwcSIDHBJOj7vlaW8rWtk0J5YOfRCTKD+tqT
+A400eQIDAQABoAAwDQYJKoZIhvcNAQEFBQADgYEAYKpGkiS4mXsD9SWtS0bvaMG8
+4UzHnZmhL4B6x3f45r5guy4c7/xIJUkxixFr/oAkOF86MGiFxNY4sZjBnrckWNzD
+CWirSMYmrc1XQwA3C9Nu5LYqUzJ6bVlXh1ySzXJo08+9JJb1vklBh5QMl/KvGsee
+RFW1LcQJ7XdwRxPyUlo=
+-----END CERTIFICATE REQUEST-----
@@ -0,0 +1,4 @@
+-----BEGIN PUBLIC KEY-----
+MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAMGB7PmHYNEUqzxptHfNDTzLxLRa7iIj
+7aEKOn+ozqLUDCFo5UTS5SkZTdUv/FCYXANfzSZgDZLGLZB8ZHJuCkECAwEAAQ==
+-----END PUBLIC KEY-----
 \ No newline at end of file
@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDWDCCAwKgAwIBAgIJAKV7PmO5YH5XMA0GCSqGSIb3DQEBBQUAMIGmMQswCQYD
+VQQGEwJESzEQMA4GA1UECBMHRGVubWFyazETMBEGA1UEBxMKQ29wZW5oYWdlbjEi
+MCAGA1UEChMZRXpDcnlwdG8gVGVzdCBDZXJ0aWZpY2F0ZTEQMA4GA1UECxMHdGVz
+dGluZzEZMBcGA1UEAxMQRXpDcnlwdG8gVGVzdGluZzEfMB0GCSqGSIb3DQEJARYQ
+cGVsbGViQGdtYWlsLmNvbTAeFw0wOTAzMTAxNjUwMjVaFw0xOTAzMDgxNjUwMjVa
+MIGmMQswCQYDVQQGEwJESzEQMA4GA1UECBMHRGVubWFyazETMBEGA1UEBxMKQ29w
+ZW5oYWdlbjEiMCAGA1UEChMZRXpDcnlwdG8gVGVzdCBDZXJ0aWZpY2F0ZTEQMA4G
+A1UECxMHdGVzdGluZzEZMBcGA1UEAxMQRXpDcnlwdG8gVGVzdGluZzEfMB0GCSqG
+SIb3DQEJARYQcGVsbGViQGdtYWlsLmNvbTBcMA0GCSqGSIb3DQEBAQUAA0sAMEgC
+QQDBgez5h2DRFKs8abR3zQ08y8S0Wu4iI+2hCjp/qM6i1AwhaOVE0uUpGU3VL/xQ
+mFwDX80mYA2Sxi2QfGRybgpBAgMBAAGjggEPMIIBCzAdBgNVHQ4EFgQUNdcj4z5p
+YRKfpdfN+Y+EeklG7n0wgdsGA1UdIwSB0zCB0IAUNdcj4z5pYRKfpdfN+Y+EeklG
+7n2hgaykgakwgaYxCzAJBgNVBAYTAkRLMRAwDgYDVQQIEwdEZW5tYXJrMRMwEQYD
+VQQHEwpDb3BlbmhhZ2VuMSIwIAYDVQQKExlFekNyeXB0byBUZXN0IENlcnRpZmlj
+YXRlMRAwDgYDVQQLEwd0ZXN0aW5nMRkwFwYDVQQDExBFekNyeXB0byBUZXN0aW5n
+MR8wHQYJKoZIhvcNAQkBFhBwZWxsZWJAZ21haWwuY29tggkApXs+Y7lgflcwDAYD
+VR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAANBAGF11JQ6+PaaklljorNsSMsvikM4
+xD8CiqYnM/TueQR6N5eWHL5L7tElfM2SxecwBtwiHpCzhPoXXBfRjCzj3Dg=
+-----END CERTIFICATE-----
@@ -0,0 +1,9 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIBOgIBAAJBAMGB7PmHYNEUqzxptHfNDTzLxLRa7iIj7aEKOn+ozqLUDCFo5UTS
+5SkZTdUv/FCYXANfzSZgDZLGLZB8ZHJuCkECAwEAAQJBAK9EHb54xtE49ku2tjWY
+LPg228g7X9reTdoBqLB91gMVlXwNAVyHMTHakhIC73K3qq9k4H1D59w1wjzx4nXJ
+/v0CIQD1R0vhhdlY2GqC+1EFCm+rPjamixcszDF2XSNp4WcwXwIhAMn3Td4aIpf6
+A9O4SIbisZaOm0DlfO2O5GMkaF+eqElfAiBHcjcmQCjpelC8Spx1DW8twHeG16ku
+gWQ/CC5SnzfBnQIgIvo3fB2enB9qhkJGHUYpZ1+vN6AG8MVsfFcT1GuPzZUCIEbx
+VUGyBYwuUfvCG88KM0NznR8xFtWD4WQ8SQejX5AN
+-----END RSA PRIVATE KEY-----
@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0
+IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz
+BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y
+aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG
+9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMTk1NFoXDTE5MDYy
+NjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y
+azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw
+Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl
+cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOOnHK5avIWZJV16vY
+dA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVCCSRrCl6zfN1SLUzm1NZ9
+WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7RfZHM047QS
+v4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9v
+UJSZSWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTu
+IYEZoDJJKPTEjlbVUjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwC
+W/POuZ6lcg5Ktz885hZo+L7tdEy8W9ViH0Pd
+-----END CERTIFICATE-----
	@@ -0,0 +1 @@		@@ -0,0 +1 @@
		1	+../vendor/ezcrypto-0.7.2/lib/ezcrypto.rb
0	\ No newline at end of file	2	\ No newline at end of file
@@ -0,0 +1,85 @@		@@ -0,0 +1,85 @@
	1	+0.7.2 March, 2009 support for base64 encrypted attributes in ActiveCrypto (Micah Wedemeyer)
	2	+
	3	+0.7 September 12th, 2006 PKYP services support
	4	+
	5	+Marking the release of http://pkyp.org a new no nonsense Public Key directory, this allows you register your public keys and certificates on a public server. If you have web applications with certificates or public keys you can point your users at http://pkyp.org/{key.digest} for more info about a certificate.
	6	+
	7	+Register a public key or certificate at PKYP with the new method register_with_pkyp like this:
	8	+
	9	+ signer=EzCrypto::Signer.generate
	10	+ signer.verifier.register_with_pkyp
	11	+
	12	+If you have the public key or certificate digest you can fetch the full public key or certificate like this:
	13	+
	14	+ verifier=EzCrypto::Verifier.from_pkyp "e93e18114cbefaaa89fda908b09df63d3662879a"
	15	+ verifier.verify sig, request_text
	16	+
	17	+This allows a simpler way of transfering certificates. The idea of including certificates with every request is not really necessary in an online world. For example you could pass the digest in a HTTP header for a REST web services request.
	18	+
	19	+0.6.2 August 15th, 2006 Trust something release
	20	+
	21	+Now comes complete with a fairly trusted list of root certs as extracted from Apple's keystore. With the addition of CACerts and GoDaddy SSL Certs (Buy from http://widecert.net). If you feel any important ones are missing let me know.
	22	+
	23	+You can create a trust store from this with TrustStore.default_trusted. Note many of these CA's are useless and you shouldn't really trust them, but this makes it easy to emulate the browsers support.
	24	+
	25	+0.6.1 August 14th, 2006 Subject!=Issuer bug fix
	26	+
	27	+I discovered a not so little bug in the certificate handling. The issuer method of the Certificate mistakenly returned the subject.
	28	+
	29	+0.6 August 10th, 2006 Certified PKI release
	30	+
	31	+Finally I have had a good reason http://www.tractis.com to add Digital Signature support to EzCrypto. We have support for RSA and DSA private and public keys as well as basic X509 certificate support. All in typical EzCrypto simple Ruby like methods.
	32	+
	33	+KNOWN PROBLEM. The DSA Signer.public_key method has some sort of problem but will be fixed for 0.6.1.
	34	+
	35	+0.5 July 19th, 2006 Good citizen release
	36	+
	37	+I have cleaned up the ActiveCrypto namespaces. It now does not use ActiveRecord::Crypto, but ActiveCrypto::*, if you have called stuff directly please update your code.
	38	+
	39	+The reason for this is to really be a good citizen in the world of rails and not unnecessarily pollute the ActiveRecord name space.
	40	+
	41	+I have also created much more thorough unit tests and refactored some things that did not work in version 0.4 that the world thankfully did not see.
	42	+
	43	+0.4 Flawed internal release
	44	+
	45	+0.3 February 25th, 2006 new encrypted file support by Dirk (dirk.barnikel@gmx.de) Thanks Dirk.
	46	+
	47	+* Added test case for the file-related stuff. file-stuff
	48	+ seems to work fine
	49	+
	50	+* Replaced hard coded IO buffersize (512) with class attribute
	51	+ Key#block_size and default value.
	52	+
	53	+* Modification to create {De,En}crypters only via the factory methods
	54	+ Key#{de,en}crypter.
	55	+
	56	+* Added Key#{de,en}crypt_file methods that take a file and de- or encrypts it.
	57	+
	58	+* The methods are implemented to call the cipher with small chunks of data (512 bytes) to keep memory usage low.
	59	+
	60	+* By default, the original file is first overwritten and then removed.
	61	+
	62	+* This overwrite is not really safe but should make it harder to restore the data of the removed file from the filesystem.
	63	+
	64	+* Added Key#{store,load} methods that read and write Key data to/from files.
	65	+
	66	+* Added Key#safe_{create,delete,read} methods to encapsulate the handling of files inside EzCrypto.
	67	+
	68	+0.2.2 January 4th, 2006 Bug fixes and unit tests for active_crypto
	69	+
	70	+There were some serious problems with ActiveCrypto's support for having keys in associated classes. I also added unit tests to active_crypto. The support code was brutaly stolen from Rick Olson's acts_as_paranoid library. Unfortunately I disabled the schema stuff for now, but will add it in the next release, which hopefully is soon.
	71	+
	72	+0.2.1 November 2nd, 2005 New method in KeyHolder
	73	+
	74	+Added set_encoded_key(enc) to KeyHolder for setting a key with the Base64 encoded keyvalue.
	75	+
	76	+0.2 October 30th, 2005 Ruby on Rails integration
	77	+
	78	+As promised I have now included my first version of ActiveCrypto the crypto layer for ActiveRecord and Ruby on Rails.
	79	+
	80	+0.1.1 August 27, 2005 Minor fixes
	81	+
	82	+Thanks to Jason Vasquez mugatu at mugfu dot com for noticing that Key#to_s
	83	+called the nonexistent encoded method.
	84	+
	85	+I also made a few slight changes to the documentation.
@@ -0,0 +1,21 @@		@@ -0,0 +1,21 @@
	1	+Copyright (c) 2004 David Heinemeier Hansson
	2	+
	3	+Permission is hereby granted, free of charge, to any person obtaining
	4	+a copy of this software and associated documentation files (the
	5	+"Software"), to deal in the Software without restriction, including
	6	+without limitation the rights to use, copy, modify, merge, publish,
	7	+distribute, sublicense, and/or sell copies of the Software, and to
	8	+permit persons to whom the Software is furnished to do so, subject to
	9	+the following conditions:
	10	+
	11	+The above copyright notice and this permission notice shall be
	12	+included in all copies or substantial portions of the Software.
	13	+
	14	+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	15	+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	16	+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	17	+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
	18	+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	19	+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	20	+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	21	+
@@ -0,0 +1,152 @@		@@ -0,0 +1,152 @@
	1	+= EzCrypto - Easy to use Crypto for Ruby
	2	+
	3	+EzCrypto is an easy to use wrapper around the poorly documented OpenSSL ruby library.
	4	+
	5	+== Features
	6	+
	7	+* Defaults to AES 128 CBC
	8	+* Will use the systems OpenSSL library for transparent hardware crypto support
	9	+* Single class object oriented access to most commonly used features
	10	+* Ruby like
	11	+
	12	+== Installation
	13	+
	14	+Download it from here:
	15	+
	16	+http://rubyforge.org/frs/?group_id=755
	17	+
	18	+or install it via Ruby Gems:
	19	+
	20	+ gem install ezcrypto
	21	+
	22	+== Simple examples
	23	+
	24	+==== To encrypt:
	25	+
	26	+Generate a key using a password and a salt. Use the keys encrypt method to encrypt a strings worth of data:
	27	+
	28	+ @key=EzCrypto::Key.with_password "password", "system salt"
	29	+ @encrypted=@key.encrypt "Top secret should not be revealed"
	30	+
	31	+==== To decrypt:
	32	+
	33	+Same procedure as encrypt. Generate a key using a password and a salt. Use the keys decrypt method to decrypt a strings worth of data:
	34	+
	35	+ @key=EzCrypto::Key.with_password "password", "system salt"
	36	+ @key.decrypt @encrypted
	37	+
	38	+==== One liners:
	39	+
	40	+These simple examples use one line each:
	41	+
	42	+ @encrypted=EzCrypto::Key.encrypt_with_password "password", @salt,"Top secret should not be revealed"
	43	+
	44	+ EzCrypto::Key.decrypt_with_password "password", @salt,@encrypted
	45	+
	46	+== Keys
	47	+
	48	+The only class you need to know for most uses og EzCrypto is the Key class. You don't need understand ciphers or the encryption life cycle.
	49	+
	50	+==== Generating a random key
	51	+
	52	+The most secure type of key is the randomly generated key:
	53	+
	54	+ @key=EzCrypto::Key.generate
	55	+
	56	+==== Initializing a key with raw key data
	57	+
	58	+If you already have a key from some other source, you simply have to call the constructor with the raw data:
	59	+
	60	+ @key=EzCrypto::Key.new @binarykey
	61	+
	62	+==== Initializing a Key with a Base64 encoded key
	63	+
	64	+As seen above you can create a key from a password. This should be used if you don't want the key to be stored on disk for example:
	65	+
	66	+ @key=EzCrypto::Key.with_password "Secret password"
	67	+
	68	+==== Initializing a Key with a Base64 encoded key
	69	+
	70	+If you already have a key from some other source in the popular Base64 encoded format, you use the decode class method:
	71	+
	72	+ @key=EzCrypto::Key.decode @binarykey
	73	+
	74	+==== Exporting the key
	75	+
	76	+To export or save a key use the encode method (or to_s) method for a Base64 encoded key or raw as the raw binary data.
	77	+
	78	+ puts @key.encode
	79	+ puts @key.raw
	80	+
	81	+The raw method could be used for storing in a database using a tinyblob column.
	82	+
	83	+== Encryption and Decryption
	84	+
	85	+EzCrypto is optimized for simple encryption and decryption of strings. There are encrypt/decrypt pairs for normal binary use as well as for Base64 encoded use.
	86	+
	87	+==== Regular raw use
	88	+
	89	+Assuming you have generated a key using one of the above methods:
	90	+
	91	+ @encrypted=@key.encrypt("clear text")
	92	+ @decrypted=@key.decrypt(@encrypted)
	93	+ assert "clear text", @decrypted
	94	+
	95	+==== Base64 encoded use
	96	+
	97	+This uses the encrypt64 and decrypt64 methods. Otherwise it is all the same:
	98	+
	99	+ @encrypted=@key.encrypt64("clear text")
	100	+ @decrypted=@key.decrypt64(@encrypted)
	101	+ assert "clear text", @decrypted
	102	+
	103	+== FAQ
	104	+
	105	+=== What algorithm does this use?
	106	+
	107	+It uses as the default algorithm the AES 128 bit standard. This is a very fast and highly secure algorithm specified as the national standard in the US. For more information see:
	108	+
	109	+http://en.wikipedia.org/wiki/AES
	110	+
	111	+=== Only 128 bits. Is that enough?
	112	+
	113	+While it might sound like more would make it more secure, there is really no real security advantage for most commercial applications to use more than 128 bit AES.
	114	+
	115	+=== What is Base64 encoding?
	116	+
	117	+This is the most efficient and commonly used encoding scheme for binary data. This is used amongst other things for email attachments. It is also very common to use it for encrypted data.
	118	+
	119	+=== What is a Salt?
	120	+
	121	+A salt is just a piece of data we hash in with the password to create the key. If it is a server based application you could use store a salt within your source file. The salt must be the same for both encryption and decryption.
	122	+
	123	+
	124	+== License
	125	+
	126	+EzCrypto and ActionCrypto is released under the MIT license.
	127	+
	128	+
	129	+== Support
	130	+
	131	+To contact the author, send mail to pelle@stakeventures.com
	132	+
	133	+Also see my blogs at:
	134	+http://stakeventures.com and
	135	+http://blog.extraeagle.com
	136	+
	137	+This project was based on code used in my projects Agree2, WideWord and WideBlog.
	138	+
	139	+Agree2 lets you create legal business agreements instantly.
	140	+
	141	+https://agree2.com
	142	+
	143	+WideWord lets you collaboratively write and share documents that remain 100% encrypted on the server. Only you have the keys:
	144	+
	145	+http://wideword.net
	146	+
	147	+WideBlog is a secure private blogging system designed for private project blogs. It uses the same encryption technology as WideWord and is very easy to use:
	148	+
	149	+http://wideblog.net
	150	+
	151	+
	152	+(C) 2005-2009 Pelle Braendgaard
@@ -0,0 +1,122 @@		@@ -0,0 +1,122 @@
	1	+= ActiveCrypto - Easy to use Crypto for Ruby on Rails
	2	+
	3	+ActiveCrypto is based on EzCrypto and provides application oriented crypto support for Ruby on Rails applications.
	4	+
	5	+== Features
	6	+
	7	+* Transparent encryption/decryption
	8	+* Ruby on Rails like domain language
	9	+
	10	+== Installation
	11	+
	12	+Download it from here:
	13	+
	14	+http://rubyforge.org/frs/?group_id=755
	15	+
	16	+or install it via Ruby Gems:
	17	+
	18	+ gem install ezruby
	19	+
	20	+
	21	+== Simple examples
	22	+
	23	+==== A simple encrypted class
	24	+
	25	+You specify in your class which fields are encrypted:
	26	+
	27	+ class Document < ActiveRecord::Base
	28	+ encrypt :title,:body
	29	+ end
	30	+
	31	+Two encrypt it you need to enter a key. For ease of use there is a method called enter_password which sets the key based on a password of your choice.
	32	+
	33	+ doc=Document.new
	34	+ doc.enter_password "This stuff is secret man!!!"
	35	+ doc.title="Plan to take over the world"
	36	+ doc.body="Write apps in Rails"
	37	+ doc.save
	38	+
	39	+This needs to be done as well if you want to read your document:
	40	+
	41	+ doc=Document.find 1
	42	+ doc.enter_password "This stuff is secret man!!!"
	43	+ puts doc.name
	44	+
	45	+If you don't remember to set a key it will through a MissingKeyError.
	46	+
	47	+==== More realistic example with KeyHolder
	48	+
	49	+It probably isn't much use if each record needs its own key. The solution to this is the KeyHolder. A KeyHolder is an object that holds keys for use by other objects. A typical example would be a user.
	50	+
	51	+ class User < ActiveRecord::Base
	52	+ has_many :documents
	53	+ keyholder
	54	+ end
	55	+
	56	+We use standard ActiveRecord associations to associate the User with his documents. We also need to specify that he is a keyholder. We now modify our Document class as follows:
	57	+
	58	+ class Document < ActiveRecord::Base
	59	+ belongs_to :user
	60	+ encrypt :title,:body,:key=>:user
	61	+ end
	62	+
	63	+We have the standard associations going on here, but we have also added the option :key=>:user to the encrypt statement. Now we could do this:
	64	+
	65	+ @user=User.new
	66	+ @user.enter_password "This stuff is secret man!!!"
	67	+ @user.save
	68	+
	69	+ @doc=Document.new
	70	+ @doc.user=@user
	71	+ @doc.title="Plan to take over the world"
	72	+ @doc.body="Write apps in Rails"
	73	+ @doc.save
	74	+
	75	+You could also do ordinary rails like stuf such as:
	76	+
	77	+ @user.documents.each do \|doc\|
	78	+ puts doc.name
	79	+ end
	80	+
	81	+Decryption is done transparently.
	82	+
	83	+When doing this within a rails application, active_crypto automatically maintains a list of keys for each user session. Besides the 2 steps below you don't need to do anything special within your controller.
	84	+
	85	+1. When a user logs on with a password enter his password like this:
	86	+
	87	+ @user.enter_password @params['password']
	88	+
	89	+2. When a user logs off call the following
	90	+
	91	+ clear_session_keys
	92	+
	93	+== Usage as a Rails plugin
	94	+
	95	+Just unpack it into your $MY_RAILS_PROJECTS/vendor/plugins folder to use it as a self contained plugin. Otherwise you can install it as a gem using:
	96	+
	97	+ $ gem install ezcrypto
	98	+
	99	+Then make sure to require "active_crypto.rb" at the end of your environment.rb file.
	100	+
	101	+== Database Schema issues
	102	+
	103	+ActiveCrypto doesn't really care about the schema, but that said you do need a schema that will accept and not mangle it's output. On MySQL I normally use TINYBLOB instead of VARCHAR and BLOB instead of TEXT.
	104	+
	105	+== License
	106	+
	107	+EzCrypto and ActionCrypto is released under the MIT license.
	108	+
	109	+
	110	+== Support
	111	+
	112	+To contact the author, send mail to pelleb@gmail.com
	113	+
	114	+Also see my blogs at:
	115	+http://stakeventures.com and
	116	+http://neubia.com
	117	+
	118	+This project was based on code used in my projects WideWord where you can securely share documents and StakeItOut, where you can securely share web services with your partners.
	119	+https://wideword.net
	120	+https://stakeitout.com
	121	+
	122	+(C) 2005 Pelle Braendgaard
@@ -0,0 +1,55 @@		@@ -0,0 +1,55 @@
	1	+= EzSig - Easy to use Digital Signatures for Ruby
	2	+
	3	+EzSig is based on OpenSSL and allows you to do create and verify digital signatures in Ruby without learning too much crypto goobledegook.
	4	+
	5	+== Features
	6	+
	7	+* Simple Signer class
	8	+* Simple Verifier class
	9	+* Certificate sub class of Verifier which lets you read the certificate data in clear ruby.
	10	+
	11	+== Installation
	12	+
	13	+Download it from here:
	14	+
	15	+http://rubyforge.org/frs/?group_id=755
	16	+
	17	+or install it via Ruby Gems:
	18	+
	19	+ gem install ezruby
	20	+
	21	+
	22	+== Simple examples
	23	+
	24	+==== Load Private key and sign
	25	+
	26	+ signer=EzCrypto::Signer.from_file "testsigner.pem"
	27	+ sig=signer.sign "hello"
	28	+
	29	+==== Load Certificate and verify
	30	+
	31	+ cert=EzCrypto::Verifier.from_file "testsigner.cert"
	32	+ cert.verify( sig,"hello")
	33	+
	34	+==== Query Certificate for information
	35	+
	36	+ assert_equal cert.email,"pelleb@gmail.com"
	37	+ assert_equal cert.country,"DK"
	38	+ assert_equal cert.state,"Denmark"
	39	+ assert_equal cert.locality,"Copenhagen"
	40	+
	41	+== PKYP integration
	42	+
	43	+http://pkyp.org allows you register your public keys and certificates on a public server. If you have web applications with certificates or public keys you can point your users at http://pkyp.org/{key.digest} for more info about a certificate.
	44	+
	45	+Register a public key or certificate at PKYP with the new method register_with_pkyp like this:
	46	+
	47	+ signer=EzCrypto::Signer.generate
	48	+ signer.verifier.register_with_pkyp
	49	+
	50	+If you have the public key or certificate digest you can fetch the full public key or certificate like this:
	51	+
	52	+ verifier=EzCrypto::Verifier.from_pkyp "e93e18114cbefaaa89fda908b09df63d3662879a"
	53	+ verifier.verify sig, request_text
	54	+
	55	+This allows a simpler way of transfering certificates. The idea of including certificates with every request is not really necessary in an online world. For example you could pass the digest in a HTTP header for a REST web services request.
@@ -0,0 +1,325 @@		@@ -0,0 +1,325 @@
	1	+require "ezcrypto.rb"
	2	+module ActiveCrypto # :nodoc:
	3	+
	4	+ def self.append_features(base) #:nodoc:
	5	+ super
	6	+ base.extend(ClassMethods)
	7	+ end
	8	+
	9	+=begin rdoc
	10	+
	11	+Usage is very simple. You will generally only need the two class methods listed here in your ActiveRecord class model.
	12	+
	13	+== License
	14	+
	15	+ActiveCrypto and EzCrypto are released under the MIT license.
	16	+
	17	+
	18	+== Support
	19	+
	20	+To contact the author, send mail to pelleb@gmail.com
	21	+
	22	+Also see my blogs at:
	23	+http://stakeventures.com and
	24	+http://neubia.com
	25	+
	26	+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
	27	+https://stakeitout.com
	28	+
	29	+(C) 2005 Pelle Braendgaard
	30	+
	31	+=end
	32	+ module ClassMethods
	33	+ @@session_keys={}
	34	+
	35	+=begin rdoc
	36	+Turn encryption on for this record. List all encrypted attributes
	37	+
	38	+ class Document < ActiveRecord::Base
	39	+ encrypt :title,:body
	40	+ end
	41	+
	42	+Options are:
	43	+ <tt>key</tt> - to specify an external KeyHolder, which holds the key used for encrypting and decrypting
	44	+ <tt>base64</tt> - set to true in order to base64 encode the encrypted attributes. defaults to false
	45	+
	46	+ class Document < ActiveRecord::Base
	47	+ belongs_to :user
	48	+ encrypt :title,:body,:key=>:user, :base64 => true
	49	+ end
	50	+
	51	+=end
	52	+ def encrypt(*attributes)
	53	+ include ActiveCrypto::Encrypted
	54	+ before_save :encrypt_attributes
	55	+ after_save :decrypt_attributes
	56	+ options=attributes.last.is_a?(Hash) ? attributes.pop : {}
	57	+ keyholder
	58	+ if options and options[:key]
	59	+ module_eval <<-"end;"
	60	+ def session_key
	61	+ (send :#{options[:key]} ).send :session_key
	62	+ end
	63	+ @@external_key=true
	64	+ end;
	65	+ end
	66	+
	67	+ base64_encode = (options and options[:base64])
	68	+ module_eval <<-"end;"
	69	+ def self.ezcrypto_base64?
	70	+ #{base64_encode.to_s}
	71	+ end
	72	+ end;
	73	+
	74	+ self.encrypted_attributes=attributes
	75	+ end
	76	+
	77	+=begin rdoc
	78	+Creates support in this class for holding a key. Adds the following methods:
	79	+
	80	+* enter_password(password,salt="onetwothree")
	81	+* set_session_key(key)
	82	+* session_key
	83	+
	84	+Use it as follows:
	85	+
	86	+ class User < ActiveRecord::Base
	87	+ has_many :documents
	88	+ keyholder
	89	+ end
	90	+
	91	+=end
	92	+ def keyholder()
	93	+ include ActiveCrypto::AssociationKeyHolder
	94	+ after_create :save_session_key
	95	+ end
	96	+
	97	+=begin rdoc
	98	+Clears the session_key array. Generally this is handled automatically as a filter in ActionController. Only use these if you need to
	99	+do something out of the ordinary.
	100	+=end
	101	+ def clear_session_keys() #:nodoc:
	102	+ @@session_keys.clear
	103	+ end
	104	+
	105	+=begin rdoc
	106	+Sets the session_keys array. Only use these if you need to
	107	+do something out of the ordinary, as it is handled
	108	+=end
	109	+ def session_keys=(keys) #:nodoc:
	110	+ @@session_keys=keys
	111	+ end
	112	+
	113	+ def session_keys() #:nodoc:
	114	+ @@session_keys
	115	+ end
	116	+
	117	+ end
	118	+
	119	+=begin rdoc
	120	+This module handles all standard key management features.
	121	+=end
	122	+ module KeyHolder
	123	+
	124	+=begin rdoc
	125	+Creates a key for object based on given password and an optional salt.
	126	+=end
	127	+ def enter_password(password,salt="onetwothree")
	128	+ set_session_key(EzCrypto::Key.with_password(password, salt))
	129	+ end
	130	+
	131	+=begin rdoc
	132	+Decodes the Base64 encoded key and uses it as it's session key
	133	+=end
	134	+ def set_encoded_key(enc)
	135	+ set_session_key(EzCrypto::Key.decode(enc))
	136	+ end
	137	+=begin rdoc
	138	+Sets a session key for the object. This should be a EzCrypto::Key instance.
	139	+=end
	140	+ def set_session_key(key)
	141	+ @session_key=key
	142	+ self.decrypt_attributes if self.class.include? Encrypted
	143	+ end
	144	+
	145	+=begin rdoc
	146	+Returns the session_key
	147	+=end
	148	+ def session_key
	149	+ @session_key
	150	+ end
	151	+
	152	+ end
	153	+
	154	+ module AssociationKeyHolder
	155	+ include ActiveCrypto::KeyHolder
	156	+
	157	+
	158	+ def save_session_key
	159	+ ActiveRecord::Base.session_keys[session_key_id]=@session_key if @session_key
	160	+ end
	161	+=begin rdoc
	162	+Sets a session key for the object. This should be a EzCrypto::Key instance.
	163	+=end
	164	+ def set_session_key(key)
	165	+ if self.new_record?
	166	+ @session_key=key
	167	+ else
	168	+ ActiveRecord::Base.session_keys[session_key_id]=key
	169	+ end
	170	+ decrypt_attributes if self.class.include? Encrypted #if respond_to?(:decrypt_attributes)
	171	+
	172	+ end
	173	+
	174	+=begin rdoc
	175	+Returns the session_key
	176	+=end
	177	+ def session_key
	178	+ if self.new_record?
	179	+ @session_key
	180	+ else
	181	+ ActiveRecord::Base.session_keys[session_key_id]
	182	+ end
	183	+ end
	184	+
	185	+
	186	+
	187	+ def session_key_id
	188	+ "#{self.class.to_s}:#{id}"
	189	+ end
	190	+
	191	+ end
	192	+
	193	+ module Encrypted #:nodoc:
	194	+ def self.append_features(base) #:nodoc:
	195	+ super
	196	+ base.extend ClassAccessors
	197	+ end
	198	+
	199	+ module ClassAccessors
	200	+ def encrypted_attributes
	201	+ @encrypted_attributes\|\|=[]
	202	+ end
	203	+
	204	+ def encrypted_attributes=(attrs)
	205	+ @encrypted_attributes=attrs
	206	+ end
	207	+
	208	+ end
	209	+
	210	+ protected
	211	+
	212	+ def encrypt_attributes
	213	+ if !is_encrypted?
	214	+ self.class.encrypted_attributes.each do \|key\|
	215	+ value=read_attribute(key)
	216	+ write_attribute(key,_encrypt(value)) if value
	217	+ end
	218	+ @is_encrypted=true
	219	+ end
	220	+ true
	221	+ end
	222	+
	223	+ def decrypt_attributes
	224	+ if is_encrypted?
	225	+ self.class.encrypted_attributes.each do \|key\|
	226	+ value=read_attribute(key)
	227	+ write_attribute(key,_decrypt(value)) if value
	228	+ end
	229	+ @is_encrypted=false
	230	+ end
	231	+ true
	232	+ end
	233	+
	234	+ def after_find
	235	+ @is_encrypted=true
	236	+ decrypt_attributes unless session_key.nil?
	237	+ end
	238	+
	239	+ private
	240	+ def is_encrypted?
	241	+ @is_encrypted
	242	+ end
	243	+
	244	+ def _decrypt(data)
	245	+ if session_key.nil?
	246	+ raise MissingKeyError
	247	+ else
	248	+ if data
	249	+ self.class.ezcrypto_base64? ? session_key.decrypt64(data) : session_key.decrypt(data)
	250	+ else
	251	+ nil
	252	+ end
	253	+ end
	254	+ end
	255	+
	256	+ def _encrypt(data)
	257	+ if session_key.nil?
	258	+ raise MissingKeyError
	259	+ else
	260	+ if data
	261	+ self.class.ezcrypto_base64? ? session_key.encrypt64(data) : session_key.encrypt(data)
	262	+ else
	263	+ nil
	264	+ end
	265	+ end
	266	+ end
	267	+
	268	+ end
	269	+
	270	+
	271	+module ActionController # :nodoc:
	272	+=begin rdoc
	273	+This includes some basic support in the ActionController for handling session keys. It creates two filters one before the action and one after.
	274	+These do the following:
	275	+
	276	+If the users session already has a 'session_keys' value it loads it into the ActiveRecord::Base.session_keys class field. If not it
	277	+clears any existing session_keys.
	278	+
	279	+Leaving the action it stores any session_keys in the corresponding session variable.
	280	+
	281	+These filters are automatically enabled. You do not have to do anything.
	282	+
	283	+To manually clear the session keys call clear_session_keys. This should be done for example as part of a session log off action.
	284	+=end
	285	+ def self.append_features(base) #:nodoc:
	286	+ super
	287	+ base.send :prepend_before_filter, :load_session_keys
	288	+ base.send :prepend_after_filter, :save_session_keys
	289	+ end
	290	+
	291	+=begin rdoc
	292	+Clears the session keys. Call this when a user logs of.
	293	+=end
	294	+ def clear_session_keys
	295	+ ActiveRecord::Base.clear_session_keys
	296	+ end
	297	+
	298	+
	299	+ private
	300	+ def load_session_keys
	301	+ if session['session_keys']
	302	+ ActiveRecord::Base.session_keys=session['session_keys']
	303	+ else
	304	+ ActiveRecord::Base.clear_session_keys
	305	+ end
	306	+ end
	307	+
	308	+ def save_session_keys
	309	+ if ActiveRecord::Base.session_keys.size>0
	310	+ session['session_keys']=ActiveRecord::Base.session_keys
	311	+ else
	312	+ session['session_keys']=nil
	313	+ end
	314	+ end
	315	+
	316	+
	317	+end
	318	+
	319	+class MissingKeyError < RuntimeError
	320	+end
	321	+end
	322	+ActiveRecord::Base.send :include, ActiveCrypto
	323	+require 'actionpack'
	324	+require 'action_controller'
	325	+ActionController::Base.send :include, ActiveCrypto::ActionController
@@ -0,0 +1,612 @@		@@ -0,0 +1,612 @@
	1	+require 'openssl'
	2	+require 'digest/sha2'
	3	+require 'digest/sha1'
	4	+require 'base64'
	5	+
	6	+module EzCrypto #:nodoc:
	7	+
	8	+
	9	+=begin rdoc
	10	+The Key is the only class you need to understand for simple use.
	11	+
	12	+=== Algorithms
	13	+
	14	+The crypto algorithms default to aes-128-cbc however on any of the class methods you can change it to one of the standard openssl cipher names using the
	15	+optional <tt>:algorithm=>alg name</tt> parameter.
	16	+
	17	+Eg.
	18	+ Key.new @raw, :algorithm=>"des"
	19	+ Key.generate :algorithm=>"blowfish"
	20	+ Key.with_password @pwd,@salt,:algorithm=>"aes256"
	21	+
	22	+
	23	+== License
	24	+
	25	+ActiveCrypto and EzCrypto are released under the MIT license.
	26	+
	27	+
	28	+== Support
	29	+
	30	+To contact the author, send mail to pelleb@gmail.com
	31	+
	32	+Also see my blogs at:
	33	+http://stakeventures.com and
	34	+http://neubia.com
	35	+
	36	+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
	37	+https://stakeitout.com
	38	+
	39	+(C) 2005 Pelle Braendgaard
	40	+
	41	+=end
	42	+
	43	+ class Key
	44	+
	45	+ attr_reader :raw, :algorithm
	46	+
	47	+ @@block_size = 512
	48	+
	49	+=begin rdoc
	50	+Set the block-size for IO-operations (default: 512 bytes)
	51	+=end
	52	+ def self.block_size=(size)
	53	+ @@block_size = size
	54	+ end
	55	+
	56	+=begin rdoc
	57	+Return the block-size for IO-operations.
	58	+=end
	59	+ def self.block_size
	60	+ @@block_size
	61	+ end
	62	+
	63	+
	64	+=begin rdoc
	65	+Initialize the key with raw unencoded binary key data. This needs to be at least
	66	+16 bytes long for the default aes-128 algorithm.
	67	+=end
	68	+ def initialize(raw,options = {})
	69	+ @raw=raw
	70	+ @algorithm=options[:algorithm]\|\|"aes-128-cbc"
	71	+ end
	72	+
	73	+=begin rdoc
	74	+Generate random key.
	75	+=end
	76	+ def self.generate(options = {})
	77	+ Key.new(EzCrypto::Digester.generate_key(calculate_key_size(options[:algorithm])),options)
	78	+ end
	79	+
	80	+=begin rdoc
	81	+Create key generated from the given password and salt
	82	+=end
	83	+ def self.with_password(password,salt,options = {})
	84	+ Key.new(EzCrypto::Digester.get_key(password,salt,calculate_key_size(options[:algorithm])),options)
	85	+ end
	86	+
	87	+=begin rdoc
	88	+Initialize the key with Base64 encoded key data.
	89	+=end
	90	+ def self.decode(encoded,options = {})
	91	+ Key.new(Base64.decode64(encoded),options)
	92	+ end
	93	+
	94	+=begin rdoc
	95	+Encrypts the data with the given password and a salt. Short hand for:
	96	+
	97	+ key=Key.with_password(password,salt,options)
	98	+ key.encrypt(data)
	99	+
	100	+=end
	101	+ def self.encrypt_with_password(password,salt,data,options = {})
	102	+ key=Key.with_password(password,salt,options)
	103	+ key.encrypt(data)
	104	+ end
	105	+
	106	+=begin rdoc
	107	+Decrypts the data with the given password and a salt. Short hand for:
	108	+
	109	+ key=Key.with_password(password,salt,options)
	110	+ key.decrypt(data)
	111	+
	112	+
	113	+=end
	114	+ def self.decrypt_with_password(password,salt,data,options = {})
	115	+ key=Key.with_password(password,salt,options)
	116	+ key.decrypt(data)
	117	+ end
	118	+
	119	+=begin rdoc
	120	+Given an algorithm this calculates the keysize. This is used by both
	121	+the generate and with_password methods. This is not yet 100% complete.
	122	+=end
	123	+ def self.calculate_key_size(algorithm)
	124	+ if !algorithm.nil?
	125	+ algorithm=~/^([[:alnum:]]+)(-(\d+))?/
	126	+ if $3
	127	+ size=($3.to_i)/8
	128	+ else
	129	+ case $1
	130	+ when "bf"
	131	+ size = 16
	132	+ when "blowfish"
	133	+ size = 16
	134	+ when "des"
	135	+ size = 8
	136	+ when "des3"
	137	+ size = 24
	138	+ when "aes128"
	139	+ size = 16
	140	+ when "aes192"
	141	+ size = 24
	142	+ when "aes256"
	143	+ size = 32
	144	+ when "rc2"
	145	+ size = 16
	146	+ when "rc4"
	147	+ size = 16
	148	+ else
	149	+ size = 16
	150	+ end
	151	+ end
	152	+ end
	153	+ if size.nil?
	154	+ size = 16
	155	+ end
	156	+
	157	+ size
	158	+ end
	159	+
	160	+=begin rdoc
	161	+returns the Base64 encoded key.
	162	+=end
	163	+ def encode
	164	+ Base64.encode64(@raw).chop
	165	+ end
	166	+
	167	+=begin rdoc
	168	+returns the Base64 encoded key. Synonym for encode.
	169	+=end
	170	+ def to_s
	171	+ encode
	172	+ end
	173	+
	174	+=begin rdoc
	175	+Encrypts the data and returns it in encrypted binary form.
	176	+=end
	177	+ def encrypt(data)
	178	+ if data==nil \|\| data==""
	179	+ nil
	180	+ else
	181	+ encrypter("")
	182	+ @cipher.encrypt(data)
	183	+ end
	184	+ end
	185	+
	186	+=begin rdoc
	187	+Encrypts the data and returns it in encrypted Base64 encoded form.
	188	+=end
	189	+ def encrypt64(data)
	190	+ Base64.encode64(encrypt(data))
	191	+ end
	192	+
	193	+=begin rdoc
	194	+Decrypts the data passed to it in binary format.
	195	+=end
	196	+ def decrypt(data)
	197	+ if data==nil \|\| data==""
	198	+ nil
	199	+ else
	200	+ decrypter("")
	201	+ @cipher.gulp(data)
	202	+ end
	203	+# rescue
	204	+# puts @algorithm
	205	+# puts self.encode
	206	+# puts data.size
	207	+# throw $!
	208	+ end
	209	+
	210	+=begin rdoc
	211	+Decrypts a Base64 formatted string
	212	+=end
	213	+ def decrypt64(data)
	214	+ decrypt(Base64.decode64(data))
	215	+ end
	216	+
	217	+=begin rdoc
	218	+Allows keys to be marshalled
	219	+=end
	220	+ def marshal_dump
	221	+ "#{self.algorithm}$$$#{self.encode}"
	222	+ end
	223	+
	224	+=begin rdoc
	225	+Allows keys to be unmarshalled
	226	+=end
	227	+ def marshal_load(s)
	228	+ a, r = s.split '$$$'
	229	+ @algorithm = a
	230	+ @raw = Base64.decode64(r)
	231	+ end
	232	+
	233	+=begin rdoc
	234	+Create a file with minimal permissions, and yield
	235	+it to a block. By default only the owner may read it.
	236	+=end
	237	+ def safe_create(file, mod=0400, mask=0066)
	238	+ begin
	239	+ old_umask = File.umask
	240	+ File.umask(mask)
	241	+ File.open(file, File::CREAT \| File::EXCL \| File::WRONLY) do \|f\|
	242	+ yield(f) if block_given?
	243	+ end
	244	+ ensure
	245	+ File.umask(old_umask)
	246	+ end
	247	+ File.chmod(mod, file) if File.exists?(file)
	248	+ File.size(file)
	249	+ end
	250	+
	251	+
	252	+=begin rdoc
	253	+Overwrite a file with zero values before removing it's filesystem inode.
	254	+This is not very safe :-)
	255	+=end
	256	+ def safe_delete(file)
	257	+ begin
	258	+ to_clear = File.size(file)
	259	+ zeroes = Array.new(Key.block_size, "\0").join
	260	+ File.chmod(0600, file)
	261	+ File.open(file, File::WRONLY) do \|f\|
	262	+ f.rewind
	263	+ while to_clear > 0
	264	+ f.write(zeroes)
	265	+ to_clear -= Key.block_size
	266	+ end
	267	+ f.flush
	268	+ end
	269	+ ensure
	270	+ File.delete(file) if File.exists?(file)
	271	+ end
	272	+ return !File.exists?(file)
	273	+ end
	274	+
	275	+
	276	+=begin rdoc
	277	+Open a file readonly and yield it to a block.
	278	+=end
	279	+ def safe_read(file)
	280	+ File.open(file, File::RDONLY) do \|i\|
	281	+ yield(i) if block_given?
	282	+ end
	283	+ end
	284	+
	285	+ private :safe_create, :safe_read, :safe_delete
	286	+
	287	+=begin rdoc
	288	+Load a key from a yaml_file generated via Key#store.
	289	+=end
	290	+ def self.load(filename)
	291	+ require 'yaml'
	292	+ hash = YAML::load_file(filename)
	293	+ req = proc { \|k\| hash[k] or raise "Missing element #{k} in #{filename}" }
	294	+ key = self.new Base64.decode64(req.call(:key)) , :algorithm => req.call(:algorithm)
	295	+ return key
	296	+ end
	297	+
	298	+
	299	+=begin rdoc
	300	+Save the key data into a file, try to do this in a secure manner.
	301	+NOTE: YAML::store & friends are not used to encance control over
	302	+the generated file format.
	303	+=end
	304	+ def store(filename)
	305	+ safe_create(filename) do \|f\|
	306	+ selfenc = self.encode
	307	+ f.puts "---"
	308	+ f.puts ":EZCRYPTO KEY FILE: KEEP THIS SECURE !"
	309	+ f.puts ":created: #{Time.now}"
	310	+ f.puts ":algorithm: #{@algorithm}"
	311	+ f.puts ":key: #{selfenc}"
	312	+ end
	313	+ end
	314	+
	315	+
	316	+=begin rdoc
	317	+Get a Encrypter object. You have to call #final on it by yourself!
	318	+=end
	319	+ def encrypter(target='')
	320	+ @cipher = EzCrypto::Encrypter.new(self,target,@algorithm)
	321	+ end
	322	+
	323	+
	324	+=begin rdoc
	325	+Get a Decrypter object. You have to call #final on it by yourself!
	326	+=end
	327	+ def decrypter(target='')
	328	+ @cipher = EzCrypto::Decrypter.new(self,target,@algorithm)
	329	+ end
	330	+
	331	+=begin rdoc
	332	+Create a Decrypter object and yield it to a block.
	333	+You must not call #final by yourself, the method
	334	+does this.
	335	+=end
	336	+ def on_decrypter(target='', &block)
	337	+ decrypter(target)
	338	+ on_cipher(&block)
	339	+ end
	340	+
	341	+=begin rdoc
	342	+Create an Encrypter object and yield it to a block.
	343	+You must not call #final by yourself, the method
	344	+does this.
	345	+=end
	346	+ def on_encrypter(target='', &block)
	347	+ encrypter(target)
	348	+ on_cipher(&block)
	349	+ end
	350	+
	351	+
	352	+=begin rdoc
	353	+Helper method, yields the current cipher to a block.
	354	+=end
	355	+ def on_cipher(&block)
	356	+ begin
	357	+ block.call @cipher
	358	+ ensure
	359	+ @cipher.final
	360	+ end
	361	+ end
	362	+
	363	+ private :on_cipher
	364	+
	365	+
	366	+=begin rdoc
	367	+Encrypt a file 'inplace' and add a suffix
	368	+see #cipher_file.
	369	+IMPORTANT: The inputfile will be deleted by default.
	370	+=end
	371	+ def encrypt_file(src, tgt=nil, options = {} )
	372	+ options = { :suffix => '.ez', :autoclean => 'true' }.update(options)
	373	+ tgt = "#{src}#{options[:suffix]}" unless tgt
	374	+ cipher_file :on_encrypter, src, tgt, options[:autoclean]
	375	+ end
	376	+
	377	+
	378	+=begin rdoc
	379	+Decrypt a file 'inplace' and remove a suffix
	380	+see #cipher_file
	381	+IMPORTANT: The inputfile will be deleted by default.
	382	+=end
	383	+ def decrypt_file(src, tgt=nil, options = {} )
	384	+ options = { :suffix => '.ez', :autoclean => 'true' }.update(options)
	385	+ unless tgt
	386	+ tgt = src
	387	+ tgt = tgt.gsub(/#{options[:suffix]}$/, '')
	388	+ end
	389	+ cipher_file :on_decrypter, src, tgt, options[:autoclean]
	390	+ end
	391	+
	392	+
	393	+=begin rdoc
	394	+uses either #on_decrypter or #on_encrypter to transform a given sourcefile
	395	+to a targetfile. the sourcefile is deleted after sucessful transformation
	396	+the delete_source is 'true'.
	397	+=end
	398	+ def cipher_file(method, sourcefile, targetfile, delete_source)
	399	+ raise(ArgumentError, "source == target #{sourcefile}") if sourcefile == targetfile
	400	+ safe_create(targetfile,0600) do \|o\|
	401	+ self.send(method, o) do \|c\|
	402	+ safe_read(sourcefile) do \|i\|
	403	+ loop do
	404	+ buffer = i.read(Key.block_size) or break
	405	+ c << buffer
	406	+ end
	407	+ end
	408	+ end
	409	+ end
	410	+ safe_delete(sourcefile) if delete_source && File.exists?(targetfile)
	411	+ return targetfile
	412	+ end
	413	+
	414	+ private :cipher_file
	415	+
	416	+ end
	417	+
	418	+=begin rdoc
	419	+Abstract Wrapper around OpenSSL's Cipher object. Extended by Encrypter and Decrypter.
	420	+
	421	+You probably should be using the Key class instead.
	422	+
	423	+Warning! The interface may change.
	424	+
	425	+=end
	426	+ class CipherWrapper #:nodoc:
	427	+
	428	+=begin rdoc
	429	+
	430	+=end
	431	+ def initialize(key,target,mode,algorithm)
	432	+ @cipher = OpenSSL::Cipher::Cipher.new(algorithm)
	433	+ if mode
	434	+ @cipher.encrypt
	435	+ else
	436	+ @cipher.decrypt
	437	+ end
	438	+ @cipher.key=key.raw
	439	+ @cipher.padding=1
	440	+ @target=target
	441	+ @finished=false
	442	+ end
	443	+
	444	+
	445	+ def to_target(data)
	446	+ return data
	447	+ end
	448	+
	449	+=begin rdoc
	450	+Process the givend data with the cipher.
	451	+=end
	452	+ def update(data)
	453	+ reset if @finished
	454	+ @target<< to_target(@cipher.update(data))
	455	+ end
	456	+
	457	+=begin rdoc
	458	+
	459	+=end
	460	+ def <<(data)
	461	+ update(data)
	462	+ end
	463	+
	464	+=begin rdoc
	465	+Finishes up any last bits of data in the cipher and returns the final result.
	466	+=end
	467	+ def final
	468	+ @target<< to_target(@cipher.final)
	469	+ @finished=true
	470	+ @target
	471	+ end
	472	+
	473	+=begin rdoc
	474	+Processes the entire data string using update and performs a final on it returning the data.
	475	+=end
	476	+ def gulp(data)
	477	+ update(data)
	478	+ final
	479	+# rescue
	480	+# breakpoint
	481	+ end
	482	+
	483	+=begin rdoc
	484	+
	485	+=end
	486	+ def reset(target="")
	487	+ @target=target
	488	+ @finished=false
	489	+ end
	490	+ end
	491	+
	492	+=begin rdoc
	493	+Wrapper around OpenSSL Cipher for Encryption use.
	494	+
	495	+You probably should be using Key instead.
	496	+
	497	+Warning! The interface may change.
	498	+
	499	+=end
	500	+ class Encrypter<EzCrypto::CipherWrapper #:nodoc:
	501	+
	502	+=begin rdoc
	503	+
	504	+=end
	505	+ def initialize(key,target="",algorithm="aes-128-cbc")
	506	+ super(key,target,true,algorithm)
	507	+ end
	508	+
	509	+=begin rdoc
	510	+
	511	+=end
	512	+ def encrypt(data)
	513	+ gulp(data)
	514	+ end
	515	+ end
	516	+
	517	+=begin rdoc
	518	+Wrapper around OpenSSL Cipher for Decryption use.
	519	+
	520	+You probably should be using Key instead.
	521	+
	522	+Warning! The interface may change.
	523	+=end
	524	+ class Decrypter<EzCrypto::CipherWrapper #:nodoc:
	525	+=begin rdoc
	526	+
	527	+=end
	528	+ def initialize(key,target="",algorithm="aes-128-cbc")
	529	+ super(key,target,false,algorithm)
	530	+ end
	531	+
	532	+=begin rdoc
	533	+
	534	+=end
	535	+ def decrypt(data)
	536	+ gulp(data)
	537	+ end
	538	+ end
	539	+
	540	+=begin rdoc
	541	+
	542	+=end
	543	+ class Digester
	544	+=begin rdoc
	545	+Various handy Digest methods.
	546	+
	547	+Warning! The interface may change.
	548	+=end
	549	+ def self.get_key(password,salt,size)
	550	+ digest(salt+password,size)
	551	+ end
	552	+
	553	+=begin rdoc
	554	+
	555	+=end
	556	+ def self.generate_key(size=16)
	557	+ key=OpenSSL::Random.random_bytes(size)
	558	+ digest(key,size)
	559	+ end
	560	+
	561	+=begin rdoc
	562	+
	563	+=end
	564	+ def self.generate_key64(size=32)
	565	+ key=OpenSSL::Random.random_bytes(size)
	566	+ digest64(key,size)
	567	+ end
	568	+=begin rdoc
	569	+
	570	+=end
	571	+ def self.generate_hexkey(size=40)
	572	+ key=OpenSSL::Random.random_bytes(size)
	573	+ hexdigest(key,size)
	574	+ end
	575	+
	576	+=begin rdoc
	577	+
	578	+=end
	579	+ def self.digest(data,size=16)
	580	+ if size==0
	581	+ ""
	582	+ elsif size<=16
	583	+ Digest::SHA1.digest(data)[0..(size-1)]
	584	+ else
	585	+ Digest::SHA256.digest(data)[0..(size-1)]
	586	+ end
	587	+ end
	588	+
	589	+=begin rdoc
	590	+
	591	+=end
	592	+ def self.hexdigest(data,size=40)
	593	+ if size==0
	594	+ ""
	595	+ elsif size<=40
	596	+ Digest::SHA1.hexdigest(data)[0..(size-1)]
	597	+ else
	598	+ Digest::SHA256.hexdigest(data)[0..(size-1)]
	599	+ end
	600	+ end
	601	+
	602	+=begin rdoc
	603	+
	604	+=end
	605	+ def self.digest64(data,size=16)
	606	+ Base64.encode64(digest(data,size))
	607	+ end
	608	+ end
	609	+
	610	+end
	611	+
	612	+
	@@ -0,0 +1,535 @@		@@ -0,0 +1,535 @@
		1	+require 'ezcrypto'
		2	+require 'net/http'
		3	+=begin rdoc
		4	+
		5	+These modules provides a simple ruby like way to create and verify digital signatures.
		6	+
		7	+== License
		8	+
		9	+ActiveCrypto and EzCrypto are released under the MIT license.
		10	+
		11	+
		12	+== Support
		13	+
		14	+To contact the author, send mail to pelleb@gmail.com
		15	+
		16	+Also see my blogs at:
		17	+http://stakeventures.com and
		18	+http://neubia.com
		19	+
		20	+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
		21	+https://stakeitout.com
		22	+
		23	+(C) 2005 Pelle Braendgaard
		24	+
		25	+=end
		26	+module EzCrypto
		27	+
		28	+=begin rdoc
		29	+ The signer is used for signing stuff. It encapsulates the functionality of a private key.
		30	+=end
		31	+ class Signer
		32	+=begin rdoc
		33	+ Initialize a Signer with a OpenSSL Private Key. You generally should not call new directly.
		34	+ Unless you are interfacing with your own underlying OpenSSL code.
		35	+=end
		36	+ def initialize(priv,options = {})
		37	+ @priv=priv
		38	+ end
		39	+
		40	+=begin rdoc
		41	+ Generate a new keypair. Defaults to 2048 bit RSA.
		42	+=end
		43	+ def self.generate(strength=2048,type=:rsa)
		44	+ key_class=case type
		45	+ when :dsa
		46	+ OpenSSL::PKey::DSA
		47	+ else
		48	+ OpenSSL::PKey::RSA
		49	+ end
		50	+ EzCrypto::Signer.new(key_class.generate(strength))
		51	+ end
		52	+
		53	+=begin rdoc
		54	+ Decode a PEM encoded Private Key and return a signer. Takes an optional password
		55	+=end
		56	+ def self.decode(encoded,password=nil)
		57	+ begin
		58	+ EzCrypto::Signer.new(OpenSSL::PKey::RSA.new( encoded,password))
		59	+ rescue
		60	+ EzCrypto::Signer.new(OpenSSL::PKey::DSA.new( encoded,password))
		61	+ end
		62	+ end
		63	+
		64	+=begin rdoc
		65	+ Decode a PEM encoded Private Key file and return a signer. Takes an optional password
		66	+=end
		67	+ def self.from_file(filename,password=nil)
		68	+ file = File.read( filename )
		69	+ decode(file,password)
		70	+ end
		71	+
		72	+=begin rdoc
		73	+ Returns the OpenSSL Public Key object. You normally do not need to use this.
		74	+=end
		75	+ def public_key
		76	+ @priv.public_key
		77	+ end
		78	+
		79	+=begin rdoc
		80	+ Returns the corresponding Verifier object.
		81	+=end
		82	+ def verifier
		83	+ Verifier.new(public_key)
		84	+ end
		85	+
		86	+=begin rdoc
		87	+ Returns the OpenSSL Private Key object. You normally do not need to use this.
		88	+=end
		89	+ def private_key
		90	+ @priv
		91	+ end
		92	+
		93	+=begin rdoc
		94	+ signs data using the private key and the corresponding digest function. SHA1 for RSA and DSS1 for DSA.
		95	+ 99% of signing use these parameters.
		96	+ Email a request or send me a patch if you have other requirements.
		97	+=end
		98	+ def sign(data)
		99	+ if rsa?
		100	+ @priv.sign(OpenSSL::Digest::SHA1.new,data)
		101	+ elsif dsa?
		102	+ @priv.sign(OpenSSL::Digest::DSS1.new,data)
		103	+ end
		104	+ end
		105	+
		106	+=begin rdoc
		107	+ Returns true if it is a RSA private key
		108	+=end
		109	+ def rsa?
		110	+ @priv.is_a? OpenSSL::PKey::RSA
		111	+ end
		112	+
		113	+=begin rdoc
		114	+ Returns true if it is a DSA private key
		115	+=end
		116	+ def dsa?
		117	+ @priv.is_a? OpenSSL::PKey::DSA
		118	+ end
		119	+
		120	+ end
		121	+
		122	+=begin rdoc
		123	+ The Verifier is used for verifying signatures. If you use the decode or
		124	+ from_file methods you can use either raw PEM encoded public keys or certificate.
		125	+=end
		126	+ class Verifier
		127	+=begin rdoc
		128	+ Initializes a Verifier using a OpenSSL public key object.
		129	+=end
		130	+ def initialize(pub)
		131	+ @pub=pub
		132	+ end
		133	+
		134	+=begin rdoc
		135	+ Decodes a PEM encoded Certificate or Public Key and returns a Verifier object.
		136	+=end
		137	+ def self.decode(encoded)
		138	+ case encoded
		139	+ when /-----BEGIN CERTIFICATE-----/
		140	+ EzCrypto::Certificate.new(OpenSSL::X509::Certificate.new( encoded))
		141	+ else
		142	+ begin
		143	+ EzCrypto::Verifier.new(OpenSSL::PKey::RSA.new( encoded))
		144	+ rescue
		145	+ EzCrypto::Verifier.new(OpenSSL::PKey::DSA.new( encoded))
		146	+ end
		147	+ end
		148	+ end
		149	+
		150	+=begin rdoc
		151	+ Decodes a PEM encoded Certificate or Public Key from a file and returns a Verifier object.
		152	+=end
		153	+ def self.from_file(filename)
		154	+ file = File.read( filename )
		155	+ decode(file)
		156	+ end
		157	+
		158	+=begin rdoc
		159	+ Load a certificate or public key from PKYP based on it's hex digest
		160	+=end
		161	+ def self.from_pkyp(digest)
		162	+ digest=digest.strip.downcase
		163	+ if digest=~/[0123456789abcdef]{40}/
		164	+# Net::HTTP.start("localhost", 9000) do \|query\|
		165	+ Net::HTTP.start("pkyp.org", 80) do \|query\|
		166	+ response=query.get "/#{digest}.pem"
		167	+ if response.code=="200"
		168	+ decode(response.body)
		169	+ else
		170	+ raise "Error occured (#{response.code}): #{response.body}"
		171	+ end
		172	+ end
		173	+ else
		174	+ raise "Invalid digest"
		175	+ end
		176	+ end
		177	+
		178	+=begin rdoc
		179	+ Decodes all certificates or public keys in a file and returns an array.
		180	+=end
		181	+ def self.load_all_from_file(filename)
		182	+ file = File.read( filename )
		183	+ certs=[]
		184	+ count=0
		185	+ file.split( %q{-----BEGIN}).each do \|pem\|
		186	+ if pem and pem!=""
		187	+ pem="-----BEGIN#{pem}\n"
		188	+ cert=decode(pem)
		189	+ if cert.is_a? EzCrypto::Verifier
		190	+ certs<<cert
		191	+ end
		192	+ end
		193	+ end
		194	+ certs
		195	+ end
		196	+
		197	+=begin rdoc
		198	+ Is the Verifier a Certificate or not.
		199	+=end
		200	+ def cert?
		201	+ false
		202	+ end
		203	+
		204	+=begin rdoc
		205	+ Returns the OpenSSL public key object. You would normally not need to use this.
		206	+=end
		207	+ def public_key
		208	+ @pub
		209	+ end
		210	+
		211	+=begin rdoc
		212	+ Returns the SHA1 hexdigest of the DER encoded public key. This can be used as a unique key identifier.
		213	+=end
		214	+ def digest
		215	+ Digest::SHA1.hexdigest(@pub.to_der)
		216	+ end
		217	+=begin rdoc
		218	+ Is this a RSA key?
		219	+=end
		220	+ def rsa?
		221	+ @pub.is_a? OpenSSL::PKey::RSA
		222	+ end
		223	+=begin rdoc
		224	+ Is this a DSA key?
		225	+=end
		226	+ def dsa?
		227	+ @pub.is_a? OpenSSL::PKey::DSA
		228	+ end
		229	+
		230	+
		231	+=begin rdoc
		232	+ Returns true if the public key signed the given data.
		233	+=end
		234	+ def verify(sig,data)
		235	+ if rsa?
		236	+ @pub.verify( OpenSSL::Digest::SHA1.new, sig, data )
		237	+ elsif dsa?
		238	+ @pub.verify( OpenSSL::Digest::DSS1.new, sig, data )
		239	+ else
		240	+ false
		241	+ end
		242	+ end
		243	+
		244	+=begin rdoc
		245	+ Register the public key or certificate at PKYP
		246	+=end
		247	+ def register_with_pkyp
		248	+ send_to_pkyp(@pub.to_s)
		249	+ end
		250	+
		251	+ protected
		252	+
		253	+ def send_to_pkyp(pem)
		254	+# Net::HTTP.start("localhost", 9000) do \|query\|
		255	+ Net::HTTP.start("pkyp.org", 80) do \|query\|
		256	+ output=URI.escape(pem).gsub("+","%2b")
		257	+ response=query.post "/register","body="+output
		258	+ if response.code=="302"
		259	+ response["Location"]=~/([0123456789abcdef]{40}$)/
		260	+ $1
		261	+ else
		262	+ raise "Error occured (#{response.code}): #{response.body}"
		263	+ end
		264	+ end
		265	+ end
		266	+
		267	+ end
		268	+
		269	+=begin rdoc
		270	+ Certificate provides functionality to make it easy to extract information from a Certificate.
		271	+ This also provides all the same functionality as a Verifier.
		272	+=end
		273	+ class Certificate < Verifier
		274	+
		275	+=begin rdoc
		276	+ Intialize with a OpenSSL cert object.
		277	+=end
		278	+ def initialize(cert)
		279	+ super(cert.public_key)
		280	+ @cert=cert
		281	+ end
		282	+
		283	+=begin rdoc
		284	+ Returns true
		285	+=end
		286	+ def cert?
		287	+ true
		288	+ end
		289	+
		290	+=begin rdoc
		291	+ Register the certificate at PKYP
		292	+=end
		293	+ def register_with_pkyp
		294	+ send_to_pkyp(@cert.to_s)
		295	+ end
		296	+
		297	+=begin rdoc
		298	+ Returns the SHA1 hex digest of a the DER encoded certificate. This is useful as a unique identifier.
		299	+=end
		300	+ def cert_digest
		301	+ Digest::SHA1.hexdigest(@cert.to_der)
		302	+ end
		303	+
		304	+=begin rdoc
		305	+ Returns a Name object containt the subject of the certificate. The subject in X509 speak is the details of the certificate owner.
		306	+=end
		307	+ def subject
		308	+ @subject=EzCrypto::Name.new(@cert.subject) unless @subject
		309	+ @subject
		310	+ end
		311	+
		312	+=begin rdoc
		313	+ Returns a Name object containt the issuer of the certificate.
		314	+=end
		315	+ def issuer
		316	+ @issuer=EzCrypto::Name.new(@cert.issuer) unless @issuer
		317	+ @issuer
		318	+ end
		319	+
		320	+=begin rdoc
		321	+ Returns the issuers serial number for this certificate
		322	+=end
		323	+ def serial
		324	+ @cert.serial
		325	+ end
		326	+
		327	+=begin rdoc
		328	+ Returns the OpenSSL Certificate object
		329	+=end
		330	+ def cert
		331	+ @cert
		332	+ end
		333	+
		334	+=begin rdoc
		335	+ Returns the certificates valid not before date.
		336	+=end
		337	+ def not_before
		338	+ @cert.not_before
		339	+ end
		340	+
		341	+=begin rdoc
		342	+ Returns the certificates valid not after date.
		343	+=end
		344	+ def not_after
		345	+ @cert.not_after
		346	+ end
		347	+
		348	+=begin rdoc
		349	+ Is this certificate valid at this point in time. Note this only checks if it is valid with respect to time.
		350	+ It is important to realize that it does not check with any CRL or OCSP services to see if the certificate was
		351	+ revoked.
		352	+=end
		353	+ def valid?(time=Time.now.utc)
		354	+ time>not_before && time<self.not_after
		355	+ end
		356	+
		357	+=begin rdoc
		358	+ Returns the hash of extensions available in the certificate. These are not always present.
		359	+=end
		360	+ def extensions
		361	+ unless @extensions
		362	+ @extensions={}
		363	+ cert.extensions.each {\|e\| @extensions[e.oid]=e.value} if cert.extensions
		364	+ end
		365	+ @extensions
		366	+ end
		367	+
		368	+=begin rdoc
		369	+ Any methods defined in Name can be used here. This means you can do cert.email rather than cert.subject.email.
		370	+=end
		371	+ def method_missing(method)
		372	+ subject.send method
		373	+ end
		374	+
		375	+ end
		376	+
		377	+=begin rdoc
		378	+ A handy ruby wrapper around OpenSSL's Name object. This was created to make it really easy to extract information out of the certificate.
		379	+=end
		380	+ class Name
		381	+=begin rdoc
		382	+ Initializes the Name object with the underlying OpenSSL Name object. You generally do not need to use this.
		383	+ Rather use the Certificates subject or issuer methods.
		384	+=end
		385	+ def initialize(name)
		386	+ @name=name
		387	+ @attributes={}
		388	+ name.to_s.split(/\//).each do \|field\|
		389	+ key, val = field.split(/=/,2)
		390	+ if key
		391	+ @attributes[key.to_sym]=val
		392	+ end
		393	+ end
		394	+ end
		395	+
		396	+=begin rdoc
		397	+ Returns the full name object in classic horrible X500 format.
		398	+=end
		399	+ def to_s
		400	+ @name.to_s
		401	+ end
		402	+
		403	+=begin rdoc
		404	+ Returns the email if present in the name
		405	+=end
		406	+ def email
		407	+ self[:emailAddress]
		408	+ end
		409	+=begin rdoc
		410	+ The 2 letter country code of the name
		411	+=end
		412	+ def country
		413	+ self[:C]
		414	+ end
		415	+ alias_method :c,:country
		416	+=begin rdoc
		417	+ The state or province code
		418	+=end
		419	+ def state
		420	+ self[:ST]
		421	+ end
		422	+ alias_method :st,:state
		423	+ alias_method :province,:state
		424	+
		425	+=begin rdoc
		426	+ The locality
		427	+=end
		428	+ def locality
		429	+ self[:L]
		430	+ end
		431	+ alias_method :l,:locality
		432	+
		433	+=begin rdoc
		434	+ The Organizational Unit
		435	+=end
		436	+ def organizational_unit
		437	+ self[:OU]
		438	+ end
		439	+ alias_method :ou,:organizational_unit
		440	+ alias_method :organisational_unit,:organizational_unit
		441	+
		442	+=begin rdoc
		443	+ The Organization
		444	+=end
		445	+ def organization
		446	+ self[:O]
		447	+ end
		448	+ alias_method :o,:organization
		449	+ alias_method :organisation,:organization
		450	+
		451	+=begin rdoc
		452	+ The common name. For SSL this means the domain name. For personal certificates it is the name.
		453	+=end
		454	+ def common_name
		455	+ self[:CN]
		456	+ end
		457	+ alias_method :name,:common_name
		458	+ alias_method :cn,:common_name
		459	+
		460	+=begin rdoc
		461	+ Lookup fields in the certificate.
		462	+=end
		463	+ def [](attr_key)
		464	+ @attributes[attr_key.to_sym]
		465	+ end
		466	+
		467	+ def method_missing(method)
		468	+ self[method]
		469	+ end
		470	+
		471	+ end
		472	+
		473	+=begin rdoc
		474	+ Wraps around the OpenSSL trust store. This allows you to decide which certificates you trust.
		475	+
		476	+ You can either point it at a path which contains a OpenSSL trust store (see OpenSSL for more) or build it up manually.
		477	+
		478	+ For a certificate to verify you need the issuer and the issuers issuers certs added to the Trust store.
		479	+
		480	+ NOTE: Currently this does not support CRL's or OCSP. We may add support for this later.
		481	+=end
		482	+ class TrustStore
		483	+
		484	+=begin rdoc
		485	+ Create a trust store of normally trusted root certificates as found in a browser. Extracted from Safari.
		486	+=end
		487	+ def self.default_trusted
		488	+ load_from_file(File.dirname(__FILE__) + "/trusted.pem")
		489	+ end
		490	+=begin rdoc
		491	+ Create a trust store from a list of certificates in a pem file.
		492	+ These certificates should just be listed one after each other.
		493	+=end
		494	+ def self.load_from_file(file)
		495	+ store=TrustStore.new
		496	+ EzCrypto::Verifier.load_all_from_file(file).each do \|cert\|
		497	+ store.add cert
		498	+ end
		499	+ store
		500	+ end
		501	+=begin rdoc
		502	+ Create trust store with an optional list of paths of openssl trust stores.
		503	+=end
		504	+ def initialize(*paths)
		505	+ @store=OpenSSL::X509::Store.new
		506	+# @store.set_default_path paths.shift if paths.length>0
		507	+ paths.each {\|path\| @store.add_path path}
		508	+ end
		509	+
		510	+=begin rdoc
		511	+ Add either a EzCrypto::Certificate or a OpenSSL::X509::Cert object to the TrustStore. This should be a trusted certificate such as a CA's issuer certificate.
		512	+=end
		513	+ def add(obj)
		514	+ if obj.kind_of?(EzCrypto::Certificate)
		515	+ @store.add_cert obj.cert
		516	+ elsif obj.kind_of?(OpenSSL::X509::Certificate)
		517	+ @store.add_cert obj
		518	+ else
		519	+ raise "unsupported object type"
		520	+ end
		521	+ end
		522	+=begin rdoc
		523	+ Returns true if either the EzCrypto::Certificate or OpenSSL::X509::Cert object is verified using issuer certificates in the trust store.
		524	+=end
		525	+ def verify(cert)
		526	+ if cert.kind_of?(EzCrypto::Certificate)
		527	+ @store.verify cert.cert
		528	+ elsif cert.kind_of?(OpenSSL::X509::Certificate)
		529	+ @store.verify cert
		530	+ else
		531	+ false
		532	+ end
		533	+ end
		534	+ end
		535	+end
0	\ No newline at end of file	536	\ No newline at end of file
@@ -0,0 +1,200 @@		@@ -0,0 +1,200 @@
	1	+require 'rubygems'
	2	+require 'rake'
	3	+require 'rake/testtask'
	4	+require 'rake/rdoctask'
	5	+require 'rake/packagetask'
	6	+require 'rake/gempackagetask'
	7	+require 'rake/contrib/rubyforgepublisher'
	8	+
	9	+PKG_BUILD = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
	10	+PKG_NAME = 'ezcrypto'
	11	+PKG_VERSION = '0.7.2' + PKG_BUILD
	12	+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
	13	+
	14	+RELEASE_NAME = "REL #{PKG_VERSION}"
	15	+
	16	+RUBY_FORGE_PROJECT = "ezcrypto"
	17	+RUBY_FORGE_USER = "pelleb"
	18	+
	19	+desc "Default Task"
	20	+task :default => [ :test ]
	21	+
	22	+# Run the unit tests
	23	+Rake::TestTask.new { \|t\|
	24	+ t.libs << "test"
	25	+ t.pattern = 'test/*_test.rb'
	26	+ t.verbose = true
	27	+}
	28	+
	29	+
	30	+# Genereate the RDoc documentation
	31	+Rake::RDocTask.new { \|rdoc\|
	32	+ rdoc.rdoc_dir = 'doc'
	33	+ rdoc.title = "EzCrypto - Simplified Crypto Library"
	34	+# rdoc.options << '--line-numbers --inline-source --main README #--template=jamis'
	35	+ rdoc.template = "#{ENV['template']}.rb" if ENV['template']
	36	+ rdoc.rdoc_files.include('README.rdoc')
	37	+ rdoc.rdoc_files.include('README_ACTIVE_CRYPTO')
	38	+ rdoc.rdoc_files.include('README_DIGITAL_SIGNATURES')
	39	+ rdoc.rdoc_files.include('CHANGELOG')
	40	+ rdoc.rdoc_files.include('lib/*.rb')
	41	+}
	42	+
	43	+
	44	+# Create compressed packages
	45	+spec = Gem::Specification.new do \|s\|
	46	+ s.platform = Gem::Platform::RUBY
	47	+ s.name = PKG_NAME
	48	+ s.summary = "Simplified encryption library."
	49	+ s.description = %q{Makes it easier and safer to write crypto code.}
	50	+ s.version = PKG_VERSION
	51	+
	52	+ s.author = "Pelle Braendgaard"
	53	+ s.email = "pelle@stakeventures.com"
	54	+ s.rubyforge_project = "ezcrypto"
	55	+ s.homepage = "http://ezcrypto.rubyforge.org"
	56	+
	57	+
	58	+ s.has_rdoc = true
	59	+ s.requirements << 'none'
	60	+ s.require_path = 'lib'
	61	+
	62	+ s.files = [ "rakefile", "README.rdoc", "README_ACTIVE_CRYPTO", "README_DIGITAL_SIGNATURES", "MIT-LICENSE","CHANGELOG","init.rb" ]
	63	+ ["lib","test"].each do \|dir\|
	64	+ s.files = s.files + Dir.glob( "#{dir}/*" )
	65	+ end
	66	+ s.extra_rdoc_files = ["CHANGELOG", "README.rdoc","README_ACTIVE_CRYPTO","README_DIGITAL_SIGNATURES"]
	67	+ s.test_files = Dir.glob("test/*")
	68	+end
	69	+
	70	+Rake::GemPackageTask.new(spec) do \|p\|
	71	+ p.gem_spec = spec
	72	+ p.need_tar = true
	73	+ p.need_zip = true
	74	+end
	75	+
	76	+
	77	+desc "Publish the GEM"
	78	+task :pgem => [:package] do
	79	+ Rake::SshFilePublisher.new("pelleb@rubyforge.org", "/var/www/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
	80	+end
	81	+
	82	+desc "Publish the API documentation"
	83	+task :pdoc => [:rdoc] do
	84	+ Rake::SshDirPublisher.new("pelleb@rubyforge.org", "/var/www/gforge-projects/ezcrypto", "doc").upload
	85	+end
	86	+
	87	+desc "Publish the release files to RubyForge."
	88	+task :rubyforge_upload => :package do
	89	+ files = %w(gem tgz zip).map { \|ext\| "pkg/#{PKG_FILE_NAME}.#{ext}" }
	90	+
	91	+ if RUBY_FORGE_PROJECT then
	92	+ require 'net/http'
	93	+ require 'open-uri'
	94	+
	95	+ project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
	96	+ project_data = open(project_uri) { \|data\| data.read }
	97	+ group_id = project_data[/[?&]group_id=(\d+)/, 1]
	98	+ raise "Couldn't get group id" unless group_id
	99	+
	100	+ # This echos password to shell which is a bit sucky
	101	+ if ENV["RUBY_FORGE_PASSWORD"]
	102	+ password = ENV["RUBY_FORGE_PASSWORD"]
	103	+ else
	104	+ print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
	105	+ password = STDIN.gets.chomp
	106	+ end
	107	+
	108	+ login_response = Net::HTTP.start("rubyforge.org", 80) do \|http\|
	109	+ data = [
	110	+ "login=1",
	111	+ "form_loginname=#{RUBY_FORGE_USER}",
	112	+ "form_pw=#{password}"
	113	+ ].join("&")
	114	+ http.post("/account/login.php", data)
	115	+ end
	116	+
	117	+ cookie = login_response["set-cookie"]
	118	+ raise "Login failed" unless cookie
	119	+ headers = { "Cookie" => cookie }
	120	+
	121	+ release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
	122	+ release_data = open(release_uri, headers) { \|data\| data.read }
	123	+ package_id = release_data[/[?&]package_id=(\d+)/, 1]
	124	+ raise "Couldn't get package id" unless package_id
	125	+
	126	+ first_file = true
	127	+ release_id = ""
	128	+
	129	+ files.each do \|filename\|
	130	+ basename = File.basename(filename)
	131	+ file_ext = File.extname(filename)
	132	+ file_data = File.open(filename, "rb") { \|file\| file.read }
	133	+
	134	+ puts "Releasing #{basename}..."
	135	+
	136	+ release_response = Net::HTTP.start("rubyforge.org", 80) do \|http\|
	137	+ release_date = Time.now.strftime("%Y-%m-%d %H:%M")
	138	+ type_map = {
	139	+ ".zip" => "3000",
	140	+ ".tgz" => "3110",
	141	+ ".gz" => "3110",
	142	+ ".gem" => "1400"
	143	+ }; type_map.default = "9999"
	144	+ type = type_map[file_ext]
	145	+ boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
	146	+
	147	+ query_hash = if first_file then
	148	+ {
	149	+ "group_id" => group_id,
	150	+ "package_id" => package_id,
	151	+ "release_name" => PKG_FILE_NAME,
	152	+ "release_date" => release_date,
	153	+ "type_id" => type,
	154	+ "processor_id" => "8000", # Any
	155	+ "release_notes" => "",
	156	+ "release_changes" => "",
	157	+ "preformatted" => "1",
	158	+ "submit" => "1"
	159	+ }
	160	+ else
	161	+ {
	162	+ "group_id" => group_id,
	163	+ "release_id" => release_id,
	164	+ "package_id" => package_id,
	165	+ "step2" => "1",
	166	+ "type_id" => type,
	167	+ "processor_id" => "8000", # Any
	168	+ "submit" => "Add This File"
	169	+ }
	170	+ end
	171	+
	172	+ query = "?" + query_hash.map do \|(name, value)\|
	173	+ [name, URI.encode(value)].join("=")
	174	+ end.join("&")
	175	+
	176	+ data = [
	177	+ "--" + boundary,
	178	+ "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
	179	+ "Content-Type: application/octet-stream",
	180	+ "Content-Transfer-Encoding: binary",
	181	+ "", file_data, ""
	182	+ ].join("\x0D\x0A")
	183	+
	184	+ release_headers = headers.merge(
	185	+ "Content-Type" => "multipart/form-data; boundary=#{boundary}"
	186	+ )
	187	+
	188	+ target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
	189	+ http.post(target + query, data, release_headers)
	190	+ end
	191	+
	192	+ if first_file then
	193	+ release_id = release_response.body[/release_id=(\d+)/, 1]
	194	+ raise("Couldn't get release id") unless release_id
	195	+ end
	196	+
	197	+ first_file = false
	198	+ end
	199	+ end
	200	+end