def initialize_soledad(tempdir, uuid): if os.path.isdir(tempdir): shutil.rmtree(tempdir) passphrase = u"verysecretpassphrase" secret_path = os.path.join(tempdir, "secret.gpg") local_db_path = os.path.join(tempdir, "soledad.u1db") server_url = "http://provider" cert_file = "" class MockSharedDB(object): get_doc = Mock(return_value=None) put_doc = Mock() lock = Mock(return_value=('atoken', 300)) unlock = Mock(return_value=True) close = Mock() def __call__(self): return self Soledad._shared_db = MockSharedDB() _soledad = Soledad( uuid, passphrase, secret_path, local_db_path, server_url, cert_file, defer_encryption=False, syncable=False) yield SoledadMailAdaptor().initialize_store(_soledad) defer.returnValue(_soledad)
def _soledad_instance(self, uuid, passphrase, secrets_path, local_db_path, server_url, cert_file): """ Return a Soledad instance for tests. """ # mock key fetching and storing so Soledad doesn't fail when trying to # reach the server. Soledad._fetch_keys_from_shared_db = Mock(return_value=None) Soledad._assert_keys_in_shared_db = Mock(return_value=None) # instantiate soledad def _put_doc_side_effect(doc): self._doc_put = doc class MockSharedDB(object): get_doc = Mock(return_value=None) put_doc = Mock(side_effect=_put_doc_side_effect) lock = Mock(return_value=('atoken', 300)) unlock = Mock(return_value=True) def __call__(self): return self Soledad._shared_db = MockSharedDB() return Soledad( uuid, passphrase, secrets_path=secrets_path, local_db_path=local_db_path, server_url=server_url, cert_file=cert_file, )
def setUp(self): self.gpg_binary_path = get_gpg_bin_path() # TODO: we pass a fake shared database to soledad because we don't want # it o try to reach network to lookup a stored secret in the shared # database. This logic still has to be improved in soledad itself to # account for tests, and when that is done we can remove this from # here. class FakeSharedDb(object): def get_doc(self, doc_id): return None def put_doc(self, doc): return None self._soledad = Soledad( u"*****@*****.**", u"123456", secrets_path=self.tempdir + "/secret.gpg", local_db_path=self.tempdir + "/soledad.u1db", server_url='', cert_file=None, auth_token=None, shared_db=FakeSharedDb(), )
def _soledad_instance(self, user=ADDRESS, passphrase=u'123', prefix='', secrets_path='secrets.json', local_db_path='soledad.u1db', server_url='https://127.0.0.1/', cert_file=None, shared_db_class=None, auth_token='auth-token'): def _put_doc_side_effect(doc): self._doc_put = doc if shared_db_class is not None: MockSharedDB = shared_db_class else: MockSharedDB = self.get_default_shared_mock(_put_doc_side_effect) soledad = Soledad( user, passphrase, secrets_path=os.path.join(self.tempdir, prefix, secrets_path), local_db_path=os.path.join(self.tempdir, prefix, local_db_path), server_url=server_url, # Soledad will fail if not given an url. cert_file=cert_file, defer_encryption=self.defer_sync_encryption, shared_db=MockSharedDB(), auth_token=auth_token) self.addCleanup(soledad.close) return soledad
def _soledad_instance(self, user=ADDRESS, passphrase=u'123', prefix='', secrets_path=Soledad.STORAGE_SECRETS_FILE_NAME, local_db_path='soledad.u1db', server_url='', cert_file=None, secret_id=None, shared_db_class=None): def _put_doc_side_effect(doc): self._doc_put = doc if shared_db_class is not None: MockSharedDB = shared_db_class else: MockSharedDB = self.get_default_shared_mock(_put_doc_side_effect) Soledad._shared_db = MockSharedDB() return Soledad( user, passphrase, secrets_path=os.path.join(self.tempdir, prefix, secrets_path), local_db_path=os.path.join(self.tempdir, prefix, local_db_path), server_url=server_url, # Soledad will fail if not given an url. cert_file=cert_file, secret_id=secret_id, defer_encryption=self.defer_sync_encryption)
def setUp(self): self.gpg_binary_path = get_gpg_bin_path() self._soledad = Soledad(u"*****@*****.**", u"123456", secrets_path=self.tempdir + "/secret.gpg", local_db_path=self.tempdir + "/soledad.u1db", server_url='', cert_file=None, auth_token=None, shared_db=defaultMockSharedDB()) self.km = self._key_manager() class Response(object): code = 200 phrase = '' def deliverBody(self, x): return '' self.km._nicknym._async_client_pinned.request = Mock( return_value=defer.succeed(Response())) d1 = self.km.put_raw_key(PRIVATE_KEY, ADDRESS) d2 = self.km.put_raw_key(PRIVATE_KEY_2, ADDRESS_2) return gatherResults([d1, d2])
def initialize_soledad(tempdir): if os.path.isdir(tempdir): shutil.rmtree(tempdir) uuid = "foobar-uuid" passphrase = u"verysecretpassphrase" secret_path = os.path.join(tempdir, "secret.gpg") local_db_path = os.path.join(tempdir, "soledad.u1db") server_url = "http://provider" cert_file = "" class MockSharedDB(object): get_doc = Mock(return_value=None) put_doc = Mock() lock = Mock(return_value=('atoken', 300)) unlock = Mock(return_value=True) close = Mock() def __call__(self): return self Soledad._shared_db = MockSharedDB() _soledad = Soledad(uuid, passphrase, secret_path, local_db_path, server_url, cert_file) return _soledad
def create(force_fresh_db=False, uuid=default_uuid, passphrase=DEFAULT_PASSPHRASE, token=DEFAULT_TOKEN): secrets_file = '%s.secret' % uuid secrets_path = os.path.join(tmpdir.strpath, secrets_file) # in some tests we might want to use the same user and remote database # but with a clean/empty local database (i.e. download benchmarks), so # here we provide a way to do that. idx = 1 if force_fresh_db: # find the next index for this user idx = len(glob.glob('%s/*-*.db' % tmpdir.strpath)) + 1 db_file = '%s-%d.db' % (uuid, idx) local_db_path = os.path.join(tmpdir.strpath, db_file) soledad_client = Soledad(uuid, unicode(passphrase), secrets_path=secrets_path, local_db_path=local_db_path, server_url=server_url, cert_file=cert_file, auth_token=token, with_blobs=True) request.addfinalizer(soledad_client.close) return soledad_client
def _soledad_instance(self, user='******', passphrase=u'123', prefix='', secrets_path='secrets.json', local_db_path='soledad.u1db', server_url='', cert_file=None, auth_token=None): """ Instantiate Soledad. """ # this callback ensures we save a document which is sent to the shared # db. def _put_doc_side_effect(doc): self._doc_put = doc soledad = Soledad( user, passphrase, secrets_path=os.path.join(self.tempdir, prefix, secrets_path), local_db_path=os.path.join( self.tempdir, prefix, local_db_path), server_url=server_url, cert_file=cert_file, auth_token=auth_token, shared_db=self.get_default_shared_mock(_put_doc_side_effect)) self.addCleanup(soledad.close) return soledad
def init_soledad(_): token = srpauth.get_token() print "token", token global soledad soledad = Soledad(uuid, _pass, secrets_path, local_db_path, server_url, cert_file, auth_token=token, defer_encryption=False) def getall(_): d = soledad.get_all_docs() return d d1 = soledad.create_doc({"test": 42}) d1.addCallback(getall) d1.addCallbacks(printStuff, printErr) d2 = soledad.sync() d2.addCallbacks(printStuff, printErr) d2.addBoth(lambda r: reactor.stop())
def _initialize_soledad(email, gnupg_home, tempdir): """ Initializes soledad by hand :param email: ID for the user :param gnupg_home: path to home used by gnupg :param tempdir: path to temporal dir :rtype: Soledad instance """ uuid = "foobar-uuid" passphrase = u"verysecretpassphrase" secret_path = os.path.join(tempdir, "secret.gpg") local_db_path = os.path.join(tempdir, "soledad.u1db") server_url = "https://provider" cert_file = "" soledad = Soledad( uuid, passphrase, secret_path, local_db_path, server_url, cert_file, syncable=False) return soledad
def _get_soledad_client(self): self._tempdir = tempfile.mkdtemp() return Soledad( uuid=self._uuid, passphrase=u'123', secrets_path=os.path.join(self._tempdir, 'secrets.json'), local_db_path=os.path.join(self._tempdir, 'soledad.db'), server_url=self._server_url, cert_file=None, auth_token=self._auth_token, secret_id=None)
def setUp(self): self.gpg_binary_path = get_gpg_bin_path() self._soledad = Soledad(u"*****@*****.**", u"123456", secrets_path=self.tempdir + "/secret.gpg", local_db_path=self.tempdir + "/soledad.u1db", server_url='', cert_file=None, auth_token=None, syncable=False)
def _try_soledad_init(self, uuid, secrets_path, local_db_path, server_url, cert_file, auth_token): """ Try to initialize soledad. :param uuid: user identifier :type uuid: str :param secrets_path: path to secrets file :type secrets_path: str :param local_db_path: path to local db file :type local_db_path: str :param server_url: soledad server uri :type server_url: str :param cert_file: path to the certificate of the ca used to validate the SSL certificate used by the remote soledad server. :type cert_file: str :param auth token: auth token :type auth_token: str """ # TODO: If selected server fails, retry with another host # (issue #3309) encoding = sys.getfilesystemencoding() # XXX We should get a flag in soledad itself if flags.OFFLINE is True: Soledad._shared_db = MockSharedDB() try: self._soledad = Soledad( uuid, self._password, secrets_path=secrets_path.encode(encoding), local_db_path=local_db_path.encode(encoding), server_url=server_url, cert_file=cert_file.encode(encoding), auth_token=auth_token, defer_encryption=True) # XXX All these errors should be handled by soledad itself, # and return a subclass of SoledadInitializationFailed # recoverable, will guarantee retries except (socket.timeout, socket.error, BootstrapSequenceError): logger.warning("Error while initializing Soledad") raise # unrecoverable except (u1db_errors.Unauthorized, u1db_errors.HTTPError): logger.error("Error while initializing Soledad (u1db error).") raise except Exception as exc: logger.exception("Unhandled error while initializating " "Soledad: %r" % (exc, )) raise
def create(): secrets_path = os.path.join(tmpdir.strpath, '%s.secret' % uuid4().hex) local_db_path = os.path.join(tmpdir.strpath, '%s.db' % uuid4().hex) soledad_client = Soledad(default_uuid, unicode(passphrase), secrets_path=secrets_path, local_db_path=local_db_path, server_url=server_url, cert_file=None, auth_token=token, defer_encryption=True) request.addfinalizer(soledad_client.close) return soledad_client
def _init_soledad(self, encryption_passphrase): try: server_url = self._discover_soledad_server() self._create_database_dir() secrets = self._secrets_path() local_db = self._local_db_path() return Soledad(self.leap_srp_session.uuid, unicode(encryption_passphrase), secrets, local_db, server_url, which_bundle(self.provider), self.leap_srp_session.token) except (WrongMac, UnknownMacMethod, MacMethods), e: raise SoledadWrongPassphraseException(e)
def create(cls, user_token, user_uuid, encryption_passphrase, secrets, local_db, server_url, api_cert): try: return Soledad(user_uuid, passphrase=unicode(encryption_passphrase), secrets_path=secrets, local_db_path=local_db, server_url=server_url, cert_file=api_cert, shared_db=None, auth_token=user_token, defer_encryption=False) except (WrongMacError, UnknownMacMethodError), e: raise SoledadWrongPassphraseException(e)
def _get_soledad_instance(uuid, passphrase, basedir, server_url, cert_file, token): # setup soledad info logger.info('UUID is %s' % uuid) logger.info('Server URL is %s' % server_url) secrets_path = os.path.join(basedir, '%s.secret' % uuid) local_db_path = os.path.join(basedir, '%s.db' % uuid) # instantiate soledad return Soledad(uuid, unicode(passphrase), secrets_path=secrets_path, local_db_path=local_db_path, server_url=server_url, cert_file=cert_file, auth_token=token)
def initialize_soledad(uuid, email, passwd, secrets, localdb, gnupg_home, tempdir): """ Initializes soledad by hand :param email: ID for the user :param gnupg_home: path to home used by gnupg :param tempdir: path to temporal dir :rtype: Soledad instance """ # XXX TODO unify with an authoritative source of mocks # for soledad (or partial initializations). # This is copied from the imap tests. server_url = "http://provider" cert_file = "" class Mock(object): def __init__(self, return_value=None): self._return = return_value def __call__(self, *args, **kwargs): return self._return class MockSharedDB(object): get_doc = Mock() put_doc = Mock() lock = Mock(return_value=('atoken', 300)) unlock = Mock(return_value=True) def __call__(self): return self Soledad._shared_db = MockSharedDB() soledad = Soledad( uuid, passwd, secrets, localdb, server_url, cert_file, defer_encryption=True) return soledad
def _init_soledad(self, encryption_passphrase): try: server_url = self._discover_soledad_server() self._create_database_dir() secrets = self._secrets_path() local_db = self._local_db_path() return Soledad(self.user_uuid, unicode(encryption_passphrase), secrets, local_db, server_url, which_api_CA_bundle(self.provider), self.user_token, defer_encryption=False) except (WrongMac, UnknownMacMethod), e: raise SoledadWrongPassphraseException(e)
def _init_soledad(self, encryption_passphrase): try: server_url = self._discover_soledad_server() self._create_database_dir() secrets = self._secrets_path() local_db = self._local_db_path() return Soledad(self.user_uuid, passphrase=unicode(encryption_passphrase), secrets_path=secrets, local_db_path=local_db, server_url=server_url, cert_file=LeapCertificate(self.provider).provider_api_cert, shared_db=None, auth_token=self.user_token, defer_encryption=False) except (WrongMacError, UnknownMacMethodError), e: raise SoledadWrongPassphraseException(e)
def _soledad_instance(self, user='******', passphrase=u'123', prefix='', secrets_path=Soledad.STORAGE_SECRETS_FILE_NAME, local_db_path='soledad.u1db', server_url='', cert_file=None, auth_token=None, secret_id=None): """ Instantiate Soledad. """ # this callback ensures we save a document which is sent to the shared # db. def _put_doc_side_effect(doc): self._doc_put = doc # we need a mocked shared db or else Soledad will try to access the # network to find if there are uploaded secrets. class MockSharedDB(object): get_doc = mock.Mock(return_value=None) put_doc = mock.Mock(side_effect=_put_doc_side_effect) lock = mock.Mock(return_value=('atoken', 300)) unlock = mock.Mock() def __call__(self): return self Soledad._shared_db = MockSharedDB() return Soledad(user, passphrase, secrets_path=os.path.join(self.tempdir, prefix, secrets_path), local_db_path=os.path.join(self.tempdir, prefix, local_db_path), server_url=server_url, cert_file=cert_file, auth_token=auth_token, secret_id=secret_id)
def setUp(self): self.setUpEnv() # setup our own stuff address = '*****@*****.**' # user's address in the form user@provider uuid = '*****@*****.**' passphrase = u'123' secrets_path = os.path.join(self.tempdir, 'secret.gpg') local_db_path = os.path.join(self.tempdir, 'soledad.u1db') server_url = 'http://provider/' cert_file = '' self._soledad = Soledad(uuid, passphrase, secrets_path=secrets_path, local_db_path=local_db_path, server_url=server_url, cert_file=cert_file, syncable=False) return self._setup_keymanager(address)
def _soledad_instance(self, user=None, passphrase=u'123', prefix='', secrets_path='secrets.json', local_db_path='soledad.u1db', server_url='', cert_file=None, auth_token=None): """ Instantiate Soledad. """ # this callback ensures we save a document which is sent to the shared # db. def _put_doc_side_effect(doc): self._doc_put = doc if not server_url: # attempt to find the soledad server url server_address = None server = getattr(self, 'server', None) if server: server_address = getattr(self.server, 'server_address', None) else: host = self.port.getHost() server_address = (host.host, host.port) if server_address: server_url = 'http://%s:%d' % (server_address) return Soledad( user, passphrase, secrets_path=os.path.join(self.tempdir, prefix, secrets_path), local_db_path=os.path.join(self.tempdir, prefix, local_db_path), server_url=server_url, cert_file=cert_file, auth_token=auth_token, shared_db=self.get_default_shared_mock(_put_doc_side_effect))
def create(force_fresh_db=False): secrets_file = '%s.secret' % default_uuid secrets_path = os.path.join(tmpdir.strpath, secrets_file) # in some tests we might want to use the same user and remote database # but with a clean/empty local database (i.e. download benchmarks), so # here we provide a way to do that. db_file = '%s.db' % default_uuid if force_fresh_db: prefix = uuid4().hex db_file = prefix + '-' + db_file local_db_path = os.path.join(tmpdir.strpath, db_file) soledad_client = Soledad(default_uuid, unicode(passphrase), secrets_path=secrets_path, local_db_path=local_db_path, server_url=server_url, cert_file=None, auth_token=token) request.addfinalizer(soledad_client.close) return soledad_client
def initialize_soledad(email, gnupg_home, tempdir): """ Initializes soledad by hand :param email: ID for the user :param gnupg_home: path to home used by gnupg :param tempdir: path to temporal dir :rtype: Soledad instance """ uuid = "foobar-uuid" passphrase = u"verysecretpassphrase" secret_path = os.path.join(tempdir, "secret.gpg") local_db_path = os.path.join(tempdir, "soledad.u1db") server_url = "http://provider" cert_file = "" class MockSharedDB(object): get_doc = Mock(return_value=None) put_doc = Mock() lock = Mock(return_value=('atoken', 300)) unlock = Mock(return_value=True) def __call__(self): return self Soledad._shared_db = MockSharedDB() _soledad = Soledad( uuid, passphrase, secret_path, local_db_path, server_url, cert_file) return _soledad
def _initialize_soledad(email, gnupg_home, tempdir): """ Initializes soledad by hand :param email: ID for the user :param gnupg_home: path to home used by gnupg :param tempdir: path to temporal dir :rtype: Soledad instance """ uuid = "foobar-uuid" passphrase = u"verysecretpassphrase" secret_path = os.path.join(tempdir, "secret.gpg") local_db_path = os.path.join(tempdir, "soledad.u1db") server_url = "https://provider" cert_file = "" # TODO: we pass a fake shared database to soledad because we don't want # it o try to reach network to lookup a stored secret in the shared # database. This logic still has to be improved in soledad itself to # account for tests, and when that is done we can remove this from # here. class FakeSharedDb(object): def get_doc(self, doc_id): return None def put_doc(self, doc): return None soledad = Soledad(uuid, passphrase, secret_path, local_db_path, server_url, cert_file, shared_db=FakeSharedDb()) return soledad