# SPDX-License-Identifier: GPL-3.0-only
import base64
import logging
import getpass
import hashlib
import json
import os
import unicodedata
import time
import datetime
import OpenSSL.crypto as cr
import pkcs11
def load_ts(ts):
t = time.strptime(ts.decode('ascii'), '%Y%m%d%H%M%SZ')
return datetime.datetime(
t.tm_year,
t.tm_mon,
t.tm_mday,
t.tm_hour,
t.tm_min,
t.tm_sec,
tzinfo=datetime.timezone.utc,
)
def check_selector(cert, selector, valid_only):
if valid_only:
valid_from = load_ts(cert.get_notBefore())
valid_until = load_ts(cert.get_notAfter())
if not (valid_from <= datetime.datetime.now(datetime.timezone.utc) <= valid_until):
return False
vals = selector.get('issuers')
if vals is not None:
issuer_cn = [val.decode('utf-8', 'surrogateescape') for name,val in cert.get_issuer().get_components() if name == b'CN']
if issuer_cn:
issuer_cn = issuer_cn[0]
else:
issuer_cn = ''
if f'CN={issuer_cn}' not in vals:
return False
return True
def describe_name(val):
return ', '.join(f'{k.decode("ascii")}={escape_bad(v.decode("utf-8", "surrogateescape"), ",=")}' for k,v in val.get_components())
def describe_cert(cert):
valid_from = load_ts(cert.get_notBefore())
valid_until = load_ts(cert.get_notAfter())
return (
f'Issuer: {describe_name(cert.get_issuer())}\n'
f'Subject: {describe_name(cert.get_subject())}\n'
f'Valid from: {valid_from:%Y-%m-%d %H:%M:%S} UTC\n'
f'Valid until: {valid_until:%Y-%m-%d %H:%M:%S} UTC\n'
)
def escape_bad(l, esc=''):
r = []
for c in l:
o = ord(c)
if 0xdc80 <= o <= 0xdd00:
r.append(f'\\x{ord(c)-0xdc00:02x}')
continue
if c == '\\':
r.append('\\\\')
continue
if o < 32 or o == 127 or (c in esc and o < 128):
r.append(f'\\x{ord(c):02x}')
continue
cat = unicodedata.category(c)
if cat in {'Cc', 'Cf', 'Cs'} or (cat.startswith('Z') and c != ' ') or c in esc:
if o < 0x10000:
r.append(f'\\u{o:04x}')
else:
r.append(f'\\U{o:08x}')
continue
r.append(c)
return ''.join(r)
def print_blob(name, data, /):
if type(data) is str:
kind = 'text'
elif type(data) is bytes:
kind = 'blob'
data = '\n'.join(escape_bad(l.decode('utf-8', 'surrogateescape')) for l in data.splitlines())
else:
kind = 'repr'
data = repr(data)
print(f'{name} ({kind}):')
for line in data.splitlines():
print(f' > {line!s}')
def prompt(txt, /, default=False):
while True:
if default:
d = 'Y/n'
else:
d = 'y/N'
txt = input(f'{txt} [{d}]? ')
if txt in {'y', 'Y'}:
return True
if txt in {'n', 'N'}:
return False
if not txt:
return default
STATUS_TEXT = {
200: 'OK',
201: 'Created',
202: 'Accepted',
203: 'Non-Authoritative Information',
204: 'No Content',
205: 'Reset Content',
206: 'Partial Content',
207: 'Multi-Status',
208: 'Already Reported',
226: 'IM Used',
300: 'Multiple Choices',
301: 'Moved Permanently',
302: 'Found',
303: 'See Other',
304: 'Not Modified',
305: 'Use Proxy',
306: 'Switch Proxy',
307: 'Temporary Redirect',
308: 'Permanent Redirect',
400: 'Bad Request',
401: 'Unauthorized',
402: 'Payment Required',
403: 'Forbidden',
404: 'Not Found',
405: 'Method Not Allowed',
406: 'Not Acceptable',
407: 'Proxy Authentication Required',
408: 'Request Timeout',
409: 'Conflict',
410: 'Gone',
411: 'Length Required',
412: 'Precondition Failed',
413: 'Payload Too Large',
414: 'URI Too Long',
415: 'Unsupported Media Type',
416: 'Range Not Satisfiable',
417: 'Expectation Failed',
418: 'I\'m a teapot',
421: 'Misdirected Request',
422: 'Unprocessable Entity',
423: 'Locked',
424: 'Failed Dependency',
425: 'Too Early',
426: 'Upgrade Required',
428: 'Precondition Required',
429: 'Too Many Requests',
431: 'Request Header Fields Too Large',
451: 'Unavailable For Legal Reasons',
500: 'Internal Server Error',
501: 'Not Implemented',
502: 'Bad Gateway',
503: 'Service Unavailable',
504: 'Gateway Timeout',
505: 'HTTP Version Not Supported',
506: 'Variant Also Negotiates',
507: 'Insufficient Storage',
508: 'Loop Detected',
510: 'Not Extended',
511: 'Network Authentication Required',
}
STATUS_FULL = {status: f'{status} {text}' for status,text in STATUS_TEXT.items()}
class Req:
__slots__ = ('path', 'query_string', 'method', 'headers', 'input')
def __init__(self, env):
self.path = env['PATH_INFO']
self.query_string = env.get('QUERY_STRING')
self.method = env['REQUEST_METHOD']
self.input = env['wsgi.input']
headers = self.headers = {}
for k,v in env.items():
if not k.startswith('HTTP_'):
continue
k = ''.join(map(str.title, k[5:].split('_')))
headers[k] = v
def read_data(self, /):
d = self.input
del self.input
return d.read()
def resp(self, /, status, headers, data, *, content_type):
assert type(status) is int
assert type(data) is bytes
assert type(content_type) is str
headers = [*headers]
assert all(type(k) is str and type(v) is str for k,v in headers)
hdr = headers.append
hdr(('Access-Control-Allow-Methods', 'GET, POST'))
hdr(('Access-Control-Allow-Headers', 'Accept, Content-Type'))
try:
hdr(('Access-Control-Allow-Origin', self.headers['Origin']))
except KeyError:
pass
if self.method != 'OPTIONS':
hdr(('Content-Type', content_type))
hdr(('Content-Length', f'{len(data)}'))
hdr(('Cache-Control', 'no-cache'))
return (status, headers, data)
def resp_json(self, /, data, *, status=200, content_type='application/json;charset=UTF-8', headers=()):
return self.resp(
status,
headers,
json.dumps(data).encode('utf-8'),
content_type=content_type,
)
def resp_error(self, status, /):
try:
text = STATUS_TEXT[status]
except KeyError:
text = f'HTTP {status}'
return self.resp(
status,
(),
text.encode('utf-8'),
content_type='text/plain',
)
def resp_404(self, /):
return self.resp_error(404)
def resp_405(self, /):
return self.resp_error(405)
def resp_biss_error(self, /, status, message):
return self.resp_json({
'status': 'failed',
'reasonCode': status,
'reasonText': message,
}, status=status)
def resp_biss_ok(self, /, **kw):
return self.resp_json({
'status': 'ok',
'reasonCode': 200,
'reasonText': 'response.success',
**kw,
})
cr.X509StoreFlags.NO_CHECK_TIME = 0x200000
store = cr.X509Store()
store.set_flags(cr.X509StoreFlags.CRL_CHECK_ALL | cr.X509StoreFlags.X509_STRICT | cr.X509StoreFlags.NO_CHECK_TIME)
store.load_locations('cacerts.pem')
keys = [*pkcs11.list()]
def req_options(req):
return req.resp(200, (), b'', content_type='')
def req_get_version(req):
return req.resp_json({
'version': '3.15',
'httpMethods': 'GET, POST',
'contentTypes': 'data',
'signatureTypes': 'signature',
'selectorAvailable': True,
'hashAlgorithms': 'SHA256, SHA384, SHA512',
})
def req_get_status(req):
return req.resp_json('')
def req_post_getsigner(req):
data = json.loads(req.read_data().decode('utf-8'))
valid_only = data.get('showValidCerts', False)
# WAT
if valid_only == 'true':
valid_only = True
if valid_only == 'false':
valid_only = False
if type(valid_only) is not bool:
return req.resp_biss_error(400, 'error.request.bad-type')
selector = data.get('selector', {})
for key in keys:
if check_selector(key.cert, selector, valid_only):
break
else:
return req.resp_biss_error(403, 'error.user-canceled')
return req.resp_biss_ok(
chain = [
base64.b64encode(key.cert_data).decode('ascii'),
],
)
def req_post_sign(req):
data = json.loads(req.read_data().decode('utf-8'))
try:
own_cert_data = data['signerCertificateB64']
own_cert_data = base64.b64decode(own_cert_data)
except (KeyError, IndexError):
return req.resp_biss_error(400, 'error.wsp-cert-not-found')
for own_key in keys:
if own_key.cert_data == own_cert_data:
break
else:
logging.error('Unknown certificate')
return req.resp_biss_error(400, 'error.request.bad-type')
# BISS ignores it
# if data['contentType'] != 'data':
# return req.resp_biss_error(400, 'error.request.bad-type')
try:
hash_alg = pkcs11.HASH_ALG[data.get('hashAlgorithm', 'SHA256')]
except KeyError:
logging.error('Unknown hash algorithm')
return req.resp_biss_error(400, 'error.request.bad-type')
msgs = []
for i,(msg,sig,server_cert) in enumerate(zip(data['contents'], data['signedContents'], data['signedContentsCert'])):
msg = base64.b64decode(msg)
sig = base64.b64decode(sig)
server_cert = cr.load_certificate(cr.FILETYPE_ASN1, base64.b64decode(server_cert))
try:
# WAT?
cr.verify(server_cert, sig, hashlib.new(hash_alg.hashlib_name, msg).digest(), hash_alg.hashlib_name)
except cr.Error:
return req.resp_biss_error(400, 'error.request.signature-not-val')
verify_ctx = cr.X509StoreContext(store, server_cert, None)
try:
verify_ctx.verify_certificate()
except cr.X509StoreContextError as exc:
if not prompt(f'Server certificate invalid ({exc!s}); continue'):
return req.resp_biss_error(403, 'error.request.certificate-not-valid')
msgs.append((msg, server_cert))
t = data.get('confirmText')
if t is not None:
print_blob('Confirmation text', t)
t = data.get('additionalConfirmText')
if t is not None:
print_blob('Additional confirmation text', t)
for (msg,server_cert) in msgs:
print_blob(f'Message #{1+i}', msg)
print_blob('Server name', describe_cert(server_cert))
if not prompt('Sign'):
return req.resp_biss_error(403, 'error.user-canceled')
own_key.pin = getpass.getpass('PIN: ')
sigs = []
for (msg, server_cert) in msgs:
sigs.append(own_key.sign(msg, hash_alg))
return req.resp_biss_ok(
signatures = [base64.b64encode(sig).decode('ascii') for sig in sigs],
)
def req_post_chain_found(req):
# stub
data = json.loads(req.read_data().decode('utf-8'))
return req.resp_biss_ok(chainFound=True)
def fix_methods(hnd):
assert type(hnd) is dict and all(type(k) is str for k in hnd)
hnd = hnd.copy()
if 'GET' in hnd and 'HEAD' not in hnd:
on_get = hnd['GET']
def on_head(req):
(status, headers, data) = on_get(req)
return (status, headers, None)
hnd['HEAD'] = on_head
hnd['OPTIONS'] = req_options
return hnd
def resp_exc(env, resp, exc):
rdata = (
'<!doctype html><html><head><meta charset="utf-8" /><title>Internal Server Error</title></head><body>'
'<h1>Internal Server Error</h1>'
'</body></html>'
).encode()
resp('500 Internal Server Error', [
('Content-Type', 'text/html;charset=utf-8'),
('Content-Length', f'{len(rdata)}'),
])
return rdata
handlers = {
'/version': {
'GET': req_get_version,
},
'/status': {
'GET': req_get_status,
},
'/getsigner': {
'POST': req_post_getsigner,
},
'/sign': {
'POST': req_post_sign,
},
'/chainFound': {
'POST': req_post_chain_found,
},
}
handlers = {path: fix_methods(sub) for path,sub in handlers.items()}
def application(env, resp):
try:
req = Req(env)
except Exception as exc:
logging.exception('Failed to parse request')
return resp_exc(env, resp, exc)
try:
h = handlers[req.path]
except KeyError:
h = Req.resp_404
else:
try:
h = h[req.method]
except KeyError:
h = Req.resp_405
try:
rcode, rhdr, rdata = h(req)
except Exception as exc:
logging.exception('Request handler failed')
return resp_exc(env, resp, exc)
assert type(rcode) is int
try:
rcode = STATUS_FULL[rcode]
except KeyError:
rcode = f'{rcode}'
resp(rcode, rhdr)
return rdata
tty = os.open('/dev/tty', os.O_RDWR)
os.dup2(tty, 0)
os.dup2(tty, 1)
