def get_favicon(self, uri, scale_factor): """ @param uri as str @param suffix as str @param scale factor as int @return cairo.surface """ try: if not uri: return None filepath = self.get_favicon_path(uri) if filepath is not None and\ GLib.file_test(filepath, GLib.FileTest.IS_REGULAR): pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale( filepath, ArtSize.FAVICON * scale_factor, ArtSize.FAVICON * scale_factor, True) surface = Gdk.cairo_surface_create_from_pixbuf(pixbuf, scale_factor, None) return surface except Exception as e: Logger.debug("Art::get_favicon(): %s", e) return None
def __save_rules(self, rules): """ Save rules to db @param rules bytes """ SqlCursor.add(self) result = rules.decode('utf-8') count = 0 for line in result.split('\n'): SqlCursor.allow_thread_execution(self) if self.__cancellable.is_cancelled(): SqlCursor.remove(self) raise Exception("Cancelled") if line.startswith('#'): continue array = line.replace( ' ', '\t', 1).replace('\t', '@', 1).split('@') if len(array) <= 1: continue netloc = array[1].replace( ' ', '').replace('\r', '').split('#')[0] # Update entry if exists, create else if netloc != "localhost": Logger.debug("Add filter: %s", netloc) self.__add_netloc(netloc) count += 1 if count == 1000: SqlCursor.commit(self) # Do not flood sqlite, this allow webkit extension to run sleep(0.1) count = 0 SqlCursor.remove(self)
def get(self, form_uri, userform, passform, callback, *args): """ Call function @param form_uri as str @param userform as str @param passform as str @param callback as function @param args """ try: self.__wait_for_secret(self.get, form_uri, userform, passform, callback, *args) SecretSchema = { "type": Secret.SchemaAttributeType.STRING, "formSubmitURL": Secret.SchemaAttributeType.STRING, "userform": Secret.SchemaAttributeType.STRING, } SecretAttributes = { "type": "eolie web login", "formSubmitURL": form_uri, "userform": userform, } if passform is not None: SecretSchema["passform"] = Secret.SchemaAttributeType.STRING SecretAttributes["passform"] = passform schema = Secret.Schema.new("org.gnome.Eolie", Secret.SchemaFlags.NONE, SecretSchema) self.__secret.search(schema, SecretAttributes, Secret.SearchFlags.ALL, None, self.__on_secret_search, form_uri, callback, *args) except Exception as e: Logger.debug("PasswordsHelper::get(): %s", e)
def __on_send_request(self, webpage, request, redirect): """ Filter based on adblock db @param webpage as WebKit2WebExtension.WebPage @param request as WebKit2.URIRequest @param redirect as WebKit2WebExtension.URIResponse """ uri = webpage.get_uri() parsed = urlparse(uri) request_uri = request.get_uri() parsed_request = urlparse(request_uri) netloc = parsed.netloc.split(".")[-2:] netloc_request = parsed_request.netloc.split(".")[-2:] document = webpage.get_dom_document() if self.__document != document: self.__document = document self.__scripts = \ document.get_elements_by_tag_name_as_html_collection("script") if netloc == netloc_request and\ App().settings.get_value("trust-websites-js"): return False if App().settings.get_value("jsblock") and\ parsed.netloc not in self.__whitelist: if parsed_request.scheme in ["http", "https"] and\ not App().js_exceptions.find(parsed_request.netloc, parsed.netloc): for i in range(0, self.__scripts.get_length()): script = self.__scripts.item(i) if script.get_src() == request_uri: Logger.debug("JSblockExtension: blocking %s -> %s", request_uri, uri) return True
def __on_secret_search(self, source, result, form_uri, callback, *args): """ Set username/password input @param source as GObject.Object @param result as Gio.AsyncResult @param form_uri as str @param callback as function @param args """ try: if result is not None: items = self.__secret.search_finish(result) count = len(items) index = 0 for item in items: item.load_secret(None, self.__on_load_secret, form_uri, index, count, callback, *args) index += 1 if not items: callback(None, None, form_uri, 0, 0, *args) else: callback(None, None, form_uri, 0, 0, *args) except Exception as e: Logger.debug("PasswordsHelper::__on_secret_search(): %s", e) callback(None, None, form_uri, 0, 0, *args)
def __on_send_request(self, webpage, request, redirect): """ Filter based on adblock db @param webpage as WebKit2WebExtension.WebPage @param request as WebKit2.URIRequest @param redirect as WebKit2WebExtension.URIResponse """ uri = webpage.get_uri() parsed = urlparse(uri) request_uri = request.get_uri() parsed_request = urlparse(request_uri) netloc = parsed.netloc.split(".")[-2:] netloc_request = parsed_request.netloc.split(".")[-2:] if netloc == netloc_request and\ App().settings.get_value("trust-websites-adblock"): pass elif App().settings.get_value("adblock") and\ parsed_request.scheme in ["http", "https"] and\ not App().adblock_exceptions.find_parsed(parsed_request): if App().adblock.is_netloc_blocked(parsed_request.netloc) or\ App().adblock.is_uri_blocked(request_uri, parsed_request.netloc): Logger.debug("AdblockExtension: blocking %s ->%s", request_uri, uri) return True if App().settings.get_value("do-not-track"): headers = request.get_http_headers() if headers is not None: headers.append("DNT", "1")
def __save_abp_rules(self, rules): """ Save rules to db @param rules as bytes """ SqlCursor.add(self) result = rules.decode("utf-8") count = 0 for line in result.split('\n'): SqlCursor.allow_thread_execution(self) if self.__cancellable.is_cancelled(): SqlCursor.remove(self) raise Exception("Cancelled") if "-abp-" in line or "$" in line or "!" in line or "[" in line: continue elif line.startswith("##"): self.__save_css_default_rule(line) elif "#@#" in line: self.__save_css_exception(line) elif "##" in line: self.__save_css_domain_rule(line) elif line.startswith("@@"): self.__save_abp_rule(line[2:], True) else: self.__save_abp_rule(line, False) Logger.debug("Add abp filter: %s", line) count += 1 if count == 1000: SqlCursor.commit(self) # Do not flood sqlite, this allow webkit extension to run sleep(0.1) count = 0 SqlCursor.remove(self)
def new_page(self, uri, loading_type): """ Open a new page @param uri as uri @param loading_type as Gdk.LoadingType """ parsed = urlparse(uri) if App().settings.get_value("adblock") and\ parsed.scheme in ["http", "https"] and\ not App().adblock_exceptions.find_parsed(parsed): if App().adblock.is_netloc_blocked(parsed.netloc) or\ App().adblock.is_uri_blocked(uri, parsed.netloc): Logger.debug("WebView::new_page(): blocking %s ->%s", uri, self.uri) return True if loading_type == LoadingType.POPOVER: if self.ephemeral: webview = WebView.new_ephemeral(self._window, None) else: webview = WebView.new(self._window, None) self._window.container.popup_webview(webview, True) GLib.idle_add(webview.load_uri, uri) else: self.__new_pages_opened += 1 webview = self._window.container.add_webview( uri, loading_type, self.ephemeral, None, self.atime - self.__new_pages_opened) webview.set_parent(self) self.add_child(webview)
def uncache(self, uri, suffix): """ Remove from cache @param uri as str @param suffix as str """ try: f = Gio.File.new_for_path(self.get_path(uri, suffix)) f.delete() except Exception as e: Logger.debug("Art::uncache(): %s", e)
def __on_get_secret(self, source, result): """ Store secret proxy @param source as GObject.Object @param result as Gio.AsyncResult """ try: self.__secret = Secret.Service.get_finish(result) except Exception as e: self.__secret = -1 Logger.debug("PasswordsHelper::__on_get_secret(): %s", e)
def store(self, user_form_name, user_form_value, pass_form_name, pass_form_value, hostname_uri, form_uri, uuid, callback, *args): """ Store password @param user_form_name as str @param user_form_value as str @param pass_form_name as str @param pass_form_value as str @param hostname_uri as str @param form_uri as str @param uuid as str @param callback as function """ # seems to happen, thanks firefox if form_uri is None: return try: self.__wait_for_secret(self.store, user_form_name, user_form_value, pass_form_name, pass_form_value, hostname_uri, form_uri, uuid, callback, *args) schema_string = "org.gnome.Eolie: %s > %s" % (user_form_value, hostname_uri) SecretSchema = { "type": Secret.SchemaAttributeType.STRING, "uuid": Secret.SchemaAttributeType.STRING, "login": Secret.SchemaAttributeType.STRING, "hostname": Secret.SchemaAttributeType.STRING, "formSubmitURL": Secret.SchemaAttributeType.STRING, "userform": Secret.SchemaAttributeType.STRING, "passform": Secret.SchemaAttributeType.STRING, } SecretAttributes = { "type": "eolie web login", "uuid": uuid, "login": user_form_value, "hostname": hostname_uri, "formSubmitURL": form_uri, "userform": user_form_name, "passform": pass_form_name } schema = Secret.Schema.new("org.gnome.Eolie", Secret.SchemaFlags.NONE, SecretSchema) Secret.password_store(schema, SecretAttributes, Secret.COLLECTION_DEFAULT, schema_string, pass_form_value, None, callback) except Exception as e: Logger.debug("PasswordsHelper::store(): %s", e)
def __on_clear_search(self, source, result, callback=None, *args): """ Clear passwords @param source as GObject.Object @param result as Gio.AsyncResult """ try: if result is not None: items = source.search_finish(result) for item in items: item.delete(None, None) if callback is not None: callback(*args) except Exception as e: Logger.debug("PasswordsHelper::__on_clear_search(): %s", e)
def clear_all(self): """ Clear passwords """ try: self.__wait_for_secret(self.clear_all) SecretSchema = {"type": Secret.SchemaAttributeType.STRING} SecretAttributes = {"type": "eolie web login"} schema = Secret.Schema.new("org.gnome.Eolie", Secret.SchemaFlags.NONE, SecretSchema) self.__secret.search(schema, SecretAttributes, Secret.SearchFlags.ALL, None, self.__on_clear_search) except Exception as e: Logger.debug("PasswordsHelper::clear_all(): %s", e)
def clear_sync(self, callback, *args): """ Clear sync secrets @param callback as function """ try: SecretSchema = {"sync": Secret.SchemaAttributeType.STRING} SecretAttributes = {"sync": "mozilla"} schema = Secret.Schema.new("org.gnome.Eolie", Secret.SchemaFlags.NONE, SecretSchema) self.__secret.search(schema, SecretAttributes, Secret.SearchFlags.ALL, None, self.__on_clear_search, callback, *args) except Exception as e: Logger.debug("PasswordsHelper::clear_sync(): %s", e)
def get_sync(self, callback, *args): """ Get sync password @param callback as function """ try: self.__wait_for_secret(self.get_sync, callback, *args) SecretSchema = {"sync": Secret.SchemaAttributeType.STRING} SecretAttributes = {"sync": "mozilla"} schema = Secret.Schema.new("org.gnome.Eolie", Secret.SchemaFlags.NONE, SecretSchema) self.__secret.search(schema, SecretAttributes, Secret.SearchFlags.NONE, None, self.__on_secret_search, None, callback, *args) except Exception as e: Logger.debug("PasswordsHelper::get_sync(): %s", e)
def update_zoom_level(self): """ Update zoom level """ try: zoom_level = App().websettings.get_zoom(self.uri) if zoom_level is None: zoom_level = 100 if self.__related_view is None: zoom_level *= self._window.zoom_level else: window = self.__related_view.get_ancestor(Gtk.Window) if window is not None and hasattr(window, "zoom_level"): zoom_level *= window.zoom_level except Exception as e: Logger.error("WebView::update_zoom_level(): %s", e) Logger.debug("Update zoom level: %s", zoom_level) self.set_zoom_level(zoom_level / 100)
def __on_load_uri_content(self, uri, status, content, uris): """ Save loaded values @param uri as str @param status as bool @param content as bytes @param uris as [str] """ Logger.debug("DatabaseAdblock::__on_load_uri_content(): %s", uri) if status: if uri in self.__URIS: self.__task_helper.run(self.__save_rules, content, callback=(self.__on_save_rules, uris)) else: self.__task_helper.run(self.__save_abp_rules, content, callback=(self.__on_save_rules, uris)) else: self.__on_save_rules(None, uris)
def store_sync(self, login, password, uid, token, keyB, callback=None, *args): """ Store Firefox Sync password @param login as str @param password as str @param uid as str @param token as str @param keyB as str @param callback as function @param data """ try: self.__wait_for_secret(self.store_sync, login, password, uid, token, keyB, callback) schema_string = "org.gnome.Eolie.sync" SecretSchema = { "sync": Secret.SchemaAttributeType.STRING, "login": Secret.SchemaAttributeType.STRING, "uid": Secret.SchemaAttributeType.STRING, "token": Secret.SchemaAttributeType.STRING, "keyB": Secret.SchemaAttributeType.STRING } schema = Secret.Schema.new("org.gnome.Eolie", Secret.SchemaFlags.NONE, SecretSchema) SecretAttributes = { "sync": "mozilla", "login": login, "uid": uid, "token": token, "keyB": keyB } Secret.password_store(schema, SecretAttributes, Secret.COLLECTION_DEFAULT, schema_string, password, None, callback, *args) except Exception as e: Logger.debug("PasswordsHelper::store_sync(): %s", e)
def clear(self, uuid, callback=None, *args): """ Clear password @param uuid as str @param callback as function """ try: self.__wait_for_secret(self.clear, uuid) SecretSchema = { "type": Secret.SchemaAttributeType.STRING, "uuid": Secret.SchemaAttributeType.STRING } SecretAttributes = {"type": "eolie web login", "uuid": uuid} schema = Secret.Schema.new("org.gnome.Eolie", Secret.SchemaFlags.NONE, SecretSchema) self.__secret.search(schema, SecretAttributes, Secret.SearchFlags.ALL, None, self.__on_clear_search, callback, *args) except Exception as e: Logger.debug("PasswordsHelper::clear(): %s", e)
def get_all(self, callback, *args): """ Call function @param callback as function @param args """ try: self.__wait_for_secret(self.get_all, callback, *args) SecretSchema = { "type": Secret.SchemaAttributeType.STRING, } SecretAttributes = { "type": "eolie web login", } schema = Secret.Schema.new("org.gnome.Eolie", Secret.SchemaFlags.NONE, SecretSchema) self.__secret.search(schema, SecretAttributes, Secret.SearchFlags.ALL, None, self.__on_secret_search, None, callback, *args) except Exception as e: Logger.debug("PasswordsHelper::get_all(): %s", e)
def _on_load_changed(self, webview, event): """ Update internals @param webview as WebView @param event as WebKit2.LoadEvent """ parsed = urlparse(self.uri) if event == WebKit2.LoadEvent.STARTED: self.emit("uri-changed", self.uri) elif event == WebKit2.LoadEvent.REDIRECTED: # Block ads if App().settings.get_value("adblock") and\ webview.__related_view is not None and\ parsed.scheme in ["http", "https"] and\ not App().adblock_exceptions.find_parsed(parsed): if App().adblock.is_netloc_blocked(parsed.netloc) or\ App().adblock.is_uri_blocked(self.uri, parsed.netloc): Logger.debug("WebView::__wait_for_uri(): blocking %s", self.uri) webview.stop_loading() self._window.container.close_view(self.view) return elif event == WebKit2.LoadEvent.COMMITTED: self.emit("uri-changed", self.uri) http_scheme = parsed.scheme in ["http", "https"] self.update_zoom_level() # Setup eolie internal adblocker if App().settings.get_value("adblock") and\ http_scheme: exception = App().adblock_exceptions.find_parsed(parsed) if not exception: noext = ".".join(parsed.netloc.split(".")[:-1]) javascripts = [ "adblock_%s.js" % parsed.netloc, "adblock_%s.js" % noext ] for javascript in javascripts: f = Gio.File.new_for_path("%s/%s" % (ADBLOCK_JS, javascript)) if f.query_exists(): (status, content, tag) = f.load_contents(None) js = content.decode("utf-8") self.run_javascript(js, None, None) break elif event == WebKit2.LoadEvent.FINISHED: self.update_spell_checking(self.uri) self.run_javascript_from_gresource( "/org/gnome/Eolie/Extensions.js", None, None) if App().show_tls: try: from OpenSSL import crypto from datetime import datetime (valid, tls, errors) = webview.get_tls_info() if tls is not None: Logger.info("***************************************" "***************************************") cert_pem = tls.get_property("certificate-pem") cert = crypto.load_certificate(crypto.FILETYPE_PEM, cert_pem) subject = cert.get_subject() Logger.info("CN: %s", subject.CN) start_bytes = cert.get_notBefore() end_bytes = cert.get_notAfter() start = datetime.strptime(start_bytes.decode("utf-8"), "%Y%m%d%H%M%SZ") end = datetime.strptime(end_bytes.decode("utf-8"), "%Y%m%d%H%M%SZ") Logger.info("Valid from %s to %s", (start, end)) Logger.info("Serial number: %s", cert.get_serial_number()) Logger.info(cert_pem) Logger.info("***************************************" "***************************************") except Exception as e: Logger.info("Please install OpenSSL python support: %s", e)