Struct kpdb::Database

pub struct Database {

    pub comment: Option<Comment>,
    pub composite_key: CompositeKey,
    pub compression: Compression,
    pub db_type: DbType,
    pub master_cipher: MasterCipher,
    pub stream_cipher: StreamCipher,
    pub transform_rounds: TransformRounds,
    pub version: Version,
    pub binaries: BinariesMap,
    pub color: Option<Color>,
    pub custom_data: CustomDataMap,
    pub custom_icons: CustomIconsMap,
    pub def_username: String,
    pub def_username_changed: DateTime<Utc>,
    pub description: String,
    pub description_changed: DateTime<Utc>,
    pub entry_templates_group_changed: DateTime<Utc>,
    pub entry_templates_group_uuid: GroupUuid,
    pub generator: String,
    pub history_max_items: i32,
    pub history_max_size: i32,
    pub last_selected_group: GroupUuid,
    pub last_top_visible_group: GroupUuid,
    pub maintenance_history_days: i32,
    pub master_key_change_force: i32,
    pub master_key_change_rec: i32,
    pub master_key_changed: DateTime<Utc>,
    pub name: String,
    pub name_changed: DateTime<Utc>,
    pub protect_notes: bool,
    pub protect_password: bool,
    pub protect_title: bool,
    pub protect_url: bool,
    pub protect_username: bool,
    pub recycle_bin_changed: DateTime<Utc>,
    pub recycle_bin_enabled: bool,
    pub recycle_bin_uuid: GroupUuid,
    pub root_group: Group,
}

The KeePass database.

Fields

comment: Option<Comment>

Content of the comment header.

composite_key: CompositeKey

Composite key.

compression: Compression

Compression algorithm.

db_type: DbType

Type of the database.

master_cipher: MasterCipher

Master encryption algorithm.

stream_cipher: StreamCipher

Stream encryption algorithm (e.g. passwords).

transform_rounds: TransformRounds

Number of times the composite key must be transformed.

version: Version

The database version.

binaries: BinariesMap

Map with binary data.

color: Option<Color>

Optional color.

custom_data: CustomDataMap

Map with custom data.

custom_icons: CustomIconsMap

Map with custom icons.

def_username: String

Default username for new entries.

def_username_changed: DateTime<Utc>

The date and time the default username was changed.

description: String

Description of this database.

description_changed: DateTime<Utc>

The date and time the description was changed.

entry_templates_group_changed: DateTime<Utc>

The date and time the entry templates group was changed.

entry_templates_group_uuid: GroupUuid

The identifier of the group containing entry templates.

generator: String

Name of the generator.

history_max_items: i32

Maximum number of history items.

history_max_size: i32

Maximum size of the history data.

last_selected_group: GroupUuid

The identifier of the last selected group.

last_top_visible_group: GroupUuid

The identifier of the last top visible group.

maintenance_history_days: i32

Number of days until history entries are being deleted.

master_key_change_force: i32

master_key_change_rec: i32

master_key_changed: DateTime<Utc>

The date and time the master key was changed.

name: String

Name of this database.

name_changed: DateTime<Utc>

The date and time the name was changed.

protect_notes: bool

Whether notes must be protected.

protect_password: bool

Whether passwords must be protected.

protect_title: bool

Whether titles must be protected.

protect_url: bool

Whether URL’s must be protected.

protect_username: bool

Whether usernames must be protected.

recycle_bin_changed: DateTime<Utc>

The date and time the recycle bin was changed.

recycle_bin_enabled: bool

Whether the recycle bin is enabled.

recycle_bin_uuid: GroupUuid

The identifier of the recycle bin.

root_group: Group

The root group.

Implementations

impl Database

pub fn new(key: &CompositeKey) -> Database

Create a new database.

Examples

use kpdb::{CompositeKey, Database};

let key = CompositeKey::from_password("password");
let db = Database::new(&key);

pub fn find_entries<'a, S: Into<String>>(&'a self, text: S) -> Vec<&'a Entry>

Returns a vector with entries that match (case insensitive) the supplied text.

Examples

use kpdb::{CompositeKey, Database, Entry, Group};

let mut protonmail = Entry::new();
protonmail.set_title("ProtonMail");
protonmail.set_username("puser");
protonmail.set_password("ppass");
protonmail.set_url("https://mail.protonmail.com");

let mut group = Group::new("Email");
group.add_entry(protonmail);

let mut db = Database::new(&CompositeKey::from_password("test"));
db.root_group.add_group(group);

let result = db.find_entries("Protonm");
assert_eq!(result.len(), 1);

let result = db.find_entries("gmail");
assert_eq!(result.len(), 0);

pub fn find_entries_mut<'a, S: Into<String>>(
    &'a mut self,
    text: S
) -> Vec<&'a mut Entry>

Returns a vector with mutable entries that match (case insensitive) the supplied text.

Examples

use kpdb::{CompositeKey, Database, Entry, Group};

let mut protonmail = Entry::new();
protonmail.set_title("ProtonMail");
protonmail.set_username("puser");
protonmail.set_password("ppass");
protonmail.set_url("https://mail.protonmail.com");

let mut group = Group::new("Email");
group.add_entry(protonmail);

let mut db = Database::new(&CompositeKey::from_password("test"));
db.root_group.add_group(group);

let result = db.find_entries_mut("Protonm");
assert_eq!(result.len(), 1);

pub fn find_groups<'a, S: Into<String>>(&'a self, name: S) -> Vec<&'a Group>

Returns a vector with groups that match (case insensitive) the supplied name.

Examples

use kpdb::{CompositeKey, Database, Group};

let group = Group::new("Email");

let mut db = Database::new(&CompositeKey::from_password("test"));
db.root_group.add_group(group);

let result = db.find_groups("mail");
assert_eq!(result.len(), 1);

let result = db.find_groups("unknown");
assert_eq!(result.len(), 0);

pub fn find_groups_mut<'a, S: Into<String>>(
    &'a mut self,
    name: S
) -> Vec<&'a mut Group>

Returns a vector with mutable groups that match (case insensitive) the supplied name.

Examples

use kpdb::{CompositeKey, Database, Group};

let group = Group::new("Email");

let mut db = Database::new(&CompositeKey::from_password("test"));
db.root_group.add_group(group);

let result = db.find_groups_mut("mail");
assert_eq!(result.len(), 1);

pub fn get_entry<'a>(&'a self, uuid: EntryUuid) -> Option<&'a Entry>

Returns the entry that matches the UUID or None if not found.

Examples

use kpdb::{CompositeKey, Database, Entry, Group};

let entry = Entry::new();
let entry_uuid = entry.uuid;

let mut db = Database::new(&CompositeKey::from_password("test"));
assert_eq!(db.get_entry(entry_uuid), None);

db.root_group.add_entry(entry.clone());
assert_eq!(db.get_entry(entry_uuid), Some(&entry));

pub fn get_entry_mut<'a>(&'a mut self, uuid: EntryUuid) -> Option<&'a mut Entry>

Returns the mutable entry that matches the UUID or None if not found.

Examples

use kpdb::{CompositeKey, Database, Entry, Group};

let mut entry = Entry::new();
let entry_uuid = entry.uuid;

let mut db = Database::new(&CompositeKey::from_password("test"));
assert_eq!(db.get_entry_mut(entry_uuid), None);

db.root_group.add_entry(entry.clone());
assert_eq!(db.get_entry_mut(entry_uuid), Some(&mut entry));

pub fn get_group<'a>(&'a self, uuid: GroupUuid) -> Option<&'a Group>

Returns the group that matches the UUID or None if not found.

Examples

use kpdb::{CompositeKey, Database, Group};

let group = Group::new("Group");
let group_uuid = group.uuid;

let mut db = Database::new(&CompositeKey::from_password("test"));
assert_eq!(db.get_group(group_uuid), None);

db.root_group.add_group(group.clone());
assert_eq!(db.get_group(group_uuid), Some(&group));

pub fn get_group_mut<'a>(&'a mut self, uuid: GroupUuid) -> Option<&'a mut Group>

Returns the mutable group that matches the UUID or None if not found.

Examples

use kpdb::{CompositeKey, Database, Group};

let mut group = Group::new("Group");
let group_uuid = group.uuid;

let mut db = Database::new(&CompositeKey::from_password("test"));
assert_eq!(db.get_group(group_uuid), None);

db.root_group.add_group(group.clone());
assert_eq!(db.get_group_mut(group_uuid), Some(&mut group));

pub fn open<R: Read>(reader: &mut R, key: &CompositeKey) -> Result<Database>

Attempts to open an existing database.

Examples

use kpdb::{CompositeKey, Database};
use std::fs::File;

let mut file = File::open("passwords.kdbx")?;
let key = CompositeKey::from_password("password");
let db = Database::open(&mut file, &key)?;

pub fn save<W: Write>(&self, writer: &mut W) -> Result<()>

Attempts to save the database.

Examples

use kpdb::{CompositeKey, Database};
use std::fs::File;

let key = CompositeKey::from_password("password");
let db = Database::new(&key);
let mut file = File::create("new.kdbx")?;

db.save(&mut file);

Trait Implementations

impl Clone for Database

fn clone(&self) -> Database

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Database

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Database> for Database

fn eq(&self, other: &Database) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Database