TestLogin & static key location map

src/MiFare/Classic/ICardReader.cs

@@ -61,6 +61,17 @@ interface ICardReader
         /// <returns>tru on success, false otherwise</returns>
         Task<bool> Login(int sector, InternalKeyType key);
 
+        /// <summary>
+        /// Tests if login into the given sector using the given key is possible
+        /// </summary>
+        /// <param name="sector">sector to login into</param>
+        /// <param name="keytype">keytype to use (e.g. KeyA, KeyB)</param>
+        /// <param name="key">key to use</param>
+        /// <returns>tru on success, false otherwise</returns>
+        Task<bool> TestLogin(int sector,KeyType keytype, byte[] key);
+
+
+
         /// <summary>
         /// read a datablock from a sector 
         /// </summary>

src/MiFare/Classic/MiFARECard.cs

@@ -231,6 +231,20 @@ public async Task SetData(int sector, int dataBlock, byte[] data)
             }
         }
 
+
+
+        /// <summary>
+        /// Tests if login into the given sector using the given key is possible
+        /// </summary>
+        /// <param name="sector">sector to login into</param>
+        /// <param name="keytype">keytype to use (e.g. KeyA, KeyB)</param>
+        /// <param name="key">key to use</param>
+        /// <returns>tru on success, false otherwise</returns>
+        public async Task<bool> TestLogin(int sector, KeyType keytype, byte[] key)
+        {
+            return await GetSector(sector).TestLogin(keytype, key);
+        }
+
         /// <summary>
         ///     reinitialize the object
         /// </summary>

src/MiFare/Classic/MiFareStandardCardReaderBase.cs

@@ -22,9 +22,9 @@ abstract class MiFareStandardCardReaderBase : ICardReader, IDisposable
 
         private Dictionary<SectorKey, byte[]> keyMap = new Dictionary<SectorKey, byte[]>();
 
-        private byte nextKeySlot;
+        private static byte nextKeySlot;
 
-        private Dictionary<byte[], byte> keyToLocationMap = new Dictionary<byte[], byte>(KeyEqualityComparer.Default);
+        private  static Dictionary<byte[], byte> keyToLocationMap = new Dictionary<byte[], byte>(KeyEqualityComparer.Default);
 
         protected MiFareStandardCardReaderBase(IReadOnlyCollection<SectorKeySet> keys)
         {
@@ -111,6 +111,33 @@ public async Task<bool> Login(int sector, InternalKeyType key)
             return res.Succeeded;
         }
 
+        public async Task<bool> TestLogin(int sector, KeyType keytype, byte[] key)
+        {
+            //for testing we ignore the keymap
+            var gaKeyType = (GeneralAuthenticate.GeneralAuthenticateKeyType)keytype;
+
+            // Get the block for the sector
+            var blockNumber = SectorToBlock(sector, 0);
+
+            // see if we have the key loaded already
+            byte location;
+            if (!keyToLocationMap.TryGetValue(key, out location))
+            {
+                location = nextKeySlot;
+                nextKeySlot++;
+                keyToLocationMap[key] = location;
+
+                // Load the key to the location
+                var r = await TransceiveAsync(new LoadKey(key, location));
+                if (!r.Succeeded)
+                    return false; // could not load the key
+            }
+
+            var res = await TransceiveAsync(new PcSc.MiFareStandard.GeneralAuthenticate(blockNumber, location, gaKeyType));
+
+            return res.Succeeded;
+        }
+
         public async Task<Tuple<bool, byte[]>> Read(int sector, int datablock)
         {
             var blockNumber = SectorToBlock(sector, datablock);

src/MiFare/Classic/Sector.cs

@@ -205,6 +205,11 @@ private async Task FlushDataBlock(DataBlock dataBlock)
                 throw new CardWriteException($"Unable to write in sector {sector}, block {dataBlock.Number}");
         }
 
+        public async Task<bool> TestLogin(KeyType keytype, byte[] key)
+        {
+            return await card.Reader.TestLogin(sector, keytype, key);
+        }
+
         private async Task<DataBlock> GetDataBlockInt(int block)
         {
             var db = dataBlocks[block];