/// <summary> /// Initializes a new instance of the <see cref="KeyVaultStorage" /> class. /// </summary> public KeyVaultStorage() { try { this._keyStore = KeyStore.GetInstance(KeyStore.DefaultType); this._protection = new KeyStore.PasswordProtection(Password); if (File.FileExists(StorageFile)) { using (var stream = new IsolatedStorageFileStream(StorageFile, FileMode.Open, FileAccess.Read, File)) { this._keyStore.Load(stream, Password); } } else { this._keyStore.Load(null, Password); } } catch (Exception ex) { var exceptionHandler = new ExceptionHandler(typeof(KeyVaultStorage).FullName + "._constructor", ex); } }
/// <summary> /// Default constructor created or loads the store /// </summary> public SecureStorageImplementation() { // verify that password is set if (string.IsNullOrWhiteSpace(StoragePassword)) { throw new Exception($"Must set StoragePassword"); } StoragePasswordArray = StoragePassword.ToCharArray(); // Instantiate store and protection _store = KeyStore.GetInstance(KeyStore.DefaultType); _passwordProtection = new KeyStore.PasswordProtection(StoragePasswordArray); // if store exists, load it from the file try { using (var stream = new IsolatedStorageFileStream(StorageFile, FileMode.Open, FileAccess.Read)) { _store.Load(stream, StoragePasswordArray); } } catch (Exception) { // this will happen for the first run. As no file is expected to be present _store.Load(null, StoragePasswordArray); } }
public void Init(string protectionPassword) { if (string.IsNullOrWhiteSpace(protectionPassword)) { throw new ArgumentException("Cannot initialize without protection password.", nameof(protectionPassword)); } _userSelectedPassword = protectionPassword.ToCharArray(); _keyStore = KeyStore.GetInstance(KeyStore.DefaultType); _passwordProtection = new KeyStore.PasswordProtection(_userSelectedPassword); try { lock (_fileLock) { using (var s = Context.OpenFileInput(FileName)) { _keyStore.Load(s, _userSelectedPassword); } } } catch (FileNotFoundException) { LoadEmptyKeyStore(_userSelectedPassword); } _keychainInitialized = true; }
/// <summary> /// In Android we have to call this method first. /// This will make sure that the store will be initialized using a user provided key as password. /// </summary> /// <param name="password">The password for the KeyStore</param> /// <param name="fileName">A filename for the KeyStore</param> public void Initialize(string password, string fileName = "Excalibur.Store") { _password = password.ToCharArray(); _fileName = fileName; if (_password == null) { throw new ArgumentNullException(nameof(_password), "Please call ProtectedStore.Init(<password>, <fileName?>) first."); } _context = global::Android.App.Application.Context; _keyStore = KeyStore.GetInstance(KeyStore.DefaultType); _passwordProtection = new KeyStore.PasswordProtection(_password); try { lock (FileLock) { using (var stream = _context.OpenFileInput(_fileName)) { _keyStore.Load(stream, _password); } } } catch (Java.IO.FileNotFoundException) { _keyStore.Load(null, _password); } catch (Java.IO.IOException) { throw new ProtectedStoreException(); } }
static KeyStore LoadKeyStore(string clientId, string key) { var context = global::Android.App.Application.Context; KeyStore ks; if(keyStores.TryGetValue(clientId, out ks)) return ks; var pw = key.ToCharArray(); ks = KeyStore.GetInstance(KeyStore.DefaultType); var prot = new KeyStore.PasswordProtection(pw); try { lock(fileLock) { using(var s = context.OpenFileInput(clientId)) { ks.Load(s, pw); } } } catch(FileNotFoundException) { //ks.Load (null, Password); LoadEmptyKeyStore(ks, pw); } keyStores[clientId] = ks; return ks; }
private async Task <byte[]> GetEncryptionKeyLockedAsync(string keyName) { byte[] key = null; try { char[] deviceId = GetDeviceId().ToCharArray(); KeyStore keyStore = await GetOrCreateKeyStoreAsync(deviceId).ConfigureAwait(false); KeyStore.IProtectionParameter protectionParameter = new KeyStore.PasswordProtection(deviceId); KeyStore.SecretKeyEntry secretKeyEntry = (KeyStore.SecretKeyEntry)keyStore.GetEntry(keyName, protectionParameter); if (secretKeyEntry != null) { ISecretKey secretKey = secretKeyEntry.SecretKey; if (secretKey != null) { key = secretKey.GetEncoded(); } } } catch (FileNotFoundException) { // If the file isn't found, it's not a big deal and should mean it's just the first run. // The caller or the GetOrCreate method above will need to create it if we don't find it here. } return(key); }
static Tuple <KeyStore, KeyStore.PasswordProtection> LoadKeyStore(Context context) { // Get our secure key which will be randomly created the first time the app is run var secureKey = GetSecureKey(context); var keyStore = KeyStore.GetInstance(KeyStore.DefaultType); var prot = new KeyStore.PasswordProtection(secureKey); try { lock (fileLock) { if (context.GetFileStreamPath(FILENAME)?.Exists() ?? false) { using (var s = context.OpenFileInput(FILENAME)) keyStore.Load(s, secureKey); } else { keyStore.Load(null, secureKey); } } } catch { keyStore.Load(null, secureKey); } return(Tuple.Create(keyStore, prot)); }
static KeyStore LoadKeyStore(string clientId, string key) { var context = global::Android.App.Application.Context; KeyStore ks; if (keyStores.TryGetValue(clientId, out ks)) { return(ks); } var pw = key.ToCharArray(); ks = KeyStore.GetInstance(KeyStore.DefaultType); var prot = new KeyStore.PasswordProtection(pw); try { lock (fileLock) { using (var s = context.OpenFileInput(clientId)) { ks.Load(s, pw); } } } catch (FileNotFoundException) { //ks.Load (null, Password); LoadEmptyKeyStore(ks, pw); } keyStores[clientId] = ks; return(ks); }
public void CreateStore() { this.context = Android.App.Application.Context; ks = KeyStore.GetInstance(KeyStore.DefaultType); prot = new KeyStore.PasswordProtection(Password); try { lock (fileLock) { using (var s = context.OpenFileInput(FileName)) { ks.Load(s, Password); } } } catch (Java.IO.FileNotFoundException) { //ks.Load (null, Password); LoadEmptyKeyStore(Password); } }
private static readonly char[] _password = "******".ToCharArray(); //todo: change this private void InitializeStore() { this._context = Android.App.Application.Context; _keyStore = KeyStore.GetInstance(KeyStore.DefaultType); _prot = new KeyStore.PasswordProtection(_password); try { lock (fileLock) { if(!this.FileExists(_context, _fileName)) { LoadEmptyKeyStore(_password); } else { using (var f = _context.OpenFileInput(_fileName)) { _keyStore.Load(f, _password); } } } } catch (Exception ex) when (ex is Java.IO.FileNotFoundException || ex is System.IO.FileNotFoundException) { System.Diagnostics.Debug.WriteLine($"Caught {ex.GetType().ToString()} in Android.AuthService.InitializeStore."); LoadEmptyKeyStore(_password); } }
/// <summary> /// Default constructor created or loads the store /// </summary> public SecureStorageImplementation() { // verify that password is set if (string.IsNullOrWhiteSpace(StoragePassword)) { throw new Exception($"Must set StoragePassword"); } StoragePasswordArray = StoragePassword.ToCharArray(); // Instantiate store and protection _store = KeyStore.GetInstance(KeyStore.DefaultType); _passwordProtection = new KeyStore.PasswordProtection(StoragePasswordArray); // if store exists, load it from the file try { using (var stream = new IsolatedStorageFileStream(StorageFile, FileMode.Open, FileAccess.Read)) { _store.Load(stream, StoragePasswordArray); } } catch (Exception) { // this will happen for the first run. As no file is expected to be present _store.Load(null, StoragePasswordArray); } }
KeychainResult getItemFromKeychain(string service) { var context = Android.App.Application.Context; var password = service.ToCharArray(); var protection = new KeyStore.PasswordProtection(password); var keystore = getKeystore(service); var aliases = keystore.Aliases(); while (aliases.HasMoreElements) { var alias = aliases.NextElement().ToString(); var item = keystore.GetEntry(alias, protection) as KeyStore.SecretKeyEntry; if (item != null) { var bytes = item.SecretKey.GetEncoded(); var serialized = System.Text.Encoding.UTF8.GetString(bytes); return(new KeychainResult(alias, serialized)); } } return(new KeychainResult()); }
/// <summary> /// Default constructor created or loads the store /// </summary> public SecureStorageImplementation() { // verify that password is set if (string.IsNullOrWhiteSpace(StoragePassword)) { throw new Exception($"Must set StoragePassword"); } this._password = StoragePassword.ToCharArray(); _keyStore = KeyStore.GetInstance(KeyStore.DefaultType); _protection = new KeyStore.PasswordProtection(this._password); if (File.FileExists(StorageFile)) { using (var stream = new IsolatedStorageFileStream(StorageFile, FileMode.Open, FileAccess.Read, File)) { this._keyStore.Load(stream, _password); } } else { this._keyStore.Load(null, _password); } }
/// <summary> /// Saves a {@code KeyStore.Entry} under the specified alias. /// The specified protection parameter is used to protect the /// {@code Entry}. /// /// <para> If an entry already exists for the specified alias, /// it is overridden. /// /// </para> /// </summary> /// <param name="alias"> save the {@code KeyStore.Entry} under this alias </param> /// <param name="entry"> the {@code Entry} to save </param> /// <param name="protParam"> the {@code ProtectionParameter} /// used to protect the {@code Entry}, /// which may be {@code null} /// </param> /// <exception cref="KeyStoreException"> if this operation fails /// /// @since 1.5 </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void engineSetEntry(String alias, KeyStore.Entry entry, KeyStore.ProtectionParameter protParam) throws KeyStoreException public virtual void EngineSetEntry(String alias, KeyStore.Entry entry, KeyStore.ProtectionParameter protParam) { // get password if (protParam != null && !(protParam is KeyStore.PasswordProtection)) { throw new KeyStoreException("unsupported protection parameter"); } KeyStore.PasswordProtection pProtect = null; if (protParam != null) { pProtect = (KeyStore.PasswordProtection)protParam; } // set entry if (entry is KeyStore.TrustedCertificateEntry) { if (protParam != null && pProtect.Password != null) { // pre-1.5 style setCertificateEntry did not allow password throw new KeyStoreException("trusted certificate entries are not password-protected"); } else { KeyStore.TrustedCertificateEntry tce = (KeyStore.TrustedCertificateEntry)entry; EngineSetCertificateEntry(alias, tce.TrustedCertificate); return; } } else if (entry is KeyStore.PrivateKeyEntry) { if (pProtect == null || pProtect.Password == null) { // pre-1.5 style setKeyEntry required password throw new KeyStoreException("non-null password required to create PrivateKeyEntry"); } else { EngineSetKeyEntry(alias, ((KeyStore.PrivateKeyEntry)entry).PrivateKey, pProtect.Password, ((KeyStore.PrivateKeyEntry)entry).CertificateChain); return; } } else if (entry is KeyStore.SecretKeyEntry) { if (pProtect == null || pProtect.Password == null) { // pre-1.5 style setKeyEntry required password throw new KeyStoreException("non-null password required to create SecretKeyEntry"); } else { EngineSetKeyEntry(alias, ((KeyStore.SecretKeyEntry)entry).SecretKey, pProtect.Password, (Certificate[])null); return; } } //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: throw new KeyStoreException("unsupported entry type: " + entry.GetType().FullName); }
/// <summary> /// Initializes a new instance of the <see cref="Xamarin.Auth.AndroidAccountStore"/> class /// with a KeyStore password provided by the application. /// </summary> /// <param name="context">Context.</param> /// <param name="password">KeyStore Password.</param> public AndroidAccountStore(Context context, string password) { if (password == null) { throw new ArgumentNullException("password"); } Password = password.ToCharArray(); this.context = context; ks = KeyStore.GetInstance(KeyStore.DefaultType); prot = new KeyStore.PasswordProtection(Password); try { lock (fileLock) { if (!this.FileExists(context, FileName)) { LoadEmptyKeyStore(Password); } else { using (var s = context.OpenFileInput(FileName)) { ks.Load(s, Password); } } } } catch (FileNotFoundException) { LoadEmptyKeyStore(Password); } catch (Java.IO.IOException ex) { if (ex.Message == "KeyStore integrity check failed.") { // Migration scenario: this exception means that the keystore could not be opened // with the app provided password, so there is probably an existing keystore // that was encoded with the old hard coded password, which was deprecated. // We'll try to open the keystore with the old password, and migrate the contents // to a new one that will be encoded with the new password. //MigrateKeyStore(context); try { //try with the original password MigrateKeyStore(context, PasswordHardCodedOriginal); } catch (System.Exception) { //migrate using the default MigrateKeyStore(context); } } } }
static internal void SetSecured(string key, string value, string clientId, string service, string sharedGrou = null) { var ks = LoadKeyStore(clientId, service); var entry = new KeyStore.SecretKeyEntry(new SecretAccount(value)); var protect = new KeyStore.PasswordProtection(service.ToCharArray()); ks.SetEntry("{0} - {1}".Fmt(clientId, key), entry, protect); Save(clientId, service, ks); }
/// <inheritdoc /> public void Terminate() { _keyStore = null; _passwordProtection = null; lock (FileLock) { _context = null; _password = null; } }
static internal void SetSecured(string key, string value, string clientId, string service, string sharedGrou = null) { var ks = LoadKeyStore(clientId, service); var entry = new KeyStore.SecretKeyEntry(new SecretAccount(value)); var protect = new KeyStore.PasswordProtection(service.ToCharArray()); ks.SetEntry("{0} - {1}".Fmt(clientId, key), entry, protect); Save(clientId, service, ks); }
/// <summary> /// Initializes a new instance of the <see cref="KeyVaultStorage"/> class. /// </summary> /// <param name="password">Password to use for encryption.</param> public KeyVaultStorage(char[] password) { this.keyStore = KeyStore.GetInstance(KeyStore.DefaultType); this.protection = new KeyStore.PasswordProtection(password); if (File.FileExists(StorageFile)) { using (var stream = new IsolatedStorageFileStream(StorageFile, FileMode.Open, FileAccess.Read, File)) { this.keyStore.Load(stream, password); } } else { this.keyStore.Load(null, password); } }
/// <summary> /// Initializes a new instance of the <see cref="KeyVaultStorage"/> class. /// </summary> /// <param name="password">Password to use for encryption.</param> public KeyVaultStorage(char[] password) { this.keyStore = KeyStore.GetInstance(KeyStore.DefaultType); this.protection = new KeyStore.PasswordProtection(password); if (File.FileExists(StorageFile)) { using (var stream = new IsolatedStorageFileStream(StorageFile, FileMode.Open, FileAccess.Read, File)) { this.keyStore.Load(stream, password); } } else { this.keyStore.Load(null, password); } }
/// <summary> /// Gets a {@code KeyStore.Entry} for the specified alias /// with the specified protection parameter. /// </summary> /// <param name="alias"> get the {@code KeyStore.Entry} for this alias </param> /// <param name="protParam"> the {@code ProtectionParameter} /// used to protect the {@code Entry}, /// which may be {@code null} /// </param> /// <returns> the {@code KeyStore.Entry} for the specified alias, /// or {@code null} if there is no such entry /// </returns> /// <exception cref="KeyStoreException"> if the operation failed </exception> /// <exception cref="NoSuchAlgorithmException"> if the algorithm for recovering the /// entry cannot be found </exception> /// <exception cref="UnrecoverableEntryException"> if the specified /// {@code protParam} were insufficient or invalid </exception> /// <exception cref="UnrecoverableKeyException"> if the entry is a /// {@code PrivateKeyEntry} or {@code SecretKeyEntry} /// and the specified {@code protParam} does not contain /// the information needed to recover the key (e.g. wrong password) /// /// @since 1.5 </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public KeyStore.Entry engineGetEntry(String alias, KeyStore.ProtectionParameter protParam) throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableEntryException public virtual KeyStore.Entry EngineGetEntry(String alias, KeyStore.ProtectionParameter protParam) { if (!EngineContainsAlias(alias)) { return(null); } if (protParam == null) { if (EngineIsCertificateEntry(alias)) { return(new KeyStore.TrustedCertificateEntry(EngineGetCertificate(alias))); } else { throw new UnrecoverableKeyException("requested entry requires a password"); } } if (protParam is KeyStore.PasswordProtection) { if (EngineIsCertificateEntry(alias)) { throw new UnsupportedOperationException("trusted certificate entries are not password-protected"); } else if (EngineIsKeyEntry(alias)) { KeyStore.PasswordProtection pp = (KeyStore.PasswordProtection)protParam; char[] password = pp.Password; Key key = EngineGetKey(alias, password); if (key is PrivateKey) { Certificate[] chain = EngineGetCertificateChain(alias); return(new KeyStore.PrivateKeyEntry((PrivateKey)key, chain)); } else if (key is SecretKey) { return(new KeyStore.SecretKeyEntry((SecretKey)key)); } } } throw new UnsupportedOperationException(); }
protected void CopyKeyStoreContents(char[] oldPassword) { var oldKeyStore = KeyStore.GetInstance(KeyStore.DefaultType); var oldProtection = new KeyStore.PasswordProtection(oldPassword); using (var s = context.OpenFileInput(FileName + "Old")) { oldKeyStore.Load(s, oldPassword); // Copy all aliases to a new keystore, using a different password var aliases = oldKeyStore.Aliases(); while (aliases.HasMoreElements) { var alias = aliases.NextElement().ToString(); var e = oldKeyStore.GetEntry(alias, oldProtection) as KeyStore.SecretKeyEntry; ks.SetEntry(alias, e, prot); } } Save(); }
public override Task <bool> LoadAsync() { var secureKey = GetKeyFromPreferences(context); var keyStore = LoadKeyStore(context, secureKey); var password = new KeyStore.PasswordProtection(secureKey); var entry = keyStore.GetEntry(FILENAME, password) as KeyStore.SecretKeyEntry; if (entry != null) { var bytes = entry.SecretKey.GetEncoded(); var json = System.Text.Encoding.UTF8.GetString(bytes); data = JsonToDictionary(json); } return(Task.FromResult(true)); }
public KeyChainHelper(Func <Context> context, string keyStoreFileProtectionPassword, string fileName, string serviceId) { if (string.IsNullOrEmpty(keyStoreFileProtectionPassword)) { throw new ArgumentNullException("Filename cannot be null or empty string"); } if (string.IsNullOrEmpty(fileName)) { throw new ArgumentNullException("Filename cannot be null or empty string"); } if (string.IsNullOrEmpty(serviceId)) { throw new ArgumentNullException("ServiceId cannot be null or empty string"); } _keyStoreFileProtectionPassword = keyStoreFileProtectionPassword; _fileName = fileName; _serviceId = serviceId; _fileProtectionPasswordArray = _keyStoreFileProtectionPassword.ToCharArray(); this.getContext = context; _androidKeyStore = KeyStore.GetInstance(KeyStore.DefaultType); _passwordProtection = new KeyStore.PasswordProtection(_fileProtectionPasswordArray); try { lock (_fileLock) { using (var s = getContext().OpenFileInput(_fileName)) { _androidKeyStore.Load(s, _fileProtectionPasswordArray); } } } catch (FileNotFoundException) { //ks.Load (null, Password); LoadEmptyKeyStore(_fileProtectionPasswordArray); } }
private void CreateStore() { _context = Android.App.Application.Context; _keyStore = KeyStore.GetInstance(KeyStore.DefaultType); _passProtection = new KeyStore.PasswordProtection(_password); try { lock (_fileLock) { using (var s = _context.OpenFileInput(_fileName)) { _keyStore.Load(s, _password); } } } catch (Java.IO.FileNotFoundException) { LoadEmptyKeyStore(_password); } }
private async Task StoreKeyAsync(string keyName, ISecretKey key) { char[] deviceId = GetDeviceId().ToCharArray(); KeyStore keyStore = await GetOrCreateKeyStoreAsync(deviceId).ConfigureAwait(false); KeyStore.IProtectionParameter protectionParameter = new KeyStore.PasswordProtection(deviceId); // Create the SecretKeyEntry wrapper around the SecretKey KeyStore.SecretKeyEntry secretKeyEntry = new KeyStore.SecretKeyEntry(key); // Store the SecretKeyEntry in the KeyStore keyStore.SetEntry(keyName, secretKeyEntry, protectionParameter); // Write the KeyStore to the app's directory with appropriate permissions // Note: we're using the same key to protect the KeyStore as we are to protect the entry inside it. using (Stream fileStream = await OpenKeyStoreFileForOutputAsync().ConfigureAwait(false)) { keyStore.Store(fileStream, deviceId); } }
public AndroidAccountStore (Context context) { this.context = context; ks = KeyStore.GetInstance (KeyStore.DefaultType); prot = new KeyStore.PasswordProtection (Password); try { lock (fileLock) { using (var s = context.OpenFileInput (FileName)) { ks.Load (s, Password); } } } catch (FileNotFoundException) { //ks.Load (null, Password); LoadEmptyKeyStore (Password); } }
public DroidKeychain() { _keyStore = KeyStore.GetInstance(KeyStore.DefaultType); _passwordProtection = new KeyStore.PasswordProtection(Password); try { lock (fileLock) { using (var s = Context.OpenFileInput(FileName)) { _keyStore.Load(s, Password); } } } catch (FileNotFoundException) { LoadEmptyKeyStore(Password); } }
public AndroidAccountStore(Context context) { this.context = context; ks = KeyStore.GetInstance(KeyStore.DefaultType); prot = new KeyStore.PasswordProtection(Password); try { lock (fileLock) { using (var s = context.OpenFileInput(FileName)) { ks.Load(s, Password); } } } catch (FileNotFoundException) { //ks.Load (null, Password); LoadEmptyKeyStore(Password); } }
/// <summary> /// Initializes a new instance of the <see cref="Xamarin.Auth.AndroidAccountStore"/> class /// with a KeyStore password provided by the application. /// </summary> /// <param name="context">Context.</param> /// <param name="password">KeyStore Password.</param> public SafeStore(Context context, string password, string fileName = "Arc4u.Secure.Store") { if (String.IsNullOrWhiteSpace(password)) { throw new ArgumentNullException("password"); } Password = password.ToCharArray(); if (String.IsNullOrWhiteSpace(fileName)) { throw new ArgumentNullException("fileName"); } FileName = fileName; this.context = context; ks = KeyStore.GetInstance(KeyStore.DefaultType); prot = new KeyStore.PasswordProtection(Password); try { lock (fileLock) { if (!this.FileExists(context, FileName)) { LoadEmptyKeyStore(Password); } else { using (var s = context.OpenFileInput(FileName)) { ks.Load(s, Password); } } } } catch (Java.IO.FileNotFoundException) { LoadEmptyKeyStore(Password); } }
public bool UnlockSecureStorage(string password) { _password = password.ToCharArray(); _passwordProtection = new KeyStore.PasswordProtection(_password); _keyStore = KeyStore.GetInstance(KeyStore.DefaultType); try { lock (_fileLocker) { var ctx = Android.App.Application.Context; if (!this.FileExists(ctx, FileName)) { LoadEmptyKeyStore(password.ToCharArray()); System.Diagnostics.Debug.WriteLine("created " + FileName); } else { using (var s = ctx.OpenFileInput(FileName)) { _keyStore.Load(s, password.ToCharArray()); System.Diagnostics.Debug.WriteLine("loaded " + FileName); } } IsUnlocked = true; } } catch (FileNotFoundException) { LoadEmptyKeyStore(password.ToCharArray()); IsUnlocked = true; Save(); } catch (Java.IO.IOException) { IsUnlocked = false; } return(IsUnlocked); }
public KeyChainUtils(Func <Context> context, string keyStoreFileProtectionPassword, string fileName, string serviceId) { if (String.IsNullOrEmpty(keyStoreFileProtectionPassword)) { keyStoreFileProtectionPassword = String.Empty; } if (String.IsNullOrEmpty(fileName)) { fileName = ".keystore"; } if (String.IsNullOrEmpty(serviceId)) { serviceId = "Advexp.Settings"; } _keyStoreFileProtectionPassword = keyStoreFileProtectionPassword; _fileName = fileName; _serviceId = serviceId; _fileProtectionPasswordArray = _keyStoreFileProtectionPassword.ToCharArray(); this.getContext = context; _androidKeyStore = KeyStore.GetInstance(KeyStore.DefaultType); _passwordProtection = new KeyStore.PasswordProtection(_fileProtectionPasswordArray); try { lock (_fileLock) { using (var s = getContext().OpenFileInput(_fileName)) { _androidKeyStore.Load(s, _fileProtectionPasswordArray); } } } catch (FileNotFoundException) { //ks.Load (null, Password); LoadEmptyKeyStore(_fileProtectionPasswordArray); } }
public PasswordStorage(string fileName, char[] passkey) { this.filename = fileName; this.PassKey = passkey; this.keystore = KeyStore.GetInstance (KeyStore.DefaultType); this.protection = new KeyStore.PasswordProtection (this.PassKey); if (File.Exists (this.filename)) { lock (this.locker) { using (var stream = new FileStream (fileName, FileMode.Open)) { keystore.Load (stream, passkey); } } } else { keystore.Load (null, passkey); } }
public PasswordStorage(string fileName, char[] passkey) { this.filename = fileName; this.PassKey = passkey; this.keystore = KeyStore.GetInstance(KeyStore.DefaultType); this.protection = new KeyStore.PasswordProtection(this.PassKey); if (File.Exists(this.filename)) { lock (this.locker) { using (var stream = new FileStream(fileName, FileMode.Open)) { keystore.Load(stream, passkey); } } } else { keystore.Load(null, passkey); } }
public void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { if (_passProtection != null) { _passProtection.Dispose(); _passProtection = null; } if (_keyStore != null) { _keyStore.Dispose(); _keyStore = null; } } _disposed = true; }
static internal string GetSecured(string key, string clientId, string service, string sharedGroup) { var keyId = $"{clientId} - {key}"; var prot = new KeyStore.PasswordProtection(service.ToCharArray()); var ks = LoadKeyStore(clientId, service); var aliases = ks.Aliases(); while(aliases.HasMoreElements) { var alias = aliases.NextElement().ToString(); if(alias == keyId) { var e = ks.GetEntry(alias, prot) as KeyStore.SecretKeyEntry; if(e != null) { var bytes = e.SecretKey.GetEncoded(); var serialized = System.Text.Encoding.UTF8.GetString(bytes); return serialized; } } } return ""; }
public override Task <bool> SaveAsync() { var secureKey = GetKeyFromPreferences(context); var keyStore = LoadKeyStore(context, secureKey); var password = new KeyStore.PasswordProtection(secureKey); var secretValue = new SecretValue(System.Text.Encoding.UTF8.GetBytes(DictionaryToJson(data))); var secretKeyEntry = new KeyStore.SecretKeyEntry(secretValue); keyStore.SetEntry(FILENAME, secretKeyEntry, password); lock (fileLock) { using (var stream = context.OpenFileOutput(FILENAME, FileCreationMode.Private)) { keyStore.Store(stream, secureKey); stream.Flush(); stream.Close(); } } return(Task.FromResult(true)); }