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.
data/lib/legion/crypt.rb CHANGED
@@ -2,6 +2,7 @@
2
2
 
3
3
  require 'openssl'
4
4
  require 'base64'
5
+ require 'monitor'
5
6
  require 'legion/logging/helper'
6
7
  require 'legion/settings'
7
8
 
@@ -9,13 +10,10 @@ require 'legion/crypt/version'
9
10
  require 'legion/crypt/settings'
10
11
  require 'legion/crypt/cipher'
11
12
  require 'legion/crypt/jwt'
12
- require 'legion/crypt/vault/jwt_auth'
13
- require 'legion/crypt/lease_manager'
14
13
  require 'legion/crypt/vault/operation'
15
14
  require 'legion/crypt/vault/cluster'
16
15
  require 'legion/crypt/vault'
17
- require 'legion/crypt/ldap_auth'
18
- require 'legion/crypt/token_renewer'
16
+ require 'legion/crypt/lease_manager'
19
17
  require 'legion/crypt/helper'
20
18
  require 'legion/crypt/mtls'
21
19
  require 'legion/crypt/cert_rotation'
@@ -24,7 +22,6 @@ require 'legion/crypt/spiffe'
24
22
  module Legion
25
23
  module Crypt
26
24
  extend Legion::Crypt::Vault::Cluster
27
- extend Legion::Crypt::LdapAuth
28
25
 
29
26
  RMQ_ROLE_MAP = {
30
27
  agent: 'legionio-infra',
@@ -37,7 +34,7 @@ module Legion
37
34
  }.freeze
38
35
 
39
36
  class << self
40
- attr_reader :sessions, :stopping
37
+ attr_reader :stopping
41
38
 
42
39
  include Legion::Logging::Helper
43
40
  include Legion::Crypt::Cipher
@@ -45,7 +42,28 @@ module Legion
45
42
  include Legion::Crypt::Vault
46
43
 
47
44
  def kerberos_principal(**)
48
- Legion::Crypt::KerberosAuth.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)
53
+ end
54
+
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
49
67
  end
50
68
 
51
69
  def spiffe_svid
@@ -63,7 +81,7 @@ module Legion
63
81
  end
64
82
 
65
83
  def start(mode: nil, **)
66
- lifecycle_mutex.synchronize do
84
+ lifecycle_monitor.synchronize do
67
85
  if @started || @stopping
68
86
  log.info 'Legion::Crypt start ignored because the lifecycle is running or stopping'
69
87
  return
@@ -79,47 +97,19 @@ module Legion
79
97
  file.write(key.to_pem)
80
98
  end
81
99
  end
82
- @token_renewers ||= []
83
100
  start_session_tracking
84
101
 
85
- if Legion::Settings[:crypt][:vault][:clusters].any?
86
- log.info "Legion::Crypt connecting #{Legion::Settings[:crypt][:vault][:clusters].size} Vault cluster(s)"
87
- connect_all_clusters
102
+ if Legion::Settings[:crypt][:vault][:enabled]
103
+ start_vault_sessions(mode: mode)
88
104
  else
89
- log.info 'Legion::Crypt connecting primary Vault client' unless Legion::Settings[:crypt][:vault][:token].nil?
90
- connect_vault unless Legion::Settings[:crypt][:vault][:token].nil?
105
+ log.info 'Legion::Crypt Vault is disabled; skipping Vault authentication and maintenance'
91
106
  end
92
- start_token_renewers
93
- start_lease_manager(mode: mode)
94
107
  start_svid_rotation
95
108
  @started = true
96
109
  log.info 'Legion::Crypt startup completed'
97
110
  end
98
111
  end
99
112
 
100
- def vault_auth_generation
101
- lifecycle_mutex.synchronize do
102
- raise 'Crypt is shutting down; login must be retried' if @stopping
103
-
104
- @token_generation || 0
105
- end
106
- end
107
-
108
- def install_vault_grant(client:, config:, grant:, auth_method:, generation:, **)
109
- issued_at = Time.now
110
- lifecycle_mutex.synchronize do
111
- raise 'Crypt stopped during login; login must be retried' if @stopping || generation != (@token_generation || 0)
112
-
113
- cluster_name = clusters.find { |_name, candidate| candidate.equal?(config) }&.first
114
- previous = (@token_renewers || []).find { |worker| worker.cluster_name == cluster_name }
115
- previous&.stop
116
- raise 'Previous token worker has not stopped; login must be retried' if previous&.running?
117
-
118
- publish_vault_grant(client: client, config: config, grant: grant, auth_method: auth_method, issued_at: issued_at)
119
- start_token_renewer(cluster_name: cluster_name, config: config, vault_client: client)
120
- end
121
- end
122
-
123
113
  def dynamic_rmq_creds?
124
114
  Legion::Settings[:crypt][:vault][:dynamic_rmq_creds] == true
125
115
  end
@@ -162,8 +152,9 @@ module Legion
162
152
  return unless vault_connected? && dynamic_rmq_creds?
163
153
  return if mode == :lite
164
154
 
165
- role = RMQ_ROLE_MAP.fetch(mode, "legionio-#{mode}")
166
155
  manager = Legion::Crypt::LeaseManager.instance
156
+
157
+ role = RMQ_ROLE_MAP.fetch(mode, "legionio-#{mode}")
167
158
  response = Legion::Crypt::Vault::Operation.with_timeout { manager.vault_logical.read(path: "rabbitmq/creds/#{role}") }
168
159
  raise "Failed to fetch identity-scoped RMQ creds for role #{role}" unless response
169
160
 
@@ -232,41 +223,38 @@ module Legion
232
223
  Legion::Crypt::JWT.verify_with_jwks(token, jwks_url: jwks_url, **)
233
224
  end
234
225
 
226
+ # Stops maintenance, then revokes dependent leases and sessions before the tokens they depend on.
235
227
  def shutdown
236
- shutdown_started = lifecycle_mutex.synchronize do
228
+ shutdown_started = lifecycle_monitor.synchronize do
237
229
  return if @stopping
238
230
  return unless @started || @vault_clients || @retired_vault_clients&.size&.positive?
239
231
 
240
232
  @stopping = true
241
- @token_generation = (@token_generation || 0) + 1
242
233
  @started = false
243
234
  true
244
235
  end
245
236
  deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + Legion::Crypt::Vault::Operation::SHUTDOWN_TIMEOUT
246
- manager = Legion::Crypt::LeaseManager.instance
247
- [manager, *(@token_renewers || [])].each do |worker|
248
- worker.request_stop
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
249
241
  rescue StandardError => e
250
- handle_exception(e, level: :warn, operation: 'crypt.shutdown.request_stop')
242
+ handle_exception(e, level: :error, operation: 'crypt.shutdown.request_stop')
251
243
  end
252
244
 
245
+ # Clients whose token Vault rejected are not used for further cleanup.
246
+ denied_clients = {}.compare_by_identity
253
247
  components = [
254
- [self, :stop_svid_rotation, { deadline: deadline }],
255
- [self, :shutdown_renewer, {}],
256
- [manager, :shutdown, { deadline: deadline }],
257
- [self, :stop_token_renewers, { deadline: deadline }],
258
- [self, :close_sessions, { deadline: deadline }],
259
- [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]
260
253
  ]
261
- components.each do |owner, operation, options|
262
- owner.send(operation, **options)
263
- rescue StandardError => e
264
- handle_exception(e, level: :warn, operation: "crypt.shutdown.#{operation}")
265
- end
266
- log.info 'Legion::Crypt shutdown completed'
254
+ run_shutdown_components(components)
267
255
  ensure
268
256
  if shutdown_started
269
- lifecycle_mutex.synchronize do
257
+ lifecycle_monitor.synchronize do
270
258
  @started = false
271
259
  @stopping = false
272
260
  end
@@ -275,37 +263,66 @@ module Legion
275
263
 
276
264
  private
277
265
 
278
- def start_lease_manager(mode: nil)
279
- leases = postgresql_leases_for_mode(leases: Legion::Settings[:crypt][:vault][:leases], mode: mode)
280
- vault_ok = connected_clusters.any? || Legion::Settings[:crypt][:vault][:connected]
281
-
282
- return if leases.empty? && !dynamic_rmq_creds?
283
- return unless vault_ok
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)
283
+ end
284
+ end
284
285
 
285
- client = nil
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
286
298
 
287
- if connected_clusters.any?
288
- selected_cluster = selected_connected_cluster_name
289
- client = selected_cluster ? vault_client(selected_cluster) : nil
290
- elsif Legion::Settings[:crypt][:vault][:connected]
291
- client = vault_client
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(', ')}"
292
312
  end
313
+ end
293
314
 
294
- lease_manager = Legion::Crypt::LeaseManager.instance
295
- lease_manager.start(leases, vault_client: client)
296
- lease_manager.start_renewal_thread
315
+ def effective_cluster_configs
316
+ clusters.empty? ? { nil => Legion::Settings[:crypt][:vault] } : clusters
317
+ end
297
318
 
298
- unless leases.empty?
299
- fetched = lease_manager.fetched_count
300
- defined = leases.size
301
- if fetched == defined
302
- log.info "LeaseManager: #{fetched} lease(s) initialized"
303
- else
304
- log.warn "LeaseManager: #{fetched}/#{defined} lease(s) initialized (#{defined - fetched} failed)"
305
- end
306
- end
307
- rescue IOError, SystemCallError, Timeout::Error, Faraday::Error, Legion::Crypt::Vault::HTTPError => e
308
- handle_exception(e, level: :warn, operation: 'crypt.start_lease_manager')
319
+ def default_session
320
+ @vault_sessions&.[](default_cluster_name)
321
+ end
322
+
323
+ def session_for(cluster_name)
324
+ name = cluster_name.nil? ? default_cluster_name : cluster_name.to_sym
325
+ @vault_sessions&.[](name)
309
326
  end
310
327
 
311
328
  def postgresql_leases_for_mode(leases:, mode:)
@@ -320,38 +337,6 @@ module Legion
320
337
  leases.merge(postgresql_key => definition.merge(path_key => "postgresql/creds/#{role}"))
321
338
  end
322
339
 
323
- def start_token_renewers
324
- started = 0
325
- configurations = clusters.empty? ? { nil => Legion::Settings[:crypt][:vault] } : clusters
326
- configurations.each do |name, config|
327
- next unless %w[kerberos ldap jwt].include?(config[:auth_method].to_s) && config[:connected]
328
-
329
- start_token_renewer(cluster_name: name, config: config, vault_client: vault_client(name))
330
- started += 1
331
- end
332
- log.info "Legion::Crypt started #{started} token renewer(s)" if started.positive?
333
- end
334
-
335
- def start_token_renewer(cluster_name:, config:, vault_client:, **)
336
- @token_renewers ||= []
337
- return if @token_renewers.any? { |worker| worker.cluster_name == cluster_name && worker.running? }
338
-
339
- @token_renewers.reject! { |worker| worker.cluster_name == cluster_name }
340
- renewer = Legion::Crypt::TokenRenewer.new(cluster_name: cluster_name, config: config, vault_client: vault_client)
341
- @token_renewers << renewer
342
- renewer.start
343
- end
344
-
345
- def stop_token_renewers(deadline: nil)
346
- renewers = @token_renewers || []
347
- @token_renewers = []
348
- renewers.each do |renewer|
349
- renewer.stop(deadline: deadline)
350
- rescue StandardError => e
351
- handle_exception(e, level: :warn, operation: 'crypt.stop_token_renewers')
352
- end
353
- end
354
-
355
340
  def start_svid_rotation
356
341
  return unless Legion::Crypt::Spiffe.enabled?
357
342
 
@@ -370,8 +355,9 @@ module Legion
370
355
  @svid_rotation = nil
371
356
  end
372
357
 
373
- def lifecycle_mutex
374
- @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
375
361
  end
376
362
  end
377
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.42
4
+ version: 1.6.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Esity
@@ -142,8 +142,6 @@ files:
142
142
  - lib/legion/crypt/helper.rb
143
143
  - lib/legion/crypt/jwks_client.rb
144
144
  - lib/legion/crypt/jwt.rb
145
- - lib/legion/crypt/kerberos_auth.rb
146
- - lib/legion/crypt/ldap_auth.rb
147
145
  - lib/legion/crypt/lease_manager.rb
148
146
  - lib/legion/crypt/mock_vault.rb
149
147
  - lib/legion/crypt/mtls.rb
@@ -154,15 +152,18 @@ files:
154
152
  - lib/legion/crypt/spiffe/svid_rotation.rb
155
153
  - lib/legion/crypt/spiffe/workload_api_client.rb
156
154
  - lib/legion/crypt/tls.rb
157
- - lib/legion/crypt/token_renewer.rb
158
155
  - lib/legion/crypt/vault.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
159
160
  - lib/legion/crypt/vault/client.rb
160
161
  - lib/legion/crypt/vault/cluster.rb
161
162
  - lib/legion/crypt/vault/entity.rb
162
- - lib/legion/crypt/vault/jwt_auth.rb
163
- - lib/legion/crypt/vault/kerberos_auth.rb
163
+ - lib/legion/crypt/vault/leases.rb
164
164
  - lib/legion/crypt/vault/operation.rb
165
165
  - lib/legion/crypt/vault/renewer.rb
166
+ - lib/legion/crypt/vault/session.rb
166
167
  - lib/legion/crypt/version.rb
167
168
  - scripts/pre-commit-rubocop.sh
168
169
  - sonar-project.properties
@@ -1,119 +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 KerberosAuth
9
- class AuthError < StandardError; end
10
- class GemMissingError < StandardError; end
11
-
12
- DEFAULT_AUTH_PATH = 'auth/kerberos/login'
13
-
14
- @kerberos_principal = nil
15
- extend Legion::Logging::Helper
16
-
17
- class << self
18
- attr_reader :kerberos_principal
19
- end
20
-
21
- def self.login(vault_client:, service_principal:, auth_path: DEFAULT_AUTH_PATH, principal_guard: nil)
22
- raise GemMissingError, 'lex-kerberos gem is required for Kerberos auth' unless spnego_available?
23
-
24
- log.info "KerberosAuth login requested auth_path=#{auth_path}"
25
- log.debug("KerberosAuth: login: SPN=#{service_principal}, auth_path=#{auth_path}")
26
- addr = vault_client.respond_to?(:address) ? vault_client.address : 'n/a'
27
- ns = vault_client.respond_to?(:namespace) ? vault_client.namespace.inspect : 'n/a'
28
- log.debug("KerberosAuth: login: vault_client.address=#{addr}, namespace=#{ns}")
29
-
30
- if principal_guard
31
- principal_guard.call { @kerberos_principal = nil }
32
- else
33
- @kerberos_principal = nil
34
- end
35
- token = obtain_token(service_principal)
36
- log.debug("KerberosAuth: login: SPNEGO token obtained (#{token.length} chars)")
37
-
38
- result = exchange_token(vault_client, token, auth_path)
39
- principal = result[:metadata]&.dig('username') || result[:metadata]&.dig(:username)
40
- if principal_guard
41
- principal_guard.call { @kerberos_principal = principal }
42
- else
43
- @kerberos_principal = principal
44
- end
45
- log.debug("KerberosAuth: login: authenticated as #{@kerberos_principal.inspect}, policies=#{result[:policies].inspect}")
46
- log.debug("KerberosAuth: login: renewable=#{result[:renewable]}, ttl=#{result[:lease_duration]}s")
47
- log.info "KerberosAuth login success principal=#{@kerberos_principal || 'unknown'} auth_path=#{auth_path}"
48
- result
49
- end
50
-
51
- def self.spnego_available?
52
- return @spnego_available unless @spnego_available.nil?
53
-
54
- @spnego_available = begin
55
- require 'legion/extensions/kerberos/helpers/spnego'
56
- true
57
- rescue LoadError => e
58
- handle_exception(e, level: :debug, operation: 'crypt.kerberos_auth.spnego_available')
59
- # check if constant was already defined (e.g. stubbed in tests or loaded via another path)
60
- defined?(Legion::Extensions::Kerberos::Helpers::Spnego) ? true : false
61
- end
62
- end
63
-
64
- def self.reset!
65
- @spnego_available = nil
66
- @kerberos_principal = nil
67
- end
68
-
69
- class << self
70
- private
71
-
72
- def obtain_token(service_principal)
73
- helper = Object.new.extend(Legion::Extensions::Kerberos::Helpers::Spnego)
74
- result = helper.obtain_spnego_token(service_principal: service_principal)
75
- raise AuthError, "SPNEGO token acquisition failed: #{result[:error]}" unless result[:success]
76
-
77
- log.info 'KerberosAuth obtained SPNEGO token'
78
- result[:token]
79
- rescue StandardError => e
80
- handle_exception(e, level: :error, operation: 'crypt.kerberos_auth.obtain_token', auth_method: 'kerberos')
81
- raise
82
- end
83
-
84
- def exchange_token(vault_client, spnego_token, auth_path)
85
- # Kerberos auth is mounted inside the target namespace. Keep the
86
- # client namespace so the token is scoped to it.
87
-
88
- # The Vault Kerberos plugin reads the SPNEGO token from the HTTP
89
- # Authorization header, not the JSON body.
90
- namespace = vault_client.respond_to?(:namespace) ? vault_client.namespace.inspect : 'n/a'
91
- log.debug("KerberosAuth: exchange_token: PUT /v1/#{auth_path} (namespace=#{namespace})")
92
- json = vault_client.put(
93
- path: "/v1/#{auth_path}",
94
- body: '{}',
95
- headers: { 'Authorization' => "Negotiate #{spnego_token}" }
96
- )
97
- response = Legion::Crypt::Vault::Client::Secret.decode(data: json)
98
- raise AuthError, 'Vault Kerberos auth returned no auth data' unless response&.auth
99
-
100
- auth = response.auth
101
- {
102
- token: auth.client_token,
103
- lease_duration: auth.lease_duration,
104
- renewable: auth.renewable?,
105
- policies: auth.policies,
106
- metadata: auth.metadata
107
- }
108
- rescue Legion::Crypt::Vault::HTTPClientError => e
109
- handle_exception(e, level: :warn, operation: 'crypt.kerberos_auth.exchange_token', auth_path: auth_path)
110
- log.debug("KerberosAuth: exchange_token: HTTP error: #{e.message}")
111
- raise AuthError, "Vault Kerberos auth failed: #{e.message}"
112
- rescue StandardError => e
113
- handle_exception(e, level: :error, operation: 'crypt.kerberos_auth.exchange_token', auth_path: auth_path)
114
- raise
115
- end
116
- end
117
- end
118
- end
119
- end
@@ -1,48 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- require 'legion/logging/helper'
4
- require 'legion/crypt/vault/operation'
5
-
6
- module Legion
7
- module Crypt
8
- module LdapAuth
9
- include Legion::Logging::Helper
10
-
11
- def ldap_login(cluster_name:, username:, password:)
12
- cluster_name = cluster_name.to_sym
13
- generation = vault_auth_generation
14
- config = clusters.fetch(cluster_name)
15
- log.info "LDAP login requested user=#{username} cluster=#{cluster_name}"
16
- client = vault_client(cluster_name)
17
- secret = Legion::Crypt::Vault::Operation.with_timeout do
18
- client.logical.write(path: "auth/ldap/login/#{username}", data: { password: password })
19
- end
20
- auth = secret.auth
21
-
22
- grant = { token: auth.client_token, lease_duration: auth.lease_duration, renewable: auth.renewable?, policies: auth.policies }
23
- install_vault_grant(client: client, config: config, grant: grant, auth_method: 'ldap', generation: generation)
24
-
25
- log.info "LDAP login success: user=#{username}, cluster=#{cluster_name}"
26
- grant
27
- rescue StandardError => e
28
- log.error "LDAP login failed: user=#{username}, cluster=#{cluster_name}, error=#{e.class}"
29
- raise
30
- end
31
-
32
- def ldap_login_all(username:, password:)
33
- results = {}
34
- clusters.each do |name, config|
35
- next unless config[:auth_method].to_s == 'ldap'
36
-
37
- results[name] = ldap_login(cluster_name: name, username: username, password: password)
38
- rescue StandardError => e
39
- log.warn("Legion::Crypt::LdapAuth#ldap_login_all cluster=#{name} failed: #{e.class}")
40
- message = password.to_s.empty? ? e.message : e.message.gsub(password.to_s, '[REDACTED]')
41
- results[name] = { error: message }
42
- end
43
- log.info "LDAP login_all complete successes=#{results.count { |_, result| result.is_a?(Hash) && !result.key?(:error) }} attempted=#{results.size}"
44
- results
45
- end
46
- end
47
- end
48
- end