keyring-manager 0.8.1

Cross-platform library for managing passwords
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::error::{KeyringError, Result};
use crate::Keyring;
use security_framework::base::Error as SfError;
use security_framework::os::macos::keychain::SecKeychain;
use security_framework::os::macos::passwords::find_generic_password;
#[cfg(feature = "macos-specify-keychain")]
use std::path::Path;

#[allow(non_upper_case_globals)]
const errSecItemNotFound: i32 = -25300;

pub struct MacosKeyringManager {
    application: String,
    keychain: SecKeychain,
}

impl MacosKeyringManager {
    pub fn new(application: &str) -> Result<Self> {
        Ok(MacosKeyringManager {
            application: application.to_owned(),
            keychain: SecKeychain::default()?,
        })
    }

    #[cfg(feature = "macos-specify-keychain")]
    pub fn with_path(application: &str, path: &Path) -> Result<Self> {
        Ok(MacosKeyringManager {
            application: application.to_owned(),
            keychain: SecKeychain::open(path)?,
        })
    }

    pub fn with_keyring<F, T>(&self, service: &str, key: &str, func: F) -> Result<T>
    where
        F: FnOnce(&mut dyn Keyring) -> Result<T>,
    {
        let mut kr = MacosKeyring::new(self, service, key)?;
        func(&mut kr)
    }
}

pub struct MacosKeyring<'a> {
    manager: &'a MacosKeyringManager,
    service: &'a str,
    key: &'a str,
}

impl<'a> MacosKeyring<'a> {
    fn new(
        manager: &'a MacosKeyringManager,
        service: &'a str,
        key: &'a str,
    ) -> Result<MacosKeyring<'a>> {
        Ok(MacosKeyring {
            manager,
            service,
            key,
        })
    }

    fn make_service_name(&self) -> String {
        [
            crate::escape(&self.manager.application),
            crate::escape(self.service),
        ]
        .join("\t")
    }
}

impl Keyring for MacosKeyring<'_> {
    fn set_value(&mut self, value: &str) -> Result<()> {
        let service_name = self.make_service_name();

        self.manager
            .keychain
            .set_generic_password(&service_name, self.key, value.as_bytes())?;

        Ok(())
    }

    fn get_value(&self) -> Result<String> {
        let service_name = self.make_service_name();

        let (password_bytes, _) = match find_generic_password(
            Some(std::slice::from_ref(&self.manager.keychain)),
            &service_name,
            self.key,
        ) {
            Ok(v) => v,
            Err(e) => {
                if e.code() == errSecItemNotFound {
                    return Err(KeyringError::NoPasswordFound);
                } else {
                    return Err(KeyringError::MacOsKeychainError(SfError::from_code(
                        e.code(),
                    )));
                }
            }
        };

        // Mac keychain allows non-UTF8 values, but this library only supports adding UTF8 items
        // to the keychain, so this should only fail if we are trying to retrieve a non-UTF8
        // password that was added to the keychain by another library

        let password = String::from_utf8(password_bytes.to_vec())?;

        Ok(password)
    }

    fn delete_value(&mut self) -> Result<()> {
        let service_name = self.make_service_name();

        let (_, item) = match find_generic_password(
            Some(std::slice::from_ref(&self.manager.keychain)),
            &service_name,
            self.key,
        ) {
            Ok(v) => v,
            Err(e) => {
                if e.code() == errSecItemNotFound {
                    return Err(KeyringError::NoPasswordFound);
                } else {
                    return Err(KeyringError::MacOsKeychainError(SfError::from_code(
                        e.code(),
                    )));
                }
            }
        };
        item.delete();

        Ok(())
    }
}