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
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/
|
|
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 :
|
|
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
|
-
|
|
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
|
-
|
|
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][:
|
|
86
|
-
|
|
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
|
|
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 =
|
|
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
|
-
|
|
247
|
-
|
|
248
|
-
|
|
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: :
|
|
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
|
-
[
|
|
257
|
-
[self, :
|
|
258
|
-
[self, :
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
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
|
-
|
|
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
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
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
|
-
|
|
295
|
-
|
|
296
|
-
|
|
315
|
+
def effective_cluster_configs
|
|
316
|
+
clusters.empty? ? { nil => Legion::Settings[:crypt][:vault] } : clusters
|
|
317
|
+
end
|
|
297
318
|
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
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
|
-
|
|
374
|
-
|
|
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.
|
|
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/
|
|
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
|