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)
