1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
|
# frozen_string_literal: true
require "abstract_unit"
require "openssl"
require "active_support/time"
require "active_support/json"
require_relative "metadata/shared_metadata_tests"
class MessageVerifierTest < ActiveSupport::TestCase
class JSONSerializer
def dump(value)
ActiveSupport::JSON.encode(value)
end
def load(value)
ActiveSupport::JSON.decode(value)
end
end
def setup
@verifier = ActiveSupport::MessageVerifier.new("Hey, I'm a secret!")
@data = { some: "data", now: Time.utc(2010) }
@secret = SecureRandom.random_bytes(32)
end
def test_valid_message
data, hash = @verifier.generate(@data).split("--")
assert !@verifier.valid_message?(nil)
assert !@verifier.valid_message?("")
assert !@verifier.valid_message?("\xff") # invalid encoding
assert !@verifier.valid_message?("#{data.reverse}--#{hash}")
assert !@verifier.valid_message?("#{data}--#{hash.reverse}")
assert !@verifier.valid_message?("purejunk")
end
def test_simple_round_tripping
message = @verifier.generate(@data)
assert_equal @data, @verifier.verified(message)
assert_equal @data, @verifier.verify(message)
end
def test_verified_returns_false_on_invalid_message
assert !@verifier.verified("purejunk")
end
def test_verify_exception_on_invalid_message
assert_raise(ActiveSupport::MessageVerifier::InvalidSignature) do
@verifier.verify("purejunk")
end
end
def test_alternative_serialization_method
prev = ActiveSupport.use_standard_json_time_format
ActiveSupport.use_standard_json_time_format = true
verifier = ActiveSupport::MessageVerifier.new("Hey, I'm a secret!", serializer: JSONSerializer.new)
message = verifier.generate(:foo => 123, "bar" => Time.utc(2010))
exp = { "foo" => 123, "bar" => "2010-01-01T00:00:00.000Z" }
assert_equal exp, verifier.verified(message)
assert_equal exp, verifier.verify(message)
ensure
ActiveSupport.use_standard_json_time_format = prev
end
def test_raise_error_when_argument_class_is_not_loaded
# To generate the valid message below:
#
# AutoloadClass = Struct.new(:foo)
# valid_message = @verifier.generate(foo: AutoloadClass.new('foo'))
#
valid_message = "BAh7BjoIZm9vbzonTWVzc2FnZVZlcmlmaWVyVGVzdDo6QXV0b2xvYWRDbGFzcwY6CUBmb29JIghmb28GOgZFVA==--f3ef39a5241c365083770566dc7a9eb5d6ace914"
exception = assert_raise(ArgumentError, NameError) do
@verifier.verified(valid_message)
end
assert_includes ["uninitialized constant MessageVerifierTest::AutoloadClass",
"undefined class/module MessageVerifierTest::AutoloadClass"], exception.message
exception = assert_raise(ArgumentError, NameError) do
@verifier.verify(valid_message)
end
assert_includes ["uninitialized constant MessageVerifierTest::AutoloadClass",
"undefined class/module MessageVerifierTest::AutoloadClass"], exception.message
end
def test_raise_error_when_secret_is_nil
exception = assert_raise(ArgumentError) do
ActiveSupport::MessageVerifier.new(nil)
end
assert_equal "Secret should not be nil.", exception.message
end
def test_backward_compatibility_messages_signed_without_metadata
signed_message = "BAh7BzoJc29tZUkiCWRhdGEGOgZFVDoIbm93SXU6CVRpbWUNIIAbgAAAAAAHOgtvZmZzZXRpADoJem9uZUkiCFVUQwY7BkY=--d03c52c91dfe4ccc5159417c660461bcce005e96"
assert_equal @data, @verifier.verify(signed_message)
end
def test_with_rotated_raw_key
old_raw_key = SecureRandom.random_bytes(32)
old_verifier = ActiveSupport::MessageVerifier.new(old_raw_key, digest: "SHA1")
old_message = old_verifier.generate("message verified with old raw key")
verifier = ActiveSupport::MessageVerifier.new(@secret, digest: "SHA1")
verifier.rotate raw_key: old_raw_key, digest: "SHA1"
assert_equal "message verified with old raw key", verifier.verified(old_message)
end
def test_with_rotated_secret_and_salt
old_secret, old_salt = SecureRandom.random_bytes(32), "old salt"
old_raw_key = ActiveSupport::KeyGenerator.new(old_secret, iterations: 1000).generate_key(old_salt)
old_verifier = ActiveSupport::MessageVerifier.new(old_raw_key, digest: "SHA1")
old_message = old_verifier.generate("message verified with old secret and salt")
verifier = ActiveSupport::MessageVerifier.new(@secret, digest: "SHA1")
verifier.rotate secret: old_secret, salt: old_salt, digest: "SHA1"
assert_equal "message verified with old secret and salt", verifier.verified(old_message)
end
def test_with_rotated_key_generator
old_key_gen, old_salt = ActiveSupport::KeyGenerator.new(SecureRandom.random_bytes(32), iterations: 256), "old salt"
old_raw_key = old_key_gen.generate_key(old_salt)
old_verifier = ActiveSupport::MessageVerifier.new(old_raw_key, digest: "SHA1")
old_message = old_verifier.generate("message verified with old key generator and salt")
verifier = ActiveSupport::MessageVerifier.new(@secret, digest: "SHA1")
verifier.rotate key_generator: old_key_gen, salt: old_salt, digest: "SHA1"
assert_equal "message verified with old key generator and salt", verifier.verified(old_message)
end
def test_with_rotating_multiple_verifiers
old_raw_key, older_raw_key = SecureRandom.random_bytes(32), SecureRandom.random_bytes(32)
old_verifier = ActiveSupport::MessageVerifier.new(old_raw_key, digest: "SHA256")
old_message = old_verifier.generate("message verified with old raw key")
older_verifier = ActiveSupport::MessageVerifier.new(older_raw_key, digest: "SHA1")
older_message = older_verifier.generate("message verified with older raw key")
verifier = ActiveSupport::MessageVerifier.new("new secret", digest: "SHA512")
verifier.rotate raw_key: old_raw_key, digest: "SHA256"
verifier.rotate raw_key: older_raw_key, digest: "SHA1"
assert_equal "verified message", verifier.verified(verifier.generate("verified message"))
assert_equal "message verified with old raw key", verifier.verified(old_message)
assert_equal "message verified with older raw key", verifier.verified(older_message)
end
def test_on_rotation_keyword_block_is_called_and_verified_returns_message
callback_ran, message = nil, nil
old_raw_key, older_raw_key = SecureRandom.random_bytes(32), SecureRandom.random_bytes(32)
older_verifier = ActiveSupport::MessageVerifier.new(older_raw_key, digest: "SHA1")
older_message = older_verifier.generate(encoded: "message")
verifier = ActiveSupport::MessageVerifier.new("new secret", digest: "SHA512")
verifier.rotate raw_key: old_raw_key, digest: "SHA256"
verifier.rotate raw_key: older_raw_key, digest: "SHA1"
message = verifier.verified(older_message, on_rotation: proc { callback_ran = true })
assert callback_ran, "callback was ran"
assert_equal({ encoded: "message" }, message)
end
def test_with_rotated_metadata
old_secret, old_salt = SecureRandom.random_bytes(32), "old salt"
old_raw_key = ActiveSupport::KeyGenerator.new(old_secret, iterations: 1000).generate_key(old_salt)
old_verifier = ActiveSupport::MessageVerifier.new(old_raw_key, digest: "SHA1")
old_message = old_verifier.generate(
"message verified with old secret, salt, and metadata", purpose: "rotation")
verifier = ActiveSupport::MessageVerifier.new(@secret, digest: "SHA1")
verifier.rotate secret: old_secret, salt: old_salt, digest: "SHA1"
assert_equal "message verified with old secret, salt, and metadata",
verifier.verified(old_message, purpose: "rotation")
end
end
class MessageVerifierMetadataTest < ActiveSupport::TestCase
include SharedMessageMetadataTests
setup do
@verifier = ActiveSupport::MessageVerifier.new("Hey, I'm a secret!", verifier_options)
end
def test_verify_raises_when_purpose_differs
assert_raise(ActiveSupport::MessageVerifier::InvalidSignature) do
@verifier.verify(generate(data, purpose: "payment"), purpose: "shipping")
end
end
def test_verify_raises_when_expired
signed_message = generate(data, expires_in: 1.month)
travel 2.months
assert_raise(ActiveSupport::MessageVerifier::InvalidSignature) do
@verifier.verify(signed_message)
end
end
private
def generate(message, **options)
@verifier.generate(message, options)
end
def parse(message, **options)
@verifier.verified(message, options)
end
def verifier_options
Hash.new
end
end
class MessageVerifierMetadataMarshalTest < MessageVerifierMetadataTest
private
def verifier_options
{ serializer: Marshal }
end
end
class MessageVerifierMetadataJSONTest < MessageVerifierMetadataTest
private
def verifier_options
{ serializer: MessageVerifierTest::JSONSerializer.new }
end
end
class MessageEncryptorMetadataNullSerializerTest < MessageVerifierMetadataTest
private
def data
"string message"
end
def null_serializing?
true
end
def verifier_options
{ serializer: ActiveSupport::MessageEncryptor::NullSerializer }
end
end
|