shrine 0.1.0

Secrets manager written in rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use crate::git::Repository;
use crate::shrine::{Closed, Shrine};
use crate::shrine::{EncryptionAlgorithm, ShrineBuilder};
use crate::utils::{read_new_password, read_password};
use crate::Error;
use secrecy::Secret;
use std::path::PathBuf;

pub fn convert(
    shrine: Shrine<Closed>,
    path: PathBuf,
    password: Option<Secret<String>>,
    change_password: bool,
    new_password: Option<Secret<String>>,
    encryption_algorithm: Option<EncryptionAlgorithm>,
) -> Result<(), Error> {
    let change_password = change_password || new_password.is_some();
    if !change_password && encryption_algorithm.is_none() {
        return Ok(());
    }

    let mut change_password = change_password;

    let password = password.unwrap_or_else(|| read_password(&shrine));
    let shrine = shrine.open(&password)?;

    let shrine_builder =
        ShrineBuilder::new().with_encryption_algorithm(shrine.encryption_algorithm());

    let shrine_builder = match encryption_algorithm {
        Some(a) if shrine.encryption_algorithm() != a => {
            change_password = true;
            shrine_builder.with_encryption_algorithm(a)
        }
        _ => shrine_builder,
    };

    let mut new_shrine = shrine_builder.build();

    let password = if change_password {
        new_password
            .map(Ok)
            .unwrap_or_else(|| read_new_password(&new_shrine))?
    } else {
        password
    };

    shrine.move_to(&mut new_shrine);

    let repository = Repository::new(path.clone(), &new_shrine);

    new_shrine.close(&password)?.to_path(&path)?;

    if let Some(repository) = repository {
        if repository.commit_auto() {
            repository
                .open()
                .and_then(|r| r.create_commit("Update shrine"))?;
        }
    }

    Ok(())
}