| 1 |
# Copyright (C) 2015 Custodia Project Contributors - see LICENSE file |
| 2 |
from __future__ import absolute_import |
| 3 |
|
| 4 |
import os |
| 5 |
import time |
| 6 |
|
| 7 |
from jwcrypto.common import json_decode |
| 8 |
from jwcrypto.common import json_encode |
| 9 |
from jwcrypto.jwe import JWE |
| 10 |
from jwcrypto.jwk import JWK |
| 11 |
from jwcrypto.jws import JWS |
| 12 |
from jwcrypto.jwt import JWT |
| 13 |
|
| 14 |
from ipaserver.custodia.httpd.authorizers import SimplePathAuthz |
| 15 |
from ipaserver.custodia.log import getLogger |
| 16 |
from ipaserver.custodia.message.common import InvalidMessage |
| 17 |
from ipaserver.custodia.message.common import MessageHandler |
| 18 |
|
| 19 |
logger = getLogger(__name__) |
| 20 |
|
| 21 |
KEY_USAGE_SIG = 0 |
| 22 |
KEY_USAGE_ENC = 1 |
| 23 |
KEY_USAGE_MAP = {KEY_USAGE_SIG: 'sig', KEY_USAGE_ENC: 'enc'} |
| 24 |
|
| 25 |
|
| 26 |
class UnknownPublicKey(Exception): |
| 27 |
def __init__(self, message=None): |
| 28 |
logger.debug(message) |
| 29 |
super(UnknownPublicKey, self).__init__(message) |
| 30 |
|
| 31 |
|
| 32 |
class KEMKeysStore(SimplePathAuthz): |
| 33 |
"""A KEM Keys Store. |
| 34 |
|
| 35 |
This is a store that holds public keys of registered |
| 36 |
clients allowed to use KEM messages. It takes the form |
| 37 |
of an authorizer merely for the purpose of attaching |
| 38 |
itself to a 'request' so that later on the KEM Parser |
| 39 |
can fetch the appropriate key to verify/decrypt an |
| 40 |
incoming request and make the payload available. |
| 41 |
|
| 42 |
The KEM Parser will actually perform additional |
| 43 |
authorization checks in this case. |
| 44 |
|
| 45 |
SimplePathAuthz is extended here as we ant to attach the |
| 46 |
store only to requests on paths we are configured to |
| 47 |
manage. |
| 48 |
""" |
| 49 |
|
| 50 |
def __init__(self, config): |
| 51 |
super(KEMKeysStore, self).__init__(config) |
| 52 |
self._server_keys = None |
| 53 |
self._alg = None |
| 54 |
self._enc = None |
| 55 |
|
| 56 |
def _db_key(self, kid): |
| 57 |
return os.path.join('kemkeys', kid) |
| 58 |
|
| 59 |
def handle(self, request): |
| 60 |
inpath = super(KEMKeysStore, self).handle(request) |
| 61 |
if inpath: |
| 62 |
request['KEMKeysStore'] = self |
| 63 |
return inpath |
| 64 |
|
| 65 |
def find_key(self, kid, usage): |
| 66 |
dbkey = self._db_key('%s/%s' % (KEY_USAGE_MAP[usage], kid)) |
| 67 |
pubkey = self.store.get(dbkey) |
| 68 |
if pubkey is None: |
| 69 |
raise UnknownPublicKey(kid) |
| 70 |
return pubkey |
| 71 |
|
| 72 |
@property |
| 73 |
def server_keys(self): |
| 74 |
if self._server_keys is None: |
| 75 |
if 'server_keys' not in self.config: |
| 76 |
raise UnknownPublicKey("Server Keys not defined") |
| 77 |
skey = self.find_key(self.config['server_keys'], KEY_USAGE_SIG) |
| 78 |
ekey = self.find_key(self.config['server_keys'], KEY_USAGE_ENC) |
| 79 |
self._server_keys = [JWK(**(json_decode(skey))), |
| 80 |
JWK(**(json_decode(ekey)))] |
| 81 |
return self._server_keys |
| 82 |
|
| 83 |
@property |
| 84 |
def alg(self): |
| 85 |
if self._alg is None: |
| 86 |
alg = self.config.get('signing_algorithm', None) |
| 87 |
if alg is None: |
| 88 |
ktype = self.server_keys[KEY_USAGE_SIG]['kty'] |
| 89 |
if ktype == 'RSA': |
| 90 |
alg = 'RS256' |
| 91 |
elif ktype == 'EC': |
| 92 |
alg = 'ES256' |
| 93 |
else: |
| 94 |
raise ValueError('Key type unsupported for signing') |
| 95 |
self._alg = alg |
| 96 |
return self._alg |
| 97 |
|
| 98 |
|
| 99 |
def check_kem_claims(claims, name): |
| 100 |
if 'sub' not in claims: |
| 101 |
raise InvalidMessage('Missing subject in payload') |
| 102 |
if claims['sub'] != name: |
| 103 |
raise InvalidMessage('Key name %s does not match subject %s' % ( |
| 104 |
name, claims['sub'])) |
| 105 |
if 'exp' not in claims: |
| 106 |
raise InvalidMessage('Missing expiration time in payload') |
| 107 |
if claims['exp'] - (10 * 60) > int(time.time()): |
| 108 |
raise InvalidMessage('Message expiration too far in the future') |
| 109 |
if claims['exp'] < int(time.time()): |
| 110 |
raise InvalidMessage('Message Expired') |
| 111 |
|
| 112 |
|
| 113 |
class KEMHandler(MessageHandler): |
| 114 |
"""Handles 'kem' messages""" |
| 115 |
|
| 116 |
def __init__(self, request): |
| 117 |
super(KEMHandler, self).__init__(request) |
| 118 |
self.kkstore = self.req.get('KEMKeysStore', None) |
| 119 |
if self.kkstore is None: |
| 120 |
raise Exception('KEM KeyStore not configured') |
| 121 |
self.client_keys = None |
| 122 |
self.name = None |
| 123 |
|
| 124 |
def _get_key(self, header, usage): |
| 125 |
if 'kid' not in header: |
| 126 |
raise InvalidMessage("Missing key identifier") |
| 127 |
|
| 128 |
key = self.kkstore.find_key(header.get('kid'), usage) |
| 129 |
if key is None: |
| 130 |
raise UnknownPublicKey('Key found [kid:%s]' % header.get('kid')) |
| 131 |
return json_decode(key) |
| 132 |
|
| 133 |
def parse(self, msg, name): |
| 134 |
"""Parses the message. |
| 135 |
|
| 136 |
We check that the message is properly formatted. |
| 137 |
|
| 138 |
:param msg: a json-encoded value containing a JWS or JWE+JWS token |
| 139 |
|
| 140 |
:raises InvalidMessage: if the message cannot be parsed or validated |
| 141 |
|
| 142 |
:returns: A verified payload |
| 143 |
""" |
| 144 |
|
| 145 |
try: |
| 146 |
jtok = JWT(jwt=msg) |
| 147 |
except Exception as e: |
| 148 |
raise InvalidMessage('Failed to parse message: %s' % str(e)) |
| 149 |
|
| 150 |
try: |
| 151 |
token = jtok.token |
| 152 |
if isinstance(token, JWE): |
| 153 |
token.decrypt(self.kkstore.server_keys[KEY_USAGE_ENC]) |
| 154 |
# If an encrypted payload is received then there must be |
| 155 |
# a nested signed payload to verify the provenance. |
| 156 |
payload = token.payload.decode('utf-8') |
| 157 |
token = JWS() |
| 158 |
token.deserialize(payload) |
| 159 |
elif isinstance(token, JWS): |
| 160 |
pass |
| 161 |
else: |
| 162 |
raise TypeError("Invalid Token type: %s" % type(jtok)) |
| 163 |
|
| 164 |
# Retrieve client keys for later use |
| 165 |
self.client_keys = [ |
| 166 |
JWK(**self._get_key(token.jose_header, KEY_USAGE_SIG)), |
| 167 |
JWK(**self._get_key(token.jose_header, KEY_USAGE_ENC))] |
| 168 |
|
| 169 |
# verify token and get payload |
| 170 |
token.verify(self.client_keys[KEY_USAGE_SIG]) |
| 171 |
claims = json_decode(token.payload) |
| 172 |
except Exception as e: |
| 173 |
logger.debug('Failed to validate message', exc_info=True) |
| 174 |
raise InvalidMessage('Failed to validate message: %s' % str(e)) |
| 175 |
|
| 176 |
check_kem_claims(claims, name) |
| 177 |
self.name = name |
| 178 |
self.payload = claims.get('value') |
| 179 |
self.msg_type = 'kem' |
| 180 |
|
| 181 |
return {'type': self.msg_type, |
| 182 |
'value': {'kid': self.client_keys[KEY_USAGE_ENC].get('kid'), |
| 183 |
'claims': claims}} |
| 184 |
|
| 185 |
def reply(self, output): |
| 186 |
if self.client_keys is None: |
| 187 |
raise UnknownPublicKey("Peer key not defined") |
| 188 |
|
| 189 |
ktype = self.client_keys[KEY_USAGE_ENC]['kty'] |
| 190 |
if ktype == 'RSA': |
| 191 |
enc = ('RSA-OAEP', 'A256CBC-HS512') |
| 192 |
else: |
| 193 |
raise ValueError("'%s' type not supported yet" % ktype) |
| 194 |
|
| 195 |
value = make_enc_kem(self.name, output, |
| 196 |
self.kkstore.server_keys[KEY_USAGE_SIG], |
| 197 |
self.kkstore.alg, |
| 198 |
self.client_keys[1], enc) |
| 199 |
|
| 200 |
return {'type': 'kem', 'value': value} |
| 201 |
|
| 202 |
|
| 203 |
class KEMClient: |
| 204 |
|
| 205 |
def __init__(self, server_keys, client_keys): |
| 206 |
self.server_keys = server_keys |
| 207 |
self.client_keys = client_keys |
| 208 |
|
| 209 |
def make_request(self, name, value=None, alg="RS256", encalg=None): |
| 210 |
if encalg is None: |
| 211 |
return make_sig_kem(name, value, |
| 212 |
self.client_keys[KEY_USAGE_SIG], alg) |
| 213 |
else: |
| 214 |
return make_enc_kem(name, value, |
| 215 |
self.client_keys[KEY_USAGE_SIG], alg, |
| 216 |
self.server_keys[KEY_USAGE_ENC], encalg) |
| 217 |
|
| 218 |
def parse_reply(self, name, message): |
| 219 |
claims = decode_enc_kem(message, |
| 220 |
self.client_keys[KEY_USAGE_ENC], |
| 221 |
self.server_keys[KEY_USAGE_SIG]) |
| 222 |
check_kem_claims(claims, name) |
| 223 |
return claims['value'] |
| 224 |
|
| 225 |
|
| 226 |
def make_sig_kem(name, value, key, alg): |
| 227 |
header = {'kid': key.get('kid'), 'alg': alg} |
| 228 |
claims = {'sub': name, 'exp': int(time.time() + (5 * 60))} |
| 229 |
if value is not None: |
| 230 |
claims['value'] = value |
| 231 |
jwt = JWT(header, claims) |
| 232 |
jwt.make_signed_token(key) |
| 233 |
return jwt.serialize(compact=True) |
| 234 |
|
| 235 |
|
| 236 |
def make_enc_kem(name, value, sig_key, alg, enc_key, enc): |
| 237 |
plaintext = make_sig_kem(name, value, sig_key, alg) |
| 238 |
eprot = {'kid': enc_key.get('kid'), 'alg': enc[0], 'enc': enc[1]} |
| 239 |
jwe = JWE(plaintext, json_encode(eprot)) |
| 240 |
jwe.add_recipient(enc_key) |
| 241 |
return jwe.serialize(compact=True) |
| 242 |
|
| 243 |
|
| 244 |
def decode_enc_kem(message, enc_key, sig_key): |
| 245 |
jwe = JWT(jwt=message, key=enc_key) |
| 246 |
jws = JWT(jwt=jwe.claims, key=sig_key) |
| 247 |
return json_decode(jws.claims) |