rs_firebase_admin_sdk/auth/import/
mod.rs

1use super::Claims;
2use serde::Serialize;
3
4#[derive(Serialize, Debug, Clone)]
5pub enum HashAlgorithmName {
6    #[serde(rename = "HMAC_SHA512")]
7    HmacSha512,
8    #[serde(rename = "HMAC_SHA256")]
9    HmacSha256,
10    #[serde(rename = "HMAC_SHA1")]
11    HmacSha1,
12    #[serde(rename = "HMAC_MD5")]
13    HmacMd5,
14    #[serde(rename = "SHA256")]
15    Sha256,
16    #[serde(rename = "SHA512")]
17    Sha512,
18    #[serde(rename = "PBKDF_SHA1")]
19    Ppkdf2Sha1,
20    #[serde(rename = "PBKDF_SHA256")]
21    Ppkdf2Sha256,
22    #[serde(rename = "SCRYPT")]
23    Scrypt,
24    #[serde(rename = "STANDARD_SCRYPT")]
25    StandardScrypt,
26    #[serde(rename = "BCRYPT")]
27    Bcrypt,
28}
29
30#[derive(Debug, Clone)]
31pub enum PasswordHash {
32    HmacSha512 {
33        hash: String,
34        salt: Option<String>,
35        key: String,
36    },
37    HmacSha256 {
38        hash: String,
39        salt: Option<String>,
40        key: String,
41    },
42    HmacSha1 {
43        hash: String,
44        salt: Option<String>,
45        key: String,
46    },
47    HmacMd5 {
48        hash: String,
49        salt: Option<String>,
50        key: String,
51    },
52    Sha256 {
53        hash: String,
54        salt: Option<String>,
55        rounds: u32,
56    },
57    Sha512 {
58        hash: String,
59        salt: Option<String>,
60        rounds: u32,
61    },
62    Ppkdf2Sha1 {
63        hash: String,
64        salt: Option<String>,
65        rounds: u32,
66    },
67    Ppkdf2Sha256 {
68        hash: String,
69        salt: Option<String>,
70        rounds: u32,
71    },
72    Scrypt {
73        hash: String,
74        salt: Option<String>,
75        key: String,
76        rounds: u32,
77        memory_cost: u8,
78        salt_separator: Option<String>,
79    },
80    StandardScrypt {
81        hash: String,
82        salt: Option<String>,
83        block_size: usize,
84        parallelization: usize,
85        memory_cost: u8,
86        dk_len: usize,
87    },
88    Bcrypt {
89        hash: String,
90        salt: Option<String>,
91    },
92}
93
94#[derive(Serialize, Debug, Clone, Default)]
95#[serde(rename_all = "camelCase")]
96pub struct UserImportRecord {
97    #[serde(skip_serializing_if = "Option::is_none")]
98    #[serde(rename = "localId")]
99    pub uid: Option<String>,
100    #[serde(skip_serializing_if = "Option::is_none")]
101    pub email: Option<String>,
102    #[serde(skip_serializing_if = "Option::is_none")]
103    pub display_name: Option<String>,
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub photo_url: Option<String>,
106    #[serde(skip_serializing_if = "Option::is_none")]
107    pub phone_number: Option<String>,
108    #[serde(skip_serializing_if = "Option::is_none")]
109    pub email_verified: Option<bool>,
110    #[serde(skip_serializing_if = "Option::is_none")]
111    pub salt: Option<String>,
112    #[serde(skip_serializing_if = "Option::is_none")]
113    pub password_hash: Option<String>,
114    #[serde(skip_serializing_if = "Option::is_none")]
115    pub hash_algorithm: Option<HashAlgorithmName>,
116    #[serde(skip_serializing_if = "Option::is_none")]
117    pub signer_key: Option<String>,
118    #[serde(skip_serializing_if = "Option::is_none")]
119    pub memory_cost: Option<u8>,
120    #[serde(skip_serializing_if = "Option::is_none")]
121    pub parallelization: Option<usize>,
122    #[serde(skip_serializing_if = "Option::is_none")]
123    pub block_size: Option<usize>,
124    #[serde(skip_serializing_if = "Option::is_none")]
125    pub dk_len: Option<usize>,
126    #[serde(skip_serializing_if = "Option::is_none")]
127    pub rounds: Option<u32>,
128    #[serde(skip_serializing_if = "Option::is_none")]
129    pub salt_separator: Option<String>,
130    #[serde(skip_serializing_if = "Option::is_none")]
131    #[serde(rename = "customAttributes")]
132    pub custom_claims: Option<Claims>,
133    #[serde(skip_serializing_if = "Option::is_none")]
134    pub disabled: Option<bool>,
135}
136
137impl UserImportRecord {
138    pub fn builder() -> UserImportRecordBuilder {
139        UserImportRecordBuilder::default()
140    }
141}
142
143#[derive(Clone, Default)]
144pub struct UserImportRecordBuilder {
145    record: UserImportRecord,
146}
147
148impl UserImportRecordBuilder {
149    pub fn build(self) -> UserImportRecord {
150        self.record
151    }
152
153    pub fn with_uid(mut self, uid: String) -> Self {
154        self.record.uid = Some(uid);
155
156        self
157    }
158
159    pub fn with_email(mut self, email: String, verified: bool) -> Self {
160        self.record.email = Some(email);
161        self.record.email_verified = Some(verified);
162
163        self
164    }
165
166    pub fn with_display_name(mut self, display_name: String) -> Self {
167        self.record.display_name = Some(display_name);
168
169        self
170    }
171
172    pub fn with_photo_url(mut self, photo_url: String) -> Self {
173        self.record.photo_url = Some(photo_url);
174
175        self
176    }
177
178    pub fn with_phone_number(mut self, phone_number: String) -> Self {
179        self.record.phone_number = Some(phone_number);
180
181        self
182    }
183
184    pub fn with_custom_claims(mut self, custom_claims: Claims) -> Self {
185        self.record.custom_claims = Some(custom_claims);
186
187        self
188    }
189
190    pub fn with_being_disabled(mut self) -> Self {
191        self.record.disabled = Some(true);
192
193        self
194    }
195
196    pub fn with_password(mut self, password: PasswordHash) -> Self {
197        match password {
198            PasswordHash::HmacSha512 { hash, salt, key } => {
199                self.record.hash_algorithm = Some(HashAlgorithmName::HmacSha512);
200                self.record.password_hash = Some(hash);
201                self.record.salt = salt;
202                self.record.signer_key = Some(key);
203            }
204            PasswordHash::HmacSha256 { hash, salt, key } => {
205                self.record.hash_algorithm = Some(HashAlgorithmName::HmacSha256);
206                self.record.password_hash = Some(hash);
207                self.record.salt = salt;
208                self.record.signer_key = Some(key);
209            }
210            PasswordHash::HmacSha1 { hash, salt, key } => {
211                self.record.hash_algorithm = Some(HashAlgorithmName::HmacSha1);
212                self.record.password_hash = Some(hash);
213                self.record.salt = salt;
214                self.record.signer_key = Some(key);
215            }
216            PasswordHash::HmacMd5 { hash, salt, key } => {
217                self.record.hash_algorithm = Some(HashAlgorithmName::HmacMd5);
218                self.record.password_hash = Some(hash);
219                self.record.salt = salt;
220                self.record.signer_key = Some(key);
221            }
222            PasswordHash::Sha256 { hash, salt, rounds } => {
223                self.record.hash_algorithm = Some(HashAlgorithmName::Sha256);
224                self.record.password_hash = Some(hash);
225                self.record.salt = salt;
226                self.record.rounds = Some(rounds);
227            }
228            PasswordHash::Sha512 { hash, salt, rounds } => {
229                self.record.hash_algorithm = Some(HashAlgorithmName::Sha512);
230                self.record.password_hash = Some(hash);
231                self.record.salt = salt;
232                self.record.rounds = Some(rounds);
233            }
234            PasswordHash::Ppkdf2Sha1 { hash, salt, rounds } => {
235                self.record.hash_algorithm = Some(HashAlgorithmName::Ppkdf2Sha1);
236                self.record.password_hash = Some(hash);
237                self.record.salt = salt;
238                self.record.rounds = Some(rounds);
239            }
240            PasswordHash::Ppkdf2Sha256 { hash, salt, rounds } => {
241                self.record.hash_algorithm = Some(HashAlgorithmName::Ppkdf2Sha256);
242                self.record.password_hash = Some(hash);
243                self.record.salt = salt;
244                self.record.rounds = Some(rounds);
245            }
246            PasswordHash::Scrypt {
247                hash,
248                salt,
249                rounds,
250                key,
251                memory_cost,
252                salt_separator,
253            } => {
254                self.record.hash_algorithm = Some(HashAlgorithmName::Scrypt);
255                self.record.password_hash = Some(hash);
256                self.record.salt = salt;
257                self.record.rounds = Some(rounds);
258                self.record.signer_key = Some(key);
259                self.record.memory_cost = Some(memory_cost);
260                self.record.salt_separator = salt_separator;
261            }
262            PasswordHash::StandardScrypt {
263                hash,
264                salt,
265                memory_cost,
266                block_size,
267                parallelization,
268                dk_len,
269            } => {
270                self.record.hash_algorithm = Some(HashAlgorithmName::StandardScrypt);
271                self.record.password_hash = Some(hash);
272                self.record.salt = salt;
273                self.record.memory_cost = Some(memory_cost);
274                self.record.block_size = Some(block_size);
275                self.record.parallelization = Some(parallelization);
276                self.record.dk_len = Some(dk_len);
277            }
278            PasswordHash::Bcrypt { hash, salt } => {
279                self.record.hash_algorithm = Some(HashAlgorithmName::Bcrypt);
280                self.record.password_hash = Some(hash);
281                self.record.salt = salt;
282            }
283        }
284
285        self
286    }
287}
288
289#[derive(Serialize, Debug, Clone)]
290#[serde(rename_all = "camelCase")]
291pub struct UserImportRecords {
292    pub users: Vec<UserImportRecord>,
293}
rs_firebase_admin_sdk/auth/import/mod.rs

rs_firebase_admin_sdk/auth/import/
mod.rs
