eric: comparison WebBrowser/Passwords/PasswordManager.py

-:f9e2e536d130
+:ad3f6c1caf8d
 from __future__ import unicode_literals
 import os
 from PyQt5.QtCore import pyqtSignal, QObject, QByteArray, QUrl, \
-QCoreApplication, QXmlStreamReader, qVersion
+QCoreApplication, QXmlStreamReader
 from PyQt5.QtWidgets import QApplication
-from PyQt5.QtNetwork import QNetworkRequest
+from PyQt5.QtWebEngineWidgets import QWebEngineScript
-##from PyQt5.QtWebKit import QWebSettings
-##from PyQt5.QtWebKitWidgets import QWebPage
 from E5Gui import E5MessageBox
 from E5Gui.E5ProgressDialog import E5ProgressDialog
 from Utilities.AutoSaver import AutoSaver
 import Utilities
 import Utilities.crypto
 import Preferences
+import WebBrowser.WebBrowserWindow
+from ..Tools import Scripts
 class PasswordManager(QObject):
 """
 Class implementing the password manager.
 Constructor
 @param parent reference to the parent object (QObject)
 """
 super(PasswordManager, self).__init__(parent)
+# setup userscript to monitor forms
+script = QWebEngineScript()
+script.setName("_eric_passwordmonitor")
+script.setInjectionPoint(QWebEngineScript.DocumentReady)
+script.setWorldId(QWebEngineScript.MainWorld)
+script.setRunsOnSubFrames(True)
+script.setSourceCode(Scripts.setupFormObserver())
+profile = WebBrowser.WebBrowserWindow.WebBrowserWindow.webProfile()
+profile.scripts().insert(script)
 self.__logins = {}
 self.__loginForms = {}
 self.__never = []
 self.__loaded = False
 return None
 return self.__logins[site][0], Utilities.crypto.pwConvert(
 self.__logins[site][1], encode=False)
-# TODO: Password Manager: processing of form data
+def formSubmitted(self, urlStr, userName, password, data, page):
-def post(self, request, data):
+"""
-"""
+Public method to record login data.
-Public method to check, if the data to be sent contains login data.
+@param urlStr form submission URL
-@param request reference to the network request (QNetworkRequest)
+@type str
-@param data data to be sent (QByteArray)
+@param userName name of the user
-"""
+@type str
-##        # shall passwords be saved?
+@param password user password
-##        if not Preferences.getUser("SavePasswords"):
+@type str
-##            return
+@param data data to be submitted
-##
+@type QByteArray
-##        # observe privacy
+@param page reference to the calling page
-##        # TODO: Privacy, i.e. isPrivate()
+@type QWrbEnginePage
-####        if QWebSettings.globalSettings().testAttribute(
+"""
-####                QWebSettings.PrivateBrowsingEnabled):
+# shall passwords be saved?
-####            return
+if not Preferences.getUser("SavePasswords"):
-##
+return
-##        if not self.__loaded:
-##            self.__load()
+if WebBrowser.WebBrowserWindow.WebBrowserWindow.mainWindow()\
-##
+.isPrivate():
-##        # determine the url
+return
-##        refererHeader = request.rawHeader(b"Referer")
-##        if refererHeader.isEmpty():
+if urlStr in self.__never:
-##            return
+return
-##        url = QUrl.fromEncoded(refererHeader)
-##        url = self.__stripUrl(url)
+if userName and password:
-##
+url = QUrl(urlStr)
-##        # check that url isn't in __never
+url = self.__stripUrl(url)
-##        if url.toString() in self.__never:
+key = self.__createKey(url, "")
-##            return
+if key not in self.__loginForms:
-##
+mb = E5MessageBox.E5MessageBox(
-##        # check the request type
+E5MessageBox.Question,
-##        navType = request.attribute(QNetworkRequest.User + 101)
+self.tr("Save password"),
-##        if navType is None:
+self.tr(
-##            return
+"""<b>Would you like to save this password?</b><br/>"""
-##        if navType != QWebPage.NavigationTypeFormSubmitted:
+"""To review passwords you have saved and remove"""
-##            return
+""" them, use the password management dialog of the"""
-##
+""" Settings menu."""),
-##        # determine the QWebPage
+modal=True, parent=page.view())
-##        webPage = request.attribute(QNetworkRequest.User + 100)
+neverButton = mb.addButton(
-##        if webPage is None:
+self.tr("Never for this site"),
-##            return
+E5MessageBox.DestructiveRole)
-##
+noButton = mb.addButton(
-##        # determine the requests content type
+self.tr("Not now"), E5MessageBox.RejectRole)
-##        contentTypeHeader = request.rawHeader(b"Content-Type")
+mb.addButton(E5MessageBox.Yes)
-##        if contentTypeHeader.isEmpty():
+mb.exec_()
-##            return
+if mb.clickedButton() == neverButton:
-##        multipart = contentTypeHeader.startsWith(b"multipart/form-data")
+self.__never.append(url.toString())
-##        if multipart:
+return
-##            boundary = contentTypeHeader.split(" ")[1].split("=")[1]
+elif mb.clickedButton() == noButton:
-##        else:
+return
-##            boundary = None
-##
+self.__logins[key] = \
-##        # find the matching form on the web page
+(userName,
-##        form = self.__findForm(webPage, data, boundary=boundary)
+Utilities.crypto.pwConvert(password, encode=True))
-##        if not form.isValid():
+from .LoginForm import LoginForm
-##            return
+form = LoginForm()
-##        form.url = QUrl(url)
+form.url = url
-##
+form.name = userName
-##        # check, if the form has a password
+form.postData = QByteArray(data)
-##        if not form.hasAPassword:
+self.__loginForms[key] = form
-##            return
+self.changed.emit()
-##
-##        # prompt, if the form has never be seen
-##        key = self.__createKey(url, "")
-##        if key not in self.__loginForms:
-##            mb = E5MessageBox.E5MessageBox(
-##                E5MessageBox.Question,
-##                self.tr("Save password"),
-##                self.tr(
-##                    """<b>Would you like to save this password?</b><br/>"""
-##                    """To review passwords you have saved and remove them, """
-##                    """use the password management dialog of the Settings"""
-##                    """ menu."""),
-##                modal=True)
-##            neverButton = mb.addButton(
-##                self.tr("Never for this site"),
-##                E5MessageBox.DestructiveRole)
-##            noButton = mb.addButton(
-##                self.tr("Not now"), E5MessageBox.RejectRole)
-##            mb.addButton(E5MessageBox.Yes)
-##            mb.exec_()
-##            if mb.clickedButton() == neverButton:
-##                self.__never.append(url.toString())
-##                return
-##            elif mb.clickedButton() == noButton:
-##                return
-##
-##        # extract user name and password
-##        user = ""
-##        password = ""
-##        for index in range(len(form.elements)):
-##            element = form.elements[index]
-##            type_ = form.elementTypes[element[0]]
-##            if user == "" and \
-##               type_ == "text":
-##                user = element[1]
-##            elif password == "" and \
-##                    type_ == "password":
-##                password = element[1]
-##                form.elements[index] = (element[0], "--PASSWORD--")
-##        if user and password:
-##            self.__logins[key] = \
-##                (user, Utilities.crypto.pwConvert(password, encode=True))
-##            self.__loginForms[key] = form
-##            self.changed.emit()
 def __stripUrl(self, url):
 """
 Private method to strip off all unneeded parts of a URL.
 cleanUrl = QUrl("{0}://{1}{2}".format(
 cleanUrl.scheme(), authority, cleanUrl.path()))
 cleanUrl.setFragment("")
 return cleanUrl
-# TODO: Password Manager: processing of form data
+def completePage(self, page):
-##    def __findForm(self, webPage, data, boundary=None):
+"""
-##        """
+Public slot to complete login forms with saved data.
-##        Private method to find the form used for logging in.
-##
+@param page reference to the web page (WebBrowserPage)
-##        @param webPage reference to the web page (QWebPage)
+"""
-##        @param data data to be sent (QByteArray)
+if page is None:
-##        @keyparam boundary boundary string (QByteArray) for multipart
+return
-##            encoded data, None for urlencoded data
-##        @return parsed form (LoginForm)
+if not self.__loaded:
-##        """
+self.__load()
-##        from .LoginForm import LoginForm
-##        form = LoginForm()
+url = page.url()
-##        if boundary is not None:
+url = self.__stripUrl(url)
-##            args = self.__extractMultipartQueryItems(data, boundary)
+key = self.__createKey(url, "")
-##        else:
+if key not in self.__loginForms or \
-##            if qVersion() >= "5.0.0":
+key not in self.__logins:
-##                from PyQt5.QtCore import QUrlQuery
+return
-##                argsUrl = QUrl.fromEncoded(
-##                    QByteArray(b"foo://bar.com/?" + QUrl.fromPercentEncoding(
+form = self.__loginForms[key]
-##                        data.replace(b"+", b"%20")).encode("utf-8")))
+if form.url != url:
-##                encodedArgs = QUrlQuery(argsUrl).queryItems()
+return
-##            else:
-##                argsUrl = QUrl.fromEncoded(
+script = Scripts.completeFormData(form.postData)
-##                    QByteArray(b"foo://bar.com/?" + data.replace(b"+", b"%20"))
+page.runJavaScript(script)
-##                )
-##                encodedArgs = argsUrl.queryItems()
-##            args = set()
-##            for arg in encodedArgs:
-##                key = arg[0]
-##                value = arg[1]
-##                args.add((key, value))
-##
-##        # extract the forms
-##        from Helpviewer.JavaScriptResources import parseForms_js
-##        lst = webPage.mainFrame().evaluateJavaScript(parseForms_js)
-##        for map in lst:
-##            formHasPasswords = False
-##            formName = map["name"]
-##            formIndex = map["index"]
-##            if isinstance(formIndex, float) and formIndex.is_integer():
-##                formIndex = int(formIndex)
-##            elements = map["elements"]
-##            formElements = set()
-##            formElementTypes = {}
-##            deadElements = set()
-##            for elementMap in elements:
-##                try:
-##                    name = elementMap["name"]
-##                    value = elementMap["value"]
-##                    type_ = elementMap["type"]
-##                except KeyError:
-##                    continue
-##                if type_ == "password":
-##                    formHasPasswords = True
-##                t = (name, value)
-##                try:
-##                    if elementMap["autocomplete"] == "off":
-##                        deadElements.add(t)
-##                except KeyError:
-##                    pass
-##                if name:
-##                    formElements.add(t)
-##                    formElementTypes[name] = type_
-##            if formElements.intersection(args) == args:
-##                form.hasAPassword = formHasPasswords
-##                if not formName:
-##                    form.name = formIndex
-##                else:
-##                    form.name = formName
-##                args.difference_update(deadElements)
-##                for elt in deadElements:
-##                    if elt[0] in formElementTypes:
-##                        del formElementTypes[elt[0]]
-##                form.elements = list(args)
-##                form.elementTypes = formElementTypes
-##                break
-##
-##        return form
-##
-##    def __extractMultipartQueryItems(self, data, boundary):
-##        """
-##        Private method to extract the query items for a post operation.
-##
-##        @param data data to be sent (QByteArray)
-##        @param boundary boundary string (QByteArray)
-##        @return set of name, value pairs (set of tuple of string, string)
-##        """
-##        args = set()
-##
-##        dataStr = bytes(data).decode()
-##        boundaryStr = bytes(boundary).decode()
-##
-##        parts = dataStr.split(boundaryStr + "\r\n")
-##        for part in parts:
-##            if part.startswith("Content-Disposition"):
-##                lines = part.split("\r\n")
-##                name = lines[0].split("=")[1][1:-1]
-##                value = lines[2]
-##                args.add((name, value))
-##
-##        return args
-##
-##    def fill(self, page):
-##        """
-##        Public slot to fill login forms with saved data.
-##
-##        @param page reference to the web page (QWebPage)
-##        """
-##        if page is None or page.mainFrame() is None:
-##            return
-##
-##        if not self.__loaded:
-##            self.__load()
-##
-##        url = page.mainFrame().url()
-##        url = self.__stripUrl(url)
-##        key = self.__createKey(url, "")
-##        if key not in self.__loginForms or \
-##           key not in self.__logins:
-##            return
-##
-##        form = self.__loginForms[key]
-##        if form.url != url:
-##            return
-##
-##        if form.name == "":
-##            formName = "0"
-##        else:
-##            try:
-##                formName = "{0:d}".format(int(form.name))
-##            except ValueError:
-##                formName = '"{0}"'.format(form.name)
-##        for element in form.elements:
-##            name = element[0]
-##            value = element[1]
-##
-##            disabled = page.mainFrame().evaluateJavaScript(
-##                'document.forms[{0}].elements["{1}"].disabled'.format(
-##                    formName, name))
-##            if disabled:
-##                continue
-##
-##            readOnly = page.mainFrame().evaluateJavaScript(
-##                'document.forms[{0}].elements["{1}"].readOnly'.format(
-##                    formName, name))
-##            if readOnly:
-##                continue
-##
-##            type_ = page.mainFrame().evaluateJavaScript(
-##                'document.forms[{0}].elements["{1}"].type'.format(
-##                    formName, name))
-##            if type_ == "" or \
-##               type_ in ["hidden", "reset", "submit"]:
-##                continue
-##            if type_ == "password":
-##                value = Utilities.crypto.pwConvert(
-##                    self.__logins[key][1], encode=False)
-##            setType = type_ == "checkbox" and "checked" or "value"
-##            value = value.replace("\\", "\\\\")
-##            value = value.replace('"', '\\"')
-##            javascript = \
-##                'document.forms[{0}].elements["{1}"].{2}="{3}";'.format(
-##                    formName, name, setType, value)
-##            page.mainFrame().evaluateJavaScript(javascript)
 def masterPasswordChanged(self, oldPassword, newPassword):
 """
 Public slot to handle the change of the master password.

Mercurial Repositories > eric / file comparison

comparison: WebBrowser/Passwords/PasswordManager.py

WebBrowser/Passwords/PasswordManager.py