leverprice 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/CHANGELOG.md +18 -0
- data/LICENSE +21 -0
- data/README.md +271 -0
- data/lib/leverprice/bots.rb +116 -0
- data/lib/leverprice/client.rb +940 -0
- data/lib/leverprice/cookie.rb +83 -0
- data/lib/leverprice/process.rb +42 -0
- data/lib/leverprice/quote.rb +28 -0
- data/lib/leverprice/rack.rb +36 -0
- data/lib/leverprice/request.rb +182 -0
- data/lib/leverprice/transport.rb +51 -0
- data/lib/leverprice/trust.rb +162 -0
- data/lib/leverprice/util.rb +172 -0
- data/lib/leverprice/version.rb +5 -0
- data/lib/leverprice/wire.rb +197 -0
- data/lib/leverprice.rb +52 -0
- metadata +61 -0
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Leverprice
|
|
4
|
+
# @api private
|
|
5
|
+
module Cookie
|
|
6
|
+
MAX_EXPERIMENTS = 10
|
|
7
|
+
MAX_LENGTH = 4096
|
|
8
|
+
VISITOR_KEY_RE = /\A[0-9a-f]{32}\z/
|
|
9
|
+
BODY_RE = /\A[A-Za-z0-9_-]+\z/
|
|
10
|
+
SIG_RE = /\A[A-Za-z0-9_-]{22}\z/
|
|
11
|
+
|
|
12
|
+
State = Struct.new(:v, :a, :x)
|
|
13
|
+
|
|
14
|
+
module_function
|
|
15
|
+
|
|
16
|
+
def new_state(visitor_key)
|
|
17
|
+
State.new(visitor_key, {}, [])
|
|
18
|
+
end
|
|
19
|
+
|
|
20
|
+
def clone_state(state)
|
|
21
|
+
State.new(state.v, state.a.dup, state.x.dup)
|
|
22
|
+
end
|
|
23
|
+
|
|
24
|
+
def assign(state, experiment_id, variant_id)
|
|
25
|
+
rest = state.a.reject { |id, _| id == experiment_id }
|
|
26
|
+
state.a = { experiment_id => variant_id }.merge(rest).first(MAX_EXPERIMENTS).to_h
|
|
27
|
+
state.x = state.x.select { |id| state.a.key?(id) }
|
|
28
|
+
end
|
|
29
|
+
|
|
30
|
+
def mark_exposed(state, experiment_id)
|
|
31
|
+
return false if state.x.include?(experiment_id)
|
|
32
|
+
|
|
33
|
+
state.x = [experiment_id, *state.x].select { |id| state.a.key?(id) }.first(MAX_EXPERIMENTS)
|
|
34
|
+
true
|
|
35
|
+
end
|
|
36
|
+
|
|
37
|
+
def serialize(state)
|
|
38
|
+
JSON.generate({ "v" => state.v, "a" => state.a, "x" => state.x })
|
|
39
|
+
end
|
|
40
|
+
|
|
41
|
+
def sign(key, state)
|
|
42
|
+
body = Util.b64url_encode(serialize(state))
|
|
43
|
+
"#{body}.#{Util.b64url_encode(Util.hmac(key, "pp:cookie:v1:#{body}")[0, 16])}"
|
|
44
|
+
end
|
|
45
|
+
|
|
46
|
+
def verify(key, raw)
|
|
47
|
+
return nil unless raw.is_a?(String)
|
|
48
|
+
|
|
49
|
+
raw = Util.utf8(raw)
|
|
50
|
+
return nil if raw.length > MAX_LENGTH
|
|
51
|
+
|
|
52
|
+
dot = raw.index(".")
|
|
53
|
+
return nil if dot.nil? || dot.zero?
|
|
54
|
+
|
|
55
|
+
body = raw[0, dot]
|
|
56
|
+
sig = raw[(dot + 1)..]
|
|
57
|
+
return nil unless BODY_RE.match?(body) && SIG_RE.match?(sig)
|
|
58
|
+
return nil unless Util.secure_equal?(Util.hmac(key, "pp:cookie:v1:#{body}")[0, 16], Util.b64url_decode(sig))
|
|
59
|
+
|
|
60
|
+
normalize(Util.decode_json_b64(body))
|
|
61
|
+
rescue StandardError
|
|
62
|
+
nil
|
|
63
|
+
end
|
|
64
|
+
|
|
65
|
+
def normalize(raw)
|
|
66
|
+
return nil unless raw.is_a?(Hash) && Util.str_match?(VISITOR_KEY_RE, raw["v"]) && raw["a"].is_a?(Hash)
|
|
67
|
+
|
|
68
|
+
assignments = {}
|
|
69
|
+
raw["a"].first(MAX_EXPERIMENTS).each do |experiment_id, variant_id|
|
|
70
|
+
assignments[experiment_id] = variant_id if Util.id?(experiment_id) && Util.id?(variant_id)
|
|
71
|
+
end
|
|
72
|
+
exposed = raw["x"].is_a?(Array) ? raw["x"].select { |id| id.is_a?(String) && assignments.key?(id) } : []
|
|
73
|
+
State.new(raw["v"], assignments, exposed.first(MAX_EXPERIMENTS))
|
|
74
|
+
end
|
|
75
|
+
|
|
76
|
+
def header(name, value, max_age, secure:, domain:)
|
|
77
|
+
parts = ["#{name}=#{value}", "Path=/", "Max-Age=#{max_age}", "SameSite=Lax", "HttpOnly"]
|
|
78
|
+
parts << "Secure" if secure
|
|
79
|
+
parts << "Domain=#{domain}" if domain && !domain.to_s.empty?
|
|
80
|
+
parts.join("; ")
|
|
81
|
+
end
|
|
82
|
+
end
|
|
83
|
+
end
|
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Leverprice
|
|
4
|
+
# Pre-forking servers copy clients into children: reset their threads, locks and queues there.
|
|
5
|
+
# @api private
|
|
6
|
+
module ForkTracker
|
|
7
|
+
@clients = ObjectSpace::WeakMap.new
|
|
8
|
+
@registry_lock = Mutex.new
|
|
9
|
+
@lock = Mutex.new
|
|
10
|
+
@count = 0
|
|
11
|
+
|
|
12
|
+
class << self
|
|
13
|
+
attr_reader :lock
|
|
14
|
+
|
|
15
|
+
def register(client)
|
|
16
|
+
@registry_lock.synchronize do
|
|
17
|
+
@clients[client] = true
|
|
18
|
+
@count += 1
|
|
19
|
+
end
|
|
20
|
+
end
|
|
21
|
+
|
|
22
|
+
def after_fork
|
|
23
|
+
@registry_lock = Mutex.new
|
|
24
|
+
@lock = Mutex.new
|
|
25
|
+
@clients.each_key(&:after_fork)
|
|
26
|
+
rescue StandardError
|
|
27
|
+
nil
|
|
28
|
+
end
|
|
29
|
+
end
|
|
30
|
+
|
|
31
|
+
# @api private
|
|
32
|
+
module Hook
|
|
33
|
+
def _fork
|
|
34
|
+
pid = super
|
|
35
|
+
ForkTracker.after_fork if pid.zero?
|
|
36
|
+
pid
|
|
37
|
+
end
|
|
38
|
+
end
|
|
39
|
+
|
|
40
|
+
Process.singleton_class.prepend(Hook) if Process.respond_to?(:_fork)
|
|
41
|
+
end
|
|
42
|
+
end
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Leverprice
|
|
4
|
+
# The price to show and charge, and why.
|
|
5
|
+
#
|
|
6
|
+
# `reason` is one of "experiment", "base_price", "bot", "disabled", "no_config", "pinned_fallback",
|
|
7
|
+
# "unknown_product", "currency_mismatch" or "out_of_bounds".
|
|
8
|
+
Quote = Struct.new(
|
|
9
|
+
:product_key, :price, :currency, :is_fallback, :reason, :experiment_id, :variant_id, :visitor_id,
|
|
10
|
+
:metadata, :set_cookie, :checkout_url, :exposure_logged,
|
|
11
|
+
keyword_init: true
|
|
12
|
+
) do
|
|
13
|
+
# @return [Boolean] true when `price` is the product's `fallback_price`
|
|
14
|
+
def fallback?
|
|
15
|
+
is_fallback
|
|
16
|
+
end
|
|
17
|
+
|
|
18
|
+
# @return [Boolean] true when the price comes from a running experiment
|
|
19
|
+
def experiment?
|
|
20
|
+
reason == "experiment"
|
|
21
|
+
end
|
|
22
|
+
|
|
23
|
+
# @return [Boolean] an exposure for this visitor and experiment has been logged
|
|
24
|
+
def exposure_logged?
|
|
25
|
+
exposure_logged
|
|
26
|
+
end
|
|
27
|
+
end
|
|
28
|
+
end
|
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Leverprice
|
|
4
|
+
# @api private
|
|
5
|
+
module ResponseCookies
|
|
6
|
+
module_function
|
|
7
|
+
|
|
8
|
+
def write(target, quote)
|
|
9
|
+
values = quote.respond_to?(:set_cookie) ? quote.set_cookie : Array(quote)
|
|
10
|
+
return target if values.nil? || values.empty?
|
|
11
|
+
|
|
12
|
+
headers = !target.is_a?(Hash) && target.respond_to?(:headers) ? target.headers : target
|
|
13
|
+
key = header_key(headers)
|
|
14
|
+
existing = headers[key]
|
|
15
|
+
lines = existing.is_a?(Array) ? existing.dup : existing.to_s.split("\n")
|
|
16
|
+
values.each do |value|
|
|
17
|
+
prefix = value[0, value.index("=").to_i + 1]
|
|
18
|
+
lines.reject! { |line| line.start_with?(prefix) }
|
|
19
|
+
lines << value
|
|
20
|
+
end
|
|
21
|
+
headers[key] = existing.is_a?(Array) || rack3? ? lines : lines.join("\n")
|
|
22
|
+
target
|
|
23
|
+
end
|
|
24
|
+
|
|
25
|
+
def header_key(headers)
|
|
26
|
+
return "set-cookie" if headers.key?("set-cookie")
|
|
27
|
+
return "Set-Cookie" if headers.key?("Set-Cookie")
|
|
28
|
+
|
|
29
|
+
rack3? ? "set-cookie" : "Set-Cookie"
|
|
30
|
+
end
|
|
31
|
+
|
|
32
|
+
def rack3?
|
|
33
|
+
defined?(::Rack::RELEASE) ? ::Rack::RELEASE.to_s.split(".").first.to_i >= 3 : false
|
|
34
|
+
end
|
|
35
|
+
end
|
|
36
|
+
end
|
|
@@ -0,0 +1,182 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Leverprice
|
|
4
|
+
# @api private
|
|
5
|
+
module Request
|
|
6
|
+
PURPOSE_HEADERS = %w[sec-purpose purpose x-purpose x-moz].freeze
|
|
7
|
+
PURPOSE_RE = /prefetch|prerender|preview/
|
|
8
|
+
COOKIE_SEPARATOR_RE = /[;,]/
|
|
9
|
+
HEX_PAIR_RE = /\A\h\h\z/
|
|
10
|
+
RACK_ENV_MARKERS = %w[REQUEST_METHOD rack.version SERVER_NAME].freeze
|
|
11
|
+
|
|
12
|
+
Info = Struct.new(:cookie_input, :assignment_cookies, :pinned, :user_agent, :prefetch, keyword_init: true)
|
|
13
|
+
|
|
14
|
+
module_function
|
|
15
|
+
|
|
16
|
+
def read(request:, cookie:, user_agent:, cookie_name:)
|
|
17
|
+
explicit = cookie.is_a?(String) ? Util.utf8(cookie) : nil
|
|
18
|
+
cookie_input = explicit || header(request, "cookie")
|
|
19
|
+
pinned = false
|
|
20
|
+
if explicit && !explicit.include?("=")
|
|
21
|
+
value = Util.trim(explicit)
|
|
22
|
+
assignment_cookies = value.empty? ? [] : [value]
|
|
23
|
+
else
|
|
24
|
+
assignment_cookies = cookie_values(cookie_input, cookie_name)
|
|
25
|
+
pinned = !cookie_values(cookie_input, "#{cookie_name}_f").empty?
|
|
26
|
+
end
|
|
27
|
+
Info.new(
|
|
28
|
+
cookie_input: cookie_input,
|
|
29
|
+
assignment_cookies: assignment_cookies,
|
|
30
|
+
pinned: pinned,
|
|
31
|
+
user_agent: user_agent.is_a?(String) ? Util.utf8(user_agent) : header(request, "user-agent"),
|
|
32
|
+
prefetch: prefetch?(request)
|
|
33
|
+
)
|
|
34
|
+
end
|
|
35
|
+
|
|
36
|
+
def header(request, name)
|
|
37
|
+
value = lookup(request, name)
|
|
38
|
+
case value
|
|
39
|
+
when String
|
|
40
|
+
Util.utf8(value)
|
|
41
|
+
when Array
|
|
42
|
+
parts = value.grep(String).map { |v| Util.utf8(v) }
|
|
43
|
+
if parts.empty?
|
|
44
|
+
nil
|
|
45
|
+
else
|
|
46
|
+
parts.join(name == "cookie" ? "; " : ", ")
|
|
47
|
+
end
|
|
48
|
+
end
|
|
49
|
+
end
|
|
50
|
+
|
|
51
|
+
def cookie_values(header, name)
|
|
52
|
+
return [] if header.nil? || header.empty?
|
|
53
|
+
|
|
54
|
+
header.split(COOKIE_SEPARATOR_RE).each_with_object([]) do |part, values|
|
|
55
|
+
eq = part.index("=")
|
|
56
|
+
next if eq.nil? || eq.zero? || Util.trim(part[0, eq]) != name
|
|
57
|
+
|
|
58
|
+
value = Util.trim(part[(eq + 1)..])
|
|
59
|
+
value = value[1..-2] if value.length >= 2 && value.start_with?('"') && value.end_with?('"')
|
|
60
|
+
value = percent_decode(value) || value if value.include?("%")
|
|
61
|
+
values << value unless value.empty?
|
|
62
|
+
end
|
|
63
|
+
end
|
|
64
|
+
|
|
65
|
+
def prefetch?(request)
|
|
66
|
+
return false if request.nil?
|
|
67
|
+
|
|
68
|
+
PURPOSE_HEADERS.each do |name|
|
|
69
|
+
value = header(request, name)
|
|
70
|
+
return true if value && PURPOSE_RE.match?(value.downcase(:ascii))
|
|
71
|
+
end
|
|
72
|
+
header(request, "next-router-prefetch") == "1"
|
|
73
|
+
end
|
|
74
|
+
|
|
75
|
+
def scope_holder(request)
|
|
76
|
+
case request
|
|
77
|
+
when Hash
|
|
78
|
+
request
|
|
79
|
+
when nil, String, Symbol, Numeric, true, false
|
|
80
|
+
nil
|
|
81
|
+
else
|
|
82
|
+
stable_env(request) || request
|
|
83
|
+
end
|
|
84
|
+
end
|
|
85
|
+
|
|
86
|
+
def stable_env(request)
|
|
87
|
+
env = rack_env(request)
|
|
88
|
+
return nil unless env
|
|
89
|
+
|
|
90
|
+
env.equal?(rack_env(request)) ? env : nil
|
|
91
|
+
end
|
|
92
|
+
|
|
93
|
+
def lookup(source, name)
|
|
94
|
+
case source
|
|
95
|
+
when nil
|
|
96
|
+
nil
|
|
97
|
+
when Hash
|
|
98
|
+
hash_lookup(source, name)
|
|
99
|
+
else
|
|
100
|
+
object_lookup(source, name)
|
|
101
|
+
end
|
|
102
|
+
rescue StandardError
|
|
103
|
+
nil
|
|
104
|
+
end
|
|
105
|
+
|
|
106
|
+
def object_lookup(source, name)
|
|
107
|
+
env = rack_env(source)
|
|
108
|
+
return hash_lookup(env, name) if env
|
|
109
|
+
return source.get_header(rack_key(name)) if source.respond_to?(:get_header)
|
|
110
|
+
|
|
111
|
+
if source.respond_to?(:headers)
|
|
112
|
+
headers = source.headers
|
|
113
|
+
return lookup(headers, name) unless headers.equal?(source)
|
|
114
|
+
end
|
|
115
|
+
return nil unless source.respond_to?(:[])
|
|
116
|
+
|
|
117
|
+
source[name] || source[canonical(name)]
|
|
118
|
+
end
|
|
119
|
+
|
|
120
|
+
def rack_env(source)
|
|
121
|
+
return nil unless source.respond_to?(:env)
|
|
122
|
+
|
|
123
|
+
env = source.env
|
|
124
|
+
env.is_a?(Hash) ? env : nil
|
|
125
|
+
rescue StandardError
|
|
126
|
+
nil
|
|
127
|
+
end
|
|
128
|
+
|
|
129
|
+
def hash_lookup(hash, name)
|
|
130
|
+
return hash[name] if hash.key?(name)
|
|
131
|
+
|
|
132
|
+
key = rack_key(name)
|
|
133
|
+
return hash[key] if hash.key?(key)
|
|
134
|
+
return nil if RACK_ENV_MARKERS.any? { |marker| hash.key?(marker) }
|
|
135
|
+
|
|
136
|
+
hash.each { |k, v| return v if key_matches?(k, name) }
|
|
137
|
+
nil
|
|
138
|
+
end
|
|
139
|
+
|
|
140
|
+
def key_matches?(key, name)
|
|
141
|
+
case key
|
|
142
|
+
when String
|
|
143
|
+
key.length == name.length && key.downcase(:ascii) == name
|
|
144
|
+
when Symbol
|
|
145
|
+
normalized = key.to_s.downcase(:ascii)
|
|
146
|
+
normalized == name || normalized.tr("_", "-") == name
|
|
147
|
+
else
|
|
148
|
+
false
|
|
149
|
+
end
|
|
150
|
+
end
|
|
151
|
+
|
|
152
|
+
def rack_key(name)
|
|
153
|
+
"HTTP_#{name.upcase.tr("-", "_")}"
|
|
154
|
+
end
|
|
155
|
+
|
|
156
|
+
def canonical(name)
|
|
157
|
+
name.split("-").map(&:capitalize).join("-")
|
|
158
|
+
end
|
|
159
|
+
|
|
160
|
+
# Same contract as JavaScript's decodeURIComponent: nil when an escape is malformed or the
|
|
161
|
+
# decoded bytes are not valid UTF-8.
|
|
162
|
+
def percent_decode(value)
|
|
163
|
+
bytes = value.b
|
|
164
|
+
out = String.new(capacity: bytes.bytesize, encoding: Encoding::BINARY)
|
|
165
|
+
index = 0
|
|
166
|
+
while index < bytes.bytesize
|
|
167
|
+
byte = bytes.getbyte(index)
|
|
168
|
+
if byte == 0x25
|
|
169
|
+
pair = bytes.byteslice(index + 1, 2)
|
|
170
|
+
return nil unless pair && HEX_PAIR_RE.match?(pair)
|
|
171
|
+
|
|
172
|
+
out << pair.to_i(16)
|
|
173
|
+
index += 3
|
|
174
|
+
else
|
|
175
|
+
out << byte
|
|
176
|
+
index += 1
|
|
177
|
+
end
|
|
178
|
+
end
|
|
179
|
+
out.force_encoding(Encoding::UTF_8).valid_encoding? ? out : nil
|
|
180
|
+
end
|
|
181
|
+
end
|
|
182
|
+
end
|
|
@@ -0,0 +1,51 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require "net/http"
|
|
4
|
+
require "uri"
|
|
5
|
+
|
|
6
|
+
module Leverprice
|
|
7
|
+
# An HTTP response as returned by a transport.
|
|
8
|
+
Response = Struct.new(:status, :headers, :body) do
|
|
9
|
+
# @param name [String] case-insensitive header name
|
|
10
|
+
# @return [String, nil]
|
|
11
|
+
def header(name)
|
|
12
|
+
value = find_header(name)
|
|
13
|
+
value.is_a?(Array) ? value.join(", ") : value
|
|
14
|
+
end
|
|
15
|
+
|
|
16
|
+
private
|
|
17
|
+
|
|
18
|
+
def find_header(name)
|
|
19
|
+
source = headers
|
|
20
|
+
return nil if source.nil?
|
|
21
|
+
return source[name] unless source.is_a?(Hash)
|
|
22
|
+
return source[name] if source.key?(name)
|
|
23
|
+
|
|
24
|
+
lower = name.downcase
|
|
25
|
+
source.each_pair { |key, value| return value if key.to_s.downcase == lower }
|
|
26
|
+
nil
|
|
27
|
+
end
|
|
28
|
+
end
|
|
29
|
+
|
|
30
|
+
# Default transport: Net::HTTP with a new connection per request.
|
|
31
|
+
#
|
|
32
|
+
# A transport is any object with `call(method:, url:, headers:, body:, timeout:)` returning a
|
|
33
|
+
# {Response} (or anything with `status`, `headers` and `body`, or a Rack-style `[status, headers, body]`).
|
|
34
|
+
class NetHTTPTransport
|
|
35
|
+
# @return [Response]
|
|
36
|
+
def call(method:, url:, headers:, body: nil, timeout: 10)
|
|
37
|
+
uri = URI(url)
|
|
38
|
+
http = Net::HTTP.new(uri.host, uri.port)
|
|
39
|
+
http.use_ssl = uri.scheme == "https"
|
|
40
|
+
http.open_timeout = timeout
|
|
41
|
+
http.read_timeout = timeout
|
|
42
|
+
http.write_timeout = timeout
|
|
43
|
+
http.ssl_timeout = timeout
|
|
44
|
+
request = (method == "POST" ? Net::HTTP::Post : Net::HTTP::Get).new(uri)
|
|
45
|
+
headers.each { |name, value| request[name] = value }
|
|
46
|
+
request.body = body if body
|
|
47
|
+
response = http.start { |connection| connection.request(request) }
|
|
48
|
+
Response.new(response.code.to_i, response.each_header.to_h, response.body.to_s)
|
|
49
|
+
end
|
|
50
|
+
end
|
|
51
|
+
end
|
|
@@ -0,0 +1,162 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Leverprice
|
|
4
|
+
# @api private
|
|
5
|
+
class TrustChain
|
|
6
|
+
ROOT_KEY_PLACEHOLDER = "REPLACE_WITH_ROOT_PUBLIC_KEY"
|
|
7
|
+
MAX_CACHED_KEYSETS = 8
|
|
8
|
+
|
|
9
|
+
SigningKey = Struct.new(:id, :public_key)
|
|
10
|
+
Keyset = Struct.new(:version, :issued_at, :expires_at, :keys, keyword_init: true)
|
|
11
|
+
Verified = Struct.new(:config, :signing_key, :dropped)
|
|
12
|
+
|
|
13
|
+
def initialize(root_keys, min_keyset_version)
|
|
14
|
+
@root_keys = root_keys.to_h.transform_keys(&:to_s).freeze
|
|
15
|
+
@min_keyset_version = min_keyset_version
|
|
16
|
+
@newest = nil
|
|
17
|
+
@verified = {}
|
|
18
|
+
end
|
|
19
|
+
|
|
20
|
+
def keyset_version
|
|
21
|
+
@newest ? @newest.version : 0
|
|
22
|
+
end
|
|
23
|
+
|
|
24
|
+
def trusted?(signing_key)
|
|
25
|
+
newest = @newest
|
|
26
|
+
newest.nil? || newest.keys.any? { |k| k.id == signing_key.id && k.public_key == signing_key.public_key }
|
|
27
|
+
end
|
|
28
|
+
|
|
29
|
+
def verify(envelope, now)
|
|
30
|
+
unless envelope.is_a?(Hash) && envelope["payload"].is_a?(String) && envelope["signature"].is_a?(String) &&
|
|
31
|
+
envelope["keyId"].is_a?(String)
|
|
32
|
+
raise Error, "Leverprice config: response is not a signed config"
|
|
33
|
+
end
|
|
34
|
+
|
|
35
|
+
keyset = verify_keyset(envelope["keyset"], now)
|
|
36
|
+
key_id = envelope["keyId"]
|
|
37
|
+
key = keyset.keys.find { |k| k.id == key_id }
|
|
38
|
+
raise Error, %(Leverprice config: signing key "#{key_id}" is not in keyset v#{keyset.version}) unless key
|
|
39
|
+
unless Util.ed25519_verify(key.public_key, envelope["signature"], envelope["payload"])
|
|
40
|
+
raise Error, %(Leverprice config: bad signature (key "#{key_id}"))
|
|
41
|
+
end
|
|
42
|
+
|
|
43
|
+
config, dropped = Wire.parse_config(envelope["payload"])
|
|
44
|
+
if now >= config.expires_at
|
|
45
|
+
raise Error, "Leverprice config v#{config.version}: expired at #{Util.iso_time(config.expires_at)}"
|
|
46
|
+
end
|
|
47
|
+
|
|
48
|
+
Verified.new(config, SigningKey.new(key.id, key.public_key), dropped)
|
|
49
|
+
end
|
|
50
|
+
|
|
51
|
+
private
|
|
52
|
+
|
|
53
|
+
def verify_keyset(signed, now)
|
|
54
|
+
unless signed.is_a?(Hash) && signed["payload"].is_a?(String) && signed["signature"].is_a?(String) &&
|
|
55
|
+
signed["rootKeyId"].is_a?(String)
|
|
56
|
+
raise Error, "Leverprice keyset: missing or malformed"
|
|
57
|
+
end
|
|
58
|
+
|
|
59
|
+
keyset = @verified[signed["payload"]] || load_keyset(signed)
|
|
60
|
+
check_keyset(keyset, now)
|
|
61
|
+
@newest = keyset if @newest.nil? || keyset.version > @newest.version
|
|
62
|
+
keyset
|
|
63
|
+
end
|
|
64
|
+
|
|
65
|
+
def load_keyset(signed)
|
|
66
|
+
root_key_id = signed["rootKeyId"]
|
|
67
|
+
root = @root_keys[root_key_id]
|
|
68
|
+
if root.nil? || root == false || root == ""
|
|
69
|
+
raise Error, %(Leverprice keyset: root key "#{root_key_id}" is not trusted by this SDK)
|
|
70
|
+
end
|
|
71
|
+
if root == ROOT_KEY_PLACEHOLDER
|
|
72
|
+
raise Error, "Leverprice: this SDK build has no root public key (ROOT_PUBLIC_KEYS is a placeholder); " \
|
|
73
|
+
"pass trusted_root_keys"
|
|
74
|
+
end
|
|
75
|
+
unless Util.ed25519_verify(root, signed["signature"], signed["payload"])
|
|
76
|
+
raise Error, %(Leverprice keyset: signature does not match root key "#{root_key_id}")
|
|
77
|
+
end
|
|
78
|
+
|
|
79
|
+
keyset = parse_keyset(signed["payload"])
|
|
80
|
+
@verified.clear if @verified.size >= MAX_CACHED_KEYSETS
|
|
81
|
+
@verified[signed["payload"]] = keyset
|
|
82
|
+
end
|
|
83
|
+
|
|
84
|
+
def check_keyset(keyset, now)
|
|
85
|
+
raise Error, "Leverprice keyset v#{keyset.version}: expired" if keyset.expires_at && now >= keyset.expires_at
|
|
86
|
+
if keyset.version < @min_keyset_version
|
|
87
|
+
raise Error, "Leverprice keyset v#{keyset.version}: below the minimum version #{@min_keyset_version}"
|
|
88
|
+
end
|
|
89
|
+
return unless @newest && keyset.version < @newest.version
|
|
90
|
+
|
|
91
|
+
raise Error, "Leverprice keyset v#{keyset.version}: older than v#{@newest.version} already seen " \
|
|
92
|
+
"(revoked keys cannot come back)"
|
|
93
|
+
end
|
|
94
|
+
|
|
95
|
+
def parse_keyset(payload)
|
|
96
|
+
raw = begin
|
|
97
|
+
Util.decode_json_b64(payload)
|
|
98
|
+
rescue StandardError
|
|
99
|
+
raise Error, "Leverprice keyset: payload is not base64url JSON"
|
|
100
|
+
end
|
|
101
|
+
version = raw.is_a?(Hash) ? Util.safe_int(raw["version"]) : nil
|
|
102
|
+
unless raw.is_a?(Hash) && raw["schema"] == 1 && version && raw["keys"].is_a?(Array)
|
|
103
|
+
raise Error, "Leverprice keyset: unsupported schema"
|
|
104
|
+
end
|
|
105
|
+
|
|
106
|
+
keys = raw["keys"].filter_map do |k|
|
|
107
|
+
if k.is_a?(Hash) && k["id"].is_a?(String) && k["publicKey"].is_a?(String)
|
|
108
|
+
SigningKey.new(k["id"],
|
|
109
|
+
k["publicKey"])
|
|
110
|
+
end
|
|
111
|
+
end
|
|
112
|
+
Keyset.new(
|
|
113
|
+
version: version,
|
|
114
|
+
issued_at: Util.number?(raw["issuedAt"]) ? raw["issuedAt"] : 0,
|
|
115
|
+
expires_at: Util.number?(raw["expiresAt"]) ? raw["expiresAt"] : nil,
|
|
116
|
+
keys: keys
|
|
117
|
+
)
|
|
118
|
+
end
|
|
119
|
+
end
|
|
120
|
+
|
|
121
|
+
# @api private
|
|
122
|
+
class Acceptance
|
|
123
|
+
Loaded = Struct.new(:config, :signing_key)
|
|
124
|
+
Result = Struct.new(:config, :dropped, :warning)
|
|
125
|
+
|
|
126
|
+
attr_reader :loaded
|
|
127
|
+
|
|
128
|
+
def initialize(trust, secret_key)
|
|
129
|
+
@trust = trust
|
|
130
|
+
@fingerprint = OpenSSL::Digest::SHA256.hexdigest(secret_key.to_s)[0, 16]
|
|
131
|
+
@loaded = nil
|
|
132
|
+
end
|
|
133
|
+
|
|
134
|
+
def config
|
|
135
|
+
@loaded&.config
|
|
136
|
+
end
|
|
137
|
+
|
|
138
|
+
def accept(envelope, now)
|
|
139
|
+
verified = @trust.verify(envelope, now)
|
|
140
|
+
config = verified.config
|
|
141
|
+
# A validly signed config of another project (e.g. from a compromised cache) is refused even on first load.
|
|
142
|
+
unless config.key_fingerprints.include?(@fingerprint)
|
|
143
|
+
raise Error, "Leverprice config: not issued for this API key; refusing"
|
|
144
|
+
end
|
|
145
|
+
|
|
146
|
+
current = self.config
|
|
147
|
+
if current && config.project_id != current.project_id
|
|
148
|
+
raise Error, "Leverprice config: project changed from #{current.project_id} to #{config.project_id}; refusing"
|
|
149
|
+
end
|
|
150
|
+
if current && config.version < current.version
|
|
151
|
+
raise Error, "Leverprice config: refusing to roll back from version #{current.version} to #{config.version}"
|
|
152
|
+
end
|
|
153
|
+
|
|
154
|
+
warning = nil
|
|
155
|
+
if verified.dropped.any? && config.version != current&.version
|
|
156
|
+
warning = "Leverprice config v#{config.version}: ignored malformed products #{verified.dropped.join(", ")}"
|
|
157
|
+
end
|
|
158
|
+
@loaded = Loaded.new(config, verified.signing_key)
|
|
159
|
+
Result.new(config, verified.dropped, warning)
|
|
160
|
+
end
|
|
161
|
+
end
|
|
162
|
+
end
|