Python crypto.CryptoEngine类代码示例

 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 changepassword(self):
     """
     Change the databases password.
     """
     enc = CryptoEngine.get()
     newkey = enc.changepassword()
     return self.savekey(newkey)

    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 forget():
    global AUTHENTICATED
    AUTHENTICATED = False
    enc = CryptoEngine.get()
    enc.forget()

    redirect('/auth')

 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 get_user_password(self):
     """
     get the databases password from the user
     """
     enc = CryptoEngine.get()
     newkey = enc.changepassword()
     return self.savekey(newkey)

    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):
     "fuck 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 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 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 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 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 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