def test_get(self):
old_engine = CryptoEngine.get()
self.assertIsInstance(old_engine, CryptoEngineOld)
CryptoEngine._instance = None
new_engine = CryptoEngine.get(dbver=0.5)
self.assertIsInstance(new_engine, CryptoEngine)
self.assertFalse(isinstance(new_engine, CryptoEngineOld))
CryptoEngine._instance = None
old_engine = CryptoEngine.get()
def __init__(self):
config.set_defaults(default_config)
enc = CryptoEngine.get(dbver=0.4)
enc.callback = DummyCallback4()
self.enc1 = copy.copy(enc)
enc = CryptoEngine.get(dbver=0.5)
enc.callback = DummyCallback4()
self.enc2 = copy.copy(enc)
self.db1 = SQLiteDatabaseNewForm('konverter-v0.4.db', dbformat=0.4)
self.db2 = SQLiteDatabaseNewForm('konverter-v0.5.db', dbformat=0.5)
assert self.enc1 is not self.enc2
def run(self):
global AUTHENTICATED, TAGS, DB
OSX = False
sys.argv = []
args = parser_options().parse_args()
xselpath, dbtype = get_conf_options(args, OSX)
dbver = 0.5
DB = pwman.data.factory.create(dbtype, dbver)
DB.open(dbver=0.5)
print(dir(DB))
CryptoEngine.get(dbver=0.5)
print(pwman.config._conf)
debug(True)
run(port=9030)
def get_user_password(self):
"""
get the databases password from the user
"""
enc = CryptoEngine.get()
newkey = enc.changepassword()
return self.savekey(newkey)
def changepassword(self):
"""
Change the databases password.
"""
enc = CryptoEngine.get()
newkey = enc.changepassword()
return self.savekey(newkey)
def do_tags(self, arg):
enc = CryptoEngine.get()
if not enc.alive():
enc._getcipher()
print ("Tags: \n",)
t = self._tags(enc)
print ('\n'.join(t))
def forget():
global AUTHENTICATED
AUTHENTICATED = False
enc = CryptoEngine.get()
enc.forget()
redirect('/auth')
def __init__(self, db, hasxsel, callback):
"""
initialize CLI interface, set up the DB
connecion, see if we have xsel ...
"""
cmd.Cmd.__init__(self)
self.intro = "%s %s (c) visit: %s" % (pwman.appname, pwman.version, pwman.website)
self._historyfile = config.get_value("Readline", "history")
self.hasxsel = hasxsel
try:
enc = CryptoEngine.get()
enc._callback = callback()
self._db = db
# this cascades down all the way to setting the database key
self._db.open()
except Exception as e: # pragma: no cover
self.error(e)
sys.exit(1)
try:
readline.read_history_file(self._historyfile)
except IOError as e: # pragma: no cover
pass
self.prompt = "pwman> "
def test_db_change_pass(self):
"f**k yeah, we change the password and the new dummy works"
enc = CryptoEngine.get()
enc._callback = DummyCallback3()
self.tester.cli._db.changepassword()
self.tester.cli.do_forget('')
enc._callback = DummyCallback4()
self.tester.cli.do_ls('')
def read_old_db(self):
"read the old db and get all nodes"
self.db = SQLiteDatabaseReader()
enc = CryptoEngine.get()
enc.set_callback(CLICallback())
self.db.open()
self.oldnodes = self.db.listnodes()
self.oldnodes = self.db.getnodes(self.oldnodes)
def get_username(self):
"""
Return the username.
This solution with strip is horribly assuming that
the username does not containg space as the last character.
The same is also true for the password.
"""
enc = CryptoEngine.get()
return enc.decrypt(self._username).strip()
def open(self):
"""Open the database."""
self._open()
enc = CryptoEngine.get()
key = self.loadkey()
if key != None:
enc.set_cryptedkey(key)
else:
self.changepassword()
def open(self):
"""Open the database."""
self._open()
enc = CryptoEngine.get()
key = self.loadkey()
if (key != None):
enc.set_cryptedkey(key)
else:
self.changepassword()
def __init__(self,username="",password="",url="",notes="",tags=[]):
"""Initialise everything to null."""
self._id = 0;
enc = CryptoEngine.get()
self._username = enc.encrypt(username)
self._password = enc.encrypt(password)
self._url = enc.encrypt(url)
self._notes = enc.encrypt(notes)
self._tags = []
self.set_tags(tags)
def __init__(self, username="", password="", url="", notes="", tags=[]):
"""Initialise everything to null."""
self._id = 0
enc = CryptoEngine.get()
self._username = enc.encrypt(username)
self._password = enc.encrypt(password)
self._url = enc.encrypt(url)
self._notes = enc.encrypt(notes)
self._tags = []
self.set_tags(tags)
def __str__(self): # pragma: no cover
enc = CryptoEngine.get()
try:
tags = ', '.join([enc.decrypt(tag).strip() for tag in filter(None,
self._tags)])
except Exception:
tags = ', '.join([tag.strip() for tag in filter(None, self._tags)])
user = enc.decrypt(self._username).strip()
url = enc.decrypt(self._url).strip()
return '{0}@{1}\t{2}'.format(user, url,
tags)
def do_tags(self, arg):
tags = self._db.listtags()
# request password
enc = CryptoEngine.get()
if not enc.alive():
enc._getcipher()
print "Tags: ",
if len(tags) == 0:
print "None",
for t in tags:
print "%s " % t,
print
def complete_filter(self, text, line, begidx, endidx):
strings = []
enc = CryptoEngine.get()
if not enc.alive():
return strings
tags = self._db.listtags()
for t in tags:
name = t.get_name()
if name.startswith(text):
strings.append(t.get_name())
return strings
def complete_filter(self, text, line, begidx, endidx):
strings = []
enc = CryptoEngine.get()
if not enc.alive():
return strings
tags = self._db.listtags()
for t in tags:
name = t.get_name()
if name.startswith(text):
strings.append(t.get_name())
return strings
def __init__(self, db):
cmd.Cmd.__init__(self)
self.intro = "%s %s (c) %s <%s>" % (pwman.appname, pwman.version, pwman.author, pwman.authoremail)
self._historyfile = config.get_value("Readline", "history")
try:
enc = CryptoEngine.get()
enc.set_callback(CLICallback())
self._db = db
self._db.open()
except Exception, e:
self.error(e)
sys.exit(1)
def __init__(self, db):
cmd.Cmd.__init__(self)
self.intro = "%s %s (c) %s <%s>" % (pwman.appname, pwman.version,
pwman.author, pwman.authoremail)
self._historyfile = config.get_value("Readline", "history")
try:
enc = CryptoEngine.get()
enc.set_callback(CLICallback())
self._db = db
self._db.open()
except Exception, e:
self.error(e)
sys.exit(1)
def run(self):
# before add nodes to db1 we have to create an encryption key!
# this is handeld by the open method
self.db1._open()
enc1 = CryptoEngine.get(dbver=0.4)
enc1.callback = DummyCallback4()
key = self.db1.loadkey()
if key is not None:
enc1.set_cryptedkey(key)
else:
newkey = enc1.changepassword()
self.db1.savekey(newkey)
enc1c = copy.copy(enc1)
if key is not None:
enc1.set_cryptedkey(key)
self.add_nodes_to_db1()
CryptoEngine._instance = None
self.db2._open()
enc2 = CryptoEngine.get(dbver=0.5)
enc2.callback = DummyCallback4()
key = self.db2.loadkey()
if key is not None:
enc2.set_cryptedkey(key)
else:
newkey = enc2.changepassword()
self.db2.savekey(newkey)
enc2c = copy.copy(enc2)
if key is not None:
enc2.set_cryptedkey(key)
self.add_nodes_to_db2()
assert enc1 is not enc2
assert enc1c is not enc2c
def open(self):
"""
Open the database, by calling the _open method of the
class inherited for the specific database.
When done validation that the file is OK, check if it has
encryption key, by calling
enc = CryptoEngine.get()
key = self.loadkey()
"""
self._open()
enc = CryptoEngine.get()
key = self.loadkey()
if (key != None):
enc.set_cryptedkey(key)
else:
self.changepassword()
def dump_to_db(self):
enc = CryptoEngine.get()
dump = ""
dump += "username:"******"##"
dump += "password:"******"##"
dump += "url:"+enc.encrypt(self._url)+"##"
dump += "notes:"+enc.encrypt(self._notes)+"##"
dump += "tags:"
tagsloc = ""
for tag in self._tags:
if isinstance(tag, str):
tagsloc += "tag:"+tag.strip()+"**endtag**"
else:
tagsloc += "tag:"+tag.get_name()+"**endtag**"
dump += tagsloc
dump = [dump]
return dump
def __init__(self, db, hasxsel):
"""
initialize CLI interface, set up the DB
connecion, see if we have xsel ...
"""
cmd.Cmd.__init__(self)
self.intro = "%s %s (c) visit: %s" % (pwman.appname, pwman.version, pwman.website)
self._historyfile = config.get_value("Readline", "history")
self.hasxsel = hasxsel
try:
enc = CryptoEngine.get()
enc.set_callback(CLICallback())
self._db = db
self._db.open()
except Exception, e:
self.error(e)
sys.exit(1)
def is_authenticated():
global AUTHENTICATED
crypto = CryptoEngine.get(dbver=0.5)
if request.method == 'POST':
key = request.POST.get('pwd', '')
while True:
try:
crypto.auth(key)
break
except Exception:
redirect('/auth')
AUTHENTICATED = True
redirect('/')
else:
return template("login.tpl", template_lookup=templates_path)
def __init__(self, db, hasxsel):
"""
initialize CLI interface, set up the DB
connecion, see if we have xsel ...
"""
_dbwarning = (
"\n*** WARNNING: You are using the old db format which" + " uses cPickle, please upgrade your db !!! ***"
)
cmd.Cmd.__init__(self)
self.intro = "%s %s (c) visit: %s %s" % (pwman.appname, pwman.version, pwman.website, _dbwarning)
self._historyfile = config.get_value("Readline", "history")
self.hasxsel = hasxsel
try:
enc = CryptoEngine.get()
enc.set_callback(CLICallback())
self._db = db
self._db.open()
except Exception, e:
self.error(e)
sys.exit(1)
def _tagids(self, tags):
ids = []
sql = "SELECT ID FROM TAGS WHERE DATA LIKE ?"
for tag in tags:
try:
if isinstance(tag, str):
enc = CryptoEngine.get()
tag = enc.encrypt(tag)
self._cur.execute(sql, [tag])
else:
self._cur.execute(sql, [tag._name+'%'])
values = self._cur.fetchall()
if values: # tags already exist in the database
ids.extend(list(itertools.chain(*values)))
else:
self._create_tag(tag)
ids.append(self._cur.lastrowid)
except sqlite.DatabaseError as e: # pragma: no cover
raise DatabaseException("SQLite: %s" % (e))
return ids
def get_notes(self):
"""Return the Notes."""
enc = CryptoEngine.get()
return enc.decrypt(self._notes)
def set_url(self, url):
"""Set the URL."""
enc = CryptoEngine.get()
self._url = enc.encrypt(url)
def get_url(self):
"""Return the URL."""
enc = CryptoEngine.get()
return enc.decrypt(self._url)
def set_password(self, password):
"""Set the password."""
enc = CryptoEngine.get()
self._password = enc.encrypt(password)
def changepassword(self):
"""Change the databases password."""
enc = CryptoEngine.get()
newkey = enc.changepassword()
return self.savekey(newkey)
def set_name(self, name):
enc = CryptoEngine.get()
self._name = enc.encrypt(name)
def name(self, value):
enc = CryptoEngine.get() # pragma: no cover
self._name = enc.encrypt(value) # pragma: no cover
def set_tags(self, tags):
self._tags = []
enc = CryptoEngine.get()
for i in tags:
self._tags.append(enc.encrypt(i))
def get_tags(self):
tags = []
enc = CryptoEngine.get()
for i in self._tags:
tags.append(enc.decrypt(i))
return tags
def do_forget(self, args):
try:
enc = CryptoEngine.get()
enc.forget()
except Exception, e:
self.error(e)
def get_name(self):
enc = CryptoEngine.get()
return enc.decrypt(self._name)
def do_forget(self, args):
try:
enc = CryptoEngine.get()
enc.forget()
except Exception as e:
self.error(e)
def set_name(self, name):
enc = CryptoEngine.get()
self._name = enc.encrypt(name)
def set_notes(self, notes):
"""Set the Notes."""
enc = CryptoEngine.get()
self._notes = enc.encrypt(notes)
def __init__(self, name):
enc = CryptoEngine.get()
self._name = enc.encrypt(name)
def get_username(self):
"""Return the username."""
enc = CryptoEngine.get()
return enc.decrypt(self._username)
def get_name(self):
enc = CryptoEngine.get()
return enc.decrypt(self._name)
def set_username(self, username):
"""Set the username."""
enc = CryptoEngine.get()
self._username = enc.encrypt(username)
def __str__(self):
enc = CryptoEngine.get()
return enc.decrypt(self._name)
def get_password(self):
"""Return the password."""
enc = CryptoEngine.get()
return enc.decrypt(self._password)