forked from mtusi2026/mtusi2026lab7
98 lines
4.0 KiB
Python
98 lines
4.0 KiB
Python
"""Small TLS-only sidecar and fail-closed service bootstrap. No secret logging."""
|
|
import asyncio
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import ssl
|
|
import sys
|
|
import urllib.request
|
|
|
|
|
|
def fetch():
|
|
role = os.environ['BAO_ROLE']
|
|
ctx = ssl.create_default_context(cafile='/tls/ca.crt')
|
|
ctx.load_cert_chain('/tls/service.crt', '/tls/service.key')
|
|
addr = os.getenv('BAO_ADDR', 'https://openbao:8200')
|
|
def request(path, data=None, token=None):
|
|
headers = {'Content-Type': 'application/json'}
|
|
if token:
|
|
headers['X-Vault-Token'] = token
|
|
req = urllib.request.Request(addr + '/v1/' + path, data=json.dumps(data).encode() if data is not None else None, headers=headers)
|
|
with urllib.request.urlopen(req, context=ctx, timeout=10) as response:
|
|
raw = response.read()
|
|
return json.loads(raw) if raw else {}
|
|
token = request('auth/cert/login', {'name': role})['auth']['client_token']
|
|
try:
|
|
values = request('secret/data/' + role, token=token)['data']['data']
|
|
out = Path('/run/app-secrets')
|
|
out.mkdir(exist_ok=True)
|
|
for name, value in values.items():
|
|
if name not in ('database_url', 'cache_url', 'broker_url', 's3_access_key_id', 's3_secret_access_key'):
|
|
raise ValueError('unexpected secret field')
|
|
file = out / name
|
|
file.write_text(value)
|
|
file.chmod(0o600)
|
|
finally:
|
|
request('auth/token/revoke-self', {}, token)
|
|
|
|
|
|
async def proxy(specs):
|
|
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
|
|
context.minimum_version = ssl.TLSVersion.TLSv1_2
|
|
context.load_cert_chain('/tls/service.crt', '/tls/service.key')
|
|
allowed = set(os.getenv('TLS_ALLOWED_IDS', '').split(',')) - {''}
|
|
if allowed:
|
|
context.load_verify_locations('/tls/ca.crt')
|
|
context.verify_mode = ssl.CERT_REQUIRED
|
|
sem = asyncio.Semaphore(256)
|
|
async def connection(reader, writer, target):
|
|
async with sem:
|
|
peer = None
|
|
try:
|
|
if allowed:
|
|
cert = writer.get_extra_info('peercert')
|
|
identities = {value for kind, value in cert.get('subjectAltName', []) if kind == 'URI'}
|
|
if not identities.intersection(allowed):
|
|
return
|
|
upstream, peer = await asyncio.wait_for(asyncio.open_connection('127.0.0.1', target), 5)
|
|
async def copy(src, dst):
|
|
while data := await src.read(65536):
|
|
dst.write(data)
|
|
await dst.drain()
|
|
tasks = [asyncio.create_task(copy(reader, peer)), asyncio.create_task(copy(upstream, writer))]
|
|
try:
|
|
await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
|
|
finally:
|
|
for task in tasks:
|
|
task.cancel()
|
|
await asyncio.gather(*tasks, return_exceptions=True)
|
|
except (OSError, asyncio.TimeoutError):
|
|
pass
|
|
finally:
|
|
writer.close()
|
|
if peer:
|
|
peer.close()
|
|
servers = []
|
|
for spec in specs:
|
|
port, target = map(int, spec.split(':'))
|
|
async def handler(r, w, target=target):
|
|
await connection(r, w, target)
|
|
servers.append(await asyncio.start_server(handler, '0.0.0.0', port, ssl=context, ssl_handshake_timeout=5, backlog=128))
|
|
await asyncio.gather(*(s.serve_forever() for s in servers))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
if sys.argv[1] == 'proxy':
|
|
asyncio.run(proxy(sys.argv[2:]))
|
|
else:
|
|
try:
|
|
fetch()
|
|
except Exception as exc:
|
|
sys.exit('OpenBao bootstrap denied/unavailable: ' + type(exc).__name__)
|
|
if os.environ['BAO_ROLE'] == 'api':
|
|
import uuid
|
|
alias = str(uuid.uuid4())
|
|
os.environ['APP_INSTANCE_ID'] = alias
|
|
Path('/tmp/instance-alias').write_text(alias)
|
|
os.execvp(sys.argv[2], sys.argv[2:])
|