Паскеи в Android - как избавиться от паролей и не сломать безопасность

dependencies {
    implementation("androidx.credentials:credentials:1.2.0")
    // Опционально для интеграции с Google Identity Services
    implementation("androidx.credentials:credentials-play-services-auth:1.2.0")
}

class AuthViewModel(application: Application) : AndroidViewModel(application) {
    private val credentialManager = CredentialManager.create(application)
    
    // Методы аутентификации и регистрации
}

suspend fun registerPasskey(username: String) {
    try {
        // Запрос параметров у сервера
        val registrationOptions = apiService.getRegistrationOptions(username)
        
        // Создание запроса на создание паскея
        val request = CreatePublicKeyCredentialRequest(
            registrationOptions.toString(),
            null
        )
        
        // Создание паскея
        val result = credentialManager.createCredential(
            context = getApplication(),
            request = request
        )
        
        // Отправка результата на сервер
        val response = result.data as CreatePublicKeyCredentialResponse
        apiService.verifyRegistration(response.registrationResponseJson)
        
        // Успешная регистрация
    } catch (e: Exception) {
        // Обработка ошибок
    }
}

suspend fun authenticateWithPasskey() {
    try {
        // Запрос параметров у сервера
        val authOptions = apiService.getAuthenticationOptions()
        
        // Создание запроса на аутентификацию
        val request = GetCredentialRequest(
            listOf(
                GetPublicKeyCredentialOption(
                    authOptions.toString(),
                    null
                )
            )
        )
        
        // Аутентификация
        val result = credentialManager.getCredential(
            context = getApplication(),
            request = request
        )
        
        // Отправка результата на сервер
        val response = result.credential as PublicKeyCredential
        val token = apiService.verifyAuthentication(response.authenticationResponseJson)
        
        // Успешная аутентификация, получен токен доступа
    } catch (e: Exception) {
        // Обработка ошибок
    }
}

when (e) {
    is GetCredentialException -> {
        if (e.isMultipleCredentialsError) {
            // Предложить пользователю выбрать устройство
            val request = GetCredentialRequest(e.credentials)
            val result = credentialManager.getCredential(context, request)
            // Продолжить обработку результата
        } else {
            // Другие ошибки
        }
    }
}

dependencies {
    // Основная библиотека для работы с паскеями
    implementation("androidx.credentials:credentials:1.2.0")
    
    // Интеграция с Google Identity Services (опционально, но рекомендуется)
    implementation("androidx.credentials:credentials-play-services-auth:1.2.0")
    
    // Для работы с HTTP-запросами (нужна для общения с сервером)
    implementation("com.squareup.okhttp3:okhttp:4.11.0")
    
    // Для преобразования JSON (опционально, но удобно)
    implementation("com.squareup.moshi:moshi-kotlin:1.15.0")
}

android:apk-key-hash:BASE64_ENCODED_SHA256

suspend fun getRegistrationOptions(username: String): String {
    val request = Request.Builder()
        .url("https://your-auth-server.com/generate-registration-options")
        .post(
            RequestBody.create(
                MediaType.parse("application/json"),
                "{"username":"$username"}"
            )
        )
        .build()
    
    val response = httpClient.newCall(request).execute()
    return response.body()?.string() ?: throw Exception("Empty response")
}

suspend fun createPasskey(username: String): Boolean {
    try {
        // Получаем параметры с сервера
        val registrationOptionsJson = getRegistrationOptions(username)
        
        // Создаем запрос на создание паскея
        val request = CreatePublicKeyCredentialRequest(
            requestJson = registrationOptionsJson,
            preferImmediatelyAvailableCredentials = false
        )
        
        // Вызываем Credential Manager для создания паскея
        val result = credentialManager.createCredential(
            context = context,
            request = request
        )
        
        // Извлекаем результат
        val response = (result.credential as? CreatePublicKeyCredentialResponse)
            ?: throw Exception("Unexpected credential type")
        
        // Отправляем результат на сервер для верификации
        return verifyRegistration(response.registrationResponseJson)
    } catch (e: CreateCredentialException) {
        // Обработка различных типов ошибок
        when (e) {
            is CreateCredentialCancellationException -> {
                // Пользователь отменил операцию
                Log.d(TAG, "User cancelled")
            }
            is CreateCredentialInterruptedException -> {
                // Операция была прервана
                Log.d(TAG, "Operation interrupted")
            }
            is CreateCredentialProviderConfigurationException -> {
                // Проблема с конфигурацией провайдера
                Log.e(TAG, "Provider configuration error", e)
            }
            is CreateCredentialException -> {
                // Другие ошибки
                Log.e(TAG, "Unknown error", e)
            }
        }
        return false
    }
}

suspend fun verifyRegistration(registrationResponseJson: String): Boolean {
    val request = Request.Builder()
        .url("https://your-auth-server.com/verify-registration")
        .post(
            RequestBody.create(
                MediaType.parse("application/json"),
                registrationResponseJson
            )
        )
        .build()
    
    val response = httpClient.newCall(request).execute()
    return response.isSuccessful
}

private fun isDeviceSecured(): Boolean {
    val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
    return keyguardManager.isDeviceSecure
}
 
// И где-то в коде:
if (!isDeviceSecured()) {
    // Показываем диалог с предложением настроить блокировку экрана
    showSetupScreenLockDialog()
    return false
}

try {
    val result = credentialManager.getCredential(
        context = context,
        request = request
    )
    // Обработка успешной аутентификации
} catch (e: GetCredentialException) {
    if (e is GetCredentialUiException) {
        val credentials = e.credentials
        if (credentials.isNotEmpty()) {
            // Пользователь имеет несколько паскеев
            // Покажем интерфейс для выбора
            val selectRequest = GetCredentialRequest(credentials)
            val selectedResult = credentialManager.getCredential(
                context = context,
                request = selectRequest
            )
            // Обработка выбранного паскея
        }
    } else {
        // Другие типы ошибок
    }
}

suspend fun getAuthenticationOptions(): String {
    val request = Request.Builder()
        .url("https://your-auth-server.com/generate-authentication-options")
        .post(RequestBody.create(MediaType.parse("application/json"), "{}"))
        .build()
    
    val response = httpClient.newCall(request).execute()
    return response.body()?.string() ?: throw Exception("Empty response")
}

suspend fun authenticateWithPasskey(): String? {
    try {
        // Получаем параметры с сервера
        val authOptionsJson = getAuthenticationOptions()
        
        // Создаем запрос на аутентификацию
        val getCredRequest = GetCredentialRequest(
            listOf(
                GetPublicKeyCredentialOption(
                    requestJson = authOptionsJson,
                    preferImmediatelyAvailableCredentials = true
                )
            )
        )
        
        // Выполняем аутентификацию
        val credentialResult = credentialManager.getCredential(
            context = context,
            request = getCredRequest
        )
        
        // Извлекаем результат
        val credential = credentialResult.credential
        if (credential is PublicKeyCredential) {
            // Отправляем результат на сервер
            return verifyAuthentication(credential.authenticationResponseJson)
        } else {
            throw Exception("Unexpected credential type")
        }
    } catch (e: GetCredentialException) {
        // Обработка ошибок
        handleGetCredentialError(e)
        return null
    }
}

suspend fun verifyAuthentication(authResponseJson: String): String {
    val request = Request.Builder()
        .url("https://your-auth-server.com/verify-authentication")
        .post(RequestBody.create(MediaType.parse("application/json"), authResponseJson))
        .build()
    
    val response = httpClient.newCall(request).execute()
    if (!response.isSuccessful) {
        throw Exception("Authentication failed")
    }
    
    // Извлекаем токен аутентификации из ответа
    val responseBody = response.body()?.string() ?: throw Exception("Empty response")
    val jsonObject = JSONObject(responseBody)
    return jsonObject.getString("token")
}

private fun handleGetCredentialError(e: GetCredentialException) {
    when (e) {
        is GetCredentialCancellationException -> {
            // Пользователь отменил операцию
            Log.d(TAG, "User cancelled authentication")
        }
        is GetCredentialInterruptedException -> {
            // Операция была прервана
            Log.d(TAG, "Authentication interrupted")
        }
        is GetCredentialProviderConfigurationException -> {
            // Проблема с конфигурацией провайдера
            Log.e(TAG, "Provider configuration error", e)
        }
        is GetCredentialUiException -> {
            // Ошибка, связанная с UI
            if (e.isMultipleCredentialsError) {
                // Пользователь имеет несколько паскеев
                Log.d(TAG, "Multiple credentials available")
            }
        }
        else -> {
            // Другие ошибки
            Log.e(TAG, "Authentication error", e)
        }
    }
}

private fun isDeviceSecured(): Boolean {
    val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
    return keyguardManager.isDeviceSecure
}
 
// И использовать эту проверку перед аутентификацией
if (!isDeviceSecured()) {
    // Показываем сообщение о необходимости настроить блокировку экрана
    showScreenLockRequiredDialog()
    return null
}

data class User(
    val id: String,
    val username: String,
    val passwordHash: String?, // Может быть null для пользователей только с паскеями
    val passkeys: List<PasskeyCredential> = emptyList()
)
 
data class PasskeyCredential(
    val credentialId: String,
    val publicKey: String,
    val createdAt: Long,
    val lastUsedAt: Long
)

suspend fun migrateToPasskey() {
    // Убедимся, что пользователь залогинен с паролем
    if (!authRepository.isLoggedIn()) {
        throw IllegalStateException("User must be logged in to create a passkey")
    }
    
    // Запрашиваем параметры регистрации с сервера
    // Сервер знает, какой пользователь делает запрос, благодаря токену авторизации
    val registrationOptions = apiService.getRegistrationOptions()
    
    // Создаем паскей
    val request = CreatePublicKeyCredentialRequest(
        registrationOptions.toString(),
        preferImmediatelyAvailableCredentials = false
    )
    
    val result = credentialManager.createCredential(context, request)
    
    // Отправляем результат на сервер
    val response = result.credential as CreatePublicKeyCredentialResponse
    val success = apiService.verifyRegistration(response.registrationResponseJson)
    
    if (success) {
        // Обновляем локальные данные о способах аутентификации
        userPrefs.setHasPasskey(true)
        showSuccessMessage("Теперь вы можете входить с помощью паскея!")
    }
}

sealed class AuthState {
    object Initial : AuthState()
    object Loading : AuthState()
    object BiometricPrompt : AuthState()
    data class Success(val username: String) : AuthState()
    data class Error(val message: String) : AuthState()
}

class AuthViewModel : ViewModel() {
    private val _authState = MutableStateFlow<AuthState>(AuthState.Initial)
    val authState = _authState.asStateFlow()
    
    fun authenticateWithPasskey() {
        viewModelScope.launch {
            try {
                _authState.value = AuthState.Loading
                // Запрос параметров аутентификации
                // ...
                _authState.value = AuthState.BiometricPrompt
                // Вызов CredentialManager
                // ...
                _authState.value = AuthState.Success(username)
            } catch (e: Exception) {
                _authState.value = AuthState.Error(e.localizedMessage ?: "Unknown error")
            }
        }
    }
}

private fun getErrorMessage(e: Exception): String {
    return when (e) {
        is CreateCredentialCancellationException -> "Вы отменили создание паскея"
        is CreateCredentialInterruptedException -> "Процесс был прерван, попробуйте снова"
        is GetCredentialProviderConfigurationException -> "Ошибка настройки провайдера учетных данных"
        else -> "Что-то пошло не так. Попробуйте еще раз или используйте другой способ входа."
    }
}

// В файле build.gradle.kts добавьте зависимости для тестирования
testImplementation("androidx.test:core:1.5.0")
testImplementation("androidx.test:runner:1.5.2")
testImplementation("androidx.test.ext:junit:1.1.5")

class FakeAuthServer {
  fun getRegistrationOptions(): String {
      return """
          {
              "challenge": "randomChallenge",
              "rp": {
                  "name": "Test App",
                  "id": "android.test.app"
              },
              "user": {
                  "id": "test-user-id",
                  "name": "testuser",
                  "displayName": "Test User"
              },
              "pubKeyCredParams": [
                  {
                      "alg": -7,
                      "type": "public-key"
                  }
              ],
              "timeout": 60000,
              "attestation": "none"
          }
      """.trimIndent()
  }
  
  fun verifyRegistration(json: String): Boolean {
      // В тестовой среде всегда возвращаем успех
      return true
  }
  
  // Аналогично для аутентификации
}

interface CredentialManagerWrapper {
  suspend fun createCredential(context: Context, request: CreatePublicKeyCredentialRequest): CreateCredentialResponse
  suspend fun getCredential(context: Context, request: GetCredentialRequest): GetCredentialResponse
}
 
// Реальная реализация
class RealCredentialManagerWrapper(private val credentialManager: CredentialManager) : CredentialManagerWrapper {
  override suspend fun createCredential(context: Context, request: CreatePublicKeyCredentialRequest) = 
      credentialManager.createCredential(context, request)
  
  override suspend fun getCredential(context: Context, request: GetCredentialRequest) = 
      credentialManager.getCredential(context, request)
}
 
// Тестовая реализация
class TestCredentialManagerWrapper : CredentialManagerWrapper {
  var shouldSucceed = true
  var exceptionToThrow: Exception? = null
  
  override suspend fun createCredential(context: Context, request: CreatePublicKeyCredentialRequest): CreateCredentialResponse {
      exceptionToThrow?.let { throw it }
      // Возвращаем мок-ответ
  }
  
  // Аналогично для getCredential
}

@Test
fun whenDeviceHasNoPasskeysSetup_shouldShowRegistrationPrompt() {
  // Настраиваем тестовую среду для имитации отсутствия паскеев
  testCredentialManager.exceptionToThrow = GetCredentialNoCredentialsException()
  
  // Запускаем аутентификацию
  viewModel.authenticateWithPasskey()
  
  // Проверяем, что показан правильный UI
  assertThat(viewModel.authState.value).isInstanceOf(AuthState.RegistrationNeeded::class.java)
}

class CredentialManagerIdlingResource(private val viewModel: AuthViewModel) : IdlingResource {
  private var callback: IdlingResource.ResourceCallback? = null
  
  override fun getName() = "credential_manager_idling_resource"
  
  override fun isIdleNow(): Boolean {
      val isIdle = viewModel.isOperationInProgress.value != true
      if (isIdle) callback?.onTransitionToIdle()
      return isIdle
  }
  
  override fun registerIdleTransitionCallback(callback: IdlingResource.ResourceCallback) {
      this.callback = callback
  }
}