493 lines
19 KiB
Rust
493 lines
19 KiB
Rust
use std::{borrow::Cow, fs};
|
|
|
|
use iced::{
|
|
Alignment, Color, Length, Subscription, Task, application, clipboard, event,
|
|
keyboard::{self, Key, key},
|
|
theme, widget, window,
|
|
};
|
|
use rfd::{AsyncFileDialog, FileHandle};
|
|
|
|
use crate::db::{self, EntrySearchExt};
|
|
|
|
type Element<'a> = iced::Element<'a, Message, iced::Theme, iced::Renderer>;
|
|
|
|
#[derive(Clone)]
|
|
enum Message {
|
|
ChangeDbPath(String),
|
|
PickDb,
|
|
PickedDb(Option<FileHandle>),
|
|
|
|
ChangeKeyfilePath(String),
|
|
PickKeyfile,
|
|
PickedKeyfile(Option<FileHandle>),
|
|
|
|
ChangePassword(String),
|
|
ToggleSecurity,
|
|
OpenDb,
|
|
DbOpened(Result<keepass::Database, String>),
|
|
|
|
ChangeSelection(usize, db::BasicField),
|
|
|
|
SelectionLeft,
|
|
SelectionDown,
|
|
SelectionUp,
|
|
SelectionRight,
|
|
|
|
SelectionTop,
|
|
SelectionBottom,
|
|
|
|
ChangeQuery(String),
|
|
|
|
Copy,
|
|
|
|
FocusNext,
|
|
FocusPrevious,
|
|
FocusSearch,
|
|
|
|
Quit,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct State {
|
|
db_path: String,
|
|
db_path_exists: bool,
|
|
|
|
keyfile_path: String,
|
|
keyfile_path_exists: bool,
|
|
|
|
is_secure: bool,
|
|
password: String,
|
|
|
|
db: Option<keepass::Database>,
|
|
|
|
db_view: Vec<keepass::db::Entry>,
|
|
selected_entry: usize,
|
|
selected_field: db::BasicField,
|
|
query: String,
|
|
|
|
status: Cow<'static, str>,
|
|
error: Cow<'static, str>,
|
|
}
|
|
|
|
impl State {
|
|
fn new() -> (Self, Task<Message>) {
|
|
(
|
|
Self {
|
|
is_secure: true,
|
|
..Default::default()
|
|
},
|
|
if let Ok(db_path) = db::get_last_opened()
|
|
.inspect_err(|e| eprintln!("failed to get last-opened db: {e}"))
|
|
{
|
|
Task::done(Message::ChangeDbPath(db_path))
|
|
} else {
|
|
Task::none()
|
|
},
|
|
)
|
|
}
|
|
fn update(&mut self, message: Message) -> Task<Message> {
|
|
match message {
|
|
Message::ChangeDbPath(db_path) => {
|
|
self.db_path_exists = fs::exists(&db_path)
|
|
.inspect_err(|e| eprintln!("failed to check '{db_path}': {e}"))
|
|
.is_ok_and(|exists| exists);
|
|
self.db_path = db_path;
|
|
}
|
|
Message::PickDb => {
|
|
return Task::perform(
|
|
AsyncFileDialog::new()
|
|
.add_filter("kdbx", &["kdbx"])
|
|
.pick_file(),
|
|
Message::PickedDb,
|
|
);
|
|
}
|
|
Message::PickedDb(Some(file)) => {
|
|
return Task::done(Message::ChangeDbPath(
|
|
file.path().to_string_lossy().to_string(),
|
|
));
|
|
}
|
|
Message::PickedDb(None) => eprintln!("no path received from picker"),
|
|
|
|
Message::ChangeKeyfilePath(keyfile_path) => {
|
|
self.keyfile_path_exists = fs::exists(&keyfile_path)
|
|
.inspect_err(|e| eprintln!("failed to check '{keyfile_path}': {e}"))
|
|
.is_ok_and(|exists| exists);
|
|
self.keyfile_path = keyfile_path
|
|
}
|
|
Message::PickKeyfile => {
|
|
return Task::perform(AsyncFileDialog::new().pick_file(), Message::PickedKeyfile);
|
|
}
|
|
Message::PickedKeyfile(Some(file)) => {
|
|
return Task::done(Message::ChangeKeyfilePath(
|
|
file.path().to_string_lossy().to_string(),
|
|
));
|
|
}
|
|
Message::PickedKeyfile(None) => eprintln!("no path received from picker"),
|
|
|
|
Message::ChangePassword(password) => self.password = password,
|
|
Message::ToggleSecurity => self.is_secure = !self.is_secure,
|
|
Message::OpenDb => return self.open_db(),
|
|
|
|
Message::DbOpened(result) => {
|
|
match result {
|
|
Ok(db) => {
|
|
self.error = "".into();
|
|
self.db = Some(db);
|
|
self.populate_view();
|
|
}
|
|
Err(e) => self.error = e.into(),
|
|
}
|
|
self.status = "".into();
|
|
}
|
|
|
|
Message::ChangeSelection(i, field) => {
|
|
self.selected_entry = i;
|
|
self.selected_field = field;
|
|
return Task::done(Message::Copy);
|
|
}
|
|
Message::SelectionLeft => self.selected_field.previous(),
|
|
Message::SelectionDown => {
|
|
self.selected_entry =
|
|
(self.selected_entry.saturating_add(1)).clamp(0, self.db_view.len() - 1)
|
|
}
|
|
Message::SelectionUp => {
|
|
self.selected_entry =
|
|
(self.selected_entry.saturating_sub(1)).clamp(0, self.db_view.len() - 1)
|
|
}
|
|
Message::SelectionRight => self.selected_field.next(),
|
|
|
|
Message::SelectionTop => self.selected_entry = 0,
|
|
Message::SelectionBottom => self.selected_entry = self.db_view.len() - 1,
|
|
|
|
Message::ChangeQuery(str) => {
|
|
self.query = str;
|
|
self.populate_view();
|
|
}
|
|
|
|
Message::Copy => {
|
|
if let Some(entry_ref) = &self.db_view.get(self.selected_entry) {
|
|
if let Some(str) = match self.selected_field {
|
|
db::BasicField::Title => entry_ref.get_password(),
|
|
db::BasicField::Username => entry_ref.get_username(),
|
|
db::BasicField::Password => entry_ref.get_password(),
|
|
db::BasicField::Url => entry_ref.get_url(),
|
|
} {
|
|
self.error = "".into();
|
|
return clipboard::write(str.to_owned());
|
|
} else {
|
|
self.error = "nothing to copy!".into();
|
|
}
|
|
} else {
|
|
self.error = "nothing selected!".into();
|
|
}
|
|
}
|
|
|
|
Message::FocusNext => return widget::operation::focus_next(),
|
|
Message::FocusPrevious => return widget::operation::focus_previous(),
|
|
Message::FocusSearch => return widget::operation::focus("search"),
|
|
|
|
Message::Quit => return window::latest().and_then(window::close),
|
|
}
|
|
|
|
Task::none()
|
|
}
|
|
fn view(&self) -> Element<'_> {
|
|
let main = if self.db.is_some() {
|
|
widget::column([
|
|
widget::text_input("search query", &self.query)
|
|
.on_input(Message::ChangeQuery)
|
|
.id("search")
|
|
.into(),
|
|
widget::scrollable(
|
|
widget::grid(self.db_view.iter().enumerate().flat_map(|(i, entry)| {
|
|
[
|
|
if let Some(title) = entry.get_title() {
|
|
let field = db::BasicField::Title;
|
|
widget::button(widget::text(title))
|
|
.style(
|
|
if i == self.selected_entry && field == self.selected_field
|
|
{
|
|
widget::button::primary
|
|
} else {
|
|
widget::button::subtle
|
|
},
|
|
)
|
|
.on_press(Message::ChangeSelection(i, field))
|
|
.into()
|
|
} else {
|
|
widget::space().into()
|
|
},
|
|
if let Some(title) = entry.get_username() {
|
|
let field = db::BasicField::Username;
|
|
widget::button(widget::text(title))
|
|
.style(
|
|
if i == self.selected_entry && field == self.selected_field
|
|
{
|
|
widget::button::primary
|
|
} else {
|
|
widget::button::subtle
|
|
},
|
|
)
|
|
.on_press(Message::ChangeSelection(i, field))
|
|
.into()
|
|
} else {
|
|
widget::space().into()
|
|
},
|
|
if entry.get_password().is_some() {
|
|
let field = db::BasicField::Password;
|
|
widget::button(widget::text("[password hidden]"))
|
|
.style(
|
|
if i == self.selected_entry && field == self.selected_field
|
|
{
|
|
widget::button::primary
|
|
} else {
|
|
widget::button::subtle
|
|
},
|
|
)
|
|
.on_press(Message::ChangeSelection(i, field))
|
|
.into()
|
|
} else {
|
|
widget::space().into()
|
|
},
|
|
if let Some(title) = entry.get_url() {
|
|
let field = db::BasicField::Url;
|
|
widget::button(widget::text(title))
|
|
.style(
|
|
if i == self.selected_entry && field == self.selected_field
|
|
{
|
|
widget::button::primary
|
|
} else {
|
|
widget::button::subtle
|
|
},
|
|
)
|
|
.on_press(Message::ChangeSelection(i, field))
|
|
.into()
|
|
} else {
|
|
widget::space().into()
|
|
},
|
|
]
|
|
}))
|
|
.height(Length::Shrink)
|
|
.columns(4),
|
|
)
|
|
// I don't know why this needs to be here,
|
|
// but without it the search bar isn't shown
|
|
.height(Length::Fill)
|
|
.into(),
|
|
])
|
|
.into()
|
|
} else {
|
|
widget::container(
|
|
widget::column([
|
|
widget::row([
|
|
widget::text_input("database path", &self.db_path)
|
|
.on_input(Message::ChangeDbPath)
|
|
.into(),
|
|
widget::button("pick db")
|
|
.style(if self.db_path_exists {
|
|
widget::button::primary
|
|
} else {
|
|
widget::button::danger
|
|
})
|
|
.on_press(Message::PickDb)
|
|
.into(),
|
|
])
|
|
.into(),
|
|
widget::row([
|
|
widget::text_input("keyfile path", &self.keyfile_path)
|
|
.on_input(Message::ChangeKeyfilePath)
|
|
.into(),
|
|
widget::button("pick keyfile")
|
|
.style(
|
|
if self.keyfile_path.is_empty() || self.keyfile_path_exists {
|
|
widget::button::primary
|
|
} else {
|
|
widget::button::danger
|
|
},
|
|
)
|
|
.on_press(Message::PickKeyfile)
|
|
.into(),
|
|
])
|
|
.into(),
|
|
widget::row([
|
|
widget::text_input("password", &self.password)
|
|
.on_input(Message::ChangePassword)
|
|
.secure(self.is_secure)
|
|
.into(),
|
|
widget::checkbox(self.is_secure)
|
|
.label("security")
|
|
.on_toggle(|_| Message::ToggleSecurity)
|
|
.into(),
|
|
])
|
|
.spacing(10)
|
|
.into(),
|
|
widget::container(widget::button("open database").on_press_maybe(
|
|
if self.db_path_exists
|
|
&& (self.keyfile_path.is_empty() || self.keyfile_path_exists)
|
|
{
|
|
Some(Message::OpenDb)
|
|
} else {
|
|
None
|
|
},
|
|
))
|
|
.center_x(Length::Fill)
|
|
.into(),
|
|
])
|
|
.spacing(20)
|
|
.padding(20),
|
|
)
|
|
.center(Length::Fill)
|
|
.into()
|
|
};
|
|
|
|
let mut bar = Vec::new();
|
|
if !self.error.is_empty() {
|
|
bar.push(
|
|
widget::container(widget::text(&self.error).style(widget::text::danger))
|
|
.align_x(Alignment::Start)
|
|
.width(Length::Fill)
|
|
.into(),
|
|
);
|
|
}
|
|
if !self.status.is_empty() {
|
|
bar.push(
|
|
widget::container(widget::text(&self.status))
|
|
.align_x(Alignment::End)
|
|
.width(Length::Fill)
|
|
.into(),
|
|
);
|
|
}
|
|
|
|
widget::column([main, widget::row(bar).into()]).into()
|
|
}
|
|
|
|
fn subscription(&self) -> Subscription<Message> {
|
|
event::listen()
|
|
.with((self.db.is_some(), self.db_path_exists))
|
|
.filter_map(|((db_loaded, db_path_exists), event)| match event {
|
|
iced::Event::Keyboard(keyboard::Event::KeyPressed { key, modifiers, .. }) => {
|
|
match key.as_ref() {
|
|
Key::Character("p" | "f" | "i") if !db_loaded => Some(Message::PickDb),
|
|
Key::Character("v" | "s") if !db_loaded => Some(Message::ToggleSecurity),
|
|
|
|
Key::Named(key::Named::Enter) if !db_loaded && db_path_exists => {
|
|
Some(Message::OpenDb)
|
|
}
|
|
|
|
Key::Named(key::Named::Tab) => Some(if modifiers.shift() {
|
|
Message::FocusPrevious
|
|
} else {
|
|
Message::FocusNext
|
|
}),
|
|
Key::Character("/" | "f") => Some(Message::FocusSearch),
|
|
|
|
Key::Character("h") | Key::Named(key::Named::ArrowLeft) => {
|
|
Some(Message::SelectionLeft)
|
|
}
|
|
Key::Character("j") | Key::Named(key::Named::ArrowDown) => {
|
|
Some(Message::SelectionDown)
|
|
}
|
|
Key::Character("k") | Key::Named(key::Named::ArrowUp) => {
|
|
Some(Message::SelectionUp)
|
|
}
|
|
Key::Character("l") | Key::Named(key::Named::ArrowRight) => {
|
|
Some(Message::SelectionRight)
|
|
}
|
|
|
|
Key::Character("g") => Some(if modifiers.shift() {
|
|
Message::SelectionBottom
|
|
} else {
|
|
Message::SelectionTop
|
|
}),
|
|
Key::Named(key::Named::Home) => Some(Message::SelectionTop),
|
|
Key::Named(key::Named::End) => Some(Message::SelectionBottom),
|
|
|
|
Key::Character("y" | "c") if db_loaded => Some(Message::Copy),
|
|
|
|
Key::Named(key::Named::Escape) => Some(Message::ChangeQuery(String::new())),
|
|
|
|
Key::Character("q") => Some(Message::Quit),
|
|
|
|
// ignore unused keys
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
// ignore unused events
|
|
_ => None,
|
|
})
|
|
}
|
|
|
|
fn open_db(&mut self) -> Task<Message> {
|
|
debug_assert!(self.db_path_exists);
|
|
|
|
self.status = "loading...".into();
|
|
|
|
let (db_path, keyfile_path, password) = (
|
|
self.db_path.clone(),
|
|
self.keyfile_path.clone(),
|
|
self.password.clone(),
|
|
);
|
|
Task::perform(
|
|
async move {
|
|
let key = {
|
|
let mut key = keepass::DatabaseKey::new();
|
|
if !password.is_empty() {
|
|
key = key.with_password(&password);
|
|
}
|
|
if !keyfile_path.is_empty() {
|
|
key = key
|
|
.with_keyfile(
|
|
&mut fs::File::open(&keyfile_path).map_err(|e| e.to_string())?,
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
}
|
|
|
|
key
|
|
};
|
|
|
|
let db = keepass::Database::open(
|
|
&mut fs::File::open(&db_path).map_err(|e| e.to_string())?,
|
|
key,
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
|
|
db::set_last_opened(&db_path).map_err(|e| e.to_string())?;
|
|
|
|
Ok(db)
|
|
},
|
|
Message::DbOpened,
|
|
)
|
|
}
|
|
|
|
fn populate_view(&mut self) {
|
|
self.db_view = self
|
|
.db
|
|
.as_ref()
|
|
.unwrap()
|
|
.iter_all_entries()
|
|
.filter_map(|entry_ref| {
|
|
// this matches everything when the query is an empty string,
|
|
// which is the desired behavior so that it displays everything
|
|
// (when search isn't being used)
|
|
entry_ref
|
|
.contains(&self.query)
|
|
.then(|| entry_ref.to_owned())
|
|
})
|
|
.collect();
|
|
}
|
|
}
|
|
|
|
pub fn run() -> Result<(), iced::Error> {
|
|
application(State::new, State::update, State::view)
|
|
.subscription(State::subscription)
|
|
.theme(theme::Theme::custom(
|
|
"high-contrast-dark",
|
|
theme::Palette {
|
|
background: Color::from_rgb8(10, 10, 10),
|
|
text: Color::WHITE,
|
|
..theme::Palette::DARK
|
|
},
|
|
))
|
|
.run()
|
|
}
|