use std::fs;
use std::path::PathBuf;
use std::sync::Mutex;
use std::time::{SystemTime, UNIX_EPOCH};
use crate::{auth, card, client, sign};
use anyhow::{Context, Result};
use reqwest::blocking::Client;
use sha1::{Digest, Sha1};
use x509_cert::der::Decode;
use x509_cert::Certificate;
const CACHE_TTL_SECS: u64 = 20 * 60;
pub struct CloudSession {
http: Client,
token: String,
card: card::Card,
cert_der: Vec<u8>,
pubkey_der: Vec<u8>,
key_id: Vec<u8>,
last: Mutex<Option<([u8; 32], Vec<u8>)>>,
}
impl CloudSession {
pub fn open(email: &str, otp_code: &str) -> Result<Self> {
let token = auth::login(email, otp_code)?.0;
let http = client::client()?;
let card = card::fetch(&http, &token)?;
Self::from_parts(http, token, card)
}
fn from_parts(http: Client, token: String, card: card::Card) -> Result<Self> {
let cert_der = crate::authenticode::pem_to_der(&card.certificate_pem)
.context("decoding the signing certificate")?;
let cert = Certificate::from_der(&cert_der).context("parsing the signing certificate")?;
let pubkey_der = cert
.tbs_certificate
.subject_public_key_info
.subject_public_key
.raw_bytes()
.to_vec();
let key_id = Sha1::digest(&cert_der).to_vec();
Ok(Self {
http,
token,
card,
cert_der,
pubkey_der,
key_id,
last: Mutex::new(None),
})
}
pub fn certificate_der(&self) -> &[u8] {
&self.cert_der
}
pub fn public_key_der(&self) -> &[u8] {
&self.pubkey_der
}
pub fn key_id(&self) -> &[u8] {
&self.key_id
}
pub fn sign_sha256(&self, digest: &[u8; 32]) -> Result<Vec<u8>> {
if let Some((cached_digest, signature)) = self.last.lock().unwrap().as_ref() {
if cached_digest == digest {
return Ok(signature.clone());
}
}
let signature = sign::request(&self.http, &self.token, &self.card, digest)?;
*self.last.lock().unwrap() = Some((*digest, signature.clone()));
Ok(signature)
}
pub fn load_cached(email: &str) -> Option<Self> {
let raw = fs::read(cache_path()?).ok()?;
let v: serde_json::Value = serde_json::from_slice(&raw).ok()?;
if v.get("email")?.as_str()? != email {
return None;
}
let expires_at = v.get("expires_at")?.as_u64()?;
if now() + 120 >= expires_at {
return None;
}
let token = v.get("token")?.as_str()?.to_string();
let serial = v.get("serial")?.as_str()?.to_string();
let certificate_pem = v.get("cert_pem")?.as_str()?.as_bytes().to_vec();
let card = card::Card {
serial,
certificate_pem,
};
Self::from_parts(client::client().ok()?, token, card).ok()
}
pub fn save(&self, email: &str) {
let Some(path) = cache_path() else { return };
let doc = serde_json::json!({
"v": 1,
"email": email,
"token": self.token,
"expires_at": now() + CACHE_TTL_SECS,
"serial": self.card.serial,
"cert_pem": String::from_utf8_lossy(&self.card.certificate_pem),
});
let _ = write_private(&path, doc.to_string().as_bytes());
}
}
fn now() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0)
}
fn cache_path() -> Option<PathBuf> {
let base = std::env::var_os("XDG_RUNTIME_DIR")
.map(PathBuf::from)
.or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".cache")))
.unwrap_or_else(std::env::temp_dir);
Some(base.join("ssign").join("session.json"))
}
fn write_private(path: &PathBuf, data: &[u8]) -> std::io::Result<()> {
if let Some(dir) = path.parent() {
fs::create_dir_all(dir)?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let _ = fs::set_permissions(dir, fs::Permissions::from_mode(0o700));
}
}
fs::write(path, data)?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
fs::set_permissions(path, fs::Permissions::from_mode(0o600))?;
}
Ok(())
}