legion-crypt 1.5.38 → 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.
Files changed (45) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +30 -3
  3. data/.rspec +2 -0
  4. data/AGENTS.md +2 -0
  5. data/CHANGELOG.md +99 -0
  6. data/CLAUDE.md +65 -192
  7. data/CODEOWNERS +4 -4
  8. data/Gemfile +4 -1
  9. data/README.md +60 -16
  10. data/legion-crypt.gemspec +1 -0
  11. data/lib/legion/crypt/cert_rotation.rb +7 -21
  12. data/lib/legion/crypt/cluster_secret.rb +3 -14
  13. data/lib/legion/crypt/ed25519.rb +2 -10
  14. data/lib/legion/crypt/erasure.rb +3 -13
  15. data/lib/legion/crypt/jwks_client.rb +4 -4
  16. data/lib/legion/crypt/lease_manager.rb +5 -831
  17. data/lib/legion/crypt/mtls.rb +8 -46
  18. data/lib/legion/crypt/partition_keys.rb +2 -6
  19. data/lib/legion/crypt/settings.rb +31 -21
  20. data/lib/legion/crypt/spiffe/svid_rotation.rb +6 -9
  21. data/lib/legion/crypt/spiffe.rb +14 -39
  22. data/lib/legion/crypt/vault/auth/jwt.rb +28 -0
  23. data/lib/legion/crypt/vault/auth/kerberos.rb +60 -0
  24. data/lib/legion/crypt/vault/auth/ldap.rb +29 -0
  25. data/lib/legion/crypt/vault/auth.rb +50 -0
  26. data/lib/legion/crypt/vault/client.rb +362 -0
  27. data/lib/legion/crypt/vault/cluster.rb +262 -0
  28. data/lib/legion/crypt/vault/entity.rb +79 -0
  29. data/lib/legion/crypt/vault/leases.rb +871 -0
  30. data/lib/legion/crypt/vault/operation.rb +29 -0
  31. data/lib/legion/crypt/vault/session.rb +405 -0
  32. data/lib/legion/crypt/vault.rb +21 -31
  33. data/lib/legion/crypt/version.rb +1 -1
  34. data/lib/legion/crypt.rb +152 -177
  35. metadata +27 -11
  36. data/lib/legion/crypt/kerberos_auth.rb +0 -119
  37. data/lib/legion/crypt/ldap_auth.rb +0 -48
  38. data/lib/legion/crypt/token_renewer.rb +0 -318
  39. data/lib/legion/crypt/vault_client.rb +0 -355
  40. data/lib/legion/crypt/vault_cluster.rb +0 -331
  41. data/lib/legion/crypt/vault_entity.rb +0 -78
  42. data/lib/legion/crypt/vault_jwt_auth.rb +0 -97
  43. data/lib/legion/crypt/vault_kerberos_auth.rb +0 -51
  44. data/lib/legion/crypt/vault_operation.rb +0 -27
  45. /data/lib/legion/crypt/{vault_renewer.rb → vault/renewer.rb} +0 -0
data/lib/legion/crypt.rb CHANGED
@@ -2,30 +2,26 @@
2
2
 
3
3
  require 'openssl'
4
4
  require 'base64'
5
+ require 'monitor'
5
6
  require 'legion/logging/helper'
7
+ require 'legion/settings'
8
+
6
9
  require 'legion/crypt/version'
7
10
  require 'legion/crypt/settings'
8
11
  require 'legion/crypt/cipher'
9
12
  require 'legion/crypt/jwt'
10
- require 'legion/crypt/vault_jwt_auth'
11
- require 'legion/crypt/lease_manager'
12
- require 'legion/crypt/vault_operation'
13
- require 'legion/crypt/vault_cluster'
13
+ require 'legion/crypt/vault/operation'
14
+ require 'legion/crypt/vault/cluster'
14
15
  require 'legion/crypt/vault'
15
- require 'legion/crypt/ldap_auth'
16
- require 'legion/crypt/token_renewer'
16
+ require 'legion/crypt/lease_manager'
17
17
  require 'legion/crypt/helper'
18
18
  require 'legion/crypt/mtls'
19
19
  require 'legion/crypt/cert_rotation'
20
20
  require 'legion/crypt/spiffe'
21
- require 'legion/crypt/spiffe/workload_api_client'
22
- require 'legion/crypt/spiffe/svid_rotation'
23
- require 'legion/crypt/spiffe/identity_helpers'
24
21
 
25
22
  module Legion
26
23
  module Crypt
27
- extend Legion::Crypt::VaultCluster
28
- extend Legion::Crypt::LdapAuth
24
+ extend Legion::Crypt::Vault::Cluster
29
25
 
30
26
  RMQ_ROLE_MAP = {
31
27
  agent: 'legionio-infra',
@@ -33,38 +29,59 @@ module Legion
33
29
  infra: 'legionio-infra'
34
30
  }.freeze
35
31
 
32
+ POSTGRES_ROLE_MAP = {
33
+ infra: 'infra'
34
+ }.freeze
35
+
36
36
  class << self
37
- attr_reader :sessions, :stopping
37
+ attr_reader :stopping
38
38
 
39
39
  include Legion::Logging::Helper
40
40
  include Legion::Crypt::Cipher
41
41
 
42
42
  include Legion::Crypt::Vault
43
43
 
44
- def vault_settings
45
- Legion::Settings[:crypt][:vault]
44
+ def kerberos_principal(**)
45
+ default_session&.principal
46
+ end
47
+
48
+ def ldap_login(cluster_name:, username:, password:, **)
49
+ session = session_for(cluster_name)
50
+ raise KeyError, "Vault cluster not configured: #{cluster_name.inspect}" if session.nil?
51
+
52
+ session.login(username: username, password: password)
46
53
  end
47
54
 
48
- def kerberos_principal
49
- KerberosAuth.kerberos_principal
55
+ def ldap_login_all(username:, password:, **)
56
+ results = {}
57
+ effective_cluster_configs.each do |name, config|
58
+ next unless config[:auth_method]&.to_s == 'ldap'
59
+
60
+ results[name] = ldap_login(cluster_name: name, username: username, password: password)
61
+ rescue StandardError => e
62
+ handle_exception(e, level: :error, operation: 'crypt.ldap_login_all', cluster_name: name)
63
+ message = password.to_s.empty? ? e.message : e.message.gsub(password.to_s, '[REDACTED]')
64
+ results[name] = { error: message }
65
+ end
66
+ results
50
67
  end
51
68
 
52
69
  def spiffe_svid
53
70
  @svid_rotation&.current_svid
54
71
  end
55
72
 
56
- def fetch_svid
57
- @workload_client ||= Spiffe::WorkloadApiClient.new
73
+ def fetch_svid(**)
74
+ @workload_client ||= Legion::Crypt::Spiffe::WorkloadApiClient.new
58
75
  @workload_client.fetch_x509_svid
59
76
  end
60
77
 
61
- def fetch_jwt_svid(audience:)
62
- @workload_client ||= Spiffe::WorkloadApiClient.new
78
+ def fetch_jwt_svid(audience:, **)
79
+ @workload_client ||= Legion::Crypt::Spiffe::WorkloadApiClient.new
63
80
  @workload_client.fetch_jwt_svid(audience: audience)
64
81
  end
65
82
 
66
- def start
67
- lifecycle_mutex.synchronize do
83
+ def start(mode: nil, **)
84
+ lifecycle_monitor.synchronize do
68
85
  if @started || @stopping
69
86
  log.info 'Legion::Crypt start ignored because the lifecycle is running or stopping'
70
87
  return
@@ -72,7 +89,7 @@ module Legion
72
89
 
73
90
  log.info 'Legion::Crypt startup initiated'
74
91
  log.debug 'Legion::Crypt start requested'
75
- if settings[:save_private_key]
92
+ if Legion::Settings[:crypt][:save_private_key]
76
93
  key = private_key
77
94
  ::File.open('./legionio.key', ::File::WRONLY | ::File::CREAT, 0o600) do |file|
78
95
  file.chmod(0o600)
@@ -80,72 +97,32 @@ module Legion
80
97
  file.write(key.to_pem)
81
98
  end
82
99
  end
83
- @token_renewers ||= []
84
100
  start_session_tracking
85
101
 
86
- if vault_settings[:clusters]&.any?
87
- log.info "Legion::Crypt connecting #{vault_settings[:clusters].size} Vault cluster(s)"
88
- connect_all_clusters
102
+ if Legion::Settings[:crypt][:vault][:enabled]
103
+ start_vault_sessions(mode: mode)
89
104
  else
90
- log.info 'Legion::Crypt connecting primary Vault client' unless settings[:vault][:token].nil?
91
- connect_vault unless settings[:vault][:token].nil?
105
+ log.info 'Legion::Crypt Vault is disabled; skipping Vault authentication and maintenance'
92
106
  end
93
- start_token_renewers
94
- start_lease_manager
95
107
  start_svid_rotation
96
108
  @started = true
97
109
  log.info 'Legion::Crypt startup completed'
98
110
  end
99
111
  end
100
112
 
101
- def vault_auth_generation
102
- lifecycle_mutex.synchronize do
103
- raise 'Crypt is shutting down; login must be retried' if @stopping
104
-
105
- @token_generation || 0
106
- end
107
- end
108
-
109
- def install_vault_grant(client:, config:, grant:, auth_method:, generation:, **)
110
- issued_at = Time.now
111
- lifecycle_mutex.synchronize do
112
- raise 'Crypt stopped during login; login must be retried' if @stopping || generation != (@token_generation || 0)
113
-
114
- cluster_name = clusters.find { |_name, candidate| candidate.equal?(config) }&.first
115
- previous = (@token_renewers || []).find { |worker| worker.cluster_name == cluster_name }
116
- previous&.stop
117
- raise 'Previous token worker has not stopped; login must be retried' if previous&.running?
118
-
119
- publish_vault_grant(client: client, config: config, grant: grant, auth_method: auth_method, issued_at: issued_at)
120
- start_token_renewer(cluster_name: cluster_name, config: config, vault_client: client)
121
- end
122
- end
123
-
124
- def settings
125
- if Legion.const_defined?('Settings')
126
- Legion::Settings[:crypt]
127
- else
128
- Legion::Crypt::Settings.default
129
- end
130
- end
131
-
132
- def jwt_settings
133
- settings[:jwt] || Legion::Crypt::Settings.jwt
134
- end
135
-
136
113
  def dynamic_rmq_creds?
137
- Legion::Settings.dig(:crypt, :vault, :dynamic_rmq_creds) == true
114
+ Legion::Settings[:crypt][:vault][:dynamic_rmq_creds] == true
138
115
  end
139
116
 
140
- def fetch_bootstrap_rmq_creds
117
+ def fetch_bootstrap_rmq_creds(**)
141
118
  return unless vault_connected? && dynamic_rmq_creds?
142
119
 
143
120
  Legion::Settings.merge_settings('transport', Legion::Transport::Settings.default) if defined?(Legion::Transport::Settings)
144
121
 
145
- response = LeaseManager.instance.vault_logical.read(path: 'rabbitmq/creds/legionio-bootstrap')
122
+ response = Legion::Crypt::LeaseManager.instance.vault_logical.read(path: 'rabbitmq/creds/legionio-bootstrap')
146
123
  return unless response&.data
147
124
 
148
- bootstrap_lease_ttl = Legion::Settings.dig(:crypt, :vault, :bootstrap_lease_ttl).to_i
125
+ bootstrap_lease_ttl = Legion::Settings[:crypt][:vault][:bootstrap_lease_ttl].to_i
149
126
  bootstrap_lease_ttl = 300 if bootstrap_lease_ttl <= 0
150
127
 
151
128
  @bootstrap_lease_id = response.lease_id
@@ -167,18 +144,18 @@ module Legion
167
144
  conn[:password] = password
168
145
 
169
146
  log.info "Bootstrap RMQ credentials acquired (lease: #{@bootstrap_lease_id[0..7]}...)"
170
- rescue StandardError => e
147
+ rescue IOError, SystemCallError, Timeout::Error, Faraday::Error, Legion::Crypt::Vault::HTTPError => e
171
148
  handle_exception(e, level: :warn, operation: 'crypt.fetch_bootstrap_rmq_creds')
172
- log.warn "Bootstrap RMQ credential fetch failed: #{e.message}"
173
149
  end
174
150
 
175
- def swap_to_identity_creds(mode:)
151
+ def swap_to_identity_creds(mode:, **)
176
152
  return unless vault_connected? && dynamic_rmq_creds?
177
153
  return if mode == :lite
178
154
 
155
+ manager = Legion::Crypt::LeaseManager.instance
156
+
179
157
  role = RMQ_ROLE_MAP.fetch(mode, "legionio-#{mode}")
180
- manager = LeaseManager.instance
181
- response = Legion::Crypt::VaultOperation.with_timeout { manager.vault_logical.read(path: "rabbitmq/creds/#{role}") }
158
+ response = Legion::Crypt::Vault::Operation.with_timeout { manager.vault_logical.read(path: "rabbitmq/creds/#{role}") }
182
159
  raise "Failed to fetch identity-scoped RMQ creds for role #{role}" unless response
183
160
 
184
161
  settings = Legion::Settings.loader.settings
@@ -199,97 +176,85 @@ module Legion
199
176
  )
200
177
  raise 'Identity credential handoff failed — bootstrap lease NOT revoked' unless installed
201
178
 
202
- Legion::Crypt::VaultOperation.with_timeout { revoke_bootstrap_lease }
179
+ Legion::Crypt::Vault::Operation.with_timeout { revoke_bootstrap_lease }
203
180
  end
204
181
 
205
- def revoke_bootstrap_lease
182
+ def revoke_bootstrap_lease(**)
206
183
  return unless @bootstrap_lease_id
207
184
 
208
- LeaseManager.instance.vault_sys.revoke(lease_id: @bootstrap_lease_id)
185
+ Legion::Crypt::LeaseManager.instance.vault_sys.revoke(lease_id: @bootstrap_lease_id)
209
186
  log.info "Bootstrap RMQ lease revoked (#{@bootstrap_lease_id[0..7]}...)"
210
187
  @bootstrap_lease_id = nil
211
188
  @bootstrap_lease_expires = nil
212
- rescue StandardError => e
189
+ rescue IOError, SystemCallError, Timeout::Error, Faraday::Error, Legion::Crypt::Vault::HTTPError => e
213
190
  handle_exception(e, level: :warn, operation: 'crypt.revoke_bootstrap_lease')
214
- log.warn "Bootstrap lease revocation failed: #{e.message} — lease will expire naturally"
215
191
  @bootstrap_lease_id = nil
216
192
  @bootstrap_lease_expires = nil
217
193
  end
218
194
 
219
- def vault_connected?
220
- return connected_clusters.any? if settings.dig(:vault, :clusters)&.any?
221
-
222
- return true if settings.dig(:vault, :connected) == true
223
- return true if respond_to?(:connected_clusters) && connected_clusters.any?
195
+ def vault_connected?(**)
196
+ return connected_clusters.any? if Legion::Settings[:crypt][:vault][:clusters].any?
224
197
 
225
- false
226
- rescue StandardError => e
227
- handle_exception(e, level: :debug, operation: 'crypt.vault_connected?')
228
- false
198
+ Legion::Settings[:crypt][:vault][:connected] == true
229
199
  end
230
200
 
231
201
  def issue_token(payload = {}, ttl: nil, algorithm: nil)
232
- jwt = jwt_settings
202
+ jwt = Legion::Settings[:crypt][:jwt]
233
203
  algo = algorithm || jwt[:default_algorithm]
234
204
  token_ttl = ttl || jwt[:default_ttl]
205
+ signing_key = algo == 'RS256' ? private_key : Legion::Settings[:crypt][:cluster_secret]
235
206
 
236
- signing_key = algo == 'RS256' ? private_key : settings[:cluster_secret]
237
-
238
- Legion::Crypt::JWT.issue(payload, signing_key: signing_key, algorithm: algo, ttl: token_ttl,
239
- issuer: jwt[:issuer])
207
+ Legion::Crypt::JWT.issue(payload, signing_key: signing_key, algorithm: algo, ttl: token_ttl, issuer: jwt[:issuer])
240
208
  end
241
209
 
242
210
  def verify_token(token, algorithm: nil)
243
- jwt = jwt_settings
211
+ jwt = Legion::Settings[:crypt][:jwt]
244
212
  algo = algorithm || jwt[:default_algorithm]
245
213
 
246
- verification_key = algo == 'RS256' ? OpenSSL::PKey::RSA.new(public_key) : settings[:cluster_secret]
214
+ verification_key = algo == 'RS256' ? OpenSSL::PKey::RSA.new(public_key) : Legion::Settings[:crypt][:cluster_secret]
247
215
 
248
216
  Legion::Crypt::JWT.verify(token, verification_key: verification_key, algorithm: algo,
249
- verify_expiration: jwt[:verify_expiration],
250
- verify_issuer: jwt[:verify_issuer],
251
- issuer: jwt[:issuer])
217
+ verify_expiration: jwt[:verify_expiration],
218
+ verify_issuer: jwt[:verify_issuer],
219
+ issuer: jwt[:issuer])
252
220
  end
253
221
 
254
222
  def verify_external_token(token, jwks_url:, **)
255
223
  Legion::Crypt::JWT.verify_with_jwks(token, jwks_url: jwks_url, **)
256
224
  end
257
225
 
226
+ # Stops maintenance, then revokes dependent leases and sessions before the tokens they depend on.
258
227
  def shutdown
259
- shutdown_started = lifecycle_mutex.synchronize do
228
+ shutdown_started = lifecycle_monitor.synchronize do
260
229
  return if @stopping
261
230
  return unless @started || @vault_clients || @retired_vault_clients&.size&.positive?
262
231
 
263
232
  @stopping = true
264
- @token_generation = (@token_generation || 0) + 1
265
233
  @started = false
266
234
  true
267
235
  end
268
- deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + Legion::Crypt::VaultOperation::SHUTDOWN_TIMEOUT
269
- manager = Legion::Crypt::LeaseManager.instance
270
- [manager, *(@token_renewers || [])].each do |worker|
271
- worker.request_stop
236
+ deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + Legion::Crypt::Vault::Operation::SHUTDOWN_TIMEOUT
237
+
238
+ # Request stop on the sessions first so their maintenance + lease renewal threads are bounded.
239
+ lifecycle_monitor.synchronize { (@vault_sessions || {}).values }.each do |session|
240
+ session.request_stop
272
241
  rescue StandardError => e
273
- handle_exception(e, level: :warn, operation: 'crypt.shutdown.request_stop')
242
+ handle_exception(e, level: :error, operation: 'crypt.shutdown.request_stop')
274
243
  end
275
244
 
245
+ # Clients whose token Vault rejected are not used for further cleanup.
246
+ denied_clients = {}.compare_by_identity
276
247
  components = [
277
- [self, :stop_svid_rotation, { deadline: deadline }],
278
- [self, :shutdown_renewer, {}],
279
- [manager, :shutdown, { deadline: deadline }],
280
- [self, :stop_token_renewers, { deadline: deadline }],
281
- [self, :close_sessions, { deadline: deadline }],
282
- [self, :clear_vault_clients, { deadline: deadline }]
248
+ [self, :stop_svid_rotation, { deadline: deadline }, false],
249
+ [self, :shutdown_renewer, {}, false],
250
+ [self, :close_sessions, { deadline: deadline, denied_clients: denied_clients }, true],
251
+ [self, :stop_vault_sessions, { deadline: deadline, denied_clients: denied_clients }, true],
252
+ [self, :clear_vault_clients, { deadline: deadline }, false]
283
253
  ]
284
- components.each do |owner, operation, options|
285
- owner.send(operation, **options)
286
- rescue StandardError => e
287
- handle_exception(e, level: :warn, operation: "crypt.shutdown.#{operation}")
288
- end
289
- log.info 'Legion::Crypt shutdown completed'
254
+ run_shutdown_components(components)
290
255
  ensure
291
256
  if shutdown_started
292
- lifecycle_mutex.synchronize do
257
+ lifecycle_monitor.synchronize do
293
258
  @started = false
294
259
  @stopping = false
295
260
  end
@@ -298,91 +263,101 @@ module Legion
298
263
 
299
264
  private
300
265
 
301
- def start_lease_manager
302
- leases = settings.dig(:vault, :leases) || {}
303
- vault_ok = connected_clusters.any? || settings.dig(:vault, :connected)
304
-
305
- return if leases.empty? && !dynamic_rmq_creds?
306
- return unless vault_ok
307
-
308
- client = nil
309
-
310
- if connected_clusters.any?
311
- selected_cluster = selected_connected_cluster_name
312
- client = selected_cluster ? vault_client(selected_cluster) : nil
313
- elsif settings.dig(:vault, :connected)
314
- client = vault_client
266
+ # Creates one Vault::Session per configured cluster; the default cluster's session also drives
267
+ # the process-wide leases. Multi-cluster by construction; a single cluster is the one-cluster case.
268
+ def start_vault_sessions(mode:)
269
+ default = default_cluster_name
270
+ lease_defs = postgresql_leases_for_mode(leases: Legion::Settings[:crypt][:vault][:leases], mode: mode)
271
+ effective_cluster_configs.each_key do |name|
272
+ client = vault_client(name)
273
+ next if client.nil?
274
+
275
+ leases = name == default ? Legion::Crypt::LeaseManager.instance : nil
276
+ session = Legion::Crypt::Vault::Session.new(cluster_name: name, client: client, leases: leases, lease_defs: lease_defs)
277
+ (@vault_sessions ||= {})[name] = session
278
+ session.start
279
+ rescue NameError
280
+ raise # programming error — never swallowed as a Vault outage
281
+ rescue StandardError => e
282
+ handle_exception(e, level: :error, operation: 'crypt.start_vault_sessions', cluster_name: name)
315
283
  end
284
+ end
316
285
 
317
- lease_manager = Legion::Crypt::LeaseManager.instance
318
- lease_manager.start(leases, vault_client: client)
319
- lease_manager.start_renewal_thread
286
+ # Stops every session (each stops its token thread, shuts down its leases, and revokes its token);
287
+ # returns whether every session completed its remote cleanup.
288
+ def stop_vault_sessions(deadline:, denied_clients: {}, **)
289
+ sessions = lifecycle_monitor.synchronize { (@vault_sessions || {}).values.tap { @vault_sessions = {} } }
290
+ sessions.map do |session|
291
+ session.stop(deadline: deadline)
292
+ rescue StandardError => e
293
+ denied_clients[session.client] = true if e.is_a?(Legion::Crypt::Vault::HTTPClientError) && e.code == 403
294
+ handle_exception(e, level: :error, operation: 'crypt.stop_vault_sessions', cluster_name: session.cluster_name, outcome: 'incomplete')
295
+ false
296
+ end.all?
297
+ end
320
298
 
321
- unless leases.empty?
322
- fetched = lease_manager.fetched_count
323
- defined = leases.size
324
- if fetched == defined
325
- log.info "LeaseManager: #{fetched} lease(s) initialized"
326
- else
327
- log.warn "LeaseManager: #{fetched}/#{defined} lease(s) initialized (#{defined - fetched} failed)"
328
- end
299
+ # Runs each shutdown component in order, collecting the cleanup operations that did not complete.
300
+ def run_shutdown_components(components)
301
+ incomplete = components.filter_map do |owner, operation, options, reports_cleanup|
302
+ completed = owner.send(operation, **options)
303
+ operation if reports_cleanup && !completed
304
+ rescue StandardError => e
305
+ handle_exception(e, level: :error, operation: "crypt.shutdown.#{operation}")
306
+ operation
307
+ end
308
+ if incomplete.empty?
309
+ log.info 'Legion::Crypt shutdown completed'
310
+ else
311
+ log.error "Legion::Crypt shutdown completed with incomplete Vault cleanup: #{incomplete.join(', ')}"
329
312
  end
330
- rescue StandardError => e
331
- handle_exception(e, level: :warn, operation: 'crypt.start_lease_manager')
332
313
  end
333
314
 
334
- def start_token_renewers
335
- started = 0
336
- configurations = clusters.empty? ? { nil => vault_settings } : clusters
337
- configurations.each do |name, config|
338
- next unless %w[kerberos ldap jwt].include?(config[:auth_method].to_s) && config[:connected]
339
-
340
- start_token_renewer(cluster_name: name, config: config, vault_client: vault_client(name))
341
- started += 1
342
- end
343
- log.info "Legion::Crypt started #{started} token renewer(s)" if started.positive?
315
+ def effective_cluster_configs
316
+ clusters.empty? ? { nil => Legion::Settings[:crypt][:vault] } : clusters
344
317
  end
345
318
 
346
- def start_token_renewer(cluster_name:, config:, vault_client:, **)
347
- @token_renewers ||= []
348
- return if @token_renewers.any? { |worker| worker.cluster_name == cluster_name && worker.running? }
319
+ def default_session
320
+ @vault_sessions&.[](default_cluster_name)
321
+ end
349
322
 
350
- @token_renewers.reject! { |worker| worker.cluster_name == cluster_name }
351
- renewer = Legion::Crypt::TokenRenewer.new(cluster_name: cluster_name, config: config, vault_client: vault_client)
352
- @token_renewers << renewer
353
- renewer.start
323
+ def session_for(cluster_name)
324
+ name = cluster_name.nil? ? default_cluster_name : cluster_name.to_sym
325
+ @vault_sessions&.[](name)
354
326
  end
355
327
 
356
- def stop_token_renewers(deadline: nil)
357
- renewers = @token_renewers || []
358
- @token_renewers = []
359
- renewers.each do |renewer|
360
- renewer.stop(deadline: deadline)
361
- rescue StandardError => e
362
- handle_exception(e, level: :warn, operation: 'crypt.stop_token_renewers')
363
- end
328
+ def postgresql_leases_for_mode(leases:, mode:)
329
+ role = POSTGRES_ROLE_MAP[mode]
330
+ return leases unless role
331
+
332
+ postgresql_key = leases.key?(:postgresql) ? :postgresql : 'postgresql'
333
+ definition = leases[postgresql_key]
334
+ return leases unless definition.is_a?(Hash)
335
+
336
+ path_key = definition.key?(:path) ? :path : 'path'
337
+ leases.merge(postgresql_key => definition.merge(path_key => "postgresql/creds/#{role}"))
364
338
  end
365
339
 
366
340
  def start_svid_rotation
367
- return unless Spiffe.enabled?
341
+ return unless Legion::Crypt::Spiffe.enabled?
368
342
 
369
343
  log.info 'Legion::Crypt starting SPIFFE SVID rotation'
370
- @svid_rotation = Spiffe::SvidRotation.new
344
+ @svid_rotation = Legion::Crypt::Spiffe::SvidRotation.new
371
345
  @svid_rotation.start
372
- rescue StandardError => e
346
+ rescue IOError, SystemCallError, Timeout::Error, Legion::Crypt::Spiffe::Error => e
373
347
  handle_exception(e, level: :warn, operation: 'crypt.start_svid_rotation')
374
348
  end
375
349
 
376
350
  def stop_svid_rotation(deadline: nil)
377
351
  return unless @svid_rotation
378
352
 
379
- Legion::Crypt::VaultOperation.with_timeout(deadline: deadline) { @svid_rotation.stop }
353
+ Legion::Crypt::Vault::Operation.with_timeout(deadline: deadline) { @svid_rotation.stop }
380
354
  ensure
381
355
  @svid_rotation = nil
382
356
  end
383
357
 
384
- def lifecycle_mutex
385
- @lifecycle_mutex ||= Mutex.new
358
+ # Reentrant so startup can activate Kerberos grants through the same login path as callers.
359
+ def lifecycle_monitor
360
+ @lifecycle_monitor ||= Monitor.new
386
361
  end
387
362
  end
388
363
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: legion-crypt
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.5.38
4
+ version: 1.6.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Esity
@@ -93,6 +93,20 @@ dependencies:
93
93
  - - ">="
94
94
  - !ruby/object:Gem::Version
95
95
  version: 1.5.0
96
+ - !ruby/object:Gem::Dependency
97
+ name: legion-settings
98
+ requirement: !ruby/object:Gem::Requirement
99
+ requirements:
100
+ - - ">="
101
+ - !ruby/object:Gem::Version
102
+ version: 1.4.2
103
+ type: :runtime
104
+ prerelease: false
105
+ version_requirements: !ruby/object:Gem::Requirement
106
+ requirements:
107
+ - - ">="
108
+ - !ruby/object:Gem::Version
109
+ version: 1.4.2
96
110
  description: A gem used by the LegionIO framework for encryption
97
111
  email:
98
112
  - matthewdiverson@gmail.com
@@ -108,6 +122,7 @@ files:
108
122
  - ".github/workflows/ci.yml"
109
123
  - ".gitignore"
110
124
  - ".pre-commit-config.yaml"
125
+ - ".rspec"
111
126
  - ".rubocop.yml"
112
127
  - AGENTS.md
113
128
  - CHANGELOG.md
@@ -127,8 +142,6 @@ files:
127
142
  - lib/legion/crypt/helper.rb
128
143
  - lib/legion/crypt/jwks_client.rb
129
144
  - lib/legion/crypt/jwt.rb
130
- - lib/legion/crypt/kerberos_auth.rb
131
- - lib/legion/crypt/ldap_auth.rb
132
145
  - lib/legion/crypt/lease_manager.rb
133
146
  - lib/legion/crypt/mock_vault.rb
134
147
  - lib/legion/crypt/mtls.rb
@@ -139,15 +152,18 @@ files:
139
152
  - lib/legion/crypt/spiffe/svid_rotation.rb
140
153
  - lib/legion/crypt/spiffe/workload_api_client.rb
141
154
  - lib/legion/crypt/tls.rb
142
- - lib/legion/crypt/token_renewer.rb
143
155
  - lib/legion/crypt/vault.rb
144
- - lib/legion/crypt/vault_client.rb
145
- - lib/legion/crypt/vault_cluster.rb
146
- - lib/legion/crypt/vault_entity.rb
147
- - lib/legion/crypt/vault_jwt_auth.rb
148
- - lib/legion/crypt/vault_kerberos_auth.rb
149
- - lib/legion/crypt/vault_operation.rb
150
- - lib/legion/crypt/vault_renewer.rb
156
+ - lib/legion/crypt/vault/auth.rb
157
+ - lib/legion/crypt/vault/auth/jwt.rb
158
+ - lib/legion/crypt/vault/auth/kerberos.rb
159
+ - lib/legion/crypt/vault/auth/ldap.rb
160
+ - lib/legion/crypt/vault/client.rb
161
+ - lib/legion/crypt/vault/cluster.rb
162
+ - lib/legion/crypt/vault/entity.rb
163
+ - lib/legion/crypt/vault/leases.rb
164
+ - lib/legion/crypt/vault/operation.rb
165
+ - lib/legion/crypt/vault/renewer.rb
166
+ - lib/legion/crypt/vault/session.rb
151
167
  - lib/legion/crypt/version.rb
152
168
  - scripts/pre-commit-rubocop.sh
153
169
  - sonar-project.properties