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.
- checksums.yaml +4 -4
- data/.github/workflows/ci.yml +30 -3
- data/.rspec +2 -0
- data/AGENTS.md +2 -0
- data/CHANGELOG.md +99 -0
- data/CLAUDE.md +65 -192
- data/CODEOWNERS +4 -4
- data/Gemfile +4 -1
- data/README.md +60 -16
- data/legion-crypt.gemspec +1 -0
- data/lib/legion/crypt/cert_rotation.rb +7 -21
- data/lib/legion/crypt/cluster_secret.rb +3 -14
- data/lib/legion/crypt/ed25519.rb +2 -10
- data/lib/legion/crypt/erasure.rb +3 -13
- data/lib/legion/crypt/jwks_client.rb +4 -4
- data/lib/legion/crypt/lease_manager.rb +5 -831
- data/lib/legion/crypt/mtls.rb +8 -46
- data/lib/legion/crypt/partition_keys.rb +2 -6
- data/lib/legion/crypt/settings.rb +31 -21
- data/lib/legion/crypt/spiffe/svid_rotation.rb +6 -9
- data/lib/legion/crypt/spiffe.rb +14 -39
- 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 +362 -0
- data/lib/legion/crypt/vault/cluster.rb +262 -0
- data/lib/legion/crypt/vault/entity.rb +79 -0
- data/lib/legion/crypt/vault/leases.rb +871 -0
- data/lib/legion/crypt/vault/operation.rb +29 -0
- data/lib/legion/crypt/vault/session.rb +405 -0
- data/lib/legion/crypt/vault.rb +21 -31
- data/lib/legion/crypt/version.rb +1 -1
- data/lib/legion/crypt.rb +152 -177
- metadata +27 -11
- 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_client.rb +0 -355
- data/lib/legion/crypt/vault_cluster.rb +0 -331
- data/lib/legion/crypt/vault_entity.rb +0 -78
- data/lib/legion/crypt/vault_jwt_auth.rb +0 -97
- data/lib/legion/crypt/vault_kerberos_auth.rb +0 -51
- data/lib/legion/crypt/vault_operation.rb +0 -27
- /data/lib/legion/crypt/{vault_renewer.rb → vault/renewer.rb} +0 -0
|
@@ -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::VaultClient::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::VaultOperation.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
|
|
@@ -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) + VaultOperation::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
|
-
VaultOperation.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
|
-
VaultOperation.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
|
-
VaultOperation.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
|