blib/lib/Langertha/Skeid/KeyBroker/OpenBao.pm untested

filter: Statementstmt 0.0% 0 / 191 Branchbran 0.0% 0 / 68 Conditioncond 0.0% 0 / 92 MC/DCmcdc 0.0% 0 / 52 Subroutinesub 0.0% 0 / 20 Podpod 0.0% 0 / 12 totaltotal 0.0% 0 / 435 CC 33 SCAR 32.4
CC
33
Cov
0%
resolve_key_async
56.0
_refresh_async
42.0
refresh
30.0
CRAP 25.5
1 package Langertha::Skeid::KeyBroker::OpenBao;
2 our $VERSION = '0.004';
3 # ABSTRACT: OpenBao-backed KeyBroker with AppRole auth and token renewal
4 use Moo;
5 use HTTP::Tiny;
6 use Mojo::IOLoop;
7 use Mojo::UserAgent;
8 use JSON::MaybeXS qw(decode_json encode_json);
9 use POSIX qw(strftime);
10 use Scalar::Util qw(weaken);
11 use namespace::clean;
12  
13 extends 'Langertha::Skeid::KeyBroker';
14  
15  
16  
17 has addr => (
18 is => 'ro',
19 required => 1,
20 default => sub { $ENV{OPENBAO_ADDR} // 'http://127.0.0.1:8200' },
21 );
22  
23 has role_id => (
24 is => 'ro',
25 required => 1,
26 );
27  
28 has secret_id => (
29 is => 'ro',
30 required => 1,
31 );
32  
33 has renew_secs => (
34 is => 'rw',
35 default => sub { 300 }, # 5 minutes
36 );
37  
38  
39 has verify_ssl => (
40 is => 'ro',
41 default => sub {
42 return (defined($ENV{OPENBAO_VERIFY_SSL}) && $ENV{OPENBAO_VERIFY_SSL} =~ /^(0|false|no|off)$/i)
43 ? 0 : 1;
44 },
45 );
46  
47 has _http => (
48 is => 'lazy',
49 builder => sub {
50 my ($self) = @_;
51 HTTP::Tiny->new(
52 timeout => 10,
53 verify_ssl => $self->verify_ssl,
54 );
55 },
56 );
57  
58 # The non-blocking client, used on the request path. HTTP::Tiny stays for boot and for callers
59 # with no IO loop (CLI, tests, setup scripts).
60 has _ua => (
61 is => 'lazy',
62 builder => sub {
63 my ($self) = @_;
64 my $ua = Mojo::UserAgent->new;
65 $ua->connect_timeout(5);
66 $ua->request_timeout(10);
67 $ua->insecure(1) unless $self->verify_ssl;
68 return $ua;
69 },
70 );
71  
72 # Callbacks waiting on a token renewal that is already in flight.
73 has _refresh_waiters => (
74 is => 'ro',
75 default => sub { [] },
76 );
77  
78 has _token => (
79 is => 'rw',
80 clearer => '_clear_token',
81 );
82  
83 has _renew_token => (
84 is => 'rw',
85 clearer => '_clear_renew_token',
86 );
87  
88 has _token_expire => (
89 is => 'rw',
90 default => sub { 0 },
91 );
92  
93 has _renewal_loop => (
94 is => 'rw',
95 clearer => '_clear_renewal_loop',
96 );
97  
98 sub BUILD {
99 my ($self) = @_;
100 # Initial token fetch
101 $self->_fetch_token;
102 }
103  
104 sub _fetch_token {
105 my ($self) = @_;
106 my $resp = $self->_http->post(
107 "${\$self->addr}/v1/auth/approle/login",
108 {
109 headers => { 'Content-Type' => 'application/json' },
110 content => encode_json({
111 role_id => $self->role_id,
112 secret_id => $self->secret_id,
113 }),
114 },
115 );
116  
117 unless ($resp->{success}) {
118 die "OpenBao AppRole login failed: " . ($resp->{content} // 'unknown error');
119 }
120  
121 my $data = decode_json($resp->{content})->{auth} // {};
122 my $token = $data->{client_token} // '';
123 my $ttl = $data->{ttl} // 0;
124  
125 die "OpenBao AppRole login returned no token" unless length $token;
126  
127 # The token from AppRole login is ONLY for renew-self
128 # Store it as _renew_token - we'll use it to get the actual API token
129 $self->_renew_token($token);
130 $self->_token_expire(time + ($ttl > 0 ? $ttl : 3600));
131  
132 return 1;
133 }
134  
135  
136 sub needs_refresh {
137 my ($self) = @_;
138 # Refresh if: time is near expiry, OR we have no client_token yet
139 return 1 if time >= ($self->_token_expire - 60);
140 return 1 unless $self->_token;
141 return 0;
142 }
143  
144  
145 sub refresh {
146 my ($self) = @_;
147 # Token renewal via renew-self endpoint
148 # _token holds the RENEW token (from initial AppRole login or previous renew-self)
149 # renew-self returns a NEW client_token for API calls AND a new renew token
150 my $renew_token = $self->_token // $self->_renew_token;
151 unless ($renew_token) {
152 die "No renew token available - call _fetch_token first";
153 }
154  
155 my $resp = $self->_http->post(
156 "${\$self->addr}/v1/auth/token/renew-self",
157 {
158 headers => {
159 'Content-Type' => 'application/json',
160 'X-Vault-Token' => $renew_token,
161 },
162 content => encode_json({}),
163 },
164 );
165  
166 if ($resp->{success}) {
167 my $data = decode_json($resp->{content})->{auth} // {};
168 my $new_client_token = $data->{client_token} // '';
169 my $ttl = $data->{ttl} // 0;
170  
171 die "renew-self returned no client_token" unless length $new_client_token;
172  
173 # Store the new client_token for API calls
174 $self->_token($new_client_token);
175  
176 # Store a new renew token (same as client_token in Vault's default behavior)
177 # The renew_token is good for the lease_duration, then we need to renew again
178 $self->_renew_token($new_client_token);
179 $self->_token_expire(time + ($ttl > 0 ? $ttl : 3600));
180  
181 return 1;
182 }
183  
184 # Renewal failed - need new AppRole credentials
185 die "OpenBao token renewal failed. Container must be restarted to get new AppRole credential.";
186 }
187  
188 # KV-v2 reads go through secret/data/. Callers name the logical path
189 # ("secret/skeid/remote/groq"); the API path is "secret/data/skeid/remote/groq".
190 sub _kv_path {
191 my ($self, $ref) = @_;
192 $ref =~ s{^/+}{};
193 $ref =~ s{^secret/?}{secret/data/};
194 return $ref;
195 }
196  
197 sub _key_from_payload {
198 my ($self, $payload) = @_;
199 my $decoded = eval { decode_json($payload // '') } or return undef;
200 my $data = $decoded->{data} // {};
201 return $data->{data}{api_key} // $data->{api_key} // undef;
202 }
203  
204  
205 sub resolve_key {
206 my ($self, $ref) = @_;
207 return undef unless defined $ref && length $ref;
208  
209 # Refresh token if needed
210 $self->refresh if $self->needs_refresh;
211  
212 my $token = $self->_token or die "No OpenBao token";
213  
214 my $path = $self->_kv_path($ref);
215 my $resp = $self->_http->get(
216 "${\$self->addr}/v1/$path",
217 {
218 headers => { 'X-Vault-Token' => $token },
219 },
220 );
221  
222 if (!$resp->{success}) {
223 # Only the status: a response body from a vault read is the last thing that belongs in a
224 # log line, and the reference alone is enough to find the misconfiguration.
225 warn "OpenBao read failed for '$ref': HTTP " . ($resp->{status} // '???');
226 return undef;
227 }
228  
229 return $self->_key_from_payload($resp->{content});
230 }
231  
232  
233 sub resolve_key_async {
234 my ($self, $ref, $cb) = @_;
235 $cb ||= sub { };
236 return $cb->(undef, 'no key reference') unless defined($ref) && length($ref);
237 return $self->SUPER::resolve_key_async($ref, $cb) unless Mojo::IOLoop->is_running;
238  
239 my $read = sub {
240 my ($token, $error) = @_;
241 return $cb->(undef, $error) unless defined($token) && length($token);
242  
243 $self->_ua->get(
244 $self->addr . '/v1/' . $self->_kv_path($ref) => { 'X-Vault-Token' => $token } => sub {
245 my (undef, $tx) = @_;
246 my $res = $tx->res;
247 my $status = $res->code // 0;
248 return $cb->(undef, "OpenBao read failed for '$ref': HTTP " . ($status || 'no response'))
249 unless $status >= 200 && $status < 300;
250  
251 my $key = $self->_key_from_payload($res->body);
252 return $cb->(undef, "OpenBao returned no api_key for '$ref'")
253 unless defined($key) && length($key);
254 $cb->($key, undef);
255 }
256 );
257 };
258  
259 return $self->_refresh_async($read) if $self->needs_refresh;
260 $read->($self->_token);
261 return;
262 }
263  
264 # Renews the token without blocking, and only once at a time: a cold start at concurrency 64
265 # would otherwise fire 64 renew-self calls, and vault would answer them with 64 different
266 # tokens, 63 of which are immediately stale.
267 sub _refresh_async {
268 my ($self, $cb) = @_;
269 $cb ||= sub { };
270  
271 my $waiters = $self->_refresh_waiters;
272 push @$waiters, $cb;
273 return if @$waiters > 1;
274  
275 my $settle = sub {
276 my ($token, $error) = @_;
277 my @waiting = splice @$waiters;
278 $_->($token, $error) for @waiting;
279 };
280  
281 my $renew_token = $self->_token // $self->_renew_token;
282 return $settle->(undef, 'No renew token available') unless $renew_token;
283  
284 $self->_ua->post(
285 $self->addr . '/v1/auth/token/renew-self' => {
286 'Content-Type' => 'application/json',
287 'X-Vault-Token' => $renew_token,
288 } => encode_json({}) => sub {
289 my (undef, $tx) = @_;
290 my $status = $tx->res->code // 0;
291 return $settle->(undef, 'OpenBao token renewal failed: HTTP ' . ($status || 'no response'))
292 unless $status >= 200 && $status < 300;
293  
294 my $data = eval { decode_json($tx->res->body)->{auth} } // {};
295 my $token = $data->{client_token} // '';
296 return $settle->(undef, 'renew-self returned no client_token') unless length $token;
297  
298 my $ttl = $data->{ttl} // 0;
299 $self->_token($token);
300 $self->_renew_token($token);
301 $self->_token_expire(time + ($ttl > 0 ? $ttl : 3600));
302 $settle->($token, undef);
303 }
304 );
305 return;
306 }
307  
308  
309 sub start_renewal {
310 my ($self) = @_;
311 return $self->_renewal_loop if $self->_renewal_loop;
312  
313 my $every = $self->renew_secs;
314 $every = 60 if !$every || $every < 1;
315  
316 # Weak, or the timer's closure keeps the broker alive forever and DEMOLISH never runs -- which
317 # is how a token outlives the object that was supposed to be the only thing holding it.
318 my $weak = $self;
319 weaken($weak);
320  
321 my $id = Mojo::IOLoop->recurring($every => sub {
322 my $broker = $weak or return;
323 $broker->_refresh_async(sub {
324 my ($token, $error) = @_;
325 return unless defined $error;
326 die "OpenBao token renewal failed and the token has expired: $error"
327 if time >= $broker->_token_expire;
328 warn "OpenBao token renewal failed (token still valid): $error";
329 });
330 });
331 $self->_renewal_loop($id);
332 return $id;
333 }
334  
335  
336 sub list_secrets {
337 my ($self, $path) = @_;
338 return [] unless defined $path && length $path;
339  
340 $self->refresh if $self->needs_refresh;
341  
342 my $token = $self->_token or return [];
343 $path =~ s{^/+}{};
344 $path .= '/' unless $path =~ m{/$};
345  
346 my $resp = $self->_http->list(
347 "${\$self->addr}/v1/$path",
348 {
349 headers => { 'X-Vault-Token' => $token },
350 },
351 );
352  
353 return [] unless $resp->{success};
354  
355 my $data = decode_json($resp->{content})->{data} // {};
356 return [ map { $_->{key} } @{$data->{keys} // []} ];
357 }
358  
359 sub DEMOLISH {
360 my ($self) = @_;
361 if (my $id = $self->_renewal_loop) {
362 eval { Mojo::IOLoop->remove($id) };
363 $self->_clear_renewal_loop;
364 }
365 $self->forget_key;
366 $self->_clear_token;
367 $self->_clear_renew_token;
368 }
369  
370 1;
371  
372 __END__