Merge pull request #16 from disk0Dancer/copilot/fix-nfc-usage-issues

Implement AID extraction for NFC emulation and automate version from git tags

Author: disk0Dancer

app/build.gradle.kts

@@ -7,6 +7,34 @@ plugins {
     id("com.google.dagger.hilt.android")
 }
 
+// Function to extract version from git tag
+fun getVersionFromGit(): Pair<Int, String> {
+    return try {
+        val gitTag = Runtime.getRuntime()
+            .exec("git describe --tags --abbrev=0")
+            .inputStream.bufferedReader().readText().trim()
+        
+        // Parse version tag (e.g., "v1.2.3" or "1.2.3")
+        val versionMatch = Regex("""v?(\d+)\.(\d+)\.(\d+)""").find(gitTag)
+        if (versionMatch != null) {
+            val (major, minor, patch) = versionMatch.destructured
+            // Calculate versionCode as major*10000 + minor*100 + patch
+            val versionCode = major.toInt() * 10000 + minor.toInt() * 100 + patch.toInt()
+            val versionName = "$major.$minor.$patch"
+            Pair(versionCode, versionName)
+        } else {
+            // Fallback if no valid tag found
+            Pair(1, "0.1.0")
+        }
+    } catch (e: Exception) {
+        // Fallback to default version if git command fails
+        println("Warning: Could not read git tag, using default version. Error: ${e.message}")
+        Pair(1, "0.1.0")
+    }
+}
+
+val (appVersionCode, appVersionName) = getVersionFromGit()
+
 android {
     namespace = "com.nfcbumber"
     compileSdk = 35
@@ -15,8 +43,8 @@ android {
         applicationId = "com.nfcbumber"
         minSdk = 26
         targetSdk = 35
-        versionCode = 4
-        versionName = "2.0.0"
+        versionCode = appVersionCode
+        versionName = appVersionName
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {

app/src/main/res/xml/apduservice.xml

@@ -4,11 +4,32 @@
     android:requireDeviceUnlock="false"
     android:apduServiceBanner="@mipmap/ic_launcher">
 
-    <!-- Default AID for generic card emulation -->
+    <!-- AID group for access control, transit, and identification cards -->
     <aid-group android:description="@string/aid_group_description" android:category="other">
-        <!-- Generic application identifier for NFC card emulation -->
+        <!-- Generic/Default AIDs -->
         <aid-filter android:name="F0010203040506"/>
-        <!-- Alternative AID for compatibility -->
+        <aid-filter android:name="F04E4643424D42455200"/>
+        
+        <!-- Payment AIDs (for reference, most terminals won't accept them from "other" category) -->
         <aid-filter android:name="A0000000031010"/>
+        <aid-filter android:name="A0000000041010"/>
+        <aid-filter android:name="A0000000032010"/>
+        <aid-filter android:name="A0000000999999"/>
+        
+        <!-- MIFARE DESFire AIDs (common in access control) -->
+        <aid-filter android:name="D2760000850100"/>
+        <aid-filter android:name="D2760000850101"/>
+        
+        <!-- Transit card AIDs -->
+        <aid-filter android:name="315449432E494341"/>
+        
+        <!-- Access control AIDs -->
+        <aid-filter android:name="A000000618"/>
+        <aid-filter android:name="A00000061701"/>
+        
+        <!-- Common transport and access control AIDs -->
+        <aid-filter android:name="F0000000000000"/>
+        <aid-filter android:name="A00000015100"/>
+        <aid-filter android:name="D2760000850100"/>
     </aid-group>
 </host-apdu-service>

data/src/main/kotlin/com/nfcbumber/data/database/AppDatabase.kt

@@ -9,7 +9,7 @@ import androidx.room.TypeConverters
  */
 @Database(
     entities = [CardEntity::class],
-    version = 1,
+    version = 2,
     exportSchema = true
 )
 @TypeConverters(Converters::class)

data/src/main/kotlin/com/nfcbumber/data/database/CardEntity.kt

@@ -14,6 +14,7 @@ data class CardEntity(
     val uid: ByteArray,
     val ats: ByteArray?,
     val historicalBytes: ByteArray?,
+    val aids: String = "", // Comma-separated Application Identifiers
     val cardType: String,
     val color: Int,
     val createdAt: Long,

data/src/main/kotlin/com/nfcbumber/data/di/DatabaseModule.kt

@@ -2,6 +2,8 @@ package com.nfcbumber.data.di
 
 import android.content.Context
 import androidx.room.Room
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
 import com.nfcbumber.data.database.AppDatabase
 import com.nfcbumber.data.database.CardDao
 import dagger.Module
@@ -18,6 +20,13 @@ import javax.inject.Singleton
 @InstallIn(SingletonComponent::class)
 object DatabaseModule {
 
+    private val MIGRATION_1_2 = object : Migration(1, 2) {
+        override fun migrate(database: SupportSQLiteDatabase) {
+            // Add the aids column to the cards table
+            database.execSQL("ALTER TABLE cards ADD COLUMN aids TEXT NOT NULL DEFAULT ''")
+        }
+    }
+
     @Provides
     @Singleton
     fun provideAppDatabase(
@@ -28,6 +37,7 @@ object DatabaseModule {
             AppDatabase::class.java,
             AppDatabase.DATABASE_NAME
         )
+            .addMigrations(MIGRATION_1_2)
             .fallbackToDestructiveMigration()
             .build()
     }

data/src/main/kotlin/com/nfcbumber/data/mapper/CardMapper.kt

@@ -18,6 +18,7 @@ object CardMapper {
             uid = entity.uid,
             ats = entity.ats,
             historicalBytes = entity.historicalBytes,
+            aids = if (entity.aids.isNotEmpty()) entity.aids.split(",") else emptyList(),
             cardType = CardType.valueOf(entity.cardType),
             color = entity.color,
             createdAt = LocalDateTime.ofInstant(
@@ -41,6 +42,7 @@ object CardMapper {
             uid = card.uid,
             ats = card.ats,
             historicalBytes = card.historicalBytes,
+            aids = card.aids.joinToString(","),
             cardType = card.cardType.name,
             color = card.color,
             createdAt = card.createdAt.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(),

data/src/main/kotlin/com/nfcbumber/data/nfc/NfcEmulatorService.kt

@@ -114,27 +114,46 @@ class NfcEmulatorService : HostApduService() {
 
     /**
      * Handle SELECT command (00 A4 04 00).
+     * Verifies that the requested AID matches one of the card's AIDs.
      * Returns ATS (Answer To Select) if available.
      */
     private fun handleSelectCommand(commandApdu: ByteArray): ByteArray {
         Log.d(TAG, "Processing SELECT command")
 
         val card = getSelectedCard()
 
-        return if (card != null) {
-            Log.d(TAG, "Card selected: ${card.name}, UID: ${card.uid.toHexString()}")
-            
-            // Return ATS if available, otherwise just success
-            if (card.ats != null && card.ats.isNotEmpty()) {
-                Log.d(TAG, "Returning ATS: ${card.ats.toHexString()}")
-                card.ats + SW_SUCCESS
-            } else {
-                Log.d(TAG, "No ATS available, returning success")
-                SW_SUCCESS
+        if (card == null) {
+            Log.w(TAG, "No card selected for emulation")
+            return SW_FILE_NOT_FOUND
+        }
+        
+        // Extract the requested AID from the SELECT command
+        // Format: 00 A4 04 00 Lc [AID bytes]
+        if (commandApdu.size >= 6) {
+            val aidLength = commandApdu[4].toInt() and 0xFF
+            if (commandApdu.size >= 5 + aidLength) {
+                val requestedAid = commandApdu.copyOfRange(5, 5 + aidLength).toHexString()
+                Log.d(TAG, "Terminal requested AID: $requestedAid")
+                
+                // Check if the card supports this AID
+                if (card.aids.isNotEmpty() && !card.aids.contains(requestedAid)) {
+                    Log.w(TAG, "Card does not support requested AID: $requestedAid")
+                    Log.d(TAG, "Card supports AIDs: ${card.aids.joinToString()}")
+                    // Return file not found for unsupported AID
+                    return SW_FILE_NOT_FOUND
+                }
+                
+                Log.d(TAG, "AID matched, card selected: ${card.name}")
             }
+        }
+        
+        // Return ATS if available, otherwise just success
+        return if (card.ats != null && card.ats.isNotEmpty()) {
+            Log.d(TAG, "Returning ATS: ${card.ats.toHexString()}")
+            card.ats + SW_SUCCESS
         } else {
-            Log.w(TAG, "No card selected for emulation")
-            SW_FILE_NOT_FOUND
+            Log.d(TAG, "No ATS available, returning success")
+            SW_SUCCESS
         }
     }
 
@@ -200,10 +219,17 @@ class NfcEmulatorService : HostApduService() {
             runBlocking {
                 val cardEntity = cardDao.getCardById(selectedCardId)
                 if (cardEntity != null) {
+                    val aids = if (cardEntity.aids.isNotEmpty()) {
+                        cardEntity.aids.split(",")
+                    } else {
+                        emptyList()
+                    }
+                    
                     EmulatedCardData(
                         uid = cardEntity.uid,
                         ats = cardEntity.ats,
                         historicalBytes = cardEntity.historicalBytes,
+                        aids = aids,
                         name = cardEntity.name
                     )
                 } else {
@@ -246,6 +272,7 @@ private data class EmulatedCardData(
     val uid: ByteArray,
     val ats: ByteArray?,
     val historicalBytes: ByteArray?,
+    val aids: List<String>,
     val name: String
 ) {
     override fun equals(other: Any?): Boolean {

data/src/main/kotlin/com/nfcbumber/data/nfc/NfcReaderService.kt

@@ -43,25 +43,29 @@ class NfcReaderService @Inject constructor() {
             Log.d(TAG, "Available technologies: ${techList.joinToString()}")
 
             // Try to read as ISO-DEP first (most common for smart cards)
-            val (ats, historicalBytes, cardType) = when {
+            val (cardData, aids) = when {
                 techList.contains(IsoDep::class.java.name) -> readIsoDep(tag)
-                techList.contains(MifareClassic::class.java.name) -> readMifareClassic(tag)
-                techList.contains(MifareUltralight::class.java.name) -> readMifareUltralight(tag)
-                techList.contains(NfcA::class.java.name) -> readNfcA(tag)
-                techList.contains(NfcB::class.java.name) -> readNfcB(tag)
-                techList.contains(NfcF::class.java.name) -> readNfcF(tag)
-                techList.contains(NfcV::class.java.name) -> readNfcV(tag)
-                else -> Triple(null, null, CardType.UNKNOWN)
+                techList.contains(MifareClassic::class.java.name) -> Pair(readMifareClassic(tag), emptyList())
+                techList.contains(MifareUltralight::class.java.name) -> Pair(readMifareUltralight(tag), emptyList())
+                techList.contains(NfcA::class.java.name) -> Pair(readNfcA(tag), emptyList())
+                techList.contains(NfcB::class.java.name) -> Pair(readNfcB(tag), emptyList())
+                techList.contains(NfcF::class.java.name) -> Pair(readNfcF(tag), emptyList())
+                techList.contains(NfcV::class.java.name) -> Pair(readNfcV(tag), emptyList())
+                else -> Pair(Triple(null, null, CardType.UNKNOWN), emptyList())
             }
 
+            val (ats, historicalBytes, cardType) = cardData
+            
             Log.d(TAG, "Card type: $cardType")
             Log.d(TAG, "ATS: ${ats?.toHexString() ?: "N/A"}")
             Log.d(TAG, "Historical bytes: ${historicalBytes?.toHexString() ?: "N/A"}")
+            Log.d(TAG, "Discovered AIDs: ${aids.joinToString()}")
 
             NfcCardData(
                 uid = uid,
                 ats = ats,
                 historicalBytes = historicalBytes,
+                aids = aids,
                 cardType = cardType
             )
         } catch (e: Exception) {
@@ -70,7 +74,7 @@ class NfcReaderService @Inject constructor() {
         }
     }
 
-    private fun readIsoDep(tag: Tag): Triple<ByteArray?, ByteArray?, CardType> {
+    private fun readIsoDep(tag: Tag): Pair<Triple<ByteArray?, ByteArray?, CardType>, List<String>> {
         val isoDep = IsoDep.get(tag)
         return try {
             isoDep.connect()
@@ -79,7 +83,10 @@ class NfcReaderService @Inject constructor() {
             val ats = isoDep.historicalBytes ?: isoDep.hiLayerResponse
             val historicalBytes = isoDep.historicalBytes
 
-            Triple(ats, historicalBytes, CardType.ISO_DEP)
+            // Try to discover AIDs by sending SELECT commands for common AIDs
+            val aids = discoverAids(isoDep)
+            
+            Pair(Triple(ats, historicalBytes, CardType.ISO_DEP), aids)
         } finally {
             try {
                 if (isoDep.isConnected) {
@@ -90,6 +97,63 @@ class NfcReaderService @Inject constructor() {
             }
         }
     }
+    
+    /**
+     * Discover AIDs supported by the card by probing common AIDs.
+     * This helps identify what applications the card supports.
+     */
+    private fun discoverAids(isoDep: IsoDep): List<String> {
+        val discoveredAids = mutableListOf<String>()
+        
+        // Common AIDs for access control, transit, and payment systems
+        val commonAids = listOf(
+            "F0010203040506",      // Generic/Default AID
+            "A0000000031010",      // Visa
+            "A0000000041010",      // Mastercard
+            "A0000000032010",      // Visa Electron
+            "A0000000999999",      // Generic payment
+            "D2760000850100",      // MIFARE DESFire
+            "D2760000850101",      // MIFARE DESFire EV1
+            "315449432E494341",    // Transit card (STIC.ICA)
+            "A000000618",          // Access control
+            "A00000061701",        // Access control (HID)
+            "F04E4643424D42455200" // NFCBUMBER (our app AID)
+        )
+        
+        for (aid in commonAids) {
+            try {
+                val selectCommand = buildSelectApdu(aid)
+                val response = isoDep.transceive(selectCommand)
+                
+                // Check if response indicates success (SW1 SW2 = 90 00)
+                if (response.size >= 2 && 
+                    response[response.size - 2] == 0x90.toByte() && 
+                    response[response.size - 1] == 0x00.toByte()) {
+                    Log.d(TAG, "Discovered AID: $aid")
+                    discoveredAids.add(aid)
+                }
+            } catch (e: Exception) {
+                // Card doesn't support this AID, continue
+                Log.v(TAG, "AID $aid not supported: ${e.message}")
+            }
+        }
+        
+        return discoveredAids
+    }
+    
+    /**
+     * Build a SELECT APDU command for a given AID.
+     */
+    private fun buildSelectApdu(aid: String): ByteArray {
+        val aidBytes = aid.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+        return byteArrayOf(
+            0x00.toByte(), // CLA
+            0xA4.toByte(), // INS (SELECT)
+            0x04.toByte(), // P1 (Select by name)
+            0x00.toByte(), // P2
+            aidBytes.size.toByte() // Lc (length of AID)
+        ) + aidBytes
+    }
 
     private fun readMifareClassic(tag: Tag): Triple<ByteArray?, ByteArray?, CardType> {
         val mifare = MifareClassic.get(tag)
@@ -233,6 +297,7 @@ data class NfcCardData(
     val uid: ByteArray,
     val ats: ByteArray?,
     val historicalBytes: ByteArray?,
+    val aids: List<String> = emptyList(),
     val cardType: CardType
 ) {
     override fun equals(other: Any?): Boolean {
@@ -250,6 +315,7 @@ data class NfcCardData(
             if (other.historicalBytes == null) return false
             if (!historicalBytes.contentEquals(other.historicalBytes)) return false
         } else if (other.historicalBytes != null) return false
+        if (aids != other.aids) return false
         if (cardType != other.cardType) return false
 
         return true
@@ -259,6 +325,7 @@ data class NfcCardData(
         var result = uid.contentHashCode()
         result = 31 * result + (ats?.contentHashCode() ?: 0)
         result = 31 * result + (historicalBytes?.contentHashCode() ?: 0)
+        result = 31 * result + aids.hashCode()
         result = 31 * result + cardType.hashCode()
         return result
     }