[PM-29846] Fix init when private key is corrupt (#614)

## 🎟️ Tracking

<!-- Paste the link to the Jira or GitHub issue or otherwise describe /
point to where this change is coming from. -->
https://bitwarden.atlassian.net/browse/PM-29846


## 📔 Objective

<!-- Describe what the purpose of this PR is, for example what bug
you're fixing or new feature you're adding. -->
#563 change the init
process which now always requires a valid private key. This does not
work for users that have a broken private key, and until those are fixed
before unlock, these need to be supported in the SDK for V1.


## 🚨 Breaking Changes

<!-- Does this PR introduce any breaking changes? If so, please describe
the impact and migration path for clients.

If you're unsure, the automated TypeScript compatibility check will run
when you open/update this PR and provide feedback.

For breaking changes:
1. Describe what changed in the client interface
2. Explain why the change was necessary
3. Provide migration steps for client developers
4. Link to any paired client PRs if needed

Otherwise, you can remove this section. -->

## ⏰ Reminders before review

- Contributor guidelines followed
- All formatters and local linters executed and passed
- Written new unit and / or integration tests where applicable
- Protected functional changes with optionality (feature flags)
- Used internationalization (i18n) for all UI strings
- CI builds passed
- Communicated to DevOps any deployment requirements
- Updated any necessary documentation (Confluence, contributing docs) or
informed the documentation
  team

## 🦮 Reviewer guidelines

<!-- Suggested interactions but feel free to use (or not) as you desire!
-->

- 👍 (`:+1:`) or similar for great changes
- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
- ❓ (`:question:`) for questions
- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry
that's not quite a confirmed
  issue and could potentially benefit from discussion
- 🎨 (`:art:`) for suggestions / improvements
- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or
concerns needing attention
- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or
indications of technical debt
- ⛏ (`:pick:`) for minor or nitpick changes

Author: quexten

crates/bitwarden-core/src/key_management/account_cryptographic_state.rs

@@ -229,11 +229,16 @@ impl WrappedAccountCryptographicState {
                     return Err(AccountCryptographyInitializationError::WrongUserKeyType);
                 }
 
-                let private_key_id = ctx
-                    .unwrap_private_key(user_key, private_key)
-                    .map_err(|_| AccountCryptographyInitializationError::WrongUserKey)?;
+                // Some users have unreadable V1 private keys. In this case, we set no keys to
+                // state.
+                if let Ok(private_key_id) = ctx.unwrap_private_key(user_key, private_key) {
+                    ctx.persist_asymmetric_key(private_key_id, AsymmetricKeyId::UserPrivateKey)?;
+                } else {
+                    tracing::warn!(
+                        "V1 private key could not be unwrapped, skipping setting private key"
+                    );
+                }
 
-                ctx.persist_asymmetric_key(private_key_id, AsymmetricKeyId::UserPrivateKey)?;
                 ctx.persist_symmetric_key(user_key, SymmetricKeyId::User)?;
             }
             WrappedAccountCryptographicState::V2 {
@@ -338,7 +343,7 @@ impl WrappedAccountCryptographicState {
 mod tests {
     use std::{str::FromStr, sync::RwLock};
 
-    use bitwarden_crypto::KeyStore;
+    use bitwarden_crypto::{KeyStore, PrimitiveEncryptable};
 
     use super::*;
     use crate::key_management::{AsymmetricKeyId, SigningKeyId, SymmetricKeyId};
@@ -512,4 +517,47 @@ mod tests {
             model.security_state.unwrap().security_version as u64
         );
     }
+
+    #[test]
+    fn test_set_to_context_v1_corrupt_private_key() {
+        // Test that a V1 account with a corrupt private key (valid EncString but invalid key data)
+        // can still initialize, but skips setting the private key
+        let temp_store: KeyStore<KeyIds> = KeyStore::default();
+        let mut temp_ctx = temp_store.context_mut();
+
+        let user_key = temp_ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
+        let corrupt_private_key = "not a private key"
+            .encrypt(&mut temp_ctx, user_key)
+            .unwrap();
+
+        // Construct the V1 wrapped state with corrupt private key
+        let wrapped = WrappedAccountCryptographicState::V1 {
+            private_key: corrupt_private_key,
+        };
+
+        #[expect(deprecated)]
+        let user_key_material = temp_ctx
+            .dangerous_get_symmetric_key(user_key)
+            .unwrap()
+            .to_owned();
+        drop(temp_ctx);
+        drop(temp_store);
+
+        // Now attempt to set this wrapped state into a fresh store
+        let store: KeyStore<KeyIds> = KeyStore::default();
+        let mut ctx = store.context_mut();
+        let user_key = ctx.add_local_symmetric_key(user_key_material);
+        let security_state = RwLock::new(None);
+
+        wrapped
+            .set_to_context(&security_state, user_key, &store, ctx)
+            .unwrap();
+
+        let ctx = store.context();
+
+        // The user symmetric key should be set
+        assert!(ctx.has_symmetric_key(SymmetricKeyId::User));
+        // But the private key should NOT be set (due to corruption)
+        assert!(!ctx.has_asymmetric_key(AsymmetricKeyId::UserPrivateKey));
+    }
 }