encryptor 1.3.0 → 2.0.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- checksums.yaml.gz.sig +0 -0
- data.tar.gz.sig +1 -0
- data/.gitignore +5 -0
- data/.travis.yml +19 -0
- data/CHANGELOG.md +24 -0
- data/Gemfile +3 -0
- data/README.md +168 -73
- data/Rakefile +5 -14
- data/certs/saghaulor.pem +21 -0
- data/encryptor.gemspec +41 -0
- data/lib/encryptor.rb +54 -19
- data/lib/encryptor/string.rb +3 -3
- data/lib/encryptor/version.rb +2 -2
- data/test/compatibility_test.rb +29 -25
- data/test/encryptor_string_test.rb +60 -0
- data/test/encryptor_test.rb +57 -65
- data/test/legacy_encryptor_string_test.rb +56 -0
- data/test/legacy_encryptor_test.rb +22 -63
- data/test/openssl_helper.rb +24 -4
- data/test/test_helper.rb +21 -12
- metadata +94 -39
- metadata.gz.sig +0 -0
data/lib/encryptor/string.rb
CHANGED
@@ -3,7 +3,7 @@ module Encryptor
|
|
3
3
|
module String
|
4
4
|
# Returns a new string containing the encrypted version of itself
|
5
5
|
def encrypt(options = {})
|
6
|
-
Encryptor.encrypt(options.merge(:
|
6
|
+
Encryptor.encrypt(options.merge(value: self))
|
7
7
|
end
|
8
8
|
|
9
9
|
# Replaces the contents of a string with the encrypted version of itself
|
@@ -13,11 +13,11 @@ module Encryptor
|
|
13
13
|
|
14
14
|
# Returns a new string containing the decrypted version of itself
|
15
15
|
def decrypt(options = {})
|
16
|
-
Encryptor.decrypt(options.merge(:
|
16
|
+
Encryptor.decrypt(options.merge(value: self))
|
17
17
|
end
|
18
18
|
|
19
19
|
# Replaces the contents of a string with the decrypted version of itself
|
20
|
-
def decrypt!(options ={})
|
20
|
+
def decrypt!(options = {})
|
21
21
|
replace decrypt(options)
|
22
22
|
end
|
23
23
|
end
|
data/lib/encryptor/version.rb
CHANGED
data/test/compatibility_test.rb
CHANGED
@@ -5,7 +5,7 @@ require File.expand_path('../test_helper', __FILE__)
|
|
5
5
|
# for data stored in databases and allows consumers of the gem to upgrade with
|
6
6
|
# confidence in the future.
|
7
7
|
#
|
8
|
-
class CompatibilityTest < Test
|
8
|
+
class CompatibilityTest < Minitest::Test
|
9
9
|
ALGORITHM = 'aes-256-cbc'
|
10
10
|
|
11
11
|
def self.base64_encode(value)
|
@@ -21,10 +21,11 @@ class CompatibilityTest < Test::Unit::TestCase
|
|
21
21
|
key = Digest::SHA256.hexdigest('my-fixed-key')
|
22
22
|
iv = Digest::SHA256.hexdigest('my-fixed-iv')
|
23
23
|
result = Encryptor.encrypt(
|
24
|
-
:
|
25
|
-
:
|
26
|
-
:
|
27
|
-
:
|
24
|
+
algorithm: ALGORITHM,
|
25
|
+
value: 'my-fixed-input',
|
26
|
+
key: key,
|
27
|
+
iv: iv,
|
28
|
+
insecure_mode: true
|
28
29
|
)
|
29
30
|
assert_equal 'nGuyGniksFXnMYj/eCxXKQ==', self.class.base64_encode(result)
|
30
31
|
end
|
@@ -32,9 +33,10 @@ class CompatibilityTest < Test::Unit::TestCase
|
|
32
33
|
def test_encrypt_without_iv
|
33
34
|
key = Digest::SHA256.hexdigest('my-fixed-key')
|
34
35
|
result = Encryptor.encrypt(
|
35
|
-
:
|
36
|
-
:
|
37
|
-
:
|
36
|
+
algorithm: ALGORITHM,
|
37
|
+
value: 'my-fixed-input',
|
38
|
+
key: key,
|
39
|
+
insecure_mode: true
|
38
40
|
)
|
39
41
|
assert_equal 'XbwHRMFWqR5M80kgwRcEEg==', self.class.base64_encode(result)
|
40
42
|
end
|
@@ -43,10 +45,11 @@ class CompatibilityTest < Test::Unit::TestCase
|
|
43
45
|
key = Digest::SHA256.hexdigest('my-fixed-key')
|
44
46
|
iv = Digest::SHA256.hexdigest('my-fixed-iv')
|
45
47
|
result = Encryptor.decrypt(
|
46
|
-
:
|
47
|
-
:
|
48
|
-
:
|
49
|
-
:
|
48
|
+
algorithm: ALGORITHM,
|
49
|
+
value: self.class.base64_decode('nGuyGniksFXnMYj/eCxXKQ=='),
|
50
|
+
key: key,
|
51
|
+
iv: iv,
|
52
|
+
insecure_mode: true
|
50
53
|
)
|
51
54
|
assert_equal 'my-fixed-input', result
|
52
55
|
end
|
@@ -54,9 +57,10 @@ class CompatibilityTest < Test::Unit::TestCase
|
|
54
57
|
def test_decrypt_without_iv
|
55
58
|
key = Digest::SHA256.hexdigest('my-fixed-key')
|
56
59
|
result = Encryptor.decrypt(
|
57
|
-
:
|
58
|
-
:
|
59
|
-
:
|
60
|
+
algorithm: ALGORITHM,
|
61
|
+
value: self.class.base64_decode('XbwHRMFWqR5M80kgwRcEEg=='),
|
62
|
+
key: key,
|
63
|
+
insecure_mode: true
|
60
64
|
)
|
61
65
|
assert_equal 'my-fixed-input', result
|
62
66
|
end
|
@@ -66,11 +70,11 @@ class CompatibilityTest < Test::Unit::TestCase
|
|
66
70
|
iv = Digest::SHA256.hexdigest('my-fixed-iv')
|
67
71
|
salt = 'my-fixed-salt'
|
68
72
|
result = Encryptor.encrypt(
|
69
|
-
:
|
70
|
-
:
|
71
|
-
:
|
72
|
-
:
|
73
|
-
:
|
73
|
+
algorithm: ALGORITHM,
|
74
|
+
value: 'my-fixed-input',
|
75
|
+
key: key,
|
76
|
+
iv: iv,
|
77
|
+
salt: salt
|
74
78
|
)
|
75
79
|
assert_equal 'DENuQSh9b0eW8GN3YLzLGw==', self.class.base64_encode(result)
|
76
80
|
end
|
@@ -80,11 +84,11 @@ class CompatibilityTest < Test::Unit::TestCase
|
|
80
84
|
iv = Digest::SHA256.hexdigest('my-fixed-iv')
|
81
85
|
salt = 'my-fixed-salt'
|
82
86
|
result = Encryptor.decrypt(
|
83
|
-
:
|
84
|
-
:
|
85
|
-
:
|
86
|
-
:
|
87
|
-
:
|
87
|
+
algorithm: ALGORITHM,
|
88
|
+
value: self.class.base64_decode('DENuQSh9b0eW8GN3YLzLGw=='),
|
89
|
+
key: key,
|
90
|
+
iv: iv,
|
91
|
+
salt: salt
|
88
92
|
)
|
89
93
|
assert_equal 'my-fixed-input', result
|
90
94
|
end
|
@@ -0,0 +1,60 @@
|
|
1
|
+
require 'test_helper'
|
2
|
+
|
3
|
+
class EncryptorStringTest < Minitest::Test
|
4
|
+
|
5
|
+
original_value = StringWithEncryptor.new
|
6
|
+
key = SecureRandom.random_bytes(64)
|
7
|
+
iv = SecureRandom.random_bytes(64)
|
8
|
+
salt = Time.now.to_i.to_s
|
9
|
+
original_value << SecureRandom.random_bytes(64)
|
10
|
+
auth_data = SecureRandom.random_bytes(64)
|
11
|
+
wrong_auth_tag = SecureRandom.random_bytes(16)
|
12
|
+
|
13
|
+
OpenSSLHelper::ALGORITHMS.each do |algorithm|
|
14
|
+
encrypted_value_with_iv = StringWithEncryptor.new
|
15
|
+
encrypted_value_without_iv = StringWithEncryptor.new
|
16
|
+
encrypted_value_with_iv << Encryptor.encrypt(value: original_value, key: key, iv: iv, salt: salt, algorithm: algorithm)
|
17
|
+
encrypted_value_without_iv << Encryptor.encrypt(value: original_value, key: key, algorithm: algorithm, insecure_mode: true)
|
18
|
+
|
19
|
+
define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
20
|
+
assert_equal encrypted_value_with_iv, original_value.encrypt(key: key, iv: iv, salt: salt, algorithm: algorithm)
|
21
|
+
end
|
22
|
+
|
23
|
+
define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
24
|
+
assert_equal encrypted_value_without_iv, original_value.encrypt(key: key, algorithm: algorithm, insecure_mode: true)
|
25
|
+
end
|
26
|
+
|
27
|
+
define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
28
|
+
assert_equal original_value, encrypted_value_with_iv.decrypt(key: key, iv: iv, salt: salt, algorithm: algorithm)
|
29
|
+
end
|
30
|
+
|
31
|
+
define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
32
|
+
assert_equal original_value, encrypted_value_without_iv.decrypt(key: key, algorithm: algorithm, insecure_mode: true)
|
33
|
+
end
|
34
|
+
|
35
|
+
define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
36
|
+
original_value_dup = original_value.dup
|
37
|
+
original_value_dup.encrypt!(key: key, iv: iv, salt: salt, algorithm: algorithm)
|
38
|
+
assert_equal original_value.encrypt(key: key, iv: iv, salt: salt, algorithm: algorithm), original_value_dup
|
39
|
+
end
|
40
|
+
|
41
|
+
define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
42
|
+
original_value_dup = original_value.dup
|
43
|
+
original_value_dup.encrypt!(key: key, algorithm: algorithm, insecure_mode: true)
|
44
|
+
assert_equal original_value.encrypt(key: key, algorithm: algorithm, insecure_mode: true), original_value_dup
|
45
|
+
end
|
46
|
+
|
47
|
+
define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
48
|
+
encrypted_value_with_iv_dup = encrypted_value_with_iv.dup
|
49
|
+
encrypted_value_with_iv_dup.decrypt!(key: key, iv: iv, salt: salt, algorithm: algorithm)
|
50
|
+
assert_equal original_value, encrypted_value_with_iv_dup
|
51
|
+
end
|
52
|
+
|
53
|
+
define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
54
|
+
encrypted_value_without_iv_dup = encrypted_value_without_iv.dup
|
55
|
+
encrypted_value_without_iv_dup.decrypt!(key: key, algorithm: algorithm, insecure_mode: true)
|
56
|
+
assert_equal original_value, encrypted_value_without_iv_dup
|
57
|
+
end
|
58
|
+
end
|
59
|
+
|
60
|
+
end
|
data/test/encryptor_test.rb
CHANGED
@@ -1,89 +1,50 @@
|
|
1
|
-
require
|
2
|
-
require File.expand_path('../openssl_helper', __FILE__)
|
1
|
+
require 'test_helper'
|
3
2
|
|
4
3
|
# Tests for new preferred salted encryption mode
|
5
4
|
#
|
6
|
-
class EncryptorTest < Test
|
5
|
+
class EncryptorTest < Minitest::Test
|
7
6
|
|
8
|
-
key =
|
9
|
-
iv =
|
10
|
-
salt =
|
11
|
-
original_value =
|
7
|
+
key = SecureRandom.random_bytes(32)
|
8
|
+
iv = SecureRandom.random_bytes(16)
|
9
|
+
salt = SecureRandom.random_bytes(16)
|
10
|
+
original_value = SecureRandom.random_bytes(64)
|
11
|
+
auth_data = SecureRandom.random_bytes(64)
|
12
|
+
wrong_auth_tag = SecureRandom.random_bytes(16)
|
12
13
|
|
13
14
|
OpenSSLHelper::ALGORITHMS.each do |algorithm|
|
14
|
-
encrypted_value_with_iv = Encryptor.encrypt(:
|
15
|
-
encrypted_value_without_iv = Encryptor.encrypt(:
|
15
|
+
encrypted_value_with_iv = Encryptor.encrypt(value: original_value, key: key, iv: iv, salt: salt, algorithm: algorithm)
|
16
|
+
encrypted_value_without_iv = Encryptor.encrypt(value: original_value, key: key, algorithm: algorithm, insecure_mode: true)
|
16
17
|
|
17
18
|
define_method "test_should_crypt_with_the_#{algorithm}_algorithm_with_iv" do
|
18
|
-
|
19
|
-
|
20
|
-
assert_equal original_value, Encryptor.decrypt(:
|
19
|
+
refute_equal original_value, encrypted_value_with_iv
|
20
|
+
refute_equal encrypted_value_without_iv, encrypted_value_with_iv
|
21
|
+
assert_equal original_value, Encryptor.decrypt(value: encrypted_value_with_iv, key: key, iv: iv, salt: salt, algorithm: algorithm)
|
21
22
|
end
|
22
23
|
|
23
24
|
define_method "test_should_crypt_with_the_#{algorithm}_algorithm_without_iv" do
|
24
|
-
|
25
|
-
assert_equal original_value, Encryptor.decrypt(:
|
25
|
+
refute_equal original_value, encrypted_value_without_iv
|
26
|
+
assert_equal original_value, Encryptor.decrypt(value: encrypted_value_without_iv, key: key, algorithm: algorithm, insecure_mode: true)
|
26
27
|
end
|
27
28
|
|
28
29
|
define_method "test_should_encrypt_with_the_#{algorithm}_algorithm_with_iv_with_the_first_arg_as_the_value" do
|
29
|
-
assert_equal encrypted_value_with_iv, Encryptor.encrypt(original_value, :
|
30
|
+
assert_equal encrypted_value_with_iv, Encryptor.encrypt(original_value, key: key, iv: iv, salt: salt, algorithm: algorithm)
|
30
31
|
end
|
31
32
|
|
32
33
|
define_method "test_should_encrypt_with_the_#{algorithm}_algorithm_without_iv_with_the_first_arg_as_the_value" do
|
33
|
-
assert_equal encrypted_value_without_iv, Encryptor.encrypt(original_value, :
|
34
|
+
assert_equal encrypted_value_without_iv, Encryptor.encrypt(original_value, key: key, algorithm: algorithm, insecure_mode: true)
|
34
35
|
end
|
35
36
|
|
36
37
|
define_method "test_should_decrypt_with_the_#{algorithm}_algorithm_with_iv_with_the_first_arg_as_the_value" do
|
37
|
-
assert_equal original_value, Encryptor.decrypt(encrypted_value_with_iv, :
|
38
|
+
assert_equal original_value, Encryptor.decrypt(encrypted_value_with_iv, key: key, iv: iv, salt: salt, algorithm: algorithm)
|
38
39
|
end
|
39
40
|
|
40
41
|
define_method "test_should_decrypt_with_the_#{algorithm}_algorithm_without_iv_with_the_first_arg_as_the_value" do
|
41
|
-
assert_equal original_value, Encryptor.decrypt(encrypted_value_without_iv, :
|
42
|
-
end
|
43
|
-
|
44
|
-
define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
45
|
-
assert_equal encrypted_value_with_iv, original_value.encrypt(:key => key, :iv => iv, :salt => salt, :algorithm => algorithm)
|
46
|
-
end
|
47
|
-
|
48
|
-
define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
49
|
-
assert_equal encrypted_value_without_iv, original_value.encrypt(:key => key, :algorithm => algorithm)
|
50
|
-
end
|
51
|
-
|
52
|
-
define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
53
|
-
assert_equal original_value, encrypted_value_with_iv.decrypt(:key => key, :iv => iv, :salt => salt, :algorithm => algorithm)
|
54
|
-
end
|
55
|
-
|
56
|
-
define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
57
|
-
assert_equal original_value, encrypted_value_without_iv.decrypt(:key => key, :algorithm => algorithm)
|
58
|
-
end
|
59
|
-
|
60
|
-
define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
61
|
-
original_value_dup = original_value.dup
|
62
|
-
original_value_dup.encrypt!(:key => key, :iv => iv, :salt => salt, :algorithm => algorithm)
|
63
|
-
assert_equal original_value.encrypt(:key => key, :iv => iv, :salt => salt, :algorithm => algorithm), original_value_dup
|
64
|
-
end
|
65
|
-
|
66
|
-
define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
67
|
-
original_value_dup = original_value.dup
|
68
|
-
original_value_dup.encrypt!(:key => key, :algorithm => algorithm)
|
69
|
-
assert_equal original_value.encrypt(:key => key, :algorithm => algorithm), original_value_dup
|
70
|
-
end
|
71
|
-
|
72
|
-
define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
73
|
-
encrypted_value_with_iv_dup = encrypted_value_with_iv.dup
|
74
|
-
encrypted_value_with_iv_dup.decrypt!(:key => key, :iv => iv, :salt => salt, :algorithm => algorithm)
|
75
|
-
assert_equal original_value, encrypted_value_with_iv_dup
|
76
|
-
end
|
77
|
-
|
78
|
-
define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
79
|
-
encrypted_value_without_iv_dup = encrypted_value_without_iv.dup
|
80
|
-
encrypted_value_without_iv_dup.decrypt!(:key => key, :algorithm => algorithm)
|
81
|
-
assert_equal original_value, encrypted_value_without_iv_dup
|
42
|
+
assert_equal original_value, Encryptor.decrypt(encrypted_value_without_iv, key: key, algorithm: algorithm, insecure_mode: true)
|
82
43
|
end
|
83
44
|
end
|
84
45
|
|
85
46
|
define_method 'test_should_use_the_default_algorithm_if_one_is_not_specified' do
|
86
|
-
assert_equal Encryptor.encrypt(:
|
47
|
+
assert_equal Encryptor.encrypt(value: original_value, key: key, salt: salt, iv: iv, algorithm: Encryptor.default_options[:algorithm]), Encryptor.encrypt(value: original_value, key: key, salt: salt, iv: iv)
|
87
48
|
end
|
88
49
|
|
89
50
|
def test_should_have_a_default_algorithm
|
@@ -92,17 +53,48 @@ class EncryptorTest < Test::Unit::TestCase
|
|
92
53
|
end
|
93
54
|
|
94
55
|
def test_should_raise_argument_error_if_key_is_not_specified
|
95
|
-
assert_raises(ArgumentError) { Encryptor.encrypt('some value') }
|
96
|
-
assert_raises(ArgumentError) { Encryptor.decrypt('some encrypted string') }
|
97
|
-
|
98
|
-
|
56
|
+
assert_raises(ArgumentError, "must specify a key") { Encryptor.encrypt('some value') }
|
57
|
+
assert_raises(ArgumentError, "must specify a key") { Encryptor.decrypt('some encrypted string') }
|
58
|
+
end
|
59
|
+
|
60
|
+
def test_should_raise_argument_error_if_key_is_too_short
|
61
|
+
assert_raises(ArgumentError, "key must be 32 bytes or longer") { Encryptor.encrypt('some value', key: '') }
|
62
|
+
assert_raises(ArgumentError, "key must be 32 bytes or longer") { Encryptor.decrypt('some encrypted string', key: '') }
|
99
63
|
end
|
100
64
|
|
101
|
-
|
65
|
+
define_method 'test_should_raise_argument_error_if_iv_is_not_specified' do
|
66
|
+
assert_raises(ArgumentError, "must specify an iv") { Encryptor.encrypt('some value', key: key) }
|
67
|
+
assert_raises(ArgumentError, "must specify an iv") { Encryptor.decrypt('some encrypted string', key: key) }
|
68
|
+
end
|
69
|
+
|
70
|
+
define_method 'test_should_raise_argument_error_if_iv_is_too_short' do
|
71
|
+
assert_raises(ArgumentError, "iv must be 16 bytes or longer") { Encryptor.encrypt('some value', key: key, iv: 'a') }
|
72
|
+
assert_raises(ArgumentError, "iv must be 16 bytes or longer") { Encryptor.decrypt('some encrypted string', key: key, iv: 'a') }
|
73
|
+
end
|
74
|
+
|
75
|
+
define_method 'test_should_yield_block_with_cipher_and_options' do
|
102
76
|
called = false
|
103
|
-
Encryptor.encrypt('some value', :key
|
77
|
+
Encryptor.encrypt('some value', key: key, iv: iv, salt: salt) { |cipher, options| called = true }
|
104
78
|
assert called
|
105
79
|
end
|
106
80
|
|
81
|
+
OpenSSLHelper::AUTHENTICATED_ENCRYPTION_ALGORITHMS.each do |algorithm|
|
82
|
+
|
83
|
+
define_method 'test_should_use_the_default_authentication_data_if_it_is_not_specified' do
|
84
|
+
encrypted_value = Encryptor.encrypt(value: original_value, key: key, iv: iv, salt: salt, algorithm: algorithm)
|
85
|
+
decrypted_value = Encryptor.decrypt(value: encrypted_value, key: key, iv: iv, salt: salt, algorithm: algorithm)
|
86
|
+
refute_equal original_value, encrypted_value
|
87
|
+
assert_equal original_value, decrypted_value
|
88
|
+
assert_raises(OpenSSL::Cipher::CipherError) { Encryptor.decrypt(value: encrypted_value[0..-17] + wrong_auth_tag, key: key, iv: iv, salt: salt, algorithm: algorithm) }
|
89
|
+
end
|
90
|
+
|
91
|
+
define_method 'test_should_use_authentication_data_if_it_is_specified' do
|
92
|
+
encrypted_value = Encryptor.encrypt(value: original_value, key: key, iv: iv, salt: salt, algorithm: algorithm, auth_data: auth_data)
|
93
|
+
decrypted_value = Encryptor.decrypt(value: encrypted_value, key: key, iv: iv, salt: salt, algorithm: algorithm, auth_data: auth_data)
|
94
|
+
refute_equal original_value, encrypted_value
|
95
|
+
assert_equal original_value, decrypted_value
|
96
|
+
assert_raises(OpenSSL::Cipher::CipherError) { Encryptor.decrypt(value: encrypted_value[0..-17] + wrong_auth_tag, key: key, iv: iv, salt: salt, algorithm: algorithm) }
|
97
|
+
end
|
98
|
+
end
|
107
99
|
end
|
108
100
|
|
@@ -0,0 +1,56 @@
|
|
1
|
+
require 'test_helper'
|
2
|
+
|
3
|
+
class LegacyEncryptorStringTest < Minitest::Test
|
4
|
+
|
5
|
+
key = SecureRandom.random_bytes(64)
|
6
|
+
iv = SecureRandom.random_bytes(64)
|
7
|
+
original_value = StringWithEncryptor.new
|
8
|
+
original_value << SecureRandom.random_bytes(64)
|
9
|
+
|
10
|
+
OpenSSLHelper::ALGORITHMS.each do |algorithm|
|
11
|
+
encrypted_value_with_iv = StringWithEncryptor.new
|
12
|
+
encrypted_value_with_iv << Encryptor.encrypt(value: original_value, key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
13
|
+
encrypted_value_without_iv = StringWithEncryptor.new
|
14
|
+
encrypted_value_without_iv << Encryptor.encrypt(value: original_value, key: key, algorithm: algorithm, insecure_mode: true)
|
15
|
+
|
16
|
+
define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
17
|
+
assert_equal encrypted_value_with_iv, original_value.encrypt(key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
18
|
+
end
|
19
|
+
|
20
|
+
define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
21
|
+
assert_equal encrypted_value_without_iv, original_value.encrypt(key: key, algorithm: algorithm, insecure_mode: true)
|
22
|
+
end
|
23
|
+
|
24
|
+
define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
25
|
+
assert_equal original_value, encrypted_value_with_iv.decrypt(key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
26
|
+
end
|
27
|
+
|
28
|
+
define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
29
|
+
assert_equal original_value, encrypted_value_without_iv.decrypt(key: key, algorithm: algorithm, insecure_mode: true)
|
30
|
+
end
|
31
|
+
|
32
|
+
define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
33
|
+
original_value_dup = original_value.dup
|
34
|
+
original_value_dup.encrypt!(key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
35
|
+
assert_equal original_value.encrypt(key: key, iv: iv, algorithm: algorithm, insecure_mode: true), original_value_dup
|
36
|
+
end
|
37
|
+
|
38
|
+
define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
39
|
+
original_value_dup = original_value.dup
|
40
|
+
original_value_dup.encrypt!(key: key, algorithm: algorithm, insecure_mode: true)
|
41
|
+
assert_equal original_value.encrypt(key: key, algorithm: algorithm, insecure_mode: true), original_value_dup
|
42
|
+
end
|
43
|
+
|
44
|
+
define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
45
|
+
encrypted_value_with_iv_dup = encrypted_value_with_iv.dup
|
46
|
+
encrypted_value_with_iv_dup.decrypt!(key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
47
|
+
assert_equal original_value, encrypted_value_with_iv_dup
|
48
|
+
end
|
49
|
+
|
50
|
+
define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
51
|
+
encrypted_value_without_iv_dup = encrypted_value_without_iv.dup
|
52
|
+
encrypted_value_without_iv_dup.decrypt!(key: key, algorithm: algorithm, insecure_mode: true)
|
53
|
+
assert_equal original_value, encrypted_value_without_iv_dup
|
54
|
+
end
|
55
|
+
end
|
56
|
+
end
|
@@ -1,88 +1,47 @@
|
|
1
|
-
require
|
2
|
-
require File.expand_path('../openssl_helper', __FILE__)
|
1
|
+
require 'test_helper'
|
3
2
|
|
4
3
|
# Tests for legacy (non-salted) encryption mode
|
5
4
|
#
|
6
|
-
class LegacyEncryptorTest < Test
|
5
|
+
class LegacyEncryptorTest < Minitest::Test
|
7
6
|
|
8
|
-
key =
|
9
|
-
iv =
|
10
|
-
original_value =
|
7
|
+
key = SecureRandom.random_bytes(64)
|
8
|
+
iv = SecureRandom.random_bytes(64)
|
9
|
+
original_value = SecureRandom.random_bytes(64)
|
11
10
|
|
12
11
|
OpenSSLHelper::ALGORITHMS.each do |algorithm|
|
13
|
-
encrypted_value_with_iv = Encryptor.encrypt(:
|
14
|
-
encrypted_value_without_iv = Encryptor.encrypt(:
|
12
|
+
encrypted_value_with_iv = Encryptor.encrypt(value: original_value, key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
13
|
+
encrypted_value_without_iv = Encryptor.encrypt(value: original_value, key: key, algorithm: algorithm, insecure_mode: true)
|
15
14
|
|
16
15
|
define_method "test_should_crypt_with_the_#{algorithm}_algorithm_with_iv" do
|
17
|
-
|
18
|
-
|
19
|
-
assert_equal original_value, Encryptor.decrypt(:
|
16
|
+
refute_equal original_value, encrypted_value_with_iv
|
17
|
+
refute_equal encrypted_value_without_iv, encrypted_value_with_iv
|
18
|
+
assert_equal original_value, Encryptor.decrypt(value: encrypted_value_with_iv, key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
20
19
|
end
|
21
20
|
|
22
21
|
define_method "test_should_crypt_with_the_#{algorithm}_algorithm_without_iv" do
|
23
|
-
|
24
|
-
assert_equal original_value, Encryptor.decrypt(:
|
22
|
+
refute_equal original_value, encrypted_value_without_iv
|
23
|
+
assert_equal original_value, Encryptor.decrypt(value: encrypted_value_without_iv, key: key, algorithm: algorithm, insecure_mode: true)
|
25
24
|
end
|
26
25
|
|
27
26
|
define_method "test_should_encrypt_with_the_#{algorithm}_algorithm_with_iv_with_the_first_arg_as_the_value" do
|
28
|
-
assert_equal encrypted_value_with_iv, Encryptor.encrypt(original_value, :
|
27
|
+
assert_equal encrypted_value_with_iv, Encryptor.encrypt(original_value, key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
29
28
|
end
|
30
29
|
|
31
30
|
define_method "test_should_encrypt_with_the_#{algorithm}_algorithm_without_iv_with_the_first_arg_as_the_value" do
|
32
|
-
assert_equal encrypted_value_without_iv, Encryptor.encrypt(original_value, :
|
31
|
+
assert_equal encrypted_value_without_iv, Encryptor.encrypt(original_value, key: key, algorithm: algorithm, insecure_mode: true)
|
33
32
|
end
|
34
33
|
|
35
34
|
define_method "test_should_decrypt_with_the_#{algorithm}_algorithm_with_iv_with_the_first_arg_as_the_value" do
|
36
|
-
assert_equal original_value, Encryptor.decrypt(encrypted_value_with_iv, :
|
35
|
+
assert_equal original_value, Encryptor.decrypt(encrypted_value_with_iv, key: key, iv: iv, algorithm: algorithm, insecure_mode: true)
|
37
36
|
end
|
38
37
|
|
39
38
|
define_method "test_should_decrypt_with_the_#{algorithm}_algorithm_without_iv_with_the_first_arg_as_the_value" do
|
40
|
-
assert_equal original_value, Encryptor.decrypt(encrypted_value_without_iv, :
|
41
|
-
end
|
42
|
-
|
43
|
-
define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
44
|
-
assert_equal encrypted_value_with_iv, original_value.encrypt(:key => key, :iv => iv, :algorithm => algorithm)
|
45
|
-
end
|
46
|
-
|
47
|
-
define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
48
|
-
assert_equal encrypted_value_without_iv, original_value.encrypt(:key => key, :algorithm => algorithm)
|
49
|
-
end
|
50
|
-
|
51
|
-
define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
52
|
-
assert_equal original_value, encrypted_value_with_iv.decrypt(:key => key, :iv => iv, :algorithm => algorithm)
|
53
|
-
end
|
54
|
-
|
55
|
-
define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
56
|
-
assert_equal original_value, encrypted_value_without_iv.decrypt(:key => key, :algorithm => algorithm)
|
57
|
-
end
|
58
|
-
|
59
|
-
define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
60
|
-
original_value_dup = original_value.dup
|
61
|
-
original_value_dup.encrypt!(:key => key, :iv => iv, :algorithm => algorithm)
|
62
|
-
assert_equal original_value.encrypt(:key => key, :iv => iv, :algorithm => algorithm), original_value_dup
|
63
|
-
end
|
64
|
-
|
65
|
-
define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
66
|
-
original_value_dup = original_value.dup
|
67
|
-
original_value_dup.encrypt!(:key => key, :algorithm => algorithm)
|
68
|
-
assert_equal original_value.encrypt(:key => key, :algorithm => algorithm), original_value_dup
|
69
|
-
end
|
70
|
-
|
71
|
-
define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
|
72
|
-
encrypted_value_with_iv_dup = encrypted_value_with_iv.dup
|
73
|
-
encrypted_value_with_iv_dup.decrypt!(:key => key, :iv => iv, :algorithm => algorithm)
|
74
|
-
assert_equal original_value, encrypted_value_with_iv_dup
|
75
|
-
end
|
76
|
-
|
77
|
-
define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
|
78
|
-
encrypted_value_without_iv_dup = encrypted_value_without_iv.dup
|
79
|
-
encrypted_value_without_iv_dup.decrypt!(:key => key, :algorithm => algorithm)
|
80
|
-
assert_equal original_value, encrypted_value_without_iv_dup
|
39
|
+
assert_equal original_value, Encryptor.decrypt(encrypted_value_without_iv, key: key, algorithm: algorithm, insecure_mode: true)
|
81
40
|
end
|
82
41
|
end
|
83
42
|
|
84
43
|
define_method 'test_should_use_the_default_algorithm_if_one_is_not_specified' do
|
85
|
-
assert_equal Encryptor.encrypt(:
|
44
|
+
assert_equal Encryptor.encrypt(value: original_value, key: key, algorithm: Encryptor.default_options[:algorithm], insecure_mode: true), Encryptor.encrypt(value: original_value, key: key, insecure_mode: true)
|
86
45
|
end
|
87
46
|
|
88
47
|
def test_should_have_a_default_algorithm
|
@@ -91,15 +50,15 @@ class LegacyEncryptorTest < Test::Unit::TestCase
|
|
91
50
|
end
|
92
51
|
|
93
52
|
def test_should_raise_argument_error_if_key_is_not_specified
|
94
|
-
assert_raises(ArgumentError) { Encryptor.encrypt('some value') }
|
95
|
-
assert_raises(ArgumentError) { Encryptor.decrypt('some encrypted string') }
|
96
|
-
assert_raises(ArgumentError) { Encryptor.encrypt('some value', :
|
97
|
-
assert_raises(ArgumentError) { Encryptor.decrypt('some encrypted string', :
|
53
|
+
assert_raises(ArgumentError) { Encryptor.encrypt('some value', insecure_mode: true) }
|
54
|
+
assert_raises(ArgumentError) { Encryptor.decrypt('some encrypted string', insecure_mode: true) }
|
55
|
+
assert_raises(ArgumentError) { Encryptor.encrypt('some value', key: '', insecure_mode: true) }
|
56
|
+
assert_raises(ArgumentError) { Encryptor.decrypt('some encrypted string', key: '', insecure_mode: true) }
|
98
57
|
end
|
99
58
|
|
100
59
|
def test_should_yield_block_with_cipher_and_options
|
101
60
|
called = false
|
102
|
-
Encryptor.encrypt('some value', :
|
61
|
+
Encryptor.encrypt('some value', key: 'some key', insecure_mode: true) { |cipher, options| called = true }
|
103
62
|
assert called
|
104
63
|
end
|
105
64
|
|