44bd587b707d99a4a9cbb424520d5b3bbbe9de5f
[keymanager.git] / src / leap / keymanager / keys.py
1 # -*- coding: utf-8 -*-
2 # keys.py
3 # Copyright (C) 2013 LEAP
4 #
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation, either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18
19 """
20 Abstact key type and encryption scheme representations.
21 """
22
23
24 try:
25     import simplejson as json
26 except ImportError:
27     import json  # noqa
28 import re
29
30
31 from abc import ABCMeta, abstractmethod
32 from leap.common.check import leap_assert
33
34
35 #
36 # Dictionary keys used for storing cryptographic keys.
37 #
38
39 KEY_ADDRESS_KEY = 'address'
40 KEY_TYPE_KEY = 'type'
41 KEY_ID_KEY = 'key_id'
42 KEY_FINGERPRINT_KEY = 'fingerprint'
43 KEY_DATA_KEY = 'key_data'
44 KEY_PRIVATE_KEY = 'private'
45 KEY_LENGTH_KEY = 'length'
46 KEY_EXPIRY_DATE_KEY = 'expiry_date'
47 KEY_FIRST_SEEN_AT_KEY = 'first_seen_at'
48 KEY_LAST_AUDITED_AT_KEY = 'last_audited_at'
49 KEY_VALIDATION_KEY = 'validation'
50 KEY_TAGS_KEY = 'tags'
51
52
53 #
54 # Key storage constants
55 #
56
57 KEYMANAGER_KEY_TAG = 'keymanager-key'
58
59
60 #
61 # key indexing constants.
62 #
63
64 TAGS_PRIVATE_INDEX = 'by-tags-private'
65 TAGS_ADDRESS_PRIVATE_INDEX = 'by-tags-address-private'
66 INDEXES = {
67     TAGS_PRIVATE_INDEX: [
68         KEY_TAGS_KEY,
69         'bool(%s)' % KEY_PRIVATE_KEY,
70     ],
71     TAGS_ADDRESS_PRIVATE_INDEX: [
72         KEY_TAGS_KEY,
73         KEY_ADDRESS_KEY,
74         'bool(%s)' % KEY_PRIVATE_KEY,
75     ]
76 }
77
78
79 #
80 # Key handling utilities
81 #
82
83 def is_address(address):
84     """
85     Return whether the given C{address} is in the form user@provider.
86
87     :param address: The address to be tested.
88     :type address: str
89     :return: Whether C{address} is in the form user@provider.
90     :rtype: bool
91     """
92     return bool(re.match('[\w.-]+@[\w.-]+', address))
93
94
95 def build_key_from_dict(kClass, address, kdict):
96     """
97     Build an C{kClass} key bound to C{address} based on info in C{kdict}.
98
99     :param address: The address bound to the key.
100     :type address: str
101     :param kdict: Dictionary with key data.
102     :type kdict: dict
103     :return: An instance of the key.
104     :rtype: C{kClass}
105     """
106     leap_assert(
107         address == kdict[KEY_ADDRESS_KEY],
108         'Wrong address in key data.')
109     return kClass(
110         address,
111         key_id=kdict[KEY_ID_KEY],
112         fingerprint=kdict[KEY_FINGERPRINT_KEY],
113         key_data=kdict[KEY_DATA_KEY],
114         private=kdict[KEY_PRIVATE_KEY],
115         length=kdict[KEY_LENGTH_KEY],
116         expiry_date=kdict[KEY_EXPIRY_DATE_KEY],
117         first_seen_at=kdict[KEY_FIRST_SEEN_AT_KEY],
118         last_audited_at=kdict[KEY_LAST_AUDITED_AT_KEY],
119         validation=kdict[KEY_VALIDATION_KEY],  # TODO: verify for validation.
120     )
121
122
123 #
124 # Abstraction for encryption keys
125 #
126
127 class EncryptionKey(object):
128     """
129     Abstract class for encryption keys.
130
131     A key is "validated" if the nicknym agent has bound the user address to a
132     public key. Nicknym supports three different levels of key validation:
133
134     * Level 3 - path trusted: A path of cryptographic signatures can be traced
135       from a trusted key to the key under evaluation. By default, only the
136       provider key from the user's provider is a "trusted key".
137     * level 2 - provider signed: The key has been signed by a provider key for
138       the same domain, but the provider key is not validated using a trust
139       path (i.e. it is only registered)
140     * level 1 - registered: The key has been encountered and saved, it has no
141       signatures (that are meaningful to the nicknym agent).
142     """
143
144     __metaclass__ = ABCMeta
145
146     def __init__(self, address, key_id=None, fingerprint=None,
147                  key_data=None, private=None, length=None, expiry_date=None,
148                  validation=None, first_seen_at=None, last_audited_at=None):
149         self.address = address
150         self.key_id = key_id
151         self.fingerprint = fingerprint
152         self.key_data = key_data
153         self.private = private
154         self.length = length
155         self.expiry_date = expiry_date
156         self.validation = validation
157         self.first_seen_at = first_seen_at
158         self.last_audited_at = last_audited_at
159
160     def get_json(self):
161         """
162         Return a JSON string describing this key.
163
164         :return: The JSON string describing this key.
165         :rtype: str
166         """
167         return json.dumps({
168             KEY_ADDRESS_KEY: self.address,
169             KEY_TYPE_KEY: str(self.__class__),
170             KEY_ID_KEY: self.key_id,
171             KEY_FINGERPRINT_KEY: self.fingerprint,
172             KEY_DATA_KEY: self.key_data,
173             KEY_PRIVATE_KEY: self.private,
174             KEY_LENGTH_KEY: self.length,
175             KEY_EXPIRY_DATE_KEY: self.expiry_date,
176             KEY_VALIDATION_KEY: self.validation,
177             KEY_FIRST_SEEN_AT_KEY: self.first_seen_at,
178             KEY_LAST_AUDITED_AT_KEY: self.last_audited_at,
179             KEY_TAGS_KEY: [KEYMANAGER_KEY_TAG],
180         })
181
182     def __repr__(self):
183         """
184         Representation of this class
185         """
186         return u"<%s 0x%s (%s - %s)>" % (
187             self.__class__.__name__,
188             self.key_id,
189             self.address,
190             "priv" if self.private else "publ")
191
192
193 #
194 # Encryption schemes
195 #
196
197 class EncryptionScheme(object):
198     """
199     Abstract class for Encryption Schemes.
200
201     A wrapper for a certain encryption schemes should know how to get and put
202     keys in local storage using Soledad, how to generate new keys and how to
203     find out about possibly encrypted content.
204     """
205
206     __metaclass__ = ABCMeta
207
208     def __init__(self, soledad):
209         """
210         Initialize this Encryption Scheme.
211
212         :param soledad: A Soledad instance for local storage of keys.
213         :type soledad: leap.soledad.Soledad
214         """
215         self._soledad = soledad
216         self._init_indexes()
217
218     def _init_indexes(self):
219         """
220         Initialize the database indexes.
221         """
222         # Ask the database for currently existing indexes.
223         db_indexes = dict(self._soledad.list_indexes())
224         # Loop through the indexes we expect to find.
225         for name, expression in INDEXES.items():
226             if name not in db_indexes:
227                 # The index does not yet exist.
228                 self._soledad.create_index(name, *expression)
229                 continue
230             if expression == db_indexes[name]:
231                 # The index exists and is up to date.
232                 continue
233             # The index exists but the definition is not what expected, so we
234             # delete it and add the proper index expression.
235             self._soledad.delete_index(name)
236             self._soledad.create_index(name, *expression)
237
238     @abstractmethod
239     def get_key(self, address, private=False):
240         """
241         Get key from local storage.
242
243         :param address: The address bound to the key.
244         :type address: str
245         :param private: Look for a private key instead of a public one?
246         :type private: bool
247
248         :return: The key bound to C{address}.
249         :rtype: EncryptionKey
250         @raise KeyNotFound: If the key was not found on local storage.
251         """
252         pass
253
254     @abstractmethod
255     def put_key(self, key):
256         """
257         Put a key in local storage.
258
259         :param key: The key to be stored.
260         :type key: EncryptionKey
261         """
262         pass
263
264     @abstractmethod
265     def gen_key(self, address):
266         """
267         Generate a new key.
268
269         :param address: The address bound to the key.
270         :type address: str
271
272         :return: The key bound to C{address}.
273         :rtype: EncryptionKey
274         """
275         pass
276
277     @abstractmethod
278     def delete_key(self, key):
279         """
280         Remove C{key} from storage.
281
282         :param key: The key to be removed.
283         :type key: EncryptionKey
284         """
285         pass