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.
@@ -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