def update_user_pass(interface, messagedialog_label, messagedialog_spinner):
"""Function that updates username and password.
"""
username_field = interface.get_object("update_username_input")
password_field = interface.get_object("update_password_input")
username_text = username_field.get_text().strip()
password_text = password_field.get_text().strip()
if len(username_text) == 0 or len(password_text) == 0:
messagedialog_label.set_markup("Both fields need to be filled!")
messagedialog_spinner.hide()
return
gui_logger.debug(">>> Running \"set_username_password\".")
set_config_value("USER", "username", username_text)
with open(PASSFILE, "w") as f:
f.write("{0}\n{1}".format(username_text, password_text))
gui_logger.debug("Passfile updated")
os.chmod(PASSFILE, 0o600)
messagedialog_label.set_markup("Username and password updated!")
password_field.set_text("")
messagedialog_spinner.hide()
messagedialog_label.set_markup("Username and password updated.")
gui_logger.debug(">>> Ended tasks in \"set_username_password\" thread.")
def update_pvpn_plan(interface, messagedialog_label, messagedialog_spinner, tier, tier_display):
"""Function that updates ProtonVPN plan.
"""
protonvpn_plan = tier
visionary_compare = 0
gui_logger.debug(">>> Running \"set_protonvpn_tier\".")
visionary_compare = protonvpn_plan
if protonvpn_plan == 4:
protonvpn_plan = 3
# Lower tier by one to match API allocation
protonvpn_plan -= 1
set_config_value("USER", "tier", str(protonvpn_plan))
messagedialog_label.set_markup("ProtonVPN Plan has been updated to <b>{}</b>!\nServers list will be refreshed.".format(tier_display))
messagedialog_spinner.hide()
gui_logger.debug(">>> Result: \"{0}\"".format("ProtonVPN Plan has been updated!"))
time.sleep(1.5)
load_on_start({"interface":interface, "gui_enabled": True})
populate_servers_dict = {
"tree_object": interface.get_object("ServerTreeStore"),
"servers": False
}
gobject.idle_add(populate_server_list, populate_servers_dict)
gui_logger.debug(">>> Ended tasks in \"set_protonvpn_tier\" thread.")
def set_dns(self, dns_value):
try:
set_config_value("USER", "dns_leak_protection", dns_value)
except:
gui_logger.debug("Could not update DNS Protection settings to: {}".format(dns_value))
return False
return True
def set_default_protocol(self, protocol):
try:
set_config_value("USER", "default_protocol", protocol)
except:
gui_logger.debug("Could not update default Protocol to: {}".format(protocol))
return False
return True
def update_def_protocol(openvpn_protocol):
"""Function that updates default protocol.
"""
gui_logger.debug(">>> Running \"set_default_protocol\".")
set_config_value("USER", "default_protocol", openvpn_protocol)
gui_logger.debug(">>> Ended tasks in \"set_default_protocol\" thread.")
def set_killswitch(self, update_to):
try:
set_config_value("USER", "killswitch", update_to)
except:
gui_logger.debug("Could not update KillSwitch to: {}".format(update_to))
return False
return True
def update_dns(dns_value):
"""Function that updates DNS settings.
"""
set_config_value("USER", "dns_leak_protection", dns_value)
# set_config_value("USER", "custom_dns", custom_dns)
gui_logger.debug(">>> Result: \"{0}\"".format("DNS Management updated."))
gui_logger.debug(">>> Ended tasks in \"dns_leak_switch_clicked\" thread.")
def update_killswitch(update_to):
"""Function that updates killswitch configurations.
"""
set_config_value("USER", "killswitch", update_to)
# Update killswitch label
result = ">>> Kill Switch configuration updated to {}".format("enabled" if update_to == "1" else "disabled")
gui_logger.debug(">>> Result: \"{0}\"".format(result))
gui_logger.debug(">>> Ended tasks in \"update_killswitch_switch_changed\" thread.")
def update_def_protocol(interface, messagedialog_label, messagedialog_spinner,
openvpn_protocol):
"""Function that updates default protocol.
"""
gui_logger.debug(">>> Running \"set_default_protocol\".")
set_config_value("USER", "default_protocol", openvpn_protocol)
messagedialog_label.set_markup("Protocol updated to <b>{}</b>!".format(
openvpn_protocol.upper()))
messagedialog_spinner.hide()
gui_logger.debug(">>> Ended tasks in \"set_default_protocol\" thread.")
def set_user_pass(self, username, password):
user_pass = "******".format(username, password)
echo_to_passfile = "echo -e {} > {}".format(user_pass, PASSFILE)
result_bool, display_message = self.root_command(["bash", "-c", echo_to_passfile])
if not result_bool:
gui_logger.debug("Could not update Passfile")
return result_bool, display_message
set_config_value("USER", "username", username)
return result_bool, "Username and password <b>updated</b>!"
def check_update(self):
"""Return the download URL if Update is available, False otherwise"""
pvpncli_logger.logger.debug("Checking for new update")
current_version = list(VERSION.split("."))
current_version = [int(i) for i in current_version]
pvpncli_logger.logger.debug(f"Current: {current_version}")
latest_version = self.get_latest_version()
if not latest_version:
# Skip if get_latest_version() ran into errors
return
latest_version = latest_version.split(".")
latest_version = [int(i) for i in latest_version]
pvpncli_logger.logger.debug(f"Latest: {latest_version}")
for idx, i in enumerate(latest_version):
if i > current_version[idx]:
pvpncli_logger.logger.debug("Update found")
update_available = True
break
elif i < current_version[idx]:
pvpncli_logger.logger.debug("No update")
update_available = False
break
else:
pvpncli_logger.logger.debug("No update")
update_available = False
pvpncli_utils.set_config_value("metadata", "last_update_check",
int(time()))
if update_available:
latest_version = '.'.join([str(x) for x in latest_version])
update_available_popup = PvpnPopup(
title='Update Available!',
label_text=(
f"protonvpn-cli-gui v{latest_version} is now available."),
dt=5,
)
update_available_popup_label = PvpnPopupLabel(
text=update_available_popup.label_text,
text_size=(400, 400),
)
update_available_popup.add_widget(update_available_popup_label)
Clock.schedule_once(
update_available_popup.open,
1,
)
def generate_user_pass_file(self, username, password):
user_pass = "******".format(username, password)
echo_to_passfile = "echo -e {} > {}".format(user_pass, PASSFILE)
sudo_type = "pkexec" if is_polkit_installed else "sudo"
try:
output = subprocess.check_output([sudo_type, "bash", "-c", echo_to_passfile], stderr=subprocess.STDOUT, timeout=30)
set_config_value("USER", "username", username)
except (subprocess.TimeoutExpired, subprocess.CalledProcessError) as e:
gui_logger.debug(e)
return False
gui_logger.debug("Passfile generated")
return True
def update_killswitch(interface, messagedialog_label, messagedialog_spinner,
ks_value):
"""Function that updates killswitch configurations.
"""
set_config_value("USER", "killswitch", ks_value)
# Update killswitch label
result = "Kill Switch configuration updated to <b>{}</b>!".format(
"enabled" if ks_value == "1" else "disabled")
messagedialog_label.set_markup()
messagedialog_spinner.hide()
gui_logger.debug(">>> Result: \"{0}\"".format(result))
gui_logger.debug(
">>> Ended tasks in \"update_killswitch_switch_changed\" thread.")
def update_dns(interface, messagedialog_label, messagedialog_spinner,
dns_value):
"""Function that updates DNS settings.
"""
set_config_value("USER", "dns_leak_protection", dns_value)
# set_config_value("USER", "custom_dns", custom_dns)
messagedialog_label.set_markup(
"DNS Management updated to <b>{0}</b>!".format(
"enabled" if dns_value == "1" else "disabled"))
messagedialog_spinner.hide()
gui_logger.debug(">>> Result: \"{0}\"".format("DNS Management updated."))
gui_logger.debug(">>> Ended tasks in \"dns_leak_switch_clicked\" thread.")
def set_pvpn_tier(self, protonvpn_plan):
visionary_compare = 0
visionary_compare = int(protonvpn_plan)
if protonvpn_plan == 4:
protonvpn_plan = 3
# Lower tier by one to match API allocation
protonvpn_plan -= 1
try:
set_config_value("USER", "tier", str(protonvpn_plan))
except:
gui_logger.debug("Could not update ProtonVPN Plan to: {}".format(protonvpn_plan))
return False
return True
def update_split_tunneling_status(update_to):
if update_to == "1":
result = "Split tunneling has been <b>enabled</b>!\n"
else:
if os.path.isfile(SPLIT_TUNNEL_FILE):
os.remove(SPLIT_TUNNEL_FILE)
result = "Split tunneling has been <b>disabled</b>!\n"
if int(get_config_value("USER", "killswitch")):
set_config_value("USER", "killswitch", 0)
result = result + "Split Tunneling <b>can't</b> be used with Kill Switch, Kill Switch has been <b>disabled</b>!\n\n"
time.sleep(1)
set_config_value("USER", "split_tunnel", update_to)
gui_logger.debug(">>> Result: \"{0}\"".format(result))
gui_logger.debug(">>> Ended tasks in \"set_split_tunnel\" thread.")
def set_split_tunneling(self, update_to):
if not update_to == "1":
try:
if os.path.isfile(SPLIT_TUNNEL_FILE):
os.remove(SPLIT_TUNNEL_FILE)
except:
return False
try:
if int(get_config_value("USER", "killswitch")):
set_config_value("USER", "killswitch", 0)
except:
gui_logger.debug("Could not disable KillSwitch")
return False
try:
set_config_value("USER", "split_tunnel", update_to)
except:
gui_logger.debug("Could not update split_tunnel to: {}".format(update_to))
return False
def setup_user(self, user_data):
ovpn_username = user_data['username']
ovpn_password = user_data['password']
user_tier = user_data['protonvpn_plan']
user_protocol = user_data['openvpn_protocol']
if not self.generate_user_pass_file(ovpn_username, ovpn_password):
shutil.rmtree(CONFIG_DIR)
return False
gui_logger.debug("Passfile created")
pull_server_data(force=True)
if user_tier == 4:
user_tier = 3
user_tier -= 1
set_config_value("USER", "username", ovpn_username)
set_config_value("USER", "tier", user_tier)
set_config_value("USER", "default_protocol", user_protocol)
set_config_value("USER", "dns_leak_protection", 1)
set_config_value("USER", "custom_dns", None)
set_config_value("USER", "killswitch", 0)
set_config_value("USER", "split_tunnel", 0)
set_config_value("USER", "initialized", 1)
return True
def update_split_tunneling(interface, messagedialog_label,
messagedialog_spinner):
"""Function that updates split tunneling configurations.
"""
result = "Split tunneling configurations <b>updated</b>!\n"
split_tunneling_buffer = interface.get_object(
"split_tunneling_textview").get_buffer()
# Get text takes a start_iter, end_iter and the buffer itself as last param
split_tunneling_content = split_tunneling_buffer.get_text(
split_tunneling_buffer.get_start_iter(),
split_tunneling_buffer.get_end_iter(), split_tunneling_buffer)
# Split IP/CIDR by either ";" and/or "\n"
split_tunneling_content = re.split('[;\n]', split_tunneling_content)
# Remove empty spaces
split_tunneling_content = [
content.strip() for content in split_tunneling_content
]
# Remove empty list elements
split_tunneling_content = list(filter(None, split_tunneling_content))
for ip in split_tunneling_content:
if not is_valid_ip(ip):
messagedialog_spinner.hide()
messagedialog_label.set_markup(
"<b>{0}</b> is not valid!\nNone of the IP's were added, please try again with a different IP."
.format(ip))
gui_logger.debug("[!] Invalid IP \"{0}\".".format(ip))
return
gui_logger.debug(">>> Running \"set_split_tunnel\".")
if len(split_tunneling_content) == 0:
set_config_value("USER", "split_tunnel", 0)
if os.path.isfile(SPLIT_TUNNEL_FILE):
os.remove(SPLIT_TUNNEL_FILE)
result = "Split tunneling <b>disabled</b>!\n\n"
if int(get_config_value("USER", "killswitch")):
set_config_value("USER", "killswitch", 0)
result = result + "Split Tunneling <b>can't</b> be used with Kill Switch.\nKill Switch has been <b>disabled</b>!\n\n"
time.sleep(1)
set_config_value("USER", "split_tunnel", 1)
with open(SPLIT_TUNNEL_FILE, "w") as f:
for ip in split_tunneling_content:
f.write("\n{0}".format(ip))
if os.path.isfile(SPLIT_TUNNEL_FILE):
change_file_owner(SPLIT_TUNNEL_FILE)
if len(split_tunneling_content) > 0:
result = result + "The following servers were added:\n\n{}".format(
[ip for ip in split_tunneling_content])
else:
# If no no config file exists,
# split tunneling should be disabled again
gui_logger.debug("No split tunneling file existing.")
set_config_value("USER", "split_tunnel", 0)
result = "No split tunneling file was found, split tunneling will be <b>disabled</b>!\n\n"
messagedialog_label.set_markup(result)
messagedialog_spinner.hide()
gui_logger.debug(">>> Result: \"{0}\"".format(result))
gui_logger.debug(">>> Ended tasks in \"set_split_tunnel\" thread.")
def on_login(interface, username_field, password_field, messagedialog_label,
user_window, login_window, messagedialog_window):
"""Function that initializes a user profile.
"""
server_list_object = interface.get_object("ServerListStore")
populate_servers_dict = {
"list_object": server_list_object,
"servers": False
}
user_data = prepare_initilizer(username_field, password_field, interface)
config = configparser.ConfigParser()
config["USER"] = {
"username": "******",
"tier": "None",
"default_protocol": "None",
"initialized": "0",
"dns_leak_protection": "1",
"custom_dns": "None",
"check_update_interval": "3",
"killswitch": "0",
"split_tunnel": "0",
"autoconnect": "0"
}
config["metadata"] = {
"last_api_pull": "0",
"last_update_check": str(int(time.time())),
}
with open(CONFIG_FILE, "w") as f:
config.write(f)
change_file_owner(CONFIG_FILE)
gui_logger.debug("pvpn-cli.cfg initialized")
change_file_owner(CONFIG_DIR)
ovpn_username = user_data['username']
ovpn_password = user_data['password']
user_tier = user_data['protonvpn_plan']
user_protocol = user_data['openvpn_protocol']
pull_server_data(force=True)
make_ovpn_template()
if user_tier == 4:
user_tier = 3
user_tier -= 1
set_config_value("USER", "username", ovpn_username)
set_config_value("USER", "tier", user_tier)
set_config_value("USER", "default_protocol", user_protocol)
set_config_value("USER", "dns_leak_protection", 1)
set_config_value("USER", "custom_dns", None)
set_config_value("USER", "killswitch", 0)
set_config_value("USER", "split_tunnel", 0)
set_config_value("USER", "autoconnect", "0")
with open(PASSFILE, "w") as f:
f.write("{0}\n{1}".format(ovpn_username, ovpn_password))
gui_logger.debug("Passfile created")
os.chmod(PASSFILE, 0o600)
gui_config = configparser.ConfigParser()
gui_config["connections"] = {"display_secure_core": False}
gui_config["general_tab"] = {
"start_min": False,
"start_on_boot": False,
"show_notifications": False,
}
gui_config["tray_tab"] = {
TRAY_CFG_DATA_TX: "0",
TRAY_CFG_SERVENAME: "0",
TRAY_CFG_TIME_CONN: "0",
TRAY_CFG_SERVERLOAD: "0",
}
gui_config["conn_tab"] = {
"autoconnect": "dis",
"quick_connect": "dis",
}
with open(GUI_CONFIG_FILE, "w") as f:
gui_config.write(f)
change_file_owner(GUI_CONFIG_FILE)
gui_logger.debug("pvpn-gui.cfg initialized")
set_config_value("USER", "initialized", 1)
load_on_start({
"interface": interface,
"gui_enabled": True,
"messagedialog_label": messagedialog_label
})
