use super::{Entry, ExportReport, Exported, Lineage, Outcome, Reading, gather};
use crate::db::Stamp;
use crate::error::{Error, Result};
use crate::expiry;
use crate::history::Version;
use crate::model::{Field, ItemKind, NewItem, Payload};
use crate::vault::Vault;
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64;
use serde::{Deserialize, Serialize};
use zeroize::Zeroizing;
pub const EXPORT_VERSION: u32 = 1;
#[derive(Debug, Serialize, Deserialize)]
pub struct Export {
#[serde(rename = "sefy_export")]
pub version: u32,
pub items: Vec<ExportItem>,
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct ExportItem {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub uuid: Option<String>,
pub title: String,
pub kind: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub tags: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub created_at: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub updated_at: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub version: Option<ExportStamp>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub history: Vec<ExportVersion>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub fields: Vec<ExportField>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub login: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub totp: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub notes: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub filename: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bytes_base64: Option<String>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub contents_not_exported: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportField {
pub name: String,
pub value: String,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub secret: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportStamp {
pub uuid: String,
pub seq: i64,
pub made_at: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub device: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ExportVersion {
pub uuid: String,
pub seq: i64,
pub made_at: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub device: Option<String>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub conflict: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub fields: Vec<ExportField>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub filename: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bytes_base64: Option<String>,
}
struct Contents<'a> {
text: &'a Option<String>,
fields: &'a [ExportField],
flat: [(&'static str, &'a Option<String>); 5],
filename: &'a Option<String>,
bytes_base64: &'a Option<String>,
}
const NONE: Option<String> = None;
impl ExportItem {
fn contents(&self) -> Contents<'_> {
Contents {
text: &self.text,
fields: &self.fields,
flat: [
("login", &self.login),
("password", &self.password),
("url", &self.url),
("totp", &self.totp),
("notes", &self.notes),
],
filename: &self.filename,
bytes_base64: &self.bytes_base64,
}
}
}
impl ExportVersion {
fn contents(&self) -> Contents<'_> {
Contents {
text: &self.text,
fields: &self.fields,
flat: [
("login", &NONE),
("password", &NONE),
("url", &NONE),
("totp", &NONE),
("notes", &NONE),
],
filename: &self.filename,
bytes_base64: &self.bytes_base64,
}
}
}
pub(super) fn write(vault: &Vault, history: bool) -> Result<Exported> {
let mut report = ExportReport::default();
let mut items = Vec::new();
for outgoing in gather(vault, history)? {
let summary = outgoing.summary;
let mut exported = ExportItem {
uuid: Some(summary.uuid),
title: summary.title,
kind: summary.kind.as_str().to_owned(),
tags: summary.tags,
created_at: Some(summary.created_at),
updated_at: Some(summary.updated_at),
version: Some(ExportStamp {
uuid: outgoing.stamp.uuid,
seq: outgoing.stamp.seq,
made_at: outgoing.stamp.made_at,
device: outgoing.stamp.device,
}),
..ExportItem::default()
};
match outgoing.payload {
Payload::Note { text } => exported.text = Some(text),
Payload::Fields { fields, .. } => {
for field in &fields {
let flat = match field.name.as_str() {
"login" => &mut exported.login,
"password" => &mut exported.password,
"url" => &mut exported.url,
"totp" => &mut exported.totp,
"notes" => &mut exported.notes,
_ => continue,
};
*flat = Some(field.value.clone());
}
exported.fields = export_fields(fields);
}
Payload::Unknown { .. } => {
exported.contents_not_exported = true;
exported.version = None;
report.unreadable += 1;
}
Payload::File { filename, bytes } => {
exported.filename = Some(filename);
exported.bytes_base64 = Some(BASE64.encode(&bytes));
}
}
for version in outgoing.past {
let mut written = ExportVersion {
uuid: version.uuid,
seq: version.seq,
made_at: version.made_at,
device: version.device,
conflict: version.conflict,
..ExportVersion::default()
};
match version.payload {
Payload::Note { text } => written.text = Some(text),
Payload::Fields { fields, .. } => written.fields = export_fields(fields),
Payload::File { filename, bytes } => {
written.filename = Some(filename);
written.bytes_base64 = Some(BASE64.encode(&bytes));
}
Payload::Unknown { .. } => continue,
}
exported.history.push(written);
report.versions += 1;
}
report.written += 1;
items.push(exported);
}
let export = Export {
version: EXPORT_VERSION,
items,
};
let text = serde_json::to_string_pretty(&export).map_err(|error| Error::Unexportable {
title: String::new(),
format: "a sefy export",
reason: error.to_string(),
})?;
Ok(Exported {
text: Zeroizing::new(text),
report,
})
}
fn export_fields(fields: Vec<Field>) -> Vec<ExportField> {
fields
.into_iter()
.map(|field| ExportField {
name: field.name,
value: field.value,
secret: field.secret,
})
.collect()
}
pub(super) fn read(body: &str) -> Result<Reading> {
let export: Export = serde_json::from_str(body).map_err(|error| Error::UnreadableImport {
format: super::Format::Sefy.describe(),
reason: error.to_string(),
})?;
if export.version != EXPORT_VERSION {
return Err(Error::UnsupportedExport(export.version));
}
let mut reading = Reading::default();
for (index, item) in export.items.iter().enumerate() {
let kind = ItemKind::parse(&item.kind);
if item.contents_not_exported {
reading.notice(
&item.title,
Outcome::NotImported,
"a newer sefy wrote it, and its contents were left out of the export",
);
continue;
}
if !kind.is_known() {
reading.notice(
&item.title,
Outcome::NotImported,
format!(
"a {kind}, a kind this version of sefy does not know; upgrade and import again"
),
);
continue;
}
let payload = payload_of(index, &kind, &item.contents())?;
let mut past = Vec::with_capacity(item.history.len());
for version in &item.history {
past.push(Version {
uuid: version.uuid.clone(),
seq: version.seq,
made_at: version.made_at,
device: version.device.clone(),
conflict: version.conflict,
current: false,
payload: payload_of(index, &kind, &version.contents())?,
});
}
reading.push(Entry {
uuid: item.uuid.clone(),
item: NewItem::new(item.title.clone(), payload).with_tags(item.tags.clone()),
created_at: item.created_at,
updated_at: item.updated_at,
lineage: Lineage::Recorded {
stamp: item.version.as_ref().map(|stamp| Stamp {
uuid: stamp.uuid.clone(),
seq: stamp.seq,
made_at: stamp.made_at,
device: stamp.device.clone(),
}),
past,
},
notices: Vec::new(),
});
}
Ok(reading)
}
fn payload_of(index: usize, kind: &ItemKind, contents: &Contents<'_>) -> Result<Payload> {
let malformed = |reason: String| Error::MalformedExport { index, reason };
Ok(match kind {
ItemKind::Note => Payload::Note {
text: contents
.text
.clone()
.ok_or_else(|| malformed("a note needs a \"text\" field".to_owned()))?,
},
kind @ (ItemKind::Login
| ItemKind::Card
| ItemKind::SshKey
| ItemKind::Wifi
| ItemKind::ApiToken
| ItemKind::Bank) => {
let fields = read_fields(index, kind, contents)?;
if fields.is_empty() {
return Err(malformed(format!("a {kind} needs at least one field")));
}
Payload::Fields {
kind: kind.clone(),
fields,
}
}
ItemKind::File => {
let encoded = contents
.bytes_base64
.as_deref()
.ok_or_else(|| malformed("a file needs a \"bytes_base64\" field".to_owned()))?;
Payload::File {
filename: contents
.filename
.clone()
.ok_or_else(|| malformed("a file needs a \"filename\" field".to_owned()))?,
bytes: BASE64.decode(encoded).map_err(|error| {
malformed(format!("bytes_base64 is not valid base64: {error}"))
})?,
}
}
ItemKind::Unknown(name) => {
return Err(malformed(format!(
"kind {name:?} is not known to this build"
)));
}
})
}
fn read_fields(index: usize, kind: &ItemKind, contents: &Contents<'_>) -> Result<Vec<Field>> {
if !contents.fields.is_empty() {
let mut seen: Vec<&str> = Vec::new();
for field in contents.fields {
if seen.contains(&field.name.as_str()) {
return Err(Error::MalformedExport {
index,
reason: format!("field {:?} appears twice", field.name),
});
}
seen.push(&field.name);
}
let mut fields: Vec<Field> = contents
.fields
.iter()
.map(|field| Field {
name: field.name.clone(),
value: field.value.clone(),
secret: field.secret,
})
.collect();
expiry::upgrade_legacy(kind, &mut fields);
return Ok(fields);
}
let template = kind.template();
Ok(contents
.flat
.into_iter()
.filter_map(|(name, value)| {
value.as_ref().map(|value| Field {
name: name.to_owned(),
value: value.clone(),
secret: template
.and_then(|template| template.field(name))
.is_none_or(|field| field.secret),
})
})
.collect())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_card_in_an_export_from_before_is_handed_over_under_the_new_name() {
let reading = read(
r#"{"sefy_export": 1, "items": [{
"title": "old card",
"kind": "card",
"fields": [
{"name": "number", "value": "4111", "secret": true},
{"name": "expiry", "value": "11/28", "secret": false}
],
"history": [{
"uuid": "0b6e1c1e-8f6a-4c55-9a51-0d3f5f7c2b11",
"seq": 1,
"made_at": 1700000000,
"fields": [{"name": "expiry", "value": "10/28", "secret": false}]
}]
}]}"#,
)
.unwrap();
let entry = &reading.entries[0];
let payload = &entry.item.payload;
assert_eq!(payload.field(expiry::FIELD).unwrap().value, "2028-11");
assert!(payload.field(expiry::LEGACY_CARD_NAME).is_none());
let Lineage::Recorded { past, .. } = &entry.lineage else {
panic!("a sefy export records its lineage");
};
assert_eq!(
past[0].payload.field(expiry::FIELD).unwrap().value,
"2028-10"
);
}
}