Add device sessions tracking, IP location lookup, and device info.

Track active client device sessions with location resolution, device models, and platform information.

Update `Session` and `RemoteWalletClient` models by replacing `clientDetails` with `clientDevice` (e.g. device model) and `clientPlatform` (e.g. OS version or browser name and version).

Update `WalletBackend` interface and `WalletBackendBase` with overridable `lookupLocationFromIpAddress()` suspending function.

Add `IpLocationLookup` interface and `IpWhoIsLocationLookup` implementation in backend utilizing ipwhois.io with 1-hour in-memory cache and automatic resolution of loopback and local network IP addresses without external network requests.

Update Android, iOS, and Web clients to collect and transmit `clientDevice` and `clientPlatform` during `markAlive()` and client creation flows, and display device sessions formatted with device model, platform version, resolved location, and last-seen timestamps.

Update `privacy.md` documentation to describe backend collection of IP address, client device model, and platform version for device session management.

Test: Unit tests in `IpWhoIsLocationLookupTest` and `WalletClientTest`.
Test: Executed `./gradlew :shared:allTests :backend:test :webApp:assemble :androidApp:assembleDebug` and verified all test suites pass cleanly.
Test: Executed `xcodebuild -project iosApp/iosApp.xcodeproj -scheme iosApp -sdk iphonesimulator build` and verified clean iOS compilation.
Signed-off-by: David Zeuthen <zeuthen@gmail.com>

Author: davidz25

androidApp/src/main/java/org/multipaz/wallet/android/App.kt

@@ -242,6 +242,8 @@ class App private constructor() {
             secureArea = secureArea,
             httpClientEngineFactory = Android,
             numReaderKeys = 10,
+            clientDevice = getAndroidClientDevice(),
+            clientPlatform = getAndroidClientPlatform()
         )
 
         userIssuerTrustManager = TrustManager(
@@ -572,3 +574,20 @@ class App private constructor() {
         }
     }
 }
+
+private fun getAndroidClientDevice(): String {
+    val manufacturer = android.os.Build.MANUFACTURER
+    val model = android.os.Build.MODEL
+    return if (model.lowercase().startsWith(manufacturer.lowercase())) {
+        model
+    } else {
+        val formattedManufacturer = manufacturer.replaceFirstChar {
+            if (it.isLowerCase()) it.titlecase(java.util.Locale.getDefault()) else it.toString()
+        }
+        "$formattedManufacturer $model"
+    }
+}
+
+private fun getAndroidClientPlatform(): String {
+    return "Android ${android.os.Build.VERSION.RELEASE}"
+}

androidApp/src/main/java/org/multipaz/wallet/android/ui/settings/DeviceSessionsScreen.kt

@@ -185,22 +185,32 @@ fun DeviceSessionsScreen(
                                 .thenByDescending { it.lastSeenMillis }
                         )
                         for (session in sortedSessions) {
-                            val deviceName = when (session.clientType) {
+                            val fallbackDeviceName = when (session.clientType) {
                                 ClientType.WEB -> stringResource(R.string.device_sessions_screen_device_web)
                                 ClientType.ANDROID -> stringResource(R.string.device_sessions_screen_device_android)
                                 ClientType.IOS -> stringResource(R.string.device_sessions_screen_device_ios)
                             }
+                            val deviceName = session.clientDevice ?: fallbackDeviceName
                             val deviceIcon = when (session.clientType) {
                                 ClientType.WEB -> Icons.Outlined.Computer
                                 ClientType.ANDROID, ClientType.IOS -> Icons.Outlined.Smartphone
                             }
                             val isCurrentDevice = (currentClientId.value != null && session.clientId == currentClientId.value)
                             val lastSeenText = durationFromNowText(Instant.fromEpochMilliseconds(session.lastSeenMillis))
-                            val secondaryText = if (isCurrentDevice) {
-                                "${stringResource(R.string.device_sessions_screen_this_device)} • $lastSeenText"
-                            } else {
-                                lastSeenText
+                            val secondaryTextParts = mutableListOf<String>()
+                            if (isCurrentDevice) {
+                                secondaryTextParts.add(stringResource(R.string.device_sessions_screen_this_device))
                             }
+                            if (!session.clientPlatform.isNullOrBlank()) {
+                                secondaryTextParts.add(session.clientPlatform!!)
+                            }
+                            if (!session.location.isNullOrBlank()) {
+                                secondaryTextParts.add(session.location!!)
+                            }
+                            if (!isCurrentDevice) {
+                                secondaryTextParts.add(lastSeenText)
+                            }
+                            val secondaryText = secondaryTextParts.joinToString(" • ")
 
                             FloatingItemText(
                                 text = deviceName,
@@ -241,11 +251,14 @@ fun DeviceSessionsScreen(
     }
 
     sessionToSignOut.value?.let { targetSession ->
-        val targetName = when (targetSession.clientType) {
+        val baseTargetName = when (targetSession.clientType) {
             ClientType.WEB -> stringResource(R.string.device_sessions_screen_device_web)
             ClientType.ANDROID -> stringResource(R.string.device_sessions_screen_device_android)
             ClientType.IOS -> stringResource(R.string.device_sessions_screen_device_ios)
         }
+        val targetName = targetSession.clientDevice
+            ?: targetSession.clientPlatform
+            ?: baseTargetName
         AlertDialog(
             onDismissRequest = { sessionToSignOut.value = null },
             title = {

backend/build.gradle.kts

@@ -36,6 +36,10 @@ dependencies {
     implementation(libs.ktor.server.logging)
     implementation(libs.logback.classic)
     implementation(libs.identity.google.api.client)
+
+    testImplementation(libs.kotlin.test)
+    testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.ktor.client.mock)
 }
 
 tasks.named<ProcessResources>("processResources") {

backend/src/main/java/org/multipaz/wallet/backend/IpLocationLookup.kt

@@ -0,0 +1,14 @@
+package org.multipaz.wallet.backend
+
+/**
+ * Interface for looking up human-readable location strings from IP addresses.
+ */
+interface IpLocationLookup {
+    /**
+     * Looks up a human-readable location string for the given IP address.
+     *
+     * @param ipAddress the IP address to look up, or `null`.
+     * @return a location string (e.g. "Mountain View, United States" or "Local Network"), or `null` if unresolvable.
+     */
+    suspend fun lookup(ipAddress: String?): String?
+}

backend/src/main/java/org/multipaz/wallet/backend/IpWhoIsLocationLookup.kt

@@ -0,0 +1,115 @@
+package org.multipaz.wallet.backend
+
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.HttpClientEngine
+import io.ktor.client.engine.java.Java
+import io.ktor.client.request.get
+import io.ktor.client.statement.bodyAsText
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.multipaz.util.Logger
+import java.net.InetAddress
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.hours
+
+/**
+ * Implementation of [IpLocationLookup] using the ipwhois.io API with in-memory caching.
+ *
+ * @param httpClientEngine optional [HttpClientEngine] for custom HTTP transport (e.g. testing with MockEngine).
+ * @param clock the time source for TTL calculation.
+ * @param cacheTtlMillis duration in milliseconds before a cached lookup expires (default 1 hour).
+ */
+class IpWhoIsLocationLookup(
+    httpClientEngine: HttpClientEngine? = null,
+    private val clock: Clock = Clock.System,
+    private val cacheTtlMillis: Long = 1.hours.inWholeMilliseconds
+) : IpLocationLookup {
+
+    private val httpClient = if (httpClientEngine != null) {
+        HttpClient(httpClientEngine)
+    } else {
+        HttpClient(Java)
+    }
+
+    private data class CacheEntry(
+        val location: String?,
+        val timestampMillis: Long
+    )
+
+    private val cache = ConcurrentHashMap<String, CacheEntry>()
+    private val json = Json { ignoreUnknownKeys = true }
+    private val mutex = Mutex()
+
+    override suspend fun lookup(ipAddress: String?): String? {
+        if (ipAddress.isNullOrBlank()) {
+            return null
+        }
+        val trimmedIp = ipAddress.trim()
+
+        if (isPrivateOrLocalIp(trimmedIp)) {
+            return "Local Network"
+        }
+
+        val now = clock.now().toEpochMilliseconds()
+        val existingEntry = cache[trimmedIp]
+        if (existingEntry != null && (now - existingEntry.timestampMillis) < cacheTtlMillis) {
+            return existingEntry.location
+        }
+
+        return mutex.withLock {
+            val entryUnderLock = cache[trimmedIp]
+            if (entryUnderLock != null && (now - entryUnderLock.timestampMillis) < cacheTtlMillis) {
+                return@withLock entryUnderLock.location
+            }
+
+            val resolvedLocation = fetchLocationFromApi(trimmedIp)
+            cache[trimmedIp] = CacheEntry(
+                location = resolvedLocation,
+                timestampMillis = now
+            )
+            resolvedLocation
+        }
+    }
+
+    private fun isPrivateOrLocalIp(ip: String): Boolean {
+        return try {
+            val inet = InetAddress.getByName(ip)
+            inet.isLoopbackAddress || inet.isSiteLocalAddress || inet.isLinkLocalAddress || inet.isAnyLocalAddress
+        } catch (_: Exception) {
+            false
+        }
+    }
+
+    private suspend fun fetchLocationFromApi(ip: String): String? {
+        return try {
+            val responseText = httpClient.get("https://ipwho.is/$ip").bodyAsText()
+            val jsonObj = json.parseToJsonElement(responseText).jsonObject
+            val success = jsonObj["success"]?.jsonPrimitive?.booleanOrNull ?: false
+            if (!success) {
+                return null
+            }
+            val city = jsonObj["city"]?.jsonPrimitive?.content?.takeIf { it.isNotBlank() }
+            val country = jsonObj["country"]?.jsonPrimitive?.content?.takeIf { it.isNotBlank() }
+            val region = jsonObj["region"]?.jsonPrimitive?.content?.takeIf { it.isNotBlank() }
+
+            when {
+                city != null && country != null -> "$city, $country"
+                region != null && country != null -> "$region, $country"
+                country != null -> country
+                else -> null
+            }
+        } catch (e: Exception) {
+            Logger.w(TAG, "Failed to resolve IP location for $ip", e)
+            null
+        }
+    }
+
+    companion object {
+        private const val TAG = "IpWhoIsLocationLookup"
+    }
+}

backend/src/main/java/org/multipaz/wallet/backend/WalletBackendImpl.kt

@@ -4,6 +4,7 @@ import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeToken
 import com.google.api.client.googleapis.auth.oauth2.GoogleIdTokenVerifier
 import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport
 import com.google.api.client.json.gson.GsonFactory
+import io.ktor.server.plugins.origin
 import org.multipaz.asn1.ASN1Integer
 import org.multipaz.cbor.annotation.CborSerializable;
 import org.multipaz.crypto.AsymmetricKey
@@ -15,6 +16,7 @@ import org.multipaz.rpc.backend.RpcAuthBackendDelegate
 import org.multipaz.rpc.handler.RpcAuthContext
 import org.multipaz.rpc.handler.RpcAuthInspector
 import org.multipaz.securearea.KeyAttestation
+import org.multipaz.server.common.KtorCall
 import org.multipaz.server.enrollment.ServerIdentity
 import org.multipaz.server.enrollment.getServerIdentity
 import org.multipaz.util.Logger
@@ -30,6 +32,8 @@ import kotlin.time.Duration.Companion.seconds
 
 private const val TAG = "WalletBackendImpl"
 
+private val ipLocationLookup: IpLocationLookup = IpWhoIsLocationLookup()
+
 @RpcState(
     endpoint = "wallet_backend",
     creatable = true
@@ -114,6 +118,12 @@ class WalletBackendImpl: WalletBackendBase(), WalletBackend, RpcAuthInspector by
 
     override suspend fun getClientId() = RpcAuthContext.getClientId()
 
+    override suspend fun getIpAddress(): String = KtorCall.getCall().request.origin.remoteAddress
+
+    override suspend fun lookupLocationFromIpAddress(ipAddress: String?): String? {
+        return ipLocationLookup.lookup(ipAddress)
+    }
+
     override suspend fun certifyReaderKeys(readerKeys: List<KeyAttestation>): List<X509CertChain> {
         // TODO: if dealing with Android client, verify attestations
         val identity = getServerIdentity(ServerIdentity.READER_ROOT) as AsymmetricKey.X509CertifiedExplicit

backend/src/main/resources/docs/privacy.md

@@ -8,6 +8,8 @@ ${APP_NAME} is a secure, privacy-preserving digital identity credential wallet d
 ## 2. Information We Collect
 ${APP_NAME} is designed with strict data minimization principles. We do not track user identity attributes or share personal data with external third parties without user consent—either given explicitly prompt-by-prompt during document presentation flows or configured via saved pre-consent policies.
 
+To help inform users where and when their account data was accessed, the backend collects the client's IP address (used to resolve coarse location), client device model, and platform name and version. This information is stored securely and displayed to the user in the Device Sessions management screen.
+
 ## 3. Secure Credential Storage & Encryption
 Credential data and personally identifiable information (PII) are stored securely in encrypted application storage, while private key material may be stored in the mobile device's hardware-backed Secure Area (such as Android KeyStore / StrongBox or iOS Secure Enclave).