diff options
Diffstat (limited to '__init__.py')
| -rw-r--r-- | __init__.py | 451 |
1 files changed, 0 insertions, 451 deletions
diff --git a/__init__.py b/__init__.py deleted file mode 100644 index 86eb762e..00000000 --- a/__init__.py +++ /dev/null @@ -1,451 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Soledad - Synchronization Of Locally Encrypted Data Among Devices. - -Soledad is the part of LEAP that manages storage and synchronization of -application data. It is built on top of U1DB reference Python API and -implements (1) a SQLCipher backend for local storage in the client, (2) a -SyncTarget that encrypts data to the user's private OpenPGP key before -syncing, and (3) a CouchDB backend for remote storage in the server side. -""" - -import os -import string -import random -import hmac -import configparser -import re -try: - import simplejson as json -except ImportError: - import json # noqa -from leap.soledad.backends import sqlcipher -from leap.soledad.util import GPGWrapper -from leap.soledad.backends.leap_backend import ( - LeapDocument, - DocumentNotEncrypted, -) -from leap.soledad.shared_db import SoledadSharedDatabase - - -class KeyDoesNotExist(Exception): - """ - Soledad attempted to find a key that does not exist locally. - """ - - -class KeyAlreadyExists(Exception): - """ - Soledad attempted to create a key that already exists locally. - """ - - -#----------------------------------------------------------------------------- -# Soledad: local encrypted storage and remote encrypted sync. -#----------------------------------------------------------------------------- - -class Soledad(object): - """ - Soledad provides encrypted data storage and sync. - - A Soledad instance is used to store and retrieve data in a local encrypted - database and synchronize this database with Soledad server. - - This class is also responsible for bootstrapping users' account by - creating OpenPGP keys and other cryptographic secrets and/or - storing/fetching them on Soledad server. - """ - - # other configs - SECRET_LENGTH = 50 - DEFAULT_CONF = { - 'gnupg_home': '%s/gnupg', - 'secret_path': '%s/secret.gpg', - 'local_db_path': '%s/soledad.u1db', - 'config_file': '%s/soledad.ini', - 'shared_db_url': '', - } - - def __init__(self, user_email, prefix=None, gnupg_home=None, - secret_path=None, local_db_path=None, - config_file=None, shared_db_url=None, auth_token=None, - initialize=True): - """ - Bootstrap Soledad, initialize cryptographic material and open - underlying U1DB database. - """ - self._user_email = user_email - self._auth_token = auth_token - self._init_config( - {'prefix': prefix, - 'gnupg_home': gnupg_home, - 'secret_path': secret_path, - 'local_db_path': local_db_path, - 'config_file': config_file, - 'shared_db_url': shared_db_url, - } - ) - if self.shared_db_url: - # TODO: eliminate need to create db here. - self._shared_db = SoledadSharedDatabase.open_database( - shared_db_url, - True, - token=auth_token) - if initialize: - self._bootstrap() - - def _bootstrap(self): - """ - Bootstrap local Soledad instance. - - There are 3 stages for Soledad Client bootstrap: - - 1. No key material has been generated, so we need to generate and - upload to the server. - - 2. Key material has already been generated and uploaded to the - server, but has not been downloaded to this device/installation - yet. - - 3. Key material has already been generated and uploaded, and is - also stored locally, so we just need to load it from disk. - - This method decides which bootstrap stage has to be performed and - performs it. - """ - # TODO: make sure key storage always happens (even if this method is - # interrupted). - # TODO: write tests for bootstrap stages. - self._init_dirs() - self._gpg = GPGWrapper(gnupghome=self.gnupg_home) - if not self._has_keys(): - try: - # stage 2 bootstrap - self._retrieve_keys() - except Exception: - # stage 1 bootstrap - self._init_keys() - # TODO: change key below - self._send_keys(self._secret) - # stage 3 bootstrap - self._load_keys() - self._send_keys(self._secret) - self._init_db() - - def _init_config(self, param_conf): - """ - Initialize configuration, with precedence order give by: instance - parameters > config file > default values. - """ - # TODO: write tests for _init_config() - self.prefix = param_conf['prefix'] or \ - os.environ['HOME'] + '/.config/leap/soledad' - m = re.compile('.*%s.*') - for key, default_value in self.DEFAULT_CONF.iteritems(): - val = param_conf[key] or default_value - if m.match(val): - val = val % self.prefix - setattr(self, key, val) - # get config from file - # TODO: sanitize options from config file. - config = configparser.ConfigParser() - config.read(self.config_file) - if 'soledad-client' in config: - for key in default_conf: - if key in config['soledad-client'] and not param_conf[key]: - setattr(self, key, config['soledad-client'][key]) - - def _init_dirs(self): - """ - Create work directories. - """ - if not os.path.isdir(self.prefix): - os.makedirs(self.prefix) - - def _init_keys(self): - """ - Generate (if needed) and load OpenPGP keypair and secret for symmetric - encryption. - """ - # TODO: write tests for methods below. - # load/generate OpenPGP keypair - if not self._has_openpgp_keypair(): - self._gen_openpgp_keypair() - self._load_openpgp_keypair() - # load/generate secret - if not self._has_secret(): - self._gen_secret() - self._load_secret() - - def _init_db(self): - """ - Initialize the database for local storage . - """ - # instantiate u1db - # TODO: verify if secret for sqlcipher should be the same as the - # one for symmetric encryption. - self._db = sqlcipher.open( - self.local_db_path, - self._secret, - create=True, - document_factory=LeapDocument, - soledad=self) - - def close(self): - """ - Close underlying U1DB database. - """ - self._db.close() - - #------------------------------------------------------------------------- - # Management of secret for symmetric encryption - #------------------------------------------------------------------------- - - # TODO: refactor the following methods to somewhere out of here - # (SoledadCrypto, maybe?) - - def _has_secret(self): - """ - Verify if secret for symmetric encryption exists in a local encrypted - file. - """ - # does the file exist in disk? - if not os.path.isfile(self.secret_path): - return False - # is it asymmetrically encrypted? - f = open(self.secret_path, 'r') - content = f.read() - if not self.is_encrypted_asym(content): - raise DocumentNotEncrypted( - "File %s is not encrypted!" % self.secret_path) - # can we decrypt it? - fp = self._gpg.encrypted_to(content)['fingerprint'] - if fp != self._fingerprint: - raise KeyDoesNotExist("Secret for symmetric encryption is " - "encrypted to key with fingerprint '%s' " - "which we don't have." % fp) - return True - - def _load_secret(self): - """ - Load secret for symmetric encryption from local encrypted file. - """ - if not self._has_secret(): - raise KeyDoesNotExist("Tried to load key for symmetric " - "encryption but it does not exist on disk.") - try: - with open(self.secret_path) as f: - self._secret = str(self._gpg.decrypt(f.read())) - except IOError: - raise IOError('Failed to open secret file %s.' % self.secret_path) - - def _gen_secret(self): - """ - Generate a secret for symmetric encryption and store in a local - encrypted file. - """ - if self._has_secret(): - raise KeyAlreadyExists("Tried to generate secret for symmetric " - "encryption but it already exists on " - "disk.") - self._secret = ''.join( - random.choice( - string.ascii_letters + - string.digits) for x in range(self.SECRET_LENGTH)) - ciphertext = self._gpg.encrypt(self._secret, self._fingerprint, - self._fingerprint) - f = open(self.secret_path, 'w') - f.write(str(ciphertext)) - f.close() - - #------------------------------------------------------------------------- - # Management of OpenPGP keypair - #------------------------------------------------------------------------- - - def _has_openpgp_keypair(self): - """ - Verify if there exists an OpenPGP keypair for this user. - """ - try: - self._load_openpgp_keypair() - return True - except: - return False - - def _gen_openpgp_keypair(self): - """ - Generate an OpenPGP keypair for this user. - """ - if self._has_openpgp_keypair(): - raise KeyAlreadyExists("Tried to generate OpenPGP keypair but it " - "already exists on disk.") - params = self._gpg.gen_key_input( - key_type='RSA', - key_length=4096, - name_real=self._user_email, - name_email=self._user_email, - name_comment='Generated by LEAP Soledad.') - self._gpg.gen_key(params) - - def _load_openpgp_keypair(self): - """ - Find fingerprint for this user's OpenPGP keypair. - """ - # TODO: verify if we have the corresponding private key. - try: - self._fingerprint = self._gpg.find_key_by_email( - self._user_email, - secret=True)['fingerprint'] - return self._fingerprint - except LookupError: - raise KeyDoesNotExist("Tried to load OpenPGP keypair but it does " - "not exist on disk.") - - def publish_pubkey(self, keyserver): - """ - Publish OpenPGP public key to a keyserver. - """ - # TODO: this has to talk to LEAP's Nickserver. - pass - - #------------------------------------------------------------------------- - # General crypto utility methods. - #------------------------------------------------------------------------- - - def _has_keys(self): - return self._has_openpgp_keypair() and self._has_secret() - - def _load_keys(self): - self._load_openpgp_keypair() - self._load_secret() - - def _gen_keys(self): - self._gen_openpgp_keypair() - self._gen_secret() - - def _user_hash(self): - return hmac.new(self._user_email, 'user').hexdigest() - - def _retrieve_keys(self): - return self._shared_db.get_doc_unauth(self._user_hash()) - # TODO: create corresponding error on server side - - def _send_keys(self, passphrase): - # TODO: change this method's name to something more meaningful. - privkey = self._gpg.export_keys(self._fingerprint, secret=True) - content = { - '_privkey': self.encrypt(privkey, passphrase=passphrase, - symmetric=True), - '_symkey': self.encrypt(self._secret), - } - doc = self._retrieve_keys() - if not doc: - doc = LeapDocument(doc_id=self._user_hash(), soledad=self) - doc.content = content - self._shared_db.put_doc(doc) - - #------------------------------------------------------------------------- - # Data encryption and decryption - #------------------------------------------------------------------------- - - def encrypt(self, data, sign=None, passphrase=None, symmetric=False): - """ - Encrypt data. - """ - return str(self._gpg.encrypt(data, self._fingerprint, sign=sign, - passphrase=passphrase, - symmetric=symmetric)) - - def encrypt_symmetric(self, doc_id, data, sign=None): - """ - Encrypt data using symmetric secret. - """ - return self.encrypt(data, sign=sign, - passphrase=self._hmac_passphrase(doc_id), - symmetric=True) - - def decrypt(self, data, passphrase=None, symmetric=False): - """ - Decrypt data. - """ - return str(self._gpg.decrypt(data, passphrase=passphrase)) - - def decrypt_symmetric(self, doc_id, data): - """ - Decrypt data using symmetric secret. - """ - return self.decrypt(data, passphrase=self._hmac_passphrase(doc_id)) - - def _hmac_passphrase(self, doc_id): - return hmac.new(self._secret, doc_id).hexdigest() - - def is_encrypted(self, data): - return self._gpg.is_encrypted(data) - - def is_encrypted_sym(self, data): - return self._gpg.is_encrypted_sym(data) - - def is_encrypted_asym(self, data): - return self._gpg.is_encrypted_asym(data) - - #------------------------------------------------------------------------- - # Document storage, retrieval and sync - #------------------------------------------------------------------------- - - # TODO: refactor the following methods to somewhere out of here - # (SoledadLocalDatabase, maybe?) - - def put_doc(self, doc): - """ - Update a document in the local encrypted database. - """ - return self._db.put_doc(doc) - - def delete_doc(self, doc): - """ - Delete a document from the local encrypted database. - """ - return self._db.delete_doc(doc) - - def get_doc(self, doc_id, include_deleted=False): - """ - Retrieve a document from the local encrypted database. - """ - return self._db.get_doc(doc_id, include_deleted=include_deleted) - - def get_docs(self, doc_ids, check_for_conflicts=True, - include_deleted=False): - """ - Get the content for many documents. - """ - return self._db.get_docs(doc_ids, - check_for_conflicts=check_for_conflicts, - include_deleted=include_deleted) - - def create_doc(self, content, doc_id=None): - """ - Create a new document in the local encrypted database. - """ - return self._db.create_doc(content, doc_id=doc_id) - - def get_doc_conflicts(self, doc_id): - """ - Get the list of conflicts for the given document. - """ - return self._db.get_doc_conflicts(doc_id) - - def resolve_doc(self, doc, conflicted_doc_revs): - """ - Mark a document as no longer conflicted. - """ - return self._db.resolve_doc(doc, conflicted_doc_revs) - - def sync(self, url): - """ - Synchronize the local encrypted database with LEAP server. - """ - # TODO: create authentication scheme for sync with server. - return self._db.sync(url, creds=None, autocreate=True) - - -__all__ = ['util', 'server', 'shared_db'] |