scrypt 2.0.2 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c836e8c175f08a62b2dd0fc2732874265aab163
-  data.tar.gz: a022b4b68060d2dd28b5ee469883ac666bb819f6
+  metadata.gz: 97e4aa9bd943a970d5809dec76392d57b80b86ab
+  data.tar.gz: d4ed6d6695db090fa341ffaae1f050d0d0ff6301
 SHA512:
-  metadata.gz: b6d28a4faf27640f452966df5a925b5f1aa2aba6364714c236632e88dcf132af2a3c1a9092ff6f1f9487d7f3fcd6ed600129af957fdd8656fa6a20d36dad438e
-  data.tar.gz: 41c2e4894c9ebbd533449fd10cab5f7e3f49e8bc9bf1675667787f5ffc685e8ecde2dcbdd7122c9627d70bc116cc9830fb46c20b095c23195e1e8b7b27669258
+  metadata.gz: e73b9d972111d155c7b75e8f84317a8dfa6995f6103be3c03e8c430feead8694c41cc96dfbc12ce5234e34916c7f7261abd5658c7428eca0236d68b3feb0bfab
+  data.tar.gz: fd8b8d3934186ae12ed492e14e66b078e5c3e56c44960e15cb5c197f76fc909671bbbc2c69e826f62c3b887bee6ecfa958f3fe8a8fb6662b52ffd3f1380e1796

checksums.yaml.gz.sig

@@ -1,2 +1,2 @@
-)$e����0b���a8=�����AP;�Ff9kN����t�f9*��R&5
-3}<.�)�|�\�*z<���9�3�#�'�+�|&G!����ُb��+'=����[㚍�z�T
��<���H�-�������کb@�l��g�F�T�W9��e���vÛ�5|��ԺI���S����'	{�b����հ���J<a����l��ƸUv�/l��
+�ԸR؎��R�(id{��dj���J�*3ylZw�~g��N�$�p(G�ƪ����o7������vs5�X�Q��0P�$�	�\E���p�!h�ʹ
+�''�r���!4��eE��|��K`��t������X��H�J:�����it:1���i��w�kP2�#����[vc��6�,9�>lcQ����2g�/�	ݰUP����׊�9��.�Q�b�,�2Y.R�h��]���sC�6f�e�����u7�h�h�Ϣ��

data/README.md

@@ -37,13 +37,13 @@ password == "a paltry guess"  # => false
 Password.create takes five options which will determine the key length and salt size, as well as the cost limits of the computation:
 
 * `:key_len` specifies the length in bytes of the key you want to generate. The default is 32 bytes (256 bits). Minimum is 16 bytes (128 bits). Maximum is 512 bytes (4096 bits).
-* `:salt_size` specifies the size in bytes of the random salt you want to generate. The default and minimum is 8 bytes (64 bits). Maximum is 32 bytes (256 bits).
+* `:salt_size` specifies the size in bytes of the random salt you want to generate. The default and maximum is 32 bytes (256 bits). Minimum is 8 bytes (64 bits).
 * `:max_time` specifies the maximum number of seconds the computation should take.
 * `:max_mem` specifies the maximum number of bytes the computation should take. A value of 0 specifies no upper limit. The minimum is always 1 MB.
 * `:max_memfrac` specifies the maximum memory in a fraction of available resources to use. Any value equal to 0 or greater than 0.5 will result in 0.5 being used.
 * `:cost` specifies a cost string (e.g. `'400$8$19$'`) from the `calibrate` method.  The `:max_*` options will be ignored if this option is given, or if `calibrate!` has been called.
 
-Default options will result in calculation time of approx. 200 ms with 1 MB memory use.
+Default options will result in calculation time of approx. 200 ms with 16 MB memory use.
 
 ## Other things you can do
 

data/lib/scrypt.rb

@@ -1,6 +1,7 @@
 # A wrapper for the scrypt algorithm.
 
 require "scrypt/scrypt_ext"
+require "scrypt/security_utils"
 require "openssl"
 require "scanf"
 require "ffi"
@@ -23,8 +24,8 @@ module SCrypt
   class Engine
     DEFAULTS = {
       :key_len     => 32,
-      :salt_size   => 8,
-      :max_mem     => 1024 * 1024,
+      :salt_size   => 32,
+      :max_mem     => 16 * 1024 * 1024,
       :max_memfrac => 0.5,
       :max_time    => 0.2,
       :cost        => nil
@@ -246,7 +247,7 @@ module SCrypt
 
     # Compares a potential secret against the hash. Returns true if the secret is the original secret, false otherwise.
     def ==(secret)
-      super(SCrypt::Engine.hash_secret(secret, @cost + @salt, self.digest.length / 2))
+      SecurityUtils.secure_compare(self, SCrypt::Engine.hash_secret(secret, @cost + @salt, self.digest.length / 2))
     end
     alias_method :is_password?, :==
 

data/lib/scrypt/security_utils.rb

@@ -0,0 +1,23 @@
+# NOTE:: a verbatim copy of https://github.com/rails/rails/blob/c8c660002f4b0e9606de96325f20b95248b6ff2d/activesupport/lib/active_support/security_utils.rb
+# Please see the Rails license: https://github.com/rails/rails/blob/master/activesupport/MIT-LICENSE
+
+module SCrypt
+  module SecurityUtils
+    # Constant time string comparison.
+    #
+    # The values compared should be of fixed length, such as strings
+    # that have already been processed by HMAC. This should not be used
+    # on variable length plaintext strings because it could leak length info
+    # via timing attacks.
+    def secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      l = a.unpack "C#{a.bytesize}"
+
+      res = 0
+      b.each_byte { |byte| res |= byte ^ l.shift }
+      res == 0
+    end
+    module_function :secure_compare
+  end
+end

data/lib/scrypt/version.rb

@@ -1,3 +1,3 @@
 module SCrypt
-  VERSION = "2.0.2"
+  VERSION = "2.1.1"
 end

data/spec/scrypt/engine_spec.rb

@@ -3,34 +3,34 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
 describe "The SCrypt engine" do
   it "should calculate a valid cost factor" do
     first = SCrypt::Engine.calibrate(:max_time => 0.2)
-    SCrypt::Engine.valid_cost?(first).should == true
+    expect(SCrypt::Engine.valid_cost?(first)).to equal(true)
   end
 end
 
 
 describe "Generating SCrypt salts" do
   it "should produce strings" do
-    SCrypt::Engine.generate_salt.should be_an_instance_of(String)
+    expect(SCrypt::Engine.generate_salt).to be_an_instance_of(String)
   end
 
   it "should produce random data" do
-    SCrypt::Engine.generate_salt.should_not equal(SCrypt::Engine.generate_salt)
+    expect(SCrypt::Engine.generate_salt).not_to equal(SCrypt::Engine.generate_salt)
   end
 
   it "should used the saved cost factor" do
     # Verify cost is different before saving
     cost = SCrypt::Engine.calibrate(:max_time => 0.01)
-    SCrypt::Engine.generate_salt(:max_time => 30, :max_mem => 64*1024*1024).should_not start_with(cost)
+    expect(SCrypt::Engine.generate_salt(:max_time => 30, :max_mem => 64*1024*1024)).not_to start_with(cost)
 
     cost = SCrypt::Engine.calibrate!(:max_time => 0.01)
-    SCrypt::Engine.generate_salt(:max_time => 30, :max_mem => 64*1024*1024).should start_with(cost)
+    expect(SCrypt::Engine.generate_salt(:max_time => 30, :max_mem => 64*1024*1024)).to start_with(cost)
   end
 end
 
 
 describe "Autodetecting of salt cost" do
   it "should work" do
-    SCrypt::Engine.autodetect_cost("2a$08$c3$randomjunkgoeshere").should == "2a$08$c3$"
+    expect(SCrypt::Engine.autodetect_cost("2a$08$c3$randomjunkgoeshere")).to eq("2a$08$c3$")
   end
 end
 
@@ -42,41 +42,41 @@ describe "Generating SCrypt hashes" do
   end
 
   before :each do
-    @salt = SCrypt::Engine.generate_salt()
+    @salt = SCrypt::Engine.generate_salt
     @password = "woo"
   end
 
   it "should produce a string" do
-    SCrypt::Engine.hash_secret(@password, @salt).should be_an_instance_of(String)
+    expect(SCrypt::Engine.hash_secret(@password, @salt)).to be_an_instance_of(String)
   end
 
   it "should raise an InvalidSalt error if the salt is invalid" do
-    lambda { SCrypt::Engine.hash_secret(@password, 'nino') }.should raise_error(SCrypt::Errors::InvalidSalt)
+    expect(lambda { SCrypt::Engine.hash_secret(@password, 'nino') }).to raise_error(SCrypt::Errors::InvalidSalt)
   end
 
   it "should raise an InvalidSecret error if the secret is invalid" do
-    lambda { SCrypt::Engine.hash_secret(MyInvalidSecret.new, @salt) }.should raise_error(SCrypt::Errors::InvalidSecret)
-    lambda { SCrypt::Engine.hash_secret(nil, @salt) }.should_not raise_error
-    lambda { SCrypt::Engine.hash_secret(false, @salt) }.should_not raise_error
+    expect(lambda { SCrypt::Engine.hash_secret(MyInvalidSecret.new, @salt) }).to raise_error(SCrypt::Errors::InvalidSecret)
+    expect(lambda { SCrypt::Engine.hash_secret(nil, @salt) }).to_not raise_error
+    expect(lambda { SCrypt::Engine.hash_secret(false, @salt) }).to_not raise_error
   end
 
   it "should call #to_s on the secret and use the return value as the actual secret data" do
-    SCrypt::Engine.hash_secret(false, @salt).should == SCrypt::Engine.hash_secret("false", @salt)
+    expect(SCrypt::Engine.hash_secret(false, @salt)).to eq(SCrypt::Engine.hash_secret("false", @salt))
   end
 end
 
 describe "SCrypt test vectors" do
   it "should match results of SCrypt function" do
-    SCrypt::Engine.scrypt('', '', 16, 1, 1, 64).unpack('H*').first.should eq('77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906')
-    SCrypt::Engine.scrypt('password', 'NaCl', 1024, 8, 16, 64).unpack('H*').first.should eq('fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640')
-    SCrypt::Engine.scrypt('pleaseletmein', 'SodiumChloride', 16384, 8, 1, 64).unpack('H*').first.should eq('7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887')
-    SCrypt::Engine.scrypt('pleaseletmein', 'SodiumChloride', 1048576, 8, 1, 64).unpack('H*').first.should eq('2101cb9b6a511aaeaddbbe09cf70f881ec568d574a2ffd4dabe5ee9820adaa478e56fd8f4ba5d09ffa1c6d927c40f4c337304049e8a952fbcbf45c6fa77a41a4')
+    expect(SCrypt::Engine.scrypt('', '', 16, 1, 1, 64).unpack('H*').first).to eq('77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906')
+    expect(SCrypt::Engine.scrypt('password', 'NaCl', 1024, 8, 16, 64).unpack('H*').first).to eq('fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640')
+    expect(SCrypt::Engine.scrypt('pleaseletmein', 'SodiumChloride', 16384, 8, 1, 64).unpack('H*').first).to eq('7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887')
+    expect(SCrypt::Engine.scrypt('pleaseletmein', 'SodiumChloride', 1048576, 8, 1, 64).unpack('H*').first).to eq('2101cb9b6a511aaeaddbbe09cf70f881ec568d574a2ffd4dabe5ee9820adaa478e56fd8f4ba5d09ffa1c6d927c40f4c337304049e8a952fbcbf45c6fa77a41a4')
   end
 
   it "should match equivalent results sent through hash_secret() function" do
-    SCrypt::Engine.hash_secret('', '10$1$1$0000000000000000', 64).should match(/\$77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906$/)
-    SCrypt::Engine.hash_secret('password', '400$8$10$000000004e61436c', 64).should match(/\$fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640$/)
-    SCrypt::Engine.hash_secret('pleaseletmein', '4000$8$1$536f6469756d43686c6f72696465', 64).should match(/\$7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887$/)
-    SCrypt::Engine.hash_secret('pleaseletmein', '100000$8$1$536f6469756d43686c6f72696465', 64).should match(/\$2101cb9b6a511aaeaddbbe09cf70f881ec568d574a2ffd4dabe5ee9820adaa478e56fd8f4ba5d09ffa1c6d927c40f4c337304049e8a952fbcbf45c6fa77a41a4$/)
+    expect(SCrypt::Engine.hash_secret('', '10$1$1$0000000000000000', 64)).to match(/\$77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906$/)
+    expect(SCrypt::Engine.hash_secret('password', '400$8$10$000000004e61436c', 64)).to match(/\$fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640$/)
+    expect(SCrypt::Engine.hash_secret('pleaseletmein', '4000$8$1$536f6469756d43686c6f72696465', 64)).to match(/\$7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887$/)
+    expect(SCrypt::Engine.hash_secret('pleaseletmein', '100000$8$1$536f6469756d43686c6f72696465', 64)).to match(/\$2101cb9b6a511aaeaddbbe09cf70f881ec568d574a2ffd4dabe5ee9820adaa478e56fd8f4ba5d09ffa1c6d927c40f4c337304049e8a952fbcbf45c6fa77a41a4$/)
   end
 end

data/spec/scrypt/password_spec.rb

@@ -6,23 +6,23 @@ describe "Creating a hashed password" do
   end
 
   it "should return a SCrypt::Password" do
-    @password.should be_an_instance_of(SCrypt::Password)
+    expect(@password).to be_an_instance_of(SCrypt::Password)
   end
 
   it "should return a valid password" do
-    lambda { SCrypt::Password.new(@password) }.should_not raise_error
+    expect(lambda { SCrypt::Password.new(@password) }).to_not raise_error
   end
 
   it "should behave normally if the secret is not a string" do
-    lambda { SCrypt::Password.create(nil) }.should_not raise_error
-    lambda { SCrypt::Password.create({:woo => "yeah"}) }.should_not raise_error
-    lambda { SCrypt::Password.create(false) }.should_not raise_error
+    expect(lambda { SCrypt::Password.create(nil) }).to_not raise_error
+    expect(lambda { SCrypt::Password.create({:woo => "yeah"}) }).to_not raise_error
+    expect(lambda { SCrypt::Password.create(false) }).to_not raise_error
   end
 
   it "should tolerate empty string secrets" do
-    lambda { SCrypt::Password.create( "\n".chop  ) }.should_not raise_error
-    lambda { SCrypt::Password.create( ""         ) }.should_not raise_error
-    lambda { SCrypt::Password.create( String.new ) }.should_not raise_error
+    expect(lambda { SCrypt::Password.create( "\n".chop  ) }).to_not raise_error
+    expect(lambda { SCrypt::Password.create( ""         ) }).to_not raise_error
+    expect(lambda { SCrypt::Password.create( String.new ) }).to_not raise_error
   end
 end
 
@@ -35,13 +35,13 @@ describe "Reading a hashed password" do
 
   it "should read the cost, salt, and hash" do
     password = SCrypt::Password.new(@hash)
-    password.cost.should == "400$8$d$"
-    password.salt.should == "173a8189751c095a29b933789560b73bf17b2e01"
-    password.to_s.should == @hash
+    expect(password.cost).to eq("400$8$d$")
+    expect(password.salt).to eq("173a8189751c095a29b933789560b73bf17b2e01")
+    expect(password.to_s).to eq(@hash)
   end
 
   it "should raise an InvalidHashError when given an invalid hash" do
-    lambda { SCrypt::Password.new('not a valid hash') }.should raise_error(SCrypt::Errors::InvalidHash)
+    expect(lambda { SCrypt::Password.new('not a valid hash') }).to raise_error(SCrypt::Errors::InvalidHash)
   end
 end
 
@@ -52,11 +52,11 @@ describe "Comparing a hashed password with a secret" do
   end
 
   it "should compare successfully to the original secret" do
-    (@password == @secret).should be(true)
+    expect((@password == @secret)).to be(true)
   end
 
   it "should compare unsuccessfully to anything besides original secret" do
-    (@password == "@secret").should be(false)
+    expect((@password == "@secret")).to be(false)
   end
 
 end
@@ -68,27 +68,27 @@ describe "non-default salt sizes" do
 
   it "should enforce a minimum salt of 8 bytes" do
     @password = SCrypt::Password.create(@secret, :salt_size => 7)
-    @password.salt.length.should eq(8 * 2)
+    expect(@password.salt.length).to eq(8 * 2)
   end
 
   it "should allow a salt of 32 bytes" do
     @password = SCrypt::Password.create(@secret, :salt_size => 32)
-    @password.salt.length.should eq(32 * 2)
+    expect(@password.salt.length).to eq(32 * 2)
   end
 
   it "should enforce a maximum salt of 32 bytes" do
     @password = SCrypt::Password.create(@secret, :salt_size => 33)
-    @password.salt.length.should eq(32 * 2)
+    expect(@password.salt.length).to eq(32 * 2)
   end
 
   it "should pad a 20-byte salt to not look like a 20-byte SHA1" do
     @password = SCrypt::Password.create(@secret, :salt_size => 20)
-    @password.salt.length.should eq(41)
+    expect(@password.salt.length).to eq(41)
   end
 
   it "should properly compare a non-standard salt hash" do
     @password = SCrypt::Password.create(@secret, :salt_size => 20)
-    (SCrypt::Password.new(@password.to_s) == @secret).should be(true)
+    expect((SCrypt::Password.new(@password.to_s) == @secret)).to be(true)
   end
 
 end
@@ -100,22 +100,22 @@ describe "non-default key lengths" do
 
   it "should enforce a minimum keylength of 16 bytes" do
     @password = SCrypt::Password.create(@secret, :key_len => 15)
-    @password.digest.length.should eq(16 * 2)
+    expect(@password.digest.length).to eq(16 * 2)
   end
 
   it "should allow a keylength of 512 bytes" do
     @password = SCrypt::Password.create(@secret, :key_len => 512)
-    @password.digest.length.should eq(512 * 2)
+    expect(@password.digest.length).to eq(512 * 2)
   end
 
   it "should enforce a maximum keylength of 512 bytes" do
     @password = SCrypt::Password.create(@secret, :key_len => 513)
-    @password.digest.length.should eq(512 * 2)
+    expect(@password.digest.length).to eq(512 * 2)
   end
 
   it "should properly compare a non-standard hash" do
     @password = SCrypt::Password.create(@secret, :key_len => 512)
-    (SCrypt::Password.new(@password.to_s) == @secret).should be(true)
+    expect((SCrypt::Password.new(@password.to_s) == @secret)).to be(true)
   end
 
 end
@@ -127,13 +127,13 @@ describe "Old-style hashes" do
   end
 
   it "should compare successfully" do
-    (SCrypt::Password.new(@hash) == @secret).should be(true)
+    expect((SCrypt::Password.new(@hash) == @secret)).to be(true)
   end
 end
 
 describe "Respecting standard ruby behaviors" do
   it 'should hash as a fixnum' do
     password = SCrypt::Password.create('')
-    password.hash.should be_kind_of(Fixnum)
+    expect(password.hash).to be_kind_of(Fixnum)
   end
 end

data/spec/scrypt/utils_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+
+describe "Security Utils" do
+  it "should perform a string comparison" do
+    expect(SCrypt::SecurityUtils.secure_compare('a', 'a')).to equal(true)
+    expect(SCrypt::SecurityUtils.secure_compare('a', 'b')).to equal(false)
+    expect(SCrypt::SecurityUtils.secure_compare('aa', 'aa')).to equal(true)
+    expect(SCrypt::SecurityUtils.secure_compare('aa', 'ab')).to equal(false)
+    expect(SCrypt::SecurityUtils.secure_compare('aa', 'aaa')).to equal(false)
+    expect(SCrypt::SecurityUtils.secure_compare('aaa', 'aa')).to equal(false)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scrypt
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.1
 platform: ruby
 authors:
 - Patrick Hogan
@@ -32,7 +32,7 @@ cert_chain:
   5Bi3W9Xf1BH2VODGXbWJ/7Wa1hBfmxXeWxat27WlvW3xFTi4NaHMlp+l3wa1gTN6
   Xm3vXPA+7+FFynIH9Fw2NiURj9auCa2HIRp63V0TGhrBSxuB7e2qZhKHVt2Jnk+o
   -----END CERTIFICATE-----
-date: 2015-06-04 00:00:00.000000000 Z
+date: 2016-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-compiler
@@ -137,10 +137,12 @@ files:
 - ext/scrypt/sysendian.h
 - lib/scrypt.rb
 - lib/scrypt/scrypt_ext.rb
+- lib/scrypt/security_utils.rb
 - lib/scrypt/version.rb
 - scrypt.gemspec
 - spec/scrypt/engine_spec.rb
 - spec/scrypt/password_spec.rb
+- spec/scrypt/utils_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/pbhogan/scrypt
 licenses:
@@ -169,4 +171,5 @@ summary: scrypt password hashing algorithm.
 test_files:
 - spec/scrypt/engine_spec.rb
 - spec/scrypt/password_spec.rb
+- spec/scrypt/utils_spec.rb
 - spec/spec_helper.rb

metadata.gz.sig

@@ -1,2 +1,4 @@
-�t�3,���W�e�`Ř<��R^z��|l����	�dY32CLJ�8^/gV�2W��9��R��|���60E8�O�uw`N%��[̇
-2���5V�(��{���&^�[o�0l� $��jtv�DUd��Wzx��{�<�8�b�t$ସ��Œ/C_ưK�L�j���St�d��bK�g ��.06o��+T�J�,�4��*F�����_��;y9.�~�K�.�A+�N�x�W���j
�/
�`A�Յ�=���V�
+�e�x���Ɖ����y�=|K�<U���Yi�%h)sW
+��e���b~5N��(�4��"��!�>c�R��l�a�B���S
+��/L�L��9�1F�}��~�E�N��&�0r��2	�jk�j٦�m0�U�*
d���}&�v
+Z���q�P�?���K	�Ґ��?�Ɏn���W<
rK��~���R��Ǜ�ܜ��x���x����C:��H�����2��=�
��5�pw38��WV� G/��S�Ǚ