Move source files to subfolder.

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']