diff --git a/.build/release/.env.example b/.build/release/.env.example new file mode 100644 index 0000000..f808dcb --- /dev/null +++ b/.build/release/.env.example @@ -0,0 +1,3 @@ +KEYSTORE_PASSWORD=your_keystore_password_here +KEY_ALIAS=your_key_alias_here +KEY_PASSWORD=your_key_password_here diff --git a/.build/release/.gitignore b/.build/release/.gitignore new file mode 100644 index 0000000..4f0f390 --- /dev/null +++ b/.build/release/.gitignore @@ -0,0 +1,2 @@ +.env +release/ diff --git a/.build/release/compose.yml b/.build/release/compose.yml new file mode 100644 index 0000000..32c8382 --- /dev/null +++ b/.build/release/compose.yml @@ -0,0 +1,9 @@ +services: + release: + image: git.shihaam.dev/dockerfiles/runners/gradle + network_mode: host + env_file: .env + volumes: + - ./release:/release + - ../../:/source + - /root/.cache/cache-runners/gradle:/root/.gradle diff --git a/.gitea/workflows/auto-tag.yml b/.gitea/workflows/auto-tag.yml new file mode 100644 index 0000000..e985798 --- /dev/null +++ b/.gitea/workflows/auto-tag.yml @@ -0,0 +1,50 @@ +name: Auto Tag on Version Change + +on: + push: + branches: + - main + +jobs: + check-version: + runs-on: docker-compose + + steps: + - name: Checkout source code + uses: actions/checkout@v4 + with: + fetch-depth: 0 + token: ${{ secrets.PAT_GITEA }} + + - name: Check version and prepare release + id: version + run: | + VERSION=$(grep 'versionName = ' app/build.gradle.kts | sed 's/.*versionName = "\(.*\)".*/\1/') + VERSION_CODE=$(grep 'versionCode = ' app/build.gradle.kts | sed 's/.*versionCode = \([0-9]*\).*/\1/') + echo "version=$VERSION" >> $GITHUB_OUTPUT + echo "version_code=$VERSION_CODE" >> $GITHUB_OUTPUT + + BEFORE="${{ github.event.before }}" + if [ -z "$BEFORE" ] || ! git cat-file -e "${BEFORE}^{commit}" 2>/dev/null; then + BEFORE="HEAD~1" + fi + PREV_VERSION_CODE=$(git show "${BEFORE}:app/build.gradle.kts" 2>/dev/null | grep 'versionCode = ' | sed 's/.*versionCode = \([0-9]*\).*/\1/') + + if [ "$VERSION_CODE" = "$PREV_VERSION_CODE" ]; then + echo "versionCode unchanged (${VERSION_CODE}), skipping" + echo "should_release=false" >> $GITHUB_OUTPUT + elif git tag -l | grep -q "^v${VERSION}$"; then + echo "versionCode changed (${PREV_VERSION_CODE} -> ${VERSION_CODE}) but tag v${VERSION} already exists; bump versionName" + exit 1 + else + echo "New versionCode detected: ${PREV_VERSION_CODE} -> ${VERSION_CODE} (v${VERSION})" + echo "should_release=true" >> $GITHUB_OUTPUT + fi + + - name: Create and push tag + if: steps.version.outputs.should_release == 'true' + run: | + VERSION="${{ steps.version.outputs.version }}" + git tag "v${VERSION}" + git push origin "v${VERSION}" + echo "Created and pushed tag v${VERSION}" diff --git a/.gitea/workflows/build-apk.yml b/.gitea/workflows/build-apk.yml new file mode 100644 index 0000000..6ac8b7f --- /dev/null +++ b/.gitea/workflows/build-apk.yml @@ -0,0 +1,86 @@ +name: Build and Release APK + +on: + push: + tags: + - 'v*' + +jobs: + build: + runs-on: docker-compose + + steps: + - name: Checkout source code + uses: actions/checkout@v4 + + - name: Setup keystore and environment + run: | + echo "${{ secrets.KEYSTORE_BASE64 }}" | tr -d '\n' | base64 -d > app/key.jks + echo "${{ secrets.DOTENV_BASE64 }}" | tr -d '\n' | base64 -d > .build/release/.env + + - name: Build APK + working-directory: .build/release + run: docker compose run --rm release + + - name: Rename APK + run: | + APP_NAME="${{ gitea.repository }}" + APP_NAME="${APP_NAME//\//-}" + TAG="${{ gitea.ref_name }}" + find .build/release/release/ -maxdepth 1 -name "*.apk" | head -1 | xargs -I{} mv {} ".build/release/release/${APP_NAME}-${TAG}.apk" + + - name: Extract release notes + run: | + VERSION_CODE=$(grep 'versionCode = ' app/build.gradle.kts | sed 's/.*versionCode = \([0-9]*\).*/\1/') + CHANGELOG="fastlane/metadata/android/en-US/changelogs/${VERSION_CODE}.txt" + + if [ -f "$CHANGELOG" ]; then + cp "$CHANGELOG" release_notes.md + else + echo "No changelog found at $CHANGELOG" + echo "No release notes" > release_notes.md + fi + + - name: Create Gitea Release + env: + GITEA_SERVER_URL: ${{ gitea.server_url }} + GITEA_REPOSITORY: ${{ gitea.repository }} + GITEA_TOKEN: ${{ secrets.PAT_GITEA }} + run: | + APP_NAME="${{ gitea.repository }}" + APP_NAME="${APP_NAME//\//-}" + TAG="${{ gitea.ref_name }}" + TITLE="${APP_NAME} ${TAG}" + NOTES_FILE="release_notes.md" + ASSET_PATH=".build/release/release/${APP_NAME}-${TAG}.apk" + + API_URL="${GITEA_SERVER_URL}/api/v1/repos/${GITEA_REPOSITORY}/releases" + + RELEASE_RESPONSE=$(curl -s -X POST "$API_URL" \ + -H "Authorization: token ${GITEA_TOKEN}" \ + -H "Content-Type: application/json" \ + -d "{ + \"tag_name\": \"${TAG}\", + \"name\": \"${TITLE}\", + \"body\": $(jq -Rs . < "$NOTES_FILE") + }") + + RELEASE_ID=$(echo "$RELEASE_RESPONSE" | jq -r '.id') + + if [ "$RELEASE_ID" = "null" ] || [ -z "$RELEASE_ID" ]; then + echo "Failed to create release:" + echo "$RELEASE_RESPONSE" + exit 1 + fi + + echo "Created release with ID: $RELEASE_ID" + + ASSET_NAME=$(basename "$ASSET_PATH") + UPLOAD_URL="${API_URL}/${RELEASE_ID}/assets?name=${ASSET_NAME}" + + curl -s -X POST "$UPLOAD_URL" \ + -H "Authorization: token ${GITEA_TOKEN}" \ + -H "Content-Type: application/octet-stream" \ + --data-binary "@${ASSET_PATH}" + + echo "Uploaded asset: $ASSET_NAME" diff --git a/.kotlin/sessions/kotlin-compiler-16707578751962836653.salive b/.kotlin/sessions/kotlin-compiler-16707578751962836653.salive deleted file mode 100644 index e69de29..0000000 diff --git a/README.md b/README.md index 754f424..b81860a 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,47 @@ # sw9000-android -Android app that reads NFC EMV cards and dumps everything: PPSE, AIDs, TLV tree, track2, PAN, expiry, AFL records, with raw APDUs. \ No newline at end of file +A read-only Android app that reads a contactless EMV card over NFC and shows **everything** +obtainable from it, with full APDU-level transparency. For reading your own cards. + +## What it does + +On launch it checks NFC: + +- **No NFC hardware** → an "NFC not supported" screen. +- **NFC off** → a prompt with a button to open NFC settings. +- **NFC on** → the "tap a card" animation (a card swinging onto a phone with NFC ripples, + ported from the sibling `android` app). On tap it reads the card and shows: + - **Formatted** — PAN, cardholder name, expiry, valid-from, PAN sequence, application label / + preferred name / AID, issuer country, currency, ATC, PIN-try counter, AIP, Track 2, plus the + tag's UID / technologies / ATQA / SAK / historical bytes. + - **Raw dump** — the full BER-TLV tree (every tag labelled and interpreted) for each + application, and the complete **APDU log**: every command sent, every response, and the + decoded status word. + +The read flow is: SELECT PPSE → for each advertised AID: SELECT AID → GET PROCESSING OPTIONS +(PDOL filled in) → READ RECORD across the AFL → GET DATA for the common counters. It never +writes to the card and runs no transaction (no GENERATE AC), so tapping is harmless. + +## Scheme / country / bank + +Derived with no network: + +- **Scheme** (Visa / Mastercard / Amex / UnionPay / JCB / Discover …) — from the application AID's + RID and, as a fallback, the PAN's leading digits. Reliable. +- **Issuer country** — from EMV tag `5F28` (ISO-3166 numeric), decoded to a country name. Present + on most cards. +- **Issuer bank / card type / product** — *not* stored on the card. Naming the bank needs a + **BIN/IIN database**, which you can optionally bundle at build time: drop a tab-separated dataset + at `app/src/main/assets/bins.tsv` (format documented in that file). It compiles into the APK, so + the app still makes no network calls. Without it, the app shows the raw BIN for manual lookup, + and the application label (`50` / `9F12`) often carries the issuer's branding anyway. + +## Privacy + +No network. The app declares only `android.permission.NFC` — **no `INTERNET` permission**, so +nothing read from a card can leave the device. + +## Build + +Standard Gradle / Android Studio project (AGP 9, Kotlin 2.2, Jetpack Compose). Needs a physical +NFC-capable device; the emulator can't read cards. diff --git a/app/.gitignore b/app/.gitignore index 42afabf..c7fec8b 100644 --- a/app/.gitignore +++ b/app/.gitignore @@ -1 +1,3 @@ -/build \ No newline at end of file +/build +# Signing keystore written by CI — never commit it. +key.jks diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 43bc407..019f1e0 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -6,9 +6,7 @@ plugins { android { namespace = "sh.sar.sw9000" compileSdk { - version = release(36) { - minorApiLevel = 1 - } + version = release(37) } defaultConfig { @@ -21,8 +19,21 @@ android { testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" } + signingConfigs { + create("release") { + // Supplied by CI: key.jks is written next to this module and the passwords come + // from the environment (.build/release/.env / Gitea secrets). Left unset locally, + // which is fine unless you run assembleRelease. + storeFile = file("key.jks") + storePassword = System.getenv("KEYSTORE_PASSWORD") + keyAlias = System.getenv("KEY_ALIAS") + keyPassword = System.getenv("KEY_PASSWORD") + } + } + buildTypes { release { + signingConfig = signingConfigs.getByName("release") isMinifyEnabled = false proguardFiles( getDefaultProguardFile("proguard-android-optimize.txt"), diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 8c777d4..3772eba 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -2,6 +2,11 @@ + + + + + iin_end scheme type brand bank country +# +# iin_start / iin_end : inclusive range over the first up-to-8 PAN digits. Pad a shorter prefix +# with 0s on start and 9s on end — e.g. the 6-digit prefix 457173 -> 45717300 and 45717399. +# Any trailing column may be left blank. Ranges should not overlap; the narrowest match wins. +# +# Example rows (SYNTHETIC — replace with a real dataset): +# 45717300 45717399 Visa credit Classic Example Bank United Kingdom +# 55555500 55555599 Mastercard debit Example Bank United States +# +# Where to get data (check each source's licence before shipping): +# - Commercial BIN providers (most accurate, licensed). +# - Open community lists on GitHub (quality/licensing varies). +# Convert whatever you obtain into the tab-separated format above. diff --git a/app/src/main/java/sh/sar/sw9000/MainActivity.kt b/app/src/main/java/sh/sar/sw9000/MainActivity.kt index 45f9124..30dcf74 100644 --- a/app/src/main/java/sh/sar/sw9000/MainActivity.kt +++ b/app/src/main/java/sh/sar/sw9000/MainActivity.kt @@ -1,47 +1,129 @@ package sh.sar.sw9000 +import android.content.Intent +import android.nfc.NfcAdapter import android.os.Bundle +import android.provider.Settings import androidx.activity.ComponentActivity import androidx.activity.compose.setContent import androidx.activity.enableEdgeToEdge import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.padding +import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.Scaffold import androidx.compose.material3.Text -import androidx.compose.runtime.Composable +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue import androidx.compose.ui.Modifier -import androidx.compose.ui.tooling.preview.Preview +import kotlin.concurrent.thread +import sh.sar.sw9000.nfc.BinLookup +import sh.sar.sw9000.nfc.EmvCardReader +import sh.sar.sw9000.ui.NfcDisabledScreen +import sh.sar.sw9000.ui.ResultScreen import sh.sar.sw9000.ui.theme.Sw9000Theme +import sh.sar.sw9000.ui.TapState +import sh.sar.sw9000.ui.UnsupportedScreen +import sh.sar.sw9000.ui.WaitingScreen +/** Reader screen states, driven by the NFC adapter and the active read. */ +sealed interface UiState { + data object Unsupported : UiState + data object Disabled : UiState + data class Waiting(val tap: TapState) : UiState + data class Done(val result: EmvCardReader.Result) : UiState +} + +/** + * Single-activity, read-only NFC/EMV dumper. The activity owns the NFC adapter: it enables + * reader mode whenever we're on the waiting screen and tears it down otherwise. The reader-mode + * callback runs on a binder thread, so the (blocking) card read happens there and the result is + * posted back to Compose state on the main thread. + */ class MainActivity : ComponentActivity() { + + private var adapter: NfcAdapter? = null + private var uiState by mutableStateOf(UiState.Waiting(TapState.WAITING)) + + @OptIn(ExperimentalMaterial3Api::class) override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) + adapter = NfcAdapter.getDefaultAdapter(this) + // Load the optional bundled BIN database off the main thread (no-op if none is bundled). + thread { BinLookup.init(applicationContext) } enableEdgeToEdge() setContent { Sw9000Theme { - Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding -> - Greeting( - name = "Android", - modifier = Modifier.padding(innerPadding) - ) + Scaffold( + modifier = Modifier.fillMaxSize(), + topBar = { TopAppBar(title = { Text(getString(R.string.app_name)) }) }, + ) { inner -> + when (val s = uiState) { + UiState.Unsupported -> UnsupportedScreen(Modifier.padding(inner)) + UiState.Disabled -> NfcDisabledScreen( + onOpenSettings = { startActivity(Intent(Settings.ACTION_NFC_SETTINGS)) }, + modifier = Modifier.padding(inner), + ) + is UiState.Waiting -> WaitingScreen( + state = s.tap, + label = if (s.tap == TapState.READING) getString(R.string.reading) + else getString(R.string.tap_card), + modifier = Modifier.padding(inner), + ) + is UiState.Done -> ResultScreen( + result = s.result, + onReadAnother = { uiState = UiState.Waiting(TapState.WAITING) }, + modifier = Modifier.padding(inner), + ) + } } } } } -} -@Composable -fun Greeting(name: String, modifier: Modifier = Modifier) { - Text( - text = "Hello $name!", - modifier = modifier - ) -} - -@Preview(showBackground = true) -@Composable -fun GreetingPreview() { - Sw9000Theme { - Greeting("Android") + override fun onResume() { + super.onResume() + syncAdapterState() } -} \ No newline at end of file + + override fun onPause() { + super.onPause() + runCatching { adapter?.disableReaderMode(this) } + } + + /** Reconciles the current UI state with NFC availability and (re)arms reader mode. */ + private fun syncAdapterState() { + val a = adapter + when { + a == null -> uiState = UiState.Unsupported + !a.isEnabled -> uiState = UiState.Disabled + else -> { + // Coming back from Disabled/Unsupported resets us to waiting. + if (uiState is UiState.Unsupported || uiState is UiState.Disabled) { + uiState = UiState.Waiting(TapState.WAITING) + } + enableReader(a) + } + } + } + + private fun enableReader(a: NfcAdapter) { + val flags = NfcAdapter.FLAG_READER_NFC_A or NfcAdapter.FLAG_READER_NFC_B or + NfcAdapter.FLAG_READER_SKIP_NDEF_CHECK + a.enableReaderMode(this, { tag -> + // Binder thread — safe to block on card I/O here. + runOnUiThread { if (uiState is UiState.Waiting) uiState = UiState.Waiting(TapState.READING) } + thread { + val result = runCatching { EmvCardReader.read(tag) }.getOrElse { + EmvCardReader.Result( + uid = "", techList = emptyList(), historicalBytes = null, hiLayerResponse = null, + atqa = null, sak = null, apps = emptyList(), fields = emptyList(), apduLog = emptyList(), + error = "Read error: ${it.message ?: it.javaClass.simpleName}", + ) + } + runOnUiThread { uiState = UiState.Done(result) } + } + }, flags, null) + } +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/BinLookup.kt b/app/src/main/java/sh/sar/sw9000/nfc/BinLookup.kt new file mode 100644 index 0000000..ed941c8 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/BinLookup.kt @@ -0,0 +1,107 @@ +package sh.sar.sw9000.nfc + +import android.content.Context +import java.io.BufferedReader + +/** + * Optional, fully-offline issuer lookup from the card's BIN/IIN (leading PAN digits). + * + * The card itself does NOT name the issuing bank; that needs an external BIN database. This loads + * one — if you bundle it — from `assets/bins.tsv`, built into the APK at compile time, so the app + * still makes no network calls and keeps the INTERNET permission off. If the asset is missing or + * empty, [lookup] simply returns null and the UI falls back to showing the raw BIN. + * + * ## File format (`app/src/main/assets/bins.tsv`), tab-separated, `#` lines ignored: + * ``` + * iin_start iin_end scheme type brand bank country + * ``` + * `iin_start`/`iin_end` are the inclusive range of the first up-to-8 PAN digits (pad shorter + * prefixes with 0s on the start and 9s on the end — e.g. the 6-digit prefix `457173` becomes + * `45717300`–`45717399`). Any trailing column may be left blank. Ranges should not overlap; if + * they do, the narrowest match wins. + */ +object BinLookup { + + data class Issuer( + val scheme: String?, + val type: String?, // debit / credit / prepaid, if known + val brand: String?, // product name, e.g. "Platinum" + val bank: String?, + val country: String?, + ) { + val isEmpty get() = listOf(scheme, type, brand, bank, country).all { it.isNullOrBlank() } + } + + @Volatile private var loaded = false + private var starts = LongArray(0) + private var ends = LongArray(0) + private var info = emptyArray() + + /** Loads the bundled dataset once. Safe to call repeatedly; no-op after the first success. */ + @Synchronized + fun init(context: Context) { + if (loaded) return + loaded = true + runCatching { + context.assets.open("bins.tsv").bufferedReader().use { parse(it) } + }.onFailure { + // No asset bundled (or unreadable): leave the index empty — lookups just return null. + starts = LongArray(0); ends = LongArray(0); info = emptyArray() + } + } + + /** Returns issuer details for [pan], or null if no dataset is bundled or nothing matches. */ + fun lookup(pan: String?): Issuer? { + if (starts.isEmpty() || pan == null) return null + val digits = pan.filter { it.isDigit() } + if (digits.length < 6) return null + val key = digits.take(8).padEnd(8, '0').toLongOrNull() ?: return null + + // Rightmost range whose start <= key, then widen the search backward for a container, + // keeping the narrowest (most specific) match. + var lo = 0; var hi = starts.size - 1; var idx = -1 + while (lo <= hi) { + val mid = (lo + hi) ushr 1 + if (starts[mid] <= key) { idx = mid; lo = mid + 1 } else hi = mid - 1 + } + if (idx < 0) return null + var best = -1 + var i = idx + var scanned = 0 + while (i >= 0 && scanned < 64) { + if (ends[i] >= key) { + if (best < 0 || (ends[i] - starts[i]) < (ends[best] - starts[best])) best = i + } + i--; scanned++ + } + return if (best >= 0) info[best] else null + } + + private fun parse(reader: BufferedReader) { + val s = ArrayList(1 shl 16) + val e = ArrayList(1 shl 16) + val list = ArrayList(1 shl 16) + reader.forEachLine { raw -> + val line = raw.trim() + if (line.isEmpty() || line.startsWith("#")) return@forEachLine + val c = line.split('\t') + val start = c.getOrNull(0)?.trim()?.padEnd(8, '0')?.toLongOrNull() ?: return@forEachLine + val end = c.getOrNull(1)?.trim()?.padEnd(8, '9')?.toLongOrNull() ?: start + s.add(start); e.add(end) + list.add( + Issuer( + scheme = c.getOrNull(2)?.trim()?.ifBlank { null }, + type = c.getOrNull(3)?.trim()?.ifBlank { null }, + brand = c.getOrNull(4)?.trim()?.ifBlank { null }, + bank = c.getOrNull(5)?.trim()?.ifBlank { null }, + country = c.getOrNull(6)?.trim()?.ifBlank { null }, + ) + ) + } + // Sort all three arrays together by range start. + val order = (0 until s.size).sortedBy { s[it] } + starts = LongArray(order.size) { s[order[it]] } + ends = LongArray(order.size) { e[order[it]] } + info = Array(order.size) { list[order[it]] } + } +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/CardIdentity.kt b/app/src/main/java/sh/sar/sw9000/nfc/CardIdentity.kt new file mode 100644 index 0000000..1df2e77 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/CardIdentity.kt @@ -0,0 +1,139 @@ +package sh.sar.sw9000.nfc + +/** + * Derives what a card reveals about itself without any network lookup: the payment **scheme** + * (Visa / Mastercard / Amex …) from the application AID and the PAN, and the **issuer country** + * from EMV tag 5F28. + * + * The specific issuing **bank** is deliberately not guessed: that needs a BIN/IIN database, which + * isn't on the card. The BIN (leading PAN digits) is exposed instead so it can be looked up + * elsewhere, and the application label often carries the issuer's own branding. + */ +object CardIdentity { + + /** Scheme name from the AID's RID (first 5 bytes / 10 hex chars), or null if unrecognised. */ + fun schemeFromAid(aidHex: String): String? { + val rid = aidHex.uppercase().take(10) + return RID[rid] + } + + /** Scheme name inferred from the PAN's leading digits (IIN), or null. */ + fun schemeFromPan(pan: String): String? { + val d = pan.filter { it.isDigit() } + if (d.length < 2) return null + fun p(n: Int) = d.take(n).toIntOrNull() ?: -1 + return when { + d[0] == '4' -> "Visa" + p(2) in 34..34 || p(2) == 37 -> "American Express" + p(2) in 51..55 || p(4) in 2221..2720 -> "Mastercard" + p(4) == 6011 || p(2) == 65 || p(3) in 644..649 -> "Discover" + p(2) == 35 -> "JCB" + p(2) == 62 || p(2) == 81 -> "UnionPay" + p(2) == 36 || p(2) == 38 || p(3) in 300..305 -> "Diners Club" + p(2) == 50 || p(2) in 56..69 -> "Maestro" + p(4) in 6521..6522 -> "RuPay" + else -> null + } + } + + /** Best-effort scheme: AID first (authoritative), PAN as fallback. */ + fun scheme(aidHex: String?, pan: String?): String? = + aidHex?.let { schemeFromAid(it) } ?: pan?.let { schemeFromPan(it) } + + /** Country name for an ISO-3166-1 numeric code (as a 3-digit string), or the code itself. */ + fun country(numeric: String): String { + val code = numeric.filter { it.isDigit() }.trimStart('0').padStart(3, '0') + return COUNTRIES[code]?.let { "$it ($code)" } ?: numeric + } + + // Registered Application Provider Identifiers (RID) → scheme. + private val RID = mapOf( + "A000000003" to "Visa", + "A000000004" to "Mastercard", + "A000000005" to "Mastercard", + "A000000025" to "American Express", + "A000000065" to "JCB", + "A000000152" to "Discover", + "A000000324" to "Discover", + "A000000333" to "UnionPay", + "A000000277" to "Interac", + "A000000042" to "Cartes Bancaires", + "A000000524" to "RuPay", + "A000000658" to "Mir", + "A000000371" to "Verve", + "A000000228" to "SPAN (Saudi)", + "A000000098" to "Visa (Debit)", + "A000000620" to "Interac", + ) + + // ISO 3166-1 numeric → country / territory name. Full assigned list. + private val COUNTRIES = mapOf( + "004" to "Afghanistan", "008" to "Albania", "010" to "Antarctica", "012" to "Algeria", + "016" to "American Samoa", "020" to "Andorra", "024" to "Angola", "028" to "Antigua and Barbuda", + "031" to "Azerbaijan", "032" to "Argentina", "036" to "Australia", "040" to "Austria", + "044" to "Bahamas", "048" to "Bahrain", "050" to "Bangladesh", "051" to "Armenia", + "052" to "Barbados", "056" to "Belgium", "060" to "Bermuda", "064" to "Bhutan", + "068" to "Bolivia", "070" to "Bosnia and Herzegovina", "072" to "Botswana", "074" to "Bouvet Island", + "076" to "Brazil", "084" to "Belize", "086" to "British Indian Ocean Territory", + "090" to "Solomon Islands", "092" to "British Virgin Islands", "096" to "Brunei", + "100" to "Bulgaria", "104" to "Myanmar", "108" to "Burundi", "112" to "Belarus", + "116" to "Cambodia", "120" to "Cameroon", "124" to "Canada", "132" to "Cape Verde", + "136" to "Cayman Islands", "140" to "Central African Republic", "144" to "Sri Lanka", + "148" to "Chad", "152" to "Chile", "156" to "China", "158" to "Taiwan", + "162" to "Christmas Island", "166" to "Cocos (Keeling) Islands", "170" to "Colombia", + "174" to "Comoros", "175" to "Mayotte", "178" to "Congo", "180" to "DR Congo", + "184" to "Cook Islands", "188" to "Costa Rica", "191" to "Croatia", "192" to "Cuba", + "196" to "Cyprus", "203" to "Czechia", "204" to "Benin", "208" to "Denmark", + "212" to "Dominica", "214" to "Dominican Republic", "218" to "Ecuador", "222" to "El Salvador", + "226" to "Equatorial Guinea", "231" to "Ethiopia", "232" to "Eritrea", "233" to "Estonia", + "234" to "Faroe Islands", "238" to "Falkland Islands", + "239" to "South Georgia and the South Sandwich Islands", "242" to "Fiji", "246" to "Finland", + "248" to "Åland Islands", "250" to "France", "254" to "French Guiana", "258" to "French Polynesia", + "260" to "French Southern Territories", "262" to "Djibouti", "266" to "Gabon", "268" to "Georgia", + "270" to "Gambia", "275" to "Palestine", "276" to "Germany", "288" to "Ghana", + "292" to "Gibraltar", "296" to "Kiribati", "300" to "Greece", "304" to "Greenland", + "308" to "Grenada", "312" to "Guadeloupe", "316" to "Guam", "320" to "Guatemala", + "324" to "Guinea", "328" to "Guyana", "332" to "Haiti", + "334" to "Heard Island and McDonald Islands", "336" to "Vatican City", "340" to "Honduras", + "344" to "Hong Kong", "348" to "Hungary", "352" to "Iceland", "356" to "India", + "360" to "Indonesia", "364" to "Iran", "368" to "Iraq", "372" to "Ireland", + "376" to "Israel", "380" to "Italy", "384" to "Côte d'Ivoire", "388" to "Jamaica", + "392" to "Japan", "398" to "Kazakhstan", "400" to "Jordan", "404" to "Kenya", + "408" to "North Korea", "410" to "South Korea", "414" to "Kuwait", "417" to "Kyrgyzstan", + "418" to "Laos", "422" to "Lebanon", "426" to "Lesotho", "428" to "Latvia", + "430" to "Liberia", "434" to "Libya", "438" to "Liechtenstein", "440" to "Lithuania", + "442" to "Luxembourg", "446" to "Macau", "450" to "Madagascar", "454" to "Malawi", + "458" to "Malaysia", "462" to "Maldives", "466" to "Mali", "470" to "Malta", + "474" to "Martinique", "478" to "Mauritania", "480" to "Mauritius", "484" to "Mexico", + "492" to "Monaco", "496" to "Mongolia", "498" to "Moldova", "499" to "Montenegro", + "500" to "Montserrat", "504" to "Morocco", "508" to "Mozambique", "512" to "Oman", + "516" to "Namibia", "520" to "Nauru", "524" to "Nepal", "528" to "Netherlands", + "531" to "Curaçao", "533" to "Aruba", "534" to "Sint Maarten", + "535" to "Bonaire, Sint Eustatius and Saba", "540" to "New Caledonia", "548" to "Vanuatu", + "554" to "New Zealand", "558" to "Nicaragua", "562" to "Niger", "566" to "Nigeria", + "570" to "Niue", "574" to "Norfolk Island", "578" to "Norway", + "580" to "Northern Mariana Islands", "581" to "U.S. Minor Outlying Islands", + "583" to "Micronesia", "584" to "Marshall Islands", "585" to "Palau", "586" to "Pakistan", + "591" to "Panama", "598" to "Papua New Guinea", "600" to "Paraguay", "604" to "Peru", + "608" to "Philippines", "612" to "Pitcairn", "616" to "Poland", "620" to "Portugal", + "624" to "Guinea-Bissau", "626" to "Timor-Leste", "630" to "Puerto Rico", "634" to "Qatar", + "638" to "Réunion", "642" to "Romania", "643" to "Russia", "646" to "Rwanda", + "652" to "Saint Barthélemy", "654" to "Saint Helena", "659" to "Saint Kitts and Nevis", + "660" to "Anguilla", "662" to "Saint Lucia", "663" to "Saint Martin", "666" to "Saint Pierre and Miquelon", + "670" to "Saint Vincent and the Grenadines", "674" to "San Marino", "678" to "São Tomé and Príncipe", + "682" to "Saudi Arabia", "686" to "Senegal", "688" to "Serbia", "690" to "Seychelles", + "694" to "Sierra Leone", "702" to "Singapore", "703" to "Slovakia", "704" to "Vietnam", + "705" to "Slovenia", "706" to "Somalia", "710" to "South Africa", "716" to "Zimbabwe", + "724" to "Spain", "728" to "South Sudan", "729" to "Sudan", "732" to "Western Sahara", + "740" to "Suriname", "744" to "Svalbard and Jan Mayen", "748" to "Eswatini", "752" to "Sweden", + "756" to "Switzerland", "760" to "Syria", "762" to "Tajikistan", "764" to "Thailand", + "768" to "Togo", "772" to "Tokelau", "776" to "Tonga", "780" to "Trinidad and Tobago", + "784" to "UAE", "788" to "Tunisia", "792" to "Turkey", "795" to "Turkmenistan", + "796" to "Turks and Caicos Islands", "798" to "Tuvalu", "800" to "Uganda", "804" to "Ukraine", + "807" to "North Macedonia", "818" to "Egypt", "826" to "United Kingdom", "831" to "Guernsey", + "832" to "Jersey", "833" to "Isle of Man", "834" to "Tanzania", "840" to "United States", + "850" to "U.S. Virgin Islands", "854" to "Burkina Faso", "858" to "Uruguay", "860" to "Uzbekistan", + "862" to "Venezuela", "876" to "Wallis and Futuna", "882" to "Samoa", "887" to "Yemen", + "894" to "Zambia", + ) +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/EmvCardReader.kt b/app/src/main/java/sh/sar/sw9000/nfc/EmvCardReader.kt new file mode 100644 index 0000000..206b3c2 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/EmvCardReader.kt @@ -0,0 +1,359 @@ +package sh.sar.sw9000.nfc + +import android.nfc.Tag +import android.nfc.tech.IsoDep +import android.nfc.tech.NfcA + +/** + * Read-only contactless EMV reader that dumps everything obtainable from a card: + * the PPSE directory, every advertised application (SELECT → GPO → AFL records), a merged + * BER-TLV tree per application, a flat list of notable fields, and — for full transparency — + * the complete command/response APDU log of the whole session. + * + * It never writes to the card and runs no transaction (no GENERATE AC), so tapping is harmless + * to your own cards. [read] blocks on NFC I/O and must be called off the main thread. + */ +object EmvCardReader { + + /** One command→response round-trip, kept verbatim so the UI can show the raw dump. */ + data class Apdu( + val label: String, + val command: ByteArray, + val response: ByteArray, + val sw1: Int, + val sw2: Int, + ) { + val sw: String get() = "%02X%02X".format(sw1, sw2) + val ok: Boolean get() = sw1 == 0x90 && sw2 == 0x00 + val swMeaning: String get() = StatusWords.describe(sw1, sw2) + } + + /** Everything learned about a single application (AID). */ + data class AppResult( + val aid: String, + val label: String?, + val preferredName: String?, + val tlv: List, + ) + + /** A single labelled value for the "formatted" view. */ + data class Field(val name: String, val value: String) + + /** The full outcome of a tap. [error] is set only when nothing usable could be read. */ + data class Result( + val uid: String, + val techList: List, + val historicalBytes: String?, + val hiLayerResponse: String?, + val atqa: String?, + val sak: String?, + val apps: List, + val fields: List, + val apduLog: List, + val error: String?, + ) { + val hasData: Boolean get() = apps.isNotEmpty() || fields.isNotEmpty() + } + + // Fallback AID list if the PPSE directory is empty or absent. + private val KNOWN_AIDS = listOf( + "A0000000031010" to "Visa", + "A0000000032010" to "Visa Electron", + "A0000000041010" to "Mastercard", + "A0000000043060" to "Maestro", + "A00000002501" to "American Express", + "A0000003330101" to "UnionPay", + "A0000001523010" to "Discover", + "A0000000651010" to "JCB", + "A0000006200620" to "Interac", + ) + + fun read(tag: Tag): Result { + val log = ArrayList() + val iso = IsoDep.get(tag) + ?: return Result( + uid = Hex.encode(tag.id), + techList = tag.techList.toList(), + historicalBytes = null, hiLayerResponse = null, + atqa = nfcA(tag)?.let { Hex.encode(it.atqa) }, + sak = nfcA(tag)?.let { "%02X".format(it.sak) }, + apps = emptyList(), fields = emptyList(), apduLog = emptyList(), + error = "Card does not support ISO-DEP (IsoDep). It may not be an EMV payment card.", + ) + + val apps = ArrayList() + var error: String? = null + try { + iso.connect() + iso.timeout = 5000 + + // 1) PPSE — the payment application directory. + val ppse = exchange(iso, selectName("2PAY.SYS.DDF01"), "SELECT PPSE (2PAY.SYS.DDF01)", log) + val aidsFromPpse = ppse?.let { Tlv.parse(it) }?.let { collectAids(it) } ?: emptyList() + val candidates = if (aidsFromPpse.isNotEmpty()) aidsFromPpse else KNOWN_AIDS + + // 2) Walk each candidate application. + for ((aidHex, hint) in candidates) { + val aid = Hex.decode(aidHex) + val fci = exchange(iso, selectAid(aid), "SELECT AID $aidHex${hint?.let { " ($it)" } ?: ""}", log) + ?: continue + val fciTlv = Tlv.parse(fci) + val merged = ArrayList().apply { addAll(fciTlv) } + + // 3) GET PROCESSING OPTIONS with the card's PDOL filled in. + val pdol = Tlv.find(fciTlv, "9F38") + val gpo = exchange(iso, gpoApdu(pdol), "GET PROCESSING OPTIONS", log) + if (gpo != null) { + val gpoTlv = Tlv.parse(gpo) + merged.addAll(gpoTlv) + + // 4) Read every record named by the AFL. + val afl = aflFrom(gpoTlv) + var i = 0 + while (i + 3 < afl.size) { + val sfi = (afl[i].toInt() and 0xFF) shr 3 + val first = afl[i + 1].toInt() and 0xFF + val last = afl[i + 2].toInt() and 0xFF + for (rec in first..last) { + val data = exchange(iso, readRecord(sfi, rec), "READ RECORD SFI $sfi rec $rec", log) + if (data != null) merged.addAll(Tlv.parse(data)) + } + i += 4 + } + } + + // 5) GET DATA for the common counters (harmless, read-only). + for ((t, name) in listOf("9F36" to "ATC", "9F13" to "Last Online ATC", "9F17" to "PIN Try Counter")) { + val d = exchange(iso, getData(t), "GET DATA $t ($name)", log) + if (d != null) merged.addAll(Tlv.parse(d)) + } + + apps.add( + AppResult( + aid = aidHex, + label = Tlv.find(merged, "50")?.let { asciiOrNull(it) } ?: hint, + preferredName = Tlv.find(merged, "9F12")?.let { asciiOrNull(it) }, + tlv = dedupe(merged), + ) + ) + } + if (apps.isEmpty() && ppse == null) { + error = "No EMV payment application responded. The card may use a scheme this tool " + + "doesn't probe, or it isn't a contactless payment card." + } + } catch (e: Exception) { + error = "Read error: ${e.message ?: e.javaClass.simpleName}" + } finally { + runCatching { iso.close() } + } + + val fields = buildFields(apps) + return Result( + uid = Hex.encode(tag.id), + techList = tag.techList.toList(), + historicalBytes = iso.historicalBytes?.takeIf { it.isNotEmpty() }?.let { Hex.encode(it) }, + hiLayerResponse = iso.hiLayerResponse?.takeIf { it.isNotEmpty() }?.let { Hex.encode(it) }, + atqa = nfcA(tag)?.let { Hex.encode(it.atqa) }, + sak = nfcA(tag)?.let { "%02X".format(it.sak) }, + apps = apps, + fields = fields, + apduLog = log, + error = if (apps.isEmpty()) (error ?: "Couldn't read any card data.") else null, + ) + } + + // ── Field extraction for the formatted view ──────────────────────────────── + + private fun buildFields(apps: List): List { + val out = LinkedHashMap() + fun put(name: String, value: String?) { if (!value.isNullOrBlank() && !out.containsKey(name)) out[name] = value } + + for (app in apps) { + val t = app.tlv + // PAN: prefer 5A, fall back to Track 2. + val pan = Tlv.find(t, "5A")?.let { Hex.encode(it).trimEnd('F') } + ?: Tlv.find(t, "57")?.let { trackPan(it) } + put("Card Number (PAN)", pan?.chunked(4)?.joinToString(" ")) + put("Card Scheme", CardIdentity.scheme(app.aid, pan)) + pan?.filter { it.isDigit() }?.takeIf { it.length >= 6 } + ?.let { put("BIN (IIN) — look up issuer", it.take(8)) } + // Issuer bank/type/brand come only from a bundled BIN database (if present); the + // card itself doesn't carry them. These fill gaps without overriding card-read values. + BinLookup.lookup(pan)?.let { iss -> + put("Card Scheme", iss.scheme) + put("Issuer Bank", iss.bank) + put("Card Type", iss.type) + put("Card Product", iss.brand) + } + put("Cardholder Name", Tlv.find(t, "5F20")?.let { asciiOrNull(it) }) + Tlv.find(t, "5F24")?.let { put("Expiry Date", expiry(it)) } + ?: Tlv.find(t, "57")?.let { put("Expiry Date", trackExpiry(it)) } + put("Valid From", Tlv.find(t, "5F25")?.let { effective(it) }) + put("PAN Sequence Number", Tlv.find(t, "5F34")?.let { Hex.encode(it) }) + put("Application Label", app.label) + put("Preferred Name", app.preferredName) + put("AID", app.aid) + put("Issuer Country", Tlv.find(t, "5F28")?.let { CardIdentity.country(Hex.encode(it)) } + ?: BinLookup.lookup(pan)?.country) + put("Application Currency", Tlv.find(t, "9F42")?.let { TlvInterpreter.interpret("9F42", it) }) + put("Language Preference", Tlv.find(t, "5F2D")?.let { asciiOrNull(it) }) + put("Application Version", Tlv.find(t, "9F08")?.let { Hex.encode(it) }) + put("ATC (Transaction Counter)", Tlv.find(t, "9F36")?.let { beInt(it).toString() }) + put("Last Online ATC", Tlv.find(t, "9F13")?.let { beInt(it).toString() }) + put("PIN Try Counter", Tlv.find(t, "9F17")?.let { beInt(it).toString() }) + put("Application Interchange Profile", Tlv.find(t, "82")?.let { TlvInterpreter.interpret("82", it) }) + put("Track 2 Equivalent", Tlv.find(t, "57")?.let { Hex.encode(it) }) + } + return out.map { Field(it.key, it.value) } + } + + // ── APDU builders ────────────────────────────────────────────────────────── + + private fun selectName(name: String): ByteArray = selectAid(name.toByteArray(Charsets.US_ASCII)) + + private fun selectAid(aid: ByteArray): ByteArray = + byteArrayOf(0x00, 0xA4.toByte(), 0x04, 0x00, aid.size.toByte()) + aid + byteArrayOf(0x00) + + private fun readRecord(sfi: Int, rec: Int): ByteArray = + byteArrayOf(0x00, 0xB2.toByte(), rec.toByte(), ((sfi shl 3) or 0x04).toByte(), 0x00) + + private fun getData(tag: String): ByteArray { + val t = Hex.decode(tag) + return byteArrayOf(0x80.toByte(), 0xCA.toByte(), t[0], t.getOrElse(1) { 0 }, 0x00) + } + + /** Builds GPO, filling the PDOL with sensible terminal values (zeros where unknown). */ + private fun gpoApdu(pdol: ByteArray?): ByteArray { + val data = ArrayList() + if (pdol != null) { + var i = 0 + while (i < pdol.size) { + var tag = pdol[i].toInt() and 0xFF + i++ + if (tag and 0x1F == 0x1F) { + while (i < pdol.size) { + val b = pdol[i++].toInt() and 0xFF + tag = (tag shl 8) or b + if (b and 0x80 == 0) break + } + } + if (i >= pdol.size) break + val len = pdol[i++].toInt() and 0xFF + val value = pdolValue(tag, len) + data.addAll(value.copyOf(len).toList()) + } + } + val pdolData = data.toByteArray() + val body = byteArrayOf(0x83.toByte(), pdolData.size.toByte()) + pdolData + return byteArrayOf(0x80.toByte(), 0xA8.toByte(), 0x00, 0x00, body.size.toByte()) + body + byteArrayOf(0x00) + } + + private fun pdolValue(tag: Int, len: Int): ByteArray = when (tag) { + 0x9F66 -> Hex.decode("B6204000") // TTQ: qVSDC, online-capable, no CVM required + 0x9F1A -> Hex.decode("0462") // Terminal country: Maldives + 0x5F2A -> Hex.decode("0462") // Transaction currency: MVR + 0x9A -> Hex.decode("260101") // Transaction date (YYMMDD) + 0x9C -> Hex.decode("00") // Transaction type: purchase + 0x9F37 -> Hex.decode("12345678") // Unpredictable number + 0x9F35 -> Hex.decode("22") // Terminal type + 0x9F33 -> Hex.decode("6008C8") // Terminal capabilities + 0x9F40 -> Hex.decode("F000F0A001") // Additional terminal capabilities + 0x9F02 -> Hex.decode("000000000100") // Amount authorised: 1 minor unit + 0x9F03 -> Hex.decode("000000000000") // Amount other + 0x95 -> Hex.decode("0000000000") // TVR + else -> ByteArray(len) + } + + // ── Transceive with 61xx / 6Cxx handling ─────────────────────────────────── + + private fun exchange(iso: IsoDep, apdu: ByteArray, label: String, log: MutableList): ByteArray? { + var cmd = apdu + var resp = iso.transceive(cmd) + if (resp.size < 2) { log.add(Apdu(label, cmd, resp, 0, 0)); return null } + + var sw1 = resp[resp.size - 2].toInt() and 0xFF + var sw2 = resp[resp.size - 1].toInt() and 0xFF + + if (sw1 == 0x6C) { // wrong Le; retry with the length the card wants + cmd = apdu.copyOf() + cmd[cmd.size - 1] = resp[resp.size - 1] + resp = iso.transceive(cmd) + sw1 = resp[resp.size - 2].toInt() and 0xFF + sw2 = resp[resp.size - 1].toInt() and 0xFF + } + // Accumulate any GET RESPONSE (61xx) continuations. + var payload = resp.copyOf(resp.size - 2) + while (sw1 == 0x61) { + val getResp = byteArrayOf(0x00, 0xC0.toByte(), 0x00, 0x00, resp[resp.size - 1]) + resp = iso.transceive(getResp) + if (resp.size < 2) break + payload += resp.copyOf(resp.size - 2) + sw1 = resp[resp.size - 2].toInt() and 0xFF + sw2 = resp[resp.size - 1].toInt() and 0xFF + } + + log.add(Apdu(label, cmd, payload + byteArrayOf(sw1.toByte(), sw2.toByte()), sw1, sw2)) + return if (sw1 == 0x90 && sw2 == 0x00) payload else null + } + + // ── Small helpers ────────────────────────────────────────────────────────── + + private fun nfcA(tag: Tag): NfcA? = runCatching { NfcA.get(tag) }.getOrNull() + + private fun collectAids(nodes: List): List> { + val out = ArrayList>() + fun walk(ns: List) { + for (n in ns) { + if (n.tag == "4F") out.add(Hex.encode(n.value) to null) + walk(n.children) + } + } + walk(nodes) + return out + } + + private fun aflFrom(gpoTlv: List): ByteArray = + Tlv.find(gpoTlv, "94") + ?: Tlv.find(gpoTlv, "80")?.let { if (it.size > 2) it.copyOfRange(2, it.size) else null } + ?: ByteArray(0) + + /** Removes duplicate leaf tags (same tag+value) that appear across records. */ + private fun dedupe(nodes: List): List { + val seen = HashSet() + val out = ArrayList() + for (n in nodes) { + val key = n.tag + ":" + if (n.constructed) "C" else Hex.encode(n.value) + if (seen.add(key)) out.add(n) + } + return out + } + + private fun asciiOrNull(v: ByteArray): String? = + String(v, Charsets.US_ASCII).trim().filter { it.code in 32..126 }.ifBlank { null } + + private fun beInt(v: ByteArray): Int = v.fold(0) { a, b -> (a shl 8) or (b.toInt() and 0xFF) } + + private fun trackPan(track2: ByteArray): String { + val h = Hex.encode(track2).uppercase() + val sep = h.indexOfFirst { it == 'D' || it == '=' } + return if (sep > 0) h.substring(0, sep) else h + } + + private fun trackExpiry(track2: ByteArray): String { + val h = Hex.encode(track2).uppercase() + val sep = h.indexOfFirst { it == 'D' || it == '=' } + if (sep < 0) return "" + val yymm = h.substring(sep + 1).take(4) + return if (yymm.length == 4) "${yymm.substring(2, 4)}/${yymm.substring(0, 2)}" else "" + } + + private fun expiry(v: ByteArray): String { + val h = Hex.encode(v) + return if (h.length >= 4) "${h.substring(2, 4)}/${h.substring(0, 2)}" else h + } + + private fun effective(v: ByteArray): String { + val h = Hex.encode(v) + return if (h.length >= 4) "${h.substring(2, 4)}/${h.substring(0, 2)}" else h + } +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/EmvTags.kt b/app/src/main/java/sh/sar/sw9000/nfc/EmvTags.kt new file mode 100644 index 0000000..577005a --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/EmvTags.kt @@ -0,0 +1,114 @@ +package sh.sar.sw9000.nfc + +/** + * Dictionary of EMV / ISO 7816 BER-TLV tags, used to label every object pulled off the card. + * Names follow the EMV 4.x specification and common issuer usage. Unknown tags fall back to + * "Unknown ()" so nothing read from the card is ever silently dropped. + */ +object EmvTags { + + private val names: Map = mapOf( + // ── Templates / FCI ────────────────────────────────────────────────── + "6F" to "FCI Template", + "84" to "Dedicated File (DF) Name / AID", + "A5" to "FCI Proprietary Template", + "87" to "Application Priority Indicator", + "88" to "Short File Identifier (SFI)", + "5F2D" to "Language Preference", + "9F11" to "Issuer Code Table Index", + "9F12" to "Application Preferred Name", + "50" to "Application Label", + "9F38" to "Processing Options Data Object List (PDOL)", + "BF0C" to "FCI Issuer Discretionary Data", + "61" to "Application Template", + "4F" to "Application Identifier (AID)", + "73" to "Directory Discretionary Template", + // ── PPSE ───────────────────────────────────────────────────────────── + "DF60" to "Kernel Identifier (proprietary)", + "9F2A" to "Kernel Identifier", + "9F0A" to "Application Selection Registered Proprietary Data", + // ── GPO / processing ───────────────────────────────────────────────── + "80" to "Response Message Template Format 1", + "77" to "Response Message Template Format 2", + "82" to "Application Interchange Profile (AIP)", + "94" to "Application File Locator (AFL)", + "83" to "Command Template", + "9F66" to "Terminal Transaction Qualifiers (TTQ)", + // ── Cardholder / account ───────────────────────────────────────────── + "5A" to "Application Primary Account Number (PAN)", + "5F34" to "PAN Sequence Number", + "5F20" to "Cardholder Name", + "5F24" to "Application Expiration Date", + "5F25" to "Application Effective Date", + "5F28" to "Issuer Country Code", + "5F2A" to "Transaction Currency Code", + "9F42" to "Application Currency Code", + "9F44" to "Application Currency Exponent", + "5F30" to "Service Code", + "5F36" to "Transaction Currency Exponent", + "57" to "Track 2 Equivalent Data", + "9F6B" to "Track 2 Data", + "56" to "Track 1 Equivalent Data", + "9F1F" to "Track 1 Discretionary Data", + "9F20" to "Track 2 Discretionary Data", + "9F5B" to "Issuer Script Results", + // ── Application control / counters ─────────────────────────────────── + "8C" to "Card Risk Management Data Object List 1 (CDOL1)", + "8D" to "Card Risk Management Data Object List 2 (CDOL2)", + "8E" to "Cardholder Verification Method (CVM) List", + "8F" to "Certification Authority Public Key Index", + "90" to "Issuer Public Key Certificate", + "92" to "Issuer Public Key Remainder", + "93" to "Signed Static Application Data", + "9F32" to "Issuer Public Key Exponent", + "9F46" to "ICC Public Key Certificate", + "9F47" to "ICC Public Key Exponent", + "9F48" to "ICC Public Key Remainder", + "9F49" to "Dynamic Data Authentication Data Object List (DDOL)", + "9F4A" to "Static Data Authentication Tag List", + "9F4B" to "Signed Dynamic Application Data", + "9F4C" to "ICC Dynamic Number", + "9F62" to "Track 1 bit map for PCII (PAN/Seq)", + "9F63" to "Track 2 bit map for PCII", + "9F64" to "Track 1 Number of ATC Digits", + "9F65" to "Track 2 bit map for CVC3", + "9F67" to "Track 2 Number of ATC Digits / NATC", + "9F68" to "Mag-stripe CVM List", + "9F69" to "Card Authentication Related Data (UDOL)", + "9F6C" to "Card Transaction Qualifiers (CTQ)", + "9F6E" to "Form Factor Indicator / 3rd Party Data", + // ── Counters read via GET DATA ─────────────────────────────────────── + "9F36" to "Application Transaction Counter (ATC)", + "9F13" to "Last Online ATC Register", + "9F17" to "PIN Try Counter", + "9F4F" to "Log Format", + "9F4D" to "Log Entry", + // ── Issuer / misc ──────────────────────────────────────────────────── + "9F07" to "Application Usage Control (AUC)", + "9F08" to "Application Version Number", + "9F0D" to "Issuer Action Code - Default", + "9F0E" to "Issuer Action Code - Denial", + "9F0F" to "Issuer Action Code - Online", + "9F5A" to "Application Program Identifier", + "9F10" to "Issuer Application Data", + "9F26" to "Application Cryptogram", + "9F27" to "Cryptogram Information Data", + "9F34" to "Cardholder Verification Method (CVM) Results", + "9F37" to "Unpredictable Number", + "9F35" to "Terminal Type", + "9F33" to "Terminal Capabilities", + "9F1A" to "Terminal Country Code", + "9F40" to "Additional Terminal Capabilities", + "95" to "Terminal Verification Results (TVR)", + "9A" to "Transaction Date", + "9C" to "Transaction Type", + "9F02" to "Amount, Authorised (Numeric)", + "9F03" to "Amount, Other (Numeric)", + "9F21" to "Transaction Time", + "9F7C" to "Customer Exclusive Data", + "BF50" to "Issuer Discretionary Data", + "DF810C" to "Kernel Identifier", + ) + + fun name(tag: String): String = names[tag.uppercase()] ?: "Unknown (0x$tag)" +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/StatusWords.kt b/app/src/main/java/sh/sar/sw9000/nfc/StatusWords.kt new file mode 100644 index 0000000..d196593 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/StatusWords.kt @@ -0,0 +1,39 @@ +package sh.sar.sw9000.nfc + +/** Human-readable meaning of ISO 7816 / EMV status words (SW1 SW2), for the raw APDU dump. */ +object StatusWords { + fun describe(sw1: Int, sw2: Int): String { + val sw = (sw1 shl 8) or sw2 + exact[sw]?.let { return it } + return when (sw1) { + 0x61 -> "$sw2 bytes available (GET RESPONSE)" + 0x6C -> "Wrong Le; $sw2 bytes expected" + 0x63 -> if (sw2 in 0xC0..0xCF) "Verification failed, ${sw2 and 0x0F} tries left" else "Warning" + 0x62 -> "Warning: state unchanged" + 0x64 -> "Error: state unchanged" + 0x65 -> "Error: state changed (memory)" + 0x67 -> "Wrong length" + 0x6A -> "Wrong parameters P1-P2" + else -> "Unknown status" + } + } + + private val exact = mapOf( + 0x9000 to "Success", + 0x6700 to "Wrong length", + 0x6283 to "Selected file invalidated", + 0x6982 to "Security status not satisfied", + 0x6983 to "Authentication method blocked", + 0x6985 to "Conditions of use not satisfied", + 0x6A80 to "Incorrect data in command", + 0x6A81 to "Function not supported", + 0x6A82 to "File or application not found", + 0x6A83 to "Record not found", + 0x6A84 to "Not enough memory space", + 0x6A86 to "Incorrect P1-P2", + 0x6A88 to "Referenced data not found", + 0x6D00 to "Instruction not supported", + 0x6E00 to "Class not supported", + 0x6F00 to "No precise diagnosis", + ) +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/Tlv.kt b/app/src/main/java/sh/sar/sw9000/nfc/Tlv.kt new file mode 100644 index 0000000..00ba581 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/Tlv.kt @@ -0,0 +1,207 @@ +package sh.sar.sw9000.nfc + +/** + * BER-TLV parsing for EMV responses, plus best-effort human interpretation of each value. + * The parser is tolerant: it stops cleanly at padding (00 / FF) and never throws on a truncated + * object, so a partial read still yields whatever objects were decodable. + */ + +/** One decoded TLV object. [children] is non-empty only for constructed tags. */ +data class TlvNode( + val tag: String, // uppercase hex, e.g. "5F24" + val length: Int, + val value: ByteArray, // raw value bytes (empty for constructed tags we recursed into) + val constructed: Boolean, + val children: List, +) { + val name: String get() = EmvTags.name(tag) + val valueHex: String get() = Hex.encode(value) + + /** A friendly rendering of the value where the tag's meaning is known; null if hex is best. */ + val interpreted: String? get() = TlvInterpreter.interpret(tag, value) +} + +object Tlv { + + /** Parses [data] as a sequence of BER-TLV objects, recursing into constructed templates. */ + fun parse(data: ByteArray): List = parse(data, 0, data.size) + + private fun parse(data: ByteArray, start: Int, end: Int): List { + val out = ArrayList() + var i = start + while (i < end) { + val b0 = data[i].toInt() and 0xFF + if (b0 == 0x00 || b0 == 0xFF) { i++; continue } // inter-object padding + val tagStart = i + val constructed = b0 and 0x20 != 0 + i++ + if (b0 and 0x1F == 0x1F) { // multi-byte tag + while (i < end) { + val b = data[i++].toInt() and 0xFF + if (b and 0x80 == 0) break + } + } + if (i >= end) break + val tag = Hex.encode(data.copyOfRange(tagStart, i)) + + var len = data[i++].toInt() and 0xFF + if (len and 0x80 != 0) { // multi-byte length + val n = len and 0x7F + if (n == 0 || i + n > end) break + len = 0 + repeat(n) { len = (len shl 8) or (data[i++].toInt() and 0xFF) } + } + if (len < 0 || i + len > end) break + val value = data.copyOfRange(i, i + len) + val children = if (constructed) parse(value, 0, value.size) else emptyList() + out.add(TlvNode(tag, len, if (constructed) ByteArray(0) else value, constructed, children)) + i += len + } + return out + } + + /** Finds the first value for [tag] anywhere in the tree (depth-first). */ + fun find(nodes: List, tag: String): ByteArray? { + val t = tag.uppercase() + for (n in nodes) { + if (n.tag == t && !n.constructed) return n.value + val c = find(n.children, t) + if (c != null) return c + } + return null + } +} + +/** Turns known EMV values into readable text. Returns null when raw hex is the clearest form. */ +object TlvInterpreter { + + fun interpret(tag: String, v: ByteArray): String? = when (tag.uppercase()) { + "5A" -> "PAN " + digitsBcd(v).trimEnd('F').chunked(4).joinToString(" ") + "5F34" -> "Sequence #" + digitsBcd(v) + "5F20" -> ascii(v) + "50", "9F12" -> ascii(v) + "5F2D" -> ascii(v) + "5F24" -> expiryDate(v) + "5F25" -> effectiveDate(v) + "5F28" -> "Country " + countryName(digitsBcd(v)) + "9F1A" -> "Country " + countryName(digitsBcd(v)) + "5F2A", "9F42" -> "Currency " + currencyName(digitsBcd(v)) + "57" -> track2(v) + "9F6B" -> track2(v) + "56" -> ascii(v) + "82" -> "AIP " + Hex.encode(v) + aipBits(v) + "94" -> "AFL " + aflText(v) + "87" -> "Priority " + (v.firstOrNull()?.toInt()?.and(0x0F) ?: 0) + "88" -> "SFI " + (v.firstOrNull()?.toInt()?.and(0xFF) ?: 0) + "9F36", "9F13", "9F17" -> (v.fold(0) { a, b -> (a shl 8) or (b.toInt() and 0xFF) }).toString() + "9F08", "9F09" -> "v" + Hex.encode(v) + "9A" -> "Date " + bcdDate(v) + "9F21" -> "Time " + bcdTime(v) + "9C" -> transactionType(v) + "5F30" -> "Service code " + digitsBcd(v) + else -> null + }?.takeIf { it.isNotBlank() } + + private fun ascii(v: ByteArray): String = + String(v, Charsets.US_ASCII).trim().filter { it.code in 32..126 } + + private fun digitsBcd(v: ByteArray): String = Hex.encode(v) + + private fun expiryDate(v: ByteArray): String { + val h = Hex.encode(v) + if (h.length < 4) return h + return "Expires ${h.substring(2, 4)}/${h.substring(0, 2)}" // MM/YY from YYMMDD + } + + private fun effectiveDate(v: ByteArray): String { + val h = Hex.encode(v) + if (h.length < 4) return h + return "Valid from ${h.substring(2, 4)}/${h.substring(0, 2)}" + } + + private fun bcdDate(v: ByteArray): String { + val h = Hex.encode(v) + return if (h.length >= 6) "20${h.substring(0, 2)}-${h.substring(2, 4)}-${h.substring(4, 6)}" else h + } + + private fun bcdTime(v: ByteArray): String { + val h = Hex.encode(v) + return if (h.length >= 6) "${h.substring(0, 2)}:${h.substring(2, 4)}:${h.substring(4, 6)}" else h + } + + private fun track2(v: ByteArray): String { + val h = Hex.encode(v).uppercase() + val sep = h.indexOfFirst { it == 'D' || it == '=' } + if (sep <= 0) return h + val pan = h.substring(0, sep) + val rest = h.substring(sep + 1) + val exp = rest.take(4) + val svc = rest.drop(4).take(3) + val expShown = if (exp.length == 4) "exp ${exp.substring(2, 4)}/${exp.substring(0, 2)}" else "" + return "PAN ${pan.chunked(4).joinToString(" ")} $expShown svc $svc" + } + + private fun aipBits(v: ByteArray): String { + if (v.isEmpty()) return "" + val b1 = v[0].toInt() and 0xFF + val flags = buildList { + if (b1 and 0x40 != 0) add("SDA") + if (b1 and 0x20 != 0) add("DDA") + if (b1 and 0x10 != 0) add("Cardholder verification") + if (b1 and 0x08 != 0) add("Terminal risk mgmt") + if (b1 and 0x04 != 0) add("Issuer auth") + if (b1 and 0x01 != 0) add("CDA") + } + return if (flags.isEmpty()) "" else " (" + flags.joinToString(", ") + ")" + } + + private fun aflText(v: ByteArray): String { + val sb = StringBuilder() + var i = 0 + while (i + 3 < v.size) { + val sfi = (v[i].toInt() and 0xFF) shr 3 + val first = v[i + 1].toInt() and 0xFF + val last = v[i + 2].toInt() and 0xFF + if (sb.isNotEmpty()) sb.append("; ") + sb.append("SFI $sfi rec $first-$last") + i += 4 + } + return sb.toString() + } + + private fun transactionType(v: ByteArray): String = when (Hex.encode(v)) { + "00" -> "Purchase" + "01" -> "Cash" + "09" -> "Purchase with cashback" + "20" -> "Refund" + else -> Hex.encode(v) + } + + private fun countryName(code: String): String = CardIdentity.country(code) + private fun currencyName(code: String): String = CURRENCY[code.trimStart('0').padStart(3, '0')] ?: code + + private val CURRENCY = mapOf( + "462" to "MVR (462)", "840" to "USD (840)", "978" to "EUR (978)", + "826" to "GBP (826)", "356" to "INR (356)", "702" to "SGD (702)", + "784" to "AED (784)", "036" to "AUD (036)", "124" to "CAD (124)", + ) +} + +/** Hex helpers shared across the NFC layer. */ +object Hex { + fun encode(b: ByteArray): String { + val sb = StringBuilder(b.size * 2) + for (x in b) sb.append(HEX[(x.toInt() ushr 4) and 0xF]).append(HEX[x.toInt() and 0xF]) + return sb.toString() + } + + fun decode(s: String): ByteArray { + val clean = s.filter { !it.isWhitespace() } + return ByteArray(clean.length / 2) { clean.substring(it * 2, it * 2 + 2).toInt(16).toByte() } + } + + /** Space-grouped hex for readable dumps, e.g. "00 A4 04 00". */ + fun pretty(b: ByteArray): String = b.joinToString(" ") { "%02X".format(it) } + + private const val HEX = "0123456789ABCDEF" +} diff --git a/app/src/main/java/sh/sar/sw9000/ui/NfcCardAnimation.kt b/app/src/main/java/sh/sar/sw9000/ui/NfcCardAnimation.kt new file mode 100644 index 0000000..cecb704 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/ui/NfcCardAnimation.kt @@ -0,0 +1,291 @@ +package sh.sar.sw9000.ui + +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.rotate +import androidx.compose.ui.graphics.drawscope.scale +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.withFrameMillis +import androidx.compose.runtime.LaunchedEffect +import kotlin.math.PI +import kotlin.math.min +import kotlin.math.sin + +/** What the reader is doing; the animation reflects it. */ +enum class TapState { WAITING, READING, SUCCESS, ERROR } + +/** + * "Tap your card" animation: a bank card swings onto the back of a phone, NFC waves ripple out + * from the antenna, then it lifts away and repeats. In READING the waves pulse continuously; + * SUCCESS pops a check badge; ERROR shakes the card. Faithful to the reference app's artwork. + */ +@Composable +fun NfcCardAnimation( + state: TapState, + label: String, + modifier: Modifier = Modifier, +) { + val cs = MaterialTheme.colorScheme + var now by remember { mutableLongStateOf(0L) } + var stateStart by remember { mutableLongStateOf(0L) } + + // Drives redraws every frame. + LaunchedEffect(Unit) { + while (true) withFrameMillis { now = it } + } + // Resets the animation clock each time the state changes (and on first show). + LaunchedEffect(state) { + withFrameMillis { stateStart = it; now = it } + } + val elapsed = (now - stateStart).coerceAtLeast(0L) + + Column( + modifier = modifier, + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center, + ) { + Canvas( + modifier = Modifier + .fillMaxWidth() + .height(220.dp) + ) { + drawScene(state, elapsed, cs.primary, cs.onSurface, cs.surfaceVariant, cs.error, cs.onPrimary) + } + Text( + text = label, + modifier = Modifier + .fillMaxWidth() + .padding(top = 12.dp, start = 24.dp, end = 24.dp), + textAlign = TextAlign.Center, + style = TextStyle( + fontSize = 16.sp, + fontWeight = FontWeight.Medium, + color = if (state == TapState.ERROR) cs.error else cs.onSurface, + ), + ) + } +} + +private const val DESIGN_W = 240f +private const val DESIGN_H = 170f +private const val CYCLE_MS = 2600f + +private fun DrawScope.drawScene( + state: TapState, + elapsed: Long, + primary: Color, + onSurface: Color, + surfaceVariant: Color, + error: Color, + onPrimary: Color, +) { + val w = size.width + val h = size.height + if (w <= 0f || h <= 0f) return + + val scale = min(min(w / DESIGN_W, h / DESIGN_H), density * 1.1f).coerceAtLeast(0.6f) + val u = scale + val cx = w / 2f + val top = (h - DESIGN_H * u) / 2f + + // Card contact: 0 = away, 1 = held on phone. + val contact = when (state) { + TapState.WAITING -> { + val p = (elapsed % CYCLE_MS.toLong()) / CYCLE_MS + when { + p < 0.35f -> easeInOut(p / 0.35f) + p < 0.70f -> 1f + p < 1.00f -> 1f - easeInOut((p - 0.70f) / 0.30f) + else -> 0f + } + } + else -> 1f + } + val shake = if (state == TapState.ERROR && elapsed < 500) + (sin(elapsed / 500f * 6 * PI).toFloat() * (1f - elapsed / 500f) * 8 * u) else 0f + + // ── Phone (back view) ── + val phoneW = 64 * u; val phoneH = 112 * u + val phoneL = cx - phoneW / 2f; val phoneT = top + 44 * u + drawRoundRect( + color = surfaceVariant, + topLeft = Offset(phoneL, phoneT), + size = Size(phoneW, phoneH), + cornerRadius = corner(10 * u), + ) + drawRoundRect( + color = onSurface, + topLeft = Offset(phoneL, phoneT), + size = Size(phoneW, phoneH), + cornerRadius = corner(10 * u), + style = Stroke(width = 2.5f * u), + ) + drawRoundRect( + color = onSurface.copy(alpha = 0.24f), + topLeft = Offset(phoneL + 8 * u, phoneT + 8 * u), + size = Size(18 * u, 22 * u), + cornerRadius = corner(5 * u), + ) + + val touchX = cx + val touchY = phoneT + phoneH * 0.42f + + // ── NFC waves ── + val waveStrength = when (state) { + TapState.WAITING -> ((contact - 0.85f) / 0.15f).coerceIn(0f, 1f) + TapState.READING -> 1f + else -> 0f + } + if (waveStrength > 0f) { + val period = if (state == TapState.READING) 700f else 1100f + val base = (elapsed % period.toLong()) / period + for (i in 0..2) { + val p = (base + i / 3f) % 1f + val r = 58 * u + p * 46 * u + drawArcOval( + center = Offset(touchX, touchY), + rx = r, ry = r * 0.72f, + color = primary.copy(alpha = (1f - p) * 0.85f * waveStrength), + stroke = 3 * u, + ) + } + } + + // ── Card ── + val cardW = 104 * u; val cardH = 66 * u + val restX = cx + 58 * u; val restY = top + 48 * u + val cardCx = restX + (touchX - restX) * contact + shake + val cardCy = restY + (touchY - restY) * contact + val rotation = 18f * (1f - contact) + val lift = 1f + 0.08f * (1f - contact) + + translate(cardCx, cardCy) { + rotate(rotation, pivot = Offset.Zero) { + scale(lift, lift, pivot = Offset.Zero) { + val outline = if (state == TapState.ERROR) error else onSurface + val left = -cardW / 2; val tp = -cardH / 2 + drawRoundRect( + color = surfaceVariant, + topLeft = Offset(left, tp), + size = Size(cardW, cardH), + cornerRadius = corner(8 * u), + ) + drawRoundRect( + color = outline, + topLeft = Offset(left, tp), + size = Size(cardW, cardH), + cornerRadius = corner(8 * u), + style = Stroke(width = 2.5f * u), + ) + // Chip + drawRoundRect( + color = primary.copy(alpha = 0.28f), + topLeft = Offset(left + 12 * u, -9 * u), + size = Size(18 * u, 14 * u), + cornerRadius = corner(3 * u), + ) + drawRoundRect( + color = outline, + topLeft = Offset(left + 12 * u, -9 * u), + size = Size(18 * u, 14 * u), + cornerRadius = corner(3 * u), + style = Stroke(width = 1.5f * u), + ) + // Contactless arcs on the card + for (i in 0..2) { + val r = (5 + i * 4.5f) * u + val arcCx = cardW / 2 - 28 * u + drawArc( + color = outline, + startAngle = -45f, + sweepAngle = 90f, + useCenter = false, + topLeft = Offset(arcCx - r, -14 * u - r), + size = Size(r * 2, r * 2), + style = Stroke(width = 1.8f * u, cap = StrokeCap.Round), + ) + } + // Number + name placeholders + for (g in 0..3) { + val x = left + 12 * u + g * 21 * u + drawLine(outline.copy(alpha = 0.6f), Offset(x, 16 * u), Offset(x + 15 * u, 16 * u), 3f * u) + } + drawLine(outline.copy(alpha = 0.4f), Offset(left + 12 * u, 26 * u), Offset(left + 48 * u, 26 * u), 2.5f * u) + } + } + } + + // ── Success badge ── + if (state == TapState.SUCCESS) { + val t = (elapsed / 450f).coerceIn(0f, 1f) + val badgeR = 22 * u * overshoot(t) + val bx = touchX + cardW / 2 - 6 * u; val by = touchY - cardH / 2 + 4 * u + drawCircle(primary, badgeR, Offset(bx, by)) + val checkT = ((elapsed - 200) / 350f).coerceIn(0f, 1f) + if (checkT > 0f) { + val x0 = bx - 9 * u; val y0 = by + val x1 = bx - 3 * u; val y1 = by + 7 * u + val x2 = bx + 10 * u; val y2 = by - 7 * u + val path = Path().apply { + moveTo(x0, y0) + if (checkT < 0.4f) { + val k = checkT / 0.4f + lineTo(x0 + (x1 - x0) * k, y0 + (y1 - y0) * k) + } else { + val k = (checkT - 0.4f) / 0.6f + lineTo(x1, y1); lineTo(x1 + (x2 - x1) * k, y1 + (y2 - y1) * k) + } + } + drawPath(path, onPrimary, style = Stroke(width = 3.5f * u, cap = StrokeCap.Round)) + } + } +} + +private fun DrawScope.drawArcOval(center: Offset, rx: Float, ry: Float, color: Color, stroke: Float) { + drawArc( + color = color, + startAngle = 0f, + sweepAngle = 360f, + useCenter = false, + topLeft = Offset(center.x - rx, center.y - ry), + size = Size(rx * 2, ry * 2), + style = Stroke(width = stroke), + ) +} + +private fun DrawScope.corner(r: Float) = androidx.compose.ui.geometry.CornerRadius(r, r) + +private fun easeInOut(x: Float): Float { + val c = x.coerceIn(0f, 1f) + return -(kotlin.math.cos(PI * c).toFloat() - 1f) / 2f +} + +private fun overshoot(x: Float, tension: Float = 2.2f): Float { + val t = x.coerceIn(0f, 1f) - 1f + return t * t * ((tension + 1) * t + tension) + 1f +} diff --git a/app/src/main/java/sh/sar/sw9000/ui/Screens.kt b/app/src/main/java/sh/sar/sw9000/ui/Screens.kt new file mode 100644 index 0000000..6dc5eb2 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/ui/Screens.kt @@ -0,0 +1,257 @@ +package sh.sar.sw9000.ui + +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.Button +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.SecondaryTabRow +import androidx.compose.material3.Tab +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import sh.sar.sw9000.nfc.EmvCardReader +import sh.sar.sw9000.nfc.Hex +import sh.sar.sw9000.nfc.TlvNode + +/** NFC hardware isn't present on this device. */ +@Composable +fun UnsupportedScreen(modifier: Modifier = Modifier) { + CenteredMessage( + modifier = modifier, + title = "NFC not supported", + body = "This device has no NFC hardware, so it can't read contactless cards. " + + "Run sw9000 on a phone with NFC.", + ) +} + +/** NFC exists but is turned off — offer to open settings. */ +@Composable +fun NfcDisabledScreen(onOpenSettings: () -> Unit, modifier: Modifier = Modifier) { + Column( + modifier = modifier + .fillMaxSize() + .padding(32.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center, + ) { + Text("NFC is off", style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold) + Spacer(Modifier.height(12.dp)) + Text( + "Turn on NFC to read a card.", + style = MaterialTheme.typography.bodyLarge, + textAlign = TextAlign.Center, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(Modifier.height(24.dp)) + Button(onClick = onOpenSettings) { Text("Open NFC settings") } + } +} + +/** Waiting for a tap (or actively reading). */ +@Composable +fun WaitingScreen(state: TapState, label: String, modifier: Modifier = Modifier) { + Box(modifier = modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + NfcCardAnimation(state = state, label = label, modifier = Modifier.fillMaxWidth()) + } +} + +/** Full dump of a card read: a success/error animation, formatted fields, and raw data. */ +@Composable +fun ResultScreen( + result: EmvCardReader.Result, + onReadAnother: () -> Unit, + modifier: Modifier = Modifier, +) { + var tab by remember { mutableIntStateOf(0) } + Column(modifier = modifier.fillMaxSize()) { + NfcCardAnimation( + state = if (result.hasData) TapState.SUCCESS else TapState.ERROR, + label = if (result.hasData) "Card read" else "Couldn't read card", + modifier = Modifier.fillMaxWidth().padding(top = 8.dp), + ) + + if (result.error != null && !result.hasData) { + Text( + result.error, + modifier = Modifier.fillMaxWidth().padding(24.dp), + textAlign = TextAlign.Center, + color = MaterialTheme.colorScheme.error, + ) + } + + SecondaryTabRow(selectedTabIndex = tab) { + Tab(selected = tab == 0, onClick = { tab = 0 }, text = { Text("Formatted") }) + Tab(selected = tab == 1, onClick = { tab = 1 }, text = { Text("Raw dump") }) + } + + Column( + Modifier + .weight(1f) + .verticalScroll(rememberScrollState()) + .padding(16.dp), + ) { + if (tab == 0) FormattedView(result) else RawDumpView(result) + Spacer(Modifier.height(16.dp)) + Button(onClick = onReadAnother, modifier = Modifier.fillMaxWidth()) { Text("Read another card") } + Spacer(Modifier.height(32.dp)) + } + } +} + +@Composable +private fun FormattedView(result: EmvCardReader.Result) { + if (result.fields.isNotEmpty()) { + SectionCard("Card data") { + result.fields.forEachIndexed { i, f -> + if (i > 0) HorizontalDivider(Modifier.padding(vertical = 8.dp)) + FieldRow(f.name, f.value) + } + } + Spacer(Modifier.height(12.dp)) + } + + result.apps.forEach { app -> + SectionCard("Application ${app.label ?: app.aid}") { + FieldRow("AID", app.aid) + app.label?.let { FieldRow("Label", it) } + app.preferredName?.let { FieldRow("Preferred name", it) } + } + Spacer(Modifier.height(12.dp)) + } + + SectionCard("Tag / NFC") { + FieldRow("UID", result.uid) + FieldRow("Technologies", result.techList.joinToString(", ") { it.substringAfterLast('.') }) + result.atqa?.let { FieldRow("ATQA", it) } + result.sak?.let { FieldRow("SAK", it) } + result.historicalBytes?.let { FieldRow("Historical bytes", it) } + result.hiLayerResponse?.let { FieldRow("Higher-layer response", it) } + } +} + +@Composable +private fun RawDumpView(result: EmvCardReader.Result) { + result.apps.forEach { app -> + SectionCard("TLV tree — ${app.label ?: app.aid}") { + app.tlv.forEach { TlvRow(it, 0) } + } + Spacer(Modifier.height(12.dp)) + } + + SectionCard("APDU log (${result.apduLog.size})") { + result.apduLog.forEachIndexed { i, a -> + if (i > 0) HorizontalDivider(Modifier.padding(vertical = 10.dp)) + Text( + a.label, + style = MaterialTheme.typography.labelLarge, + fontWeight = FontWeight.SemiBold, + ) + Spacer(Modifier.height(4.dp)) + MonoLabeled(">>", Hex.pretty(a.command), MaterialTheme.colorScheme.primary) + MonoLabeled("<<", Hex.pretty(a.response), MaterialTheme.colorScheme.onSurface) + Text( + "SW ${a.sw} — ${a.swMeaning}", + fontSize = 12.sp, + color = if (a.ok) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error, + modifier = Modifier.padding(top = 2.dp), + ) + } + } +} + +@Composable +private fun TlvRow(node: TlvNode, depth: Int) { + Column(Modifier.padding(start = (depth * 12).dp, top = 4.dp, bottom = 4.dp)) { + Row { + Text( + node.tag, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Bold, + fontSize = 13.sp, + color = MaterialTheme.colorScheme.primary, + ) + Spacer(Modifier.width(8.dp)) + Text(node.name, fontSize = 13.sp, fontWeight = FontWeight.Medium) + } + if (node.constructed) { + node.children.forEach { TlvRow(it, depth + 1) } + } else { + MonoLabeled("", node.valueHex, MaterialTheme.colorScheme.onSurfaceVariant) + node.interpreted?.let { + Text(it, fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(top = 1.dp)) + } + } + } +} + +@Composable +private fun MonoLabeled(prefix: String, text: String, color: androidx.compose.ui.graphics.Color) { + Row(Modifier.fillMaxWidth().horizontalScroll(rememberScrollState())) { + if (prefix.isNotEmpty()) { + Text(prefix, fontFamily = FontFamily.Monospace, fontSize = 12.sp, color = color) + Spacer(Modifier.width(6.dp)) + } + Text(text.ifBlank { "(empty)" }, fontFamily = FontFamily.Monospace, fontSize = 12.sp, color = color) + } +} + +@Composable +private fun FieldRow(name: String, value: String) { + Column(Modifier.fillMaxWidth()) { + Text(name, fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) + Text(value, fontSize = 15.sp, fontWeight = FontWeight.Medium) + } +} + +@Composable +private fun SectionCard(title: String, content: @Composable () -> Unit) { + Card( + modifier = Modifier.fillMaxWidth(), + shape = RoundedCornerShape(16.dp), + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.35f)), + ) { + Column(Modifier.padding(16.dp)) { + Text(title, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold) + Spacer(Modifier.height(12.dp)) + content() + } + } +} + +@Composable +private fun CenteredMessage(title: String, body: String, modifier: Modifier = Modifier) { + Column( + modifier = modifier.fillMaxSize().padding(32.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center, + ) { + Text(title, style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold, textAlign = TextAlign.Center) + Spacer(Modifier.height(12.dp)) + Text(body, style = MaterialTheme.typography.bodyLarge, textAlign = TextAlign.Center, color = MaterialTheme.colorScheme.onSurfaceVariant) + } +} diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml index 07d5da9..58f9128 100644 --- a/app/src/main/res/drawable/ic_launcher_background.xml +++ b/app/src/main/res/drawable/ic_launcher_background.xml @@ -1,170 +1,11 @@ + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/app/src/main/res/drawable/ic_launcher_foreground.xml b/app/src/main/res/drawable/ic_launcher_foreground.xml index 2b068d1..e79b9fa 100644 --- a/app/src/main/res/drawable/ic_launcher_foreground.xml +++ b/app/src/main/res/drawable/ic_launcher_foreground.xml @@ -1,30 +1,50 @@ + + - - - - - - - - - - \ No newline at end of file + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/app/src/main/res/mipmap-hdpi/ic_launcher.webp deleted file mode 100644 index c209e78..0000000 Binary files a/app/src/main/res/mipmap-hdpi/ic_launcher.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp deleted file mode 100644 index b2dfe3d..0000000 Binary files a/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/app/src/main/res/mipmap-mdpi/ic_launcher.webp deleted file mode 100644 index 4f0f1d6..0000000 Binary files a/app/src/main/res/mipmap-mdpi/ic_launcher.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp deleted file mode 100644 index 62b611d..0000000 Binary files a/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp deleted file mode 100644 index 948a307..0000000 Binary files a/app/src/main/res/mipmap-xhdpi/ic_launcher.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp deleted file mode 100644 index 1b9a695..0000000 Binary files a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp deleted file mode 100644 index 28d4b77..0000000 Binary files a/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp deleted file mode 100644 index 9287f50..0000000 Binary files a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp deleted file mode 100644 index aa7d642..0000000 Binary files a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp and /dev/null differ diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp deleted file mode 100644 index 9126ae3..0000000 Binary files a/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp and /dev/null differ diff --git a/app/src/main/res/mipmap/ic_launcher.xml b/app/src/main/res/mipmap/ic_launcher.xml new file mode 100644 index 0000000..95437fa --- /dev/null +++ b/app/src/main/res/mipmap/ic_launcher.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/app/src/main/res/mipmap/ic_launcher_round.xml b/app/src/main/res/mipmap/ic_launcher_round.xml new file mode 100644 index 0000000..ba29788 --- /dev/null +++ b/app/src/main/res/mipmap/ic_launcher_round.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/app/src/main/res/values-night/colors.xml b/app/src/main/res/values-night/colors.xml new file mode 100644 index 0000000..00a6443 --- /dev/null +++ b/app/src/main/res/values-night/colors.xml @@ -0,0 +1,5 @@ + + + + #FF1C1B1F + diff --git a/app/src/main/res/values-night/themes.xml b/app/src/main/res/values-night/themes.xml new file mode 100644 index 0000000..bdb6a08 --- /dev/null +++ b/app/src/main/res/values-night/themes.xml @@ -0,0 +1,11 @@ + + + + + + diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml index f8c6127..0d3841a 100644 --- a/app/src/main/res/values/colors.xml +++ b/app/src/main/res/values/colors.xml @@ -7,4 +7,6 @@ #FF018786 #FF000000 #FFFFFFFF + + #FFFFFBFE \ No newline at end of file diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index bdff66b..20f70be 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1,3 +1,5 @@ sw9000 - \ No newline at end of file + Tap a card to read it + Reading card… hold still + diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml index 9a98ff2..787fe3c 100644 --- a/app/src/main/res/values/themes.xml +++ b/app/src/main/res/values/themes.xml @@ -1,5 +1,11 @@ - +