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.
- checksums.yaml +4 -4
- data/CHANGELOG.md +71 -0
- data/CLAUDE.md +12 -11
- data/lib/legion/crypt/lease_manager.rb +5 -831
- data/lib/legion/crypt/settings.rb +7 -0
- data/lib/legion/crypt/vault/auth/jwt.rb +28 -0
- data/lib/legion/crypt/vault/auth/kerberos.rb +60 -0
- data/lib/legion/crypt/vault/auth/ldap.rb +29 -0
- data/lib/legion/crypt/vault/auth.rb +50 -0
- data/lib/legion/crypt/vault/client.rb +9 -2
- data/lib/legion/crypt/vault/cluster.rb +47 -115
- data/lib/legion/crypt/vault/entity.rb +3 -4
- data/lib/legion/crypt/vault/leases.rb +871 -0
- data/lib/legion/crypt/vault/session.rb +405 -0
- data/lib/legion/crypt/vault.rb +16 -21
- data/lib/legion/crypt/version.rb +1 -1
- data/lib/legion/crypt.rb +105 -119
- metadata +7 -6
- data/lib/legion/crypt/kerberos_auth.rb +0 -119
- data/lib/legion/crypt/ldap_auth.rb +0 -48
- data/lib/legion/crypt/token_renewer.rb +0 -318
- data/lib/legion/crypt/vault/jwt_auth.rb +0 -99
- data/lib/legion/crypt/vault/kerberos_auth.rb +0 -53
|
@@ -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
|