legion-crypt 1.5.42 → 1.6.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.
@@ -1,318 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- require 'legion/logging/helper'
4
- require 'legion/crypt/kerberos_auth'
5
- require 'legion/crypt/vault/operation'
6
- require 'legion/crypt/vault/client'
7
-
8
- module Legion
9
- module Crypt
10
- class TokenRenewer
11
- include Legion::Logging::Helper
12
-
13
- INITIAL_BACKOFF = 30
14
- MAX_BACKOFF = 600
15
- MIN_SLEEP = 30
16
- RENEWAL_RATIO = 0.75
17
- MINIMUM_WAIT = 0.01
18
-
19
- attr_reader :cluster_name
20
-
21
- def initialize(cluster_name:, config:, vault_client:)
22
- @cluster_name = cluster_name
23
- @config = config
24
- @vault_client = vault_client
25
- @thread = nil
26
- @stop = false
27
- @backoff = INITIAL_BACKOFF
28
- @state_mutex = Mutex.new
29
- @wake = ConditionVariable.new
30
- @generation = 0
31
- @stopping = false
32
- ttl = config[:lease_duration].to_f
33
- @expires_at = config[:expires_at] || (Time.now + ttl if ttl.positive?)
34
- @renewal_terminal = false
35
- end
36
-
37
- def start
38
- @state_mutex.synchronize do
39
- return if @stopping || @thread&.alive? || crypt_stopping?
40
-
41
- @stop = false
42
- @generation += 1
43
- generation = @generation
44
- @thread = Thread.new { renewal_loop(generation: generation) }
45
- @thread.name = "vault-renewer-#{@cluster_name}"
46
- end
47
- log.info("TokenRenewer[#{@cluster_name}]: token renewal thread started")
48
- end
49
-
50
- def request_stop
51
- @state_mutex.synchronize do
52
- @stop = true
53
- @generation += 1
54
- @wake.broadcast
55
- end
56
- nil
57
- end
58
-
59
- def stop(deadline: nil)
60
- deadline ||= ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + Legion::Crypt::Vault::Operation::SHUTDOWN_TIMEOUT
61
- @state_mutex.synchronize do
62
- return if @stopping
63
-
64
- @stopping = true
65
- end
66
-
67
- begin
68
- request_stop
69
- thread = @state_mutex.synchronize { @thread }
70
- stop_thread_and_revoke(thread: thread, deadline: deadline)
71
- rescue StandardError => e
72
- handle_exception(e, level: :warn, operation: 'crypt.token_renewer.stop', cluster_name: @cluster_name)
73
- ensure
74
- @state_mutex.synchronize { @stopping = false }
75
- end
76
- end
77
-
78
- def running?
79
- @state_mutex.synchronize { @thread&.alive? == true }
80
- end
81
-
82
- def renew_token(generation: nil)
83
- generation ||= @state_mutex.synchronize { @generation }
84
- return false unless @state_mutex.synchronize { active_generation?(generation: generation) }
85
-
86
- deadline = @state_mutex.synchronize do
87
- ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + (@expires_at - Time.now) if @expires_at
88
- end
89
- Legion::Crypt::Vault::Operation.with_timeout(deadline: deadline) do
90
- result = @vault_client.auth_token.renew_self
91
- @state_mutex.synchronize do
92
- return false unless active_generation?(generation: generation)
93
-
94
- @config[:lease_duration] = result.auth.lease_duration
95
- @config[:renewable] = result.auth.renewable? if result.auth.respond_to?(:renewable?)
96
- ttl = result.auth.lease_duration.to_f
97
- @expires_at = ttl.positive? ? Time.now + ttl : nil
98
- @config[:expires_at] = @expires_at
99
- @config[:connected] = true
100
- @config[:relogin_required] = false
101
- end
102
- log.info("TokenRenewer[#{@cluster_name}]: token renewed, ttl=#{result.auth.lease_duration}s")
103
- true
104
- end
105
- rescue StandardError => e
106
- @state_mutex.synchronize do
107
- if active_generation?(generation: generation) && @config[:auth_method].to_s != 'kerberos'
108
- @renewal_terminal = e.is_a?(Legion::Crypt::Vault::HTTPClientError) && ![408, 429].include?(e.code)
109
- if @renewal_terminal || (@expires_at && @expires_at <= Time.now)
110
- @config[:connected] = false
111
- @config[:relogin_required] = true
112
- end
113
- end
114
- end
115
- handle_exception(e, level: :warn, operation: 'crypt.token_renewer.renew_token', cluster_name: @cluster_name)
116
- log.warn("TokenRenewer[#{@cluster_name}]: token renewal failed: #{e.message}")
117
- false
118
- end
119
-
120
- def reauth_kerberos(generation: nil)
121
- generation ||= @state_mutex.synchronize { @generation }
122
- krb_config = @state_mutex.synchronize do
123
- return false unless active_generation?(generation: generation)
124
- return false unless @config[:auth_method].to_s == 'kerberos'
125
-
126
- (@config[:kerberos] || {}).dup
127
- end
128
- active = lambda do |&mutation|
129
- @state_mutex.synchronize do
130
- next false unless active_generation?(generation: generation)
131
-
132
- mutation&.call
133
- true
134
- end
135
- end
136
- Legion::Crypt::Vault::Operation.with_timeout do
137
- result = Legion::Crypt::KerberosAuth.login(
138
- vault_client: @vault_client,
139
- service_principal: krb_config[:service_principal],
140
- auth_path: krb_config[:auth_path] || KerberosAuth::DEFAULT_AUTH_PATH,
141
- principal_guard: active
142
- )
143
-
144
- @state_mutex.synchronize do
145
- return false unless active_generation?(generation: generation)
146
-
147
- Legion::Crypt.publish_vault_grant(client: @vault_client, config: @config, grant: result, auth_method: 'kerberos')
148
- @expires_at = @config[:expires_at]
149
- end
150
- log.info("TokenRenewer[#{@cluster_name}]: re-authenticated via Kerberos, ttl=#{result[:lease_duration]}s")
151
- end
152
- reissue_all_leases(active: active)
153
- true
154
- rescue StandardError => e
155
- handle_exception(e, level: :warn, operation: 'crypt.token_renewer.reauth_kerberos', cluster_name: @cluster_name)
156
- log.warn("TokenRenewer[#{@cluster_name}]: Kerberos re-auth failed: #{e.message}")
157
- false
158
- end
159
-
160
- def sleep_duration
161
- @state_mutex.synchronize do
162
- return MIN_SLEEP unless @expires_at
163
-
164
- remaining = @expires_at - Time.now
165
- renewable = @config[:renewable] || @config[:auth_method].to_s == 'kerberos'
166
- delay = renewable ? remaining - (@config[:lease_duration].to_f * (1 - RENEWAL_RATIO)) : remaining
167
- [delay, MINIMUM_WAIT].max
168
- end
169
- end
170
-
171
- def next_backoff(generation: nil)
172
- @state_mutex.synchronize do
173
- return unless active_generation?(generation: generation || @generation)
174
-
175
- current = @backoff
176
- @backoff = [@backoff * 2, MAX_BACKOFF].min
177
- current
178
- end
179
- end
180
-
181
- def reset_backoff(generation: nil)
182
- @state_mutex.synchronize do
183
- return unless active_generation?(generation: generation || @generation)
184
-
185
- @backoff = INITIAL_BACKOFF
186
- end
187
- end
188
-
189
- private
190
-
191
- def crypt_stopping?
192
- Legion::Crypt.respond_to?(:stopping) && Legion::Crypt.stopping
193
- end
194
-
195
- def active_generation?(generation:, **)
196
- !@stop && !crypt_stopping? && @generation == generation
197
- end
198
-
199
- def renewal_loop(generation:)
200
- interruptible_sleep(sleep_duration, generation: generation)
201
-
202
- loop do
203
- policy = renewal_policy(generation: generation)
204
- return unless policy
205
-
206
- renewable, kerberos = policy
207
- renewed = (renewable && renew_token(generation: generation)) || (kerberos && reauth_kerberos(generation: generation))
208
- return unless @state_mutex.synchronize { active_generation?(generation: generation) }
209
-
210
- if renewed
211
- on_renewal_success(generation: generation)
212
- else
213
- on_renewal_failure(generation: generation)
214
- end
215
- end
216
- rescue StandardError => e
217
- handle_exception(e, level: :warn, operation: 'crypt.token_renewer.renewal_loop', cluster_name: @cluster_name)
218
- log.warn("TokenRenewer[#{@cluster_name}]: renewal loop error: #{e.message}")
219
- on_renewal_failure(generation: generation)
220
- retry if @state_mutex.synchronize { active_generation?(generation: generation) }
221
- end
222
-
223
- def renewal_policy(generation:, **)
224
- @state_mutex.synchronize do
225
- return unless active_generation?(generation: generation)
226
-
227
- kerberos = @config[:auth_method].to_s == 'kerberos'
228
- if @expires_at && @expires_at <= Time.now
229
- @config[:connected] = false
230
- @config[:relogin_required] = true unless kerberos
231
- return unless kerberos
232
- end
233
- return if !kerberos && (!@config[:renewable] || @config[:relogin_required])
234
-
235
- [@config[:renewable], kerberos]
236
- end
237
- end
238
-
239
- def on_renewal_success(generation:)
240
- return unless reset_backoff(generation: generation)
241
-
242
- interruptible_sleep(sleep_duration, generation: generation)
243
- end
244
-
245
- def on_renewal_failure(generation:)
246
- delay = next_backoff(generation: generation)
247
- return unless delay
248
-
249
- @state_mutex.synchronize do
250
- return unless active_generation?(generation: generation)
251
-
252
- kerberos = @config[:auth_method].to_s == 'kerberos'
253
- remaining = @expires_at && (@expires_at - Time.now)
254
- if kerberos || @renewal_terminal || (remaining && !remaining.positive?)
255
- @config[:connected] = false
256
- @config[:relogin_required] = true unless kerberos
257
- end
258
- return if !kerberos && @config[:relogin_required]
259
-
260
- delay = [delay, [remaining / 2, MINIMUM_WAIT].max, remaining].min if remaining&.positive?
261
- end
262
- log.warn("TokenRenewer[#{@cluster_name}]: backoff retry in #{delay}s")
263
- interruptible_sleep(delay, generation: generation)
264
- end
265
-
266
- def reissue_all_leases(active:)
267
- return unless defined?(Legion::Crypt::LeaseManager)
268
- return unless active.call
269
-
270
- Legion::Crypt::LeaseManager.instance.reissue_all(active: active)
271
- rescue StandardError => e
272
- handle_exception(e, level: :warn, operation: 'crypt.token_renewer.reissue_all_leases', cluster_name: @cluster_name)
273
- log.warn("TokenRenewer[#{@cluster_name}]: failed to reissue leases after reauth: #{e.message}")
274
- end
275
-
276
- def interruptible_sleep(seconds, generation:)
277
- deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + seconds
278
- @state_mutex.synchronize do
279
- while active_generation?(generation: generation)
280
- remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
281
- break unless remaining.positive?
282
-
283
- @wake.wait(@state_mutex, remaining)
284
- end
285
- end
286
- end
287
-
288
- def stop_thread_and_revoke(thread:, deadline:)
289
- return unless thread
290
-
291
- log.info("TokenRenewer[#{@cluster_name}]: stopping token renewal thread")
292
- remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
293
- thread.join(remaining) if remaining.positive? && thread != Thread.current
294
-
295
- if thread.alive?
296
- log.warn("TokenRenewer[#{@cluster_name}]: token renewal thread did not stop within timeout; skipping token revocation")
297
- else
298
- @state_mutex.synchronize { @thread = nil if @thread == thread }
299
- revoke_token(deadline: deadline)
300
- log.info("TokenRenewer[#{@cluster_name}]: token renewal thread stopped")
301
- end
302
- end
303
-
304
- def revoke_token(deadline: nil)
305
- owned_token = @state_mutex.synchronize do
306
- @config[:auth_method]&.to_s == 'kerberos' && @vault_client&.token
307
- end
308
- return unless owned_token
309
-
310
- Legion::Crypt::Vault::Operation.with_timeout(deadline: deadline) { @vault_client.auth_token.revoke_self }
311
- log.info("TokenRenewer[#{@cluster_name}]: Vault token revoked")
312
- rescue StandardError => e
313
- handle_exception(e, level: :warn, operation: 'crypt.token_renewer.revoke_token', cluster_name: @cluster_name)
314
- log.warn("TokenRenewer[#{@cluster_name}]: Vault token revoke failed: #{e.message}")
315
- end
316
- end
317
- end
318
- end
@@ -1,99 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- require 'legion/logging/helper'
4
- require 'legion/crypt/vault/client'
5
-
6
- module Legion
7
- module Crypt
8
- # Vault JWT auth backend integration.
9
- #
10
- # Allows Legion workers to authenticate to Vault using JWT tokens
11
- # via Vault's JWT/OIDC auth method. The worker presents a signed JWT
12
- # and receives a Vault token with policies scoped to the worker's role.
13
- #
14
- # Vault config prerequisites:
15
- # vault auth enable jwt
16
- # vault write auth/jwt/config jwks_url="..." (or bound_issuer + jwt_validation_pubkeys)
17
- # vault write auth/jwt/role/legion-worker bound_audiences="legion" ...
18
- module Vault
19
- module JwtAuth
20
- DEFAULT_AUTH_PATH = 'auth/jwt/login'
21
- DEFAULT_ROLE = 'legion-worker'
22
-
23
- class AuthError < StandardError; end
24
-
25
- extend Legion::Logging::Helper
26
-
27
- # Authenticate to Vault using a JWT token.
28
- # Returns a Vault token string on success.
29
- #
30
- # @param jwt [String] Signed JWT token (issued by Legion or Entra ID)
31
- # @param role [String] Vault JWT auth role name (default: 'legion-worker')
32
- # @param auth_path [String] Vault auth mount path (default: 'auth/jwt/login')
33
- # @return [Hash] { token:, lease_duration:, policies:, metadata: }
34
- def self.login(jwt:, role: DEFAULT_ROLE, auth_path: DEFAULT_AUTH_PATH)
35
- raise AuthError, 'Vault is not connected' unless Legion::Crypt.vault_connected?
36
-
37
- log.info "[crypt:vault_jwt] authenticating role=#{role} auth_path=#{auth_path}"
38
- response = Legion::Crypt.vault_client.logical.write(path: auth_path, data: { role: role, jwt: jwt })
39
-
40
- raise AuthError, 'Vault JWT auth returned no auth data' unless response&.auth
41
-
42
- {
43
- token: response.auth.client_token,
44
- lease_duration: response.auth.lease_duration,
45
- renewable: response.auth.renewable?,
46
- policies: response.auth.policies,
47
- metadata: response.auth.metadata
48
- }
49
- rescue Legion::Crypt::Vault::HTTPClientError => e
50
- handle_exception(e, level: :warn, operation: 'crypt.vault_jwt_auth.login', role: role, auth_path: auth_path,
51
- category: 'client_error')
52
- raise AuthError, "Vault JWT auth failed: #{e.message}"
53
- rescue Legion::Crypt::Vault::HTTPServerError => e
54
- handle_exception(e, level: :warn, operation: 'crypt.vault_jwt_auth.login', role: role, auth_path: auth_path,
55
- category: 'server_error')
56
- raise AuthError, "Vault server error during JWT auth: #{e.message}"
57
- rescue StandardError => e
58
- handle_exception(e, level: :error, operation: 'crypt.vault_jwt_auth.login', role: role, auth_path: auth_path)
59
- raise if e.is_a?(AuthError)
60
-
61
- raise AuthError, "Vault JWT auth failed: #{e.message}"
62
- end
63
-
64
- # Authenticate and set the Vault client token for subsequent operations.
65
- # This replaces the current Vault token with the JWT-authenticated one.
66
- #
67
- # @return [Hash] Same as login
68
- def self.login!(jwt:, role: DEFAULT_ROLE, auth_path: DEFAULT_AUTH_PATH)
69
- generation = Legion::Crypt.vault_auth_generation
70
- client = Legion::Crypt.vault_client
71
- config = Legion::Crypt.cluster || Legion::Settings[:crypt][:vault]
72
- result = login(jwt: jwt, role: role, auth_path: auth_path)
73
- Legion::Crypt.install_vault_grant(client: client, config: config, grant: result, auth_method: 'jwt', generation: generation)
74
- log.info "[crypt:vault_jwt] authenticated via JWT auth, policies=#{result[:policies].join(',')}"
75
- result
76
- end
77
-
78
- # Issue a Legion JWT and use it to authenticate to Vault in one step.
79
- # Convenience method for workers that need Vault access.
80
- #
81
- # @param worker_id [String] Digital worker ID
82
- # @param owner_msid [String] Worker's owner MSID
83
- # @param role [String] Vault JWT auth role name
84
- # @return [Hash] Same as login
85
- def self.worker_login(worker_id:, owner_msid:, role: DEFAULT_ROLE)
86
- log.info "[crypt:vault_jwt] worker login requested role=#{role} worker_id=#{worker_id}"
87
- jwt = Legion::Crypt::JWT.issue(
88
- { worker_id: worker_id, sub: owner_msid, scope: 'vault', aud: 'legion' },
89
- signing_key: Legion::Crypt.cluster_secret,
90
- ttl: 300,
91
- issuer: 'legion'
92
- )
93
-
94
- login(jwt: jwt, role: role)
95
- end
96
- end
97
- end
98
- end
99
- end
@@ -1,53 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- require 'legion/logging/helper'
4
- require 'legion/crypt/vault/client'
5
-
6
- module Legion
7
- module Crypt
8
- module Vault
9
- module KerberosAuth
10
- DEFAULT_AUTH_PATH = 'auth/kerberos/login'
11
-
12
- class AuthError < StandardError; end
13
-
14
- extend Legion::Logging::Helper
15
-
16
- def self.login(spnego_token:, auth_path: DEFAULT_AUTH_PATH)
17
- raise AuthError, 'Vault is not connected' unless Legion::Crypt.vault_connected?
18
-
19
- log.info "[crypt:vault_kerberos] login requested auth_path=#{auth_path}"
20
- data = Legion::Crypt.vault_client.put(
21
- path: auth_path, body: '{}', headers: { 'Authorization' => "Negotiate #{spnego_token}" }
22
- )
23
- response = Legion::Crypt::Vault::Client::Secret.decode(data: data)
24
- raise AuthError, 'Vault Kerberos auth returned no auth data' unless response&.auth
25
-
26
- {
27
- token: response.auth.client_token,
28
- lease_duration: response.auth.lease_duration,
29
- renewable: response.auth.renewable?,
30
- policies: response.auth.policies,
31
- metadata: response.auth.metadata
32
- }
33
- rescue Legion::Crypt::Vault::HTTPClientError => e
34
- handle_exception(e, level: :warn, operation: 'crypt.vault_kerberos_auth.login', auth_path: auth_path)
35
- raise AuthError, "Vault Kerberos auth failed: #{e.message}"
36
- rescue StandardError => e
37
- handle_exception(e, level: :error, operation: 'crypt.vault_kerberos_auth.login', auth_path: auth_path)
38
- raise
39
- end
40
-
41
- def self.login!(spnego_token:, auth_path: DEFAULT_AUTH_PATH)
42
- generation = Legion::Crypt.vault_auth_generation
43
- client = Legion::Crypt.vault_client
44
- config = Legion::Crypt.cluster || Legion::Settings[:crypt][:vault]
45
- result = login(spnego_token: spnego_token, auth_path: auth_path)
46
- Legion::Crypt.install_vault_grant(client: client, config: config, grant: result, auth_method: 'kerberos', generation: generation)
47
- log.info "[crypt:vault_kerberos] authenticated via Kerberos auth, policies=#{result[:policies].join(',')}"
48
- result
49
- end
50
- end
51
- end
52
- end
53
- end