Debian Codegraph @

ipaserver/custodia/message/kem.py

raw
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)