protected override void OnCreate (Bundle savedInstanceState)
		{
			base.OnCreate (savedInstanceState);
			fingerprintModule = new FingerprintModule(this);
			mKeyguardManager = fingerprintModule.ProvidesKeyguardManager (this);
			mKeyStore = fingerprintModule.ProvidesKeystore ();
			mKeyGenerator = fingerprintModule.ProvidesKeyGenerator ();
			mCipher = fingerprintModule.ProvidesCipher (mKeyStore);

			RequestPermissions (new [] { Manifest.Permission.UseFingerprint }, 0);
		}
 /// <summary>
 /// Initializes a new instance of the <see cref="AesObfuscator"/> class. 
 /// The aes obfuscator.
 /// </summary>
 /// <param name="salt">
 /// an array of random bytes to use for each (un)obfuscation
 /// </param>
 /// <param name="applicationId">
 /// application identifier, e.g. the package name
 /// </param>
 /// <param name="deviceId">
 /// device identifier. Use as many sources as possible to 
 /// create this unique identifier.
 /// </param>
 public AesObfuscator(byte[] salt, string applicationId, string deviceId)
 {
     try
     {
         SecretKeyFactory factory = SecretKeyFactory.GetInstance(KeygenAlgorithm);
         IKeySpec keySpec = new PBEKeySpec((applicationId + deviceId).ToCharArray(), salt, 1024, 256);
         ISecretKey tmp = factory.GenerateSecret(keySpec);
         ISecretKey secret = new SecretKeySpec(tmp.GetEncoded(), "AES");
         this.encryptor = Cipher.GetInstance(CipherAlgorithm);
         this.encryptor.Init(CipherMode.EncryptMode, secret, new IvParameterSpec(Iv));
         this.decryptor = Cipher.GetInstance(CipherAlgorithm);
         this.decryptor.Init(CipherMode.DecryptMode, secret, new IvParameterSpec(Iv));
     }
     catch (GeneralSecurityException e)
     {
         // This can't happen on a compatible Android device.
         throw new RuntimeException("Invalid environment", e);
     }
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="CryptoTransformAdaptor"/> class.
 /// </summary>
 /// <param name="algorithm">The algorithm.</param>
 /// <param name="transform">The transform.</param>
 internal CryptoTransformAdaptor(SymmetricAlgorithm algorithm, Cipher transform)
 {
     Requires.NotNull(transform, "transform");
     this.algorithm = algorithm;
     this.transform = transform;
 }
        /// <summary>
        /// Initializes the cipher if it has not yet been initialized.
        /// </summary>
        /// <param name="mode">The mode.</param>
        /// <param name="iv">The iv.</param>
        /// <param name="cipher">The cipher.</param>
        /// <exception cref="System.ArgumentException">
        /// Invalid algorithm parameter.
        /// </exception>
        /// <exception cref="System.NotSupportedException">Algorithm not supported.</exception>
        private void InitializeCipher(CipherMode mode, byte[] iv, ref Cipher cipher)
        {
            try
            {
                bool newCipher = false;
                if (cipher == null)
                {
                    cipher = Cipher.GetInstance(this.GetCipherAcquisitionName().ToString());
                    newCipher = true;
                }

                if (this.algorithm.IsBlockCipher() || newCipher)
                {
                    iv = this.ThisOrDefaultIV(iv);
                    using (var ivspec = iv != null ? new IvParameterSpec(iv) : null)
                    {
                        cipher.Init(mode, this.key, ivspec);
                    }
                }
            }
            catch (InvalidKeyException ex)
            {
                throw new ArgumentException(ex.Message, ex);
            }
            catch (NoSuchAlgorithmException ex)
            {
                throw new NotSupportedException("Algorithm not supported.", ex);
            }
            catch (InvalidAlgorithmParameterException ex)
            {
                throw new ArgumentException("Invalid algorithm parameter.", ex);
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="CryptoTransformAdaptor"/> class.
 /// </summary>
 /// <param name="name">The name of the base algorithm to use.</param>
 /// <param name="mode">The algorithm's mode (i.e. streaming or some block mode).</param>
 /// <param name="padding">The padding to use.</param>
 /// <param name="transform">The transform.</param>
 internal CryptoTransformAdaptor(SymmetricAlgorithmName name, SymmetricAlgorithmMode mode, SymmetricAlgorithmPadding padding, Cipher transform)
 {
     Requires.NotNull(transform, "transform");
     this.name = name;
     this.mode = mode;
     this.padding = padding;
     this.transform = transform;
 }
        private byte[] DoCipherOperation(Cipher cipher, byte[] data)
        {
            Requires.NotNull(cipher, nameof(cipher));
            Requires.NotNull(data, nameof(data));

            // Android returns null when given an empty input.
            if (this.Padding != SymmetricAlgorithmPadding.PKCS7 && data.Length == 0)
            {
                return data;
            }

            try
            {
                return this.CanStreamAcrossTopLevelCipherOperations
                    ? cipher.Update(data)
                    : cipher.DoFinal(data);
            }
            catch (IllegalBlockSizeException ex)
            {
                throw new ArgumentException("Illegal block size.", ex);
            }
        }
        /// <summary>
        /// Gets the block size (in bytes) for the specified algorithm.
        /// </summary>
        /// <param name="pclAlgorithm">The PCL algorithm.</param>
        /// <param name="algorithm">The platform-specific algorithm.</param>
        /// <returns>The block size (in bytes).</returns>
        internal static int GetBlockSize(SymmetricAlgorithm pclAlgorithm, Cipher algorithm)
        {
            Requires.NotNull(algorithm, "algorithm");

            if (algorithm.BlockSize == 0 && pclAlgorithm.GetName() == SymmetricAlgorithmName.Rc4)
            {
                // This is a streaming cipher without a block size. Return 1 to emulate behavior of other platforms.
                return 1;
            }

            return algorithm.BlockSize;
        }