nik/liana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gui: allow user to not validate the ssl domain for an electrum server

Browse Source
This commit is contained in:
pythcoiner 2024-12-16 09:43:23 +01:00
parent efb23300da
commit 09bb450b1f
9 changed files with 119 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
contrib/lianad_config_example.toml
View File

@ -50,8 +50,13 @@ poll_interval_secs = 30
# In order to connect, it needs the address as a string, which can be
# optionally prefixed with "ssl://" or "tcp://". If omitted, "tcp://"
# will be assumed.
# `validate_domain` field is optional: used in case of SSL connection,
# if set to `false`, internal electrum client will not try to validate
# the domain associated to the certificate: it's useful in case of
# self-signed certificate. Its default value is `true`.
# [electrum_config]
# addr = "127.0.0.1:50001"
# validate_domain = false
#
#
[bitcoind_config]

8
liana-gui/src/app/state/settings/bitcoind.rs
View File

@ -323,6 +323,7 @@ impl BitcoindSettings {
}
}
}
view::SettingsEditMessage::ValidateDomainEdited(_) => {}
view::SettingsEditMessage::BitcoindRpcAuthTypeSelected(auth_type) => {
if !self.processing {
self.selected_auth_type = auth_type;
@ -462,6 +463,7 @@ impl ElectrumSettings {
daemon_config.bitcoin_backend =
Some(lianad::config::BitcoinBackend::Electrum(ElectrumConfig {
addr: self.addr.value.clone(),
validate_domain: self.electrum_config.validate_domain,
}));
self.processing = true;
return Command::perform(async move { daemon_config }, |cfg| {
@ -470,6 +472,11 @@ impl ElectrumSettings {
}
}
view::SettingsEditMessage::Clipboard(text) => return clipboard::write(text),
view::SettingsEditMessage::ValidateDomainEdited(b) => {
if !self.processing {
self.electrum_config.validate_domain = b;
}
}
_ => {}
};
Command::none()
@ -484,6 +491,7 @@ impl ElectrumSettings {
cache.blockheight,
&self.addr,
self.processing,
self.electrum_config.validate_domain,
)
} else {
view::settings::electrum(

1
liana-gui/src/app/view/message.rs
View File

@ -88,6 +88,7 @@ pub enum RemoteBackendSettingsMessage {
pub enum SettingsEditMessage {
Select,
FieldEdited(&'static str, String),
ValidateDomainEdited(bool),
BitcoindRpcAuthTypeSelected(RpcAuthType),
Cancel,
Confirm,

7
liana-gui/src/app/view/settings.rs
View File

@ -32,7 +32,7 @@ use crate::{
hw::HardwareWallet,
node::{
bitcoind::{RpcAuthType, RpcAuthValues},
electrum,
electrum::{self, validate_domain_checkbox},
},
};
@ -563,6 +563,7 @@ pub fn electrum_edit<'a>(
blockheight: i32,
addr: &form::Value<String>,
processing: bool,
validate_domain: bool,
) -> Element<'a, SettingsEditMessage> {
let mut col = Column::new().spacing(20);
if is_configured_node_type && blockheight != 0 {
@ -595,6 +596,9 @@ pub fn electrum_edit<'a>(
.push(separation().width(Length::Fill));
}
let checkbox = validate_domain_checkbox(addr, validate_domain, |b| {
SettingsEditMessage::ValidateDomainEdited(b)
});
col = col.push(
Column::new()
.push(text("Address:").bold().small())
@ -606,6 +610,7 @@ pub fn electrum_edit<'a>(
.size(P1_SIZE)
.padding(5),
)
.push_maybe(checkbox)
.push(text(electrum::ADDRESS_NOTES).size(P2_SIZE))
.spacing(5),
);

1
liana-gui/src/installer/message.rs
View File

@ -81,6 +81,7 @@ pub enum DefineBitcoind {
#[derive(Debug, Clone)]
pub enum DefineElectrum {
ConfigFieldEdited(electrum::ConfigField, String),
ValidDomainChanged(bool),
}
#[derive(Debug, Clone)]

21
liana-gui/src/installer/step/node/electrum.rs
View File

@ -14,9 +14,19 @@ use crate::{
node::electrum::ConfigField,
};
#[derive(Clone, Default)]
#[derive(Clone)]
pub struct DefineElectrum {
address: form::Value<String>,
validate_domain: bool,
}
impl Default for DefineElectrum {
fn default() -> Self {
Self {
address: Default::default(),
validate_domain: true,
}
}
}
impl DefineElectrum {
@ -38,6 +48,7 @@ impl DefineElectrum {
crate::node::electrum::is_electrum_address_valid(&value);
}
},
message::DefineElectrum::ValidDomainChanged(v) => self.validate_domain = v,
};
};
Command::none()
@ -47,6 +58,7 @@ impl DefineElectrum {
if self.can_try_ping() {
ctx.bitcoin_backend = Some(lianad::config::BitcoinBackend::Electrum(ElectrumConfig {
addr: self.address.value.clone(),
validate_domain: self.validate_domain,
}));
return true;
}
@ -54,12 +66,15 @@ impl DefineElectrum {
}
pub fn view(&self) -> Element<Message> {
view::define_electrum(&self.address)
view::define_electrum(&self.address, self.validate_domain)
}
pub fn ping(&self) -> Result<(), Error> {
let builder = electrum_client::Config::builder();
let config = builder.timeout(Some(3)).build();
let config = builder
.timeout(Some(3))
.validate_domain(self.validate_domain)
.build();
let client = electrum_client::Client::from_config(&self.address.value, config)
.map_err(|e| Error::Electrum(e.to_string()))?;
client

14
liana-gui/src/installer/view/mod.rs
View File

@ -29,6 +29,7 @@ use liana_ui::{
widget::*,
};
use crate::node::electrum::validate_domain_checkbox;
use crate::{
hw::{is_compatible_with_tapminiscript, HardwareWallet, UnsupportedReason},
installer::{
@ -1134,7 +1135,15 @@ pub fn define_bitcoind<'a>(
.into()
}
pub fn define_electrum<'a>(address: &form::Value<String>) -> Element<'a, Message> {
pub fn define_electrum<'a>(
address: &form::Value<String>,
validate_domain: bool,
) -> Element<'a, Message> {
let checkbox = validate_domain_checkbox(address, validate_domain, |b| {
Message::DefineNode(DefineNode::DefineElectrum(
message::DefineElectrum::ValidDomainChanged(b),
))
});
let col_address = Column::new()
.push(text("Address:").bold())
.push(
@ -1150,7 +1159,8 @@ pub fn define_electrum<'a>(address: &form::Value<String>) -> Element<'a, Message
.size(text::P1_SIZE)
.padding(10),
)
.push(text(electrum::ADDRESS_NOTES).size(text::P2_SIZE))
.push_maybe(checkbox)
.push(text(electrum::ADDRESS_NOTES))
.spacing(10);
Column::new().push(col_address).spacing(50).into()

30
liana-gui/src/node/electrum.rs
View File

@ -1,13 +1,18 @@
use std::fmt;
use iced::{widget::checkbox, Element, Renderer};
use liana_ui::{component::form, theme::Theme};
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum ConfigField {
Address,
}
pub const ADDRESS_NOTES: &str = "Note: include \"ssl://\" as a prefix \
for SSL connections. Be aware that self-signed \
SSL certificates are currently not supported.";
for SSL connections.";
pub const VALID_SSL_DOMAIN_NOTES: &str = "Do not validate SSL Domain \
(check this only if you want to use a self-signed certificate)";
impl fmt::Display for ConfigField {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@ -17,6 +22,27 @@ impl fmt::Display for ConfigField {
}
}
pub fn validate_domain_checkbox<'a, F, M>(
addr: &form::Value<String>,
value: bool,
closure: F,
) -> Option<Element<'a, M, Theme, Renderer>>
where
F: 'a + Fn(bool) -> M,
M: 'a,
{
let checkbox = checkbox(VALID_SSL_DOMAIN_NOTES, !value).on_toggle(move |b| closure(!b));
if addr.valid && is_ssl(&addr.value) {
Some(checkbox.into())
} else {
None
}
}
pub fn is_ssl(value: &str) -> bool {
value.starts_with("ssl://")
}
pub fn is_electrum_address_valid(value: &str) -> bool {
let value_noprefix = if value.starts_with("ssl://") {
value.replacen("ssl://", "", 1)

50
lianad/src/config.rs
View File

@ -122,7 +122,7 @@ pub struct BitcoindConfig {
}
/// Everything we need to know for talking to Electrum serenely.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct ElectrumConfig {
/// The URL the Electrum's RPC is listening on.
/// Include "ssl://" for SSL. otherwise TCP will be assumed.
@ -130,17 +130,12 @@ pub struct ElectrumConfig {
pub addr: String,
/// If validate_domain == false, domain of ssl certificate will not be validated
/// (useful to allow usage of self signed certificates on local network)
#[serde(default)]
#[serde(default = "default_validate_domain")]
pub validate_domain: bool,
}
impl Default for ElectrumConfig {
fn default() -> Self {
Self {
addr: Default::default(),
validate_domain: true,
}
}
fn default_validate_domain() -> bool {
true
}
#[derive(Debug, Clone, Deserialize, Serialize)]
@ -299,7 +294,7 @@ impl Config {
mod tests {
use std::path::PathBuf;
use super::{config_file_path, BitcoindConfig, BitcoindRpcAuth, Config};
use super::*;
// Test the format of the configuration file
#[test]
@ -492,6 +487,41 @@ mod tests {
.contains("`auth` must be 'user:password'"));
}
// Test the format of the `electrum_config` section
#[test]
fn toml_electrum_config() {
// A valid config with `validate_domain`
let toml_str = r#"
addr = 'ssl://electrum.blockstream.info:60002'
validate_domain = false
"#
.trim_start()
.replace(" ", "");
toml::from_str::<ElectrumConfig>(&toml_str).expect("Deserializing toml_str");
let parsed = toml::from_str::<ElectrumConfig>(&toml_str).expect("Deserializing toml_str");
let serialized = toml::to_string_pretty(&parsed).expect("Serializing to toml");
assert_eq!(toml_str, serialized);
let expected = ElectrumConfig {
addr: "ssl://electrum.blockstream.info:60002".into(),
validate_domain: false,
};
assert_eq!(parsed, expected,);
// A valid config w/o `validate_domain`
let toml_str = r#"
addr = 'ssl://electrum.blockstream.info:60002'
"#
.trim_start()
.replace(" ", "");
let parsed = toml::from_str::<ElectrumConfig>(&toml_str).expect("Deserializing toml_str");
let expected = ElectrumConfig {
addr: "ssl://electrum.blockstream.info:60002".into(),
// `validate_domain` must default to true
validate_domain: true,
};
assert_eq!(parsed, expected,);
}
#[test]
fn config_directory() {
let filepath = config_file_path().expect("Getting config file path");