1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
# -*- coding: utf-8 -*-
# shared_db.py
# Copyright (C) 2013 LEAP
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
A shared database for storing/retrieving encrypted key material.
"""
try:
import simplejson as json
except ImportError:
import json # noqa
from u1db import errors
from u1db.remote import http_database
#-----------------------------------------------------------------------------
# Soledad shared database
#-----------------------------------------------------------------------------
class NoTokenForAuth(Exception):
"""
No token was found for token-based authentication.
"""
class Unauthorized(Exception):
"""
User does not have authorization to perform task.
"""
class SoledadSharedDatabase(http_database.HTTPDatabase):
"""
This is a shared remote database that holds users' encrypted keys.
An authorization token is attached to every request other than
get_doc_unauth, which has the purpose of retrieving encrypted content from
the shared database without the need to associate user information with
the request.
"""
# TODO: prevent client from messing with the shared DB.
# TODO: define and document API.
@staticmethod
def open_database(url, create, token=None):
# TODO: users should not be able to create the shared database, so we
# have to remove this from here in the future.
"""
Open a Soledad shared database.
@param url: URL of the remote database.
@type url: str
@param create: Should the database be created if it does not already
exist?
@type create: bool
@param token: An authentication token for accessing the shared db.
@type token: str
@return: The shared database in the given url.
@rtype: SoledadSharedDatabase
"""
db = SoledadSharedDatabase(url, token=token)
db.open(create)
return db
@staticmethod
def delete_database(url):
"""
Dummy method that prevents from deleting shared database.
@raise: This will always raise an Unauthorized exception.
@param url: The database URL.
@type url: str
"""
raise Unauthorized("Can't delete shared database.")
def __init__(self, url, document_factory=None, creds=None, token=None):
"""
Initialize database with auth token and encryption powers.
@param url: URL of the remote database.
@type url: str
@param document_factory: A factory for U1BD documents.
@type document_factory: u1db.Document
@param creds: A tuple containing the authentication method and
credentials.
@type creds: tuple
@param token: An authentication token for accessing the shared db.
@type token: str
"""
self._token = token
http_database.HTTPDatabase.__init__(self, url, document_factory,
creds)
def _request(self, method, url_parts, params=None, body=None,
content_type=None, auth=True):
"""
Perform token-based http request.
@param method: The HTTP method for the request.
@type method: str
@param url_parts: A list with extra parts for the URL.
@type url_parts: list
@param params: Parameters to be added as query string.
@type params: dict
@param body: The body of the request (must be JSON serializable).
@type body: object
@param content_type: The content-type of the request.
@type content_type: str
@param auth: Should the request be authenticated?
@type auth: bool
@raise u1db.errors.Unavailable: If response status is 503.
@raise u1db.errors.HTTPError: If response status is neither 200, 201
or 503
@return: The headers and body of the HTTP response.
@rtype: tuple
"""
# add `auth-token` as a request parameter
if auth:
if not self._token:
raise NoTokenForAuth()
if not params:
params = {}
params['auth_token'] = self._token
return http_database.HTTPDatabase._request(
self,
method, url_parts,
params,
body,
content_type)
def _request_json(self, method, url_parts, params=None, body=None,
content_type=None, auth=True):
"""
Perform token-based http request and deserialize the JSON results.
@param method: The HTTP method for the request.
@type method: str
@param url_parts: A list with extra parts for the URL.
@type url_parts: list
@param params: Parameters to be added as query string.
@type params: dict
@param body: The body of the request (must be JSON serializable).
@type body: object
@param content_type: The content-type of the request.
@type content_type: str
@param auth: Should the request be authenticated?
@type auth: bool
@raise u1db.errors.Unavailable: If response status is 503.
@raise u1db.errors.HTTPError: If response status is neither 200, 201
or 503
@return: The headers and body of the HTTP response.
@rtype: tuple
"""
# allow for token-authenticated requests.
res, headers = self._request(method, url_parts,
params=params, body=body,
content_type=content_type, auth=auth)
return json.loads(res), headers
def get_doc_unauth(self, doc_id):
"""
Modified method to allow for unauth request.
This is the only (public) way to make an unauthenticaded request on
the shared database.
@param doc_id: The document id.
@type doc_id: str
@return: The requested document.
@rtype: Document
"""
db = http_database.HTTPDatabase(self._url.geturl(),
document_factory=self._factory)
return db.get_doc(doc_id)
|
