Hier zijn de beste praktijken en richtlijnen voor het implementeren van een robuust sessiebeheersysteem in je Kotlin Android-app, met gebruik van Firebase Authenticatie en Retrofit: 1. Veilige opslag van tokens: - Gebruik de Android Keystore voor het veilig opslaan van gevoelige gegevens zoals tokens. - Vermijd het opslaan van tokens in gedeelde voorkeuren of platte bestanden zonder encryptie. - Overweeg het gebruik van EncryptedSharedPreferences voor extra beveiliging. 2. Authenticatie en tokenbeheer: - Firebase Authenticatie beheert meestal de tokens automatisch, maar als je de ID-token nodig hebt: - Verkrijg de ID-token via FirebaseAuth.getInstance().currentUser?.getIdToken() - Ververs tokens tijdig voordat ze verlopen (Firebase doet dit automatisch, maar je kunt handmatig verversen als nodig). 3. Retrofit configuratie: - Voeg een OkHttp Interceptor toe die de ID-token automatisch toevoegt aan elke API-aanroep: ```kotlin class AuthInterceptor : Interceptor { override fun intercept(chain: Interceptor.Chain): Response { val user = FirebaseAuth.getInstance().currentUser val requestBuilder = chain.request().newBuilder() user?.getIdToken(false)?.addOnSuccessListener { result -> val token = result.token if (token != null) { requestBuilder.addHeader("Authorization", "Bearer $token") } }?.addOnFailureListener { // Afhandeling bij mislukken token ophalen } return chain.proceed(requestBuilder.build()) } } ``` - Voeg deze interceptor toe aan je OkHttpClient. 4. Omgaan met sessieverval: - Firebase Token vervalt automatisch na een bepaalde tijd. Zorg dat je app dit detecteert: - Bij een 401 Unauthorized response, probeer het token te verversen. - Als verversen niet lukt, vraag de gebruiker opnieuw in te loggen. ```kotlin // Voorbeeld van automatische verversing fun handleUnauthorized() { FirebaseAuth.getInstance().currentUser?.getIdToken(true) ?.addOnSuccessListener { // Token vernieuwd, herhaal de API-aanroep } ?.addOnFailureListener { // Sessiesessie hernieuwen door gebruiker uit te loggen en opnieuw in te loggen } } ``` 5. Gebruikersafmelding: - Bij afmelden: - Roep FirebaseAuth.getInstance().signOut() aan. - Wis alle lokale opgeslagen tokens en gegevens uit beveiligde opslag. - Navigeer de gebruiker terug naar het inlogscherm. ```kotlin fun signOut() { FirebaseAuth.getInstance().signOut() // Verwijder tokens uit opslag // Bijvoorbeeld met EncryptedSharedPreferences } ``` 6. Extra beveiligingsmaatregelen: - Gebruik HTTPS voor alle API-verkeer. - Beperk de API-toegang tot alleen vertrouwde clients via API-sleutels of OAuth2. - Log en monitor authenticatie- en sessie-activiteiten. - Overweeg multi-factor authenticatie voor extra beveiliging. Kortom: - Gebruik Firebase Auth voor gebruikersbeheer. - Sla tokens veilig op met EncryptedSharedPreferences of Keystore. - Voeg tokens automatisch toe via een interceptor. - Detecteer en handel sessieverval af door tokenvernieuwing en herauthenticatie. - Zorg dat afmelden alles correct reinigt en de gebruiker uitlogt. Heeft u specifieke codevoorbeelden nodig voor een van deze stappen?

Hier zijn richtlijnen voor een robuust sessiebeheersysteem in Kotlin voor Android: ## 1. Veilige Tokenopslag ### Gebruik EncryptedSharedPreferences ```kotlin import androidx.security.crypto.EncryptedSharedPreferences import androidx.security.crypto.MasterKeys class SecureTokenManager(private val context: Context) { private val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC) private val sharedPreferences = EncryptedSharedPreferences.create( "secure_tokens", masterKeyAlias, context, EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV, EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM ) fun saveAuthToken(token: String) { sharedPreferences.edit().putString("auth_token", token).apply() } fun getAuthToken(): String? { return sharedPreferences.getString("auth_token", null) } fun saveRefreshToken(token: String) { sharedPreferences.edit().putString("refresh_token", token).apply() } fun getRefreshToken(): String? { return sharedPreferences.getString("refresh_token", null) } fun clearTokens() { sharedPreferences.edit().clear().apply() } } ``` ## 2. Sessiebeheer met Repository Pattern ```kotlin class SessionRepository( private val secureTokenManager: SecureTokenManager, private val authService: AuthService ) { private var currentUser: User? = null suspend fun login(email: String, password: String): Result<Unit> { return try { val response = authService.login(LoginRequest(email, password)) if (response.isSuccessful) { response.body()?.let { authResponse -> secureTokenManager.saveAuthToken(authResponse.accessToken) secureTokenManager.saveRefreshToken(authResponse.refreshToken) currentUser = authResponse.user } Result.success(Unit) } else { Result.failure(Exception("Login failed")) } } catch (e: Exception) { Result.failure(e) } } fun isUserLoggedIn(): Boolean { return secureTokenManager.getAuthToken() != null } fun getCurrentUser(): User? { return currentUser } suspend fun refreshToken(): Boolean { val refreshToken = secureTokenManager.getRefreshToken() ?: return false return try { val response = authService.refreshToken(RefreshTokenRequest(refreshToken)) if (response.isSuccessful) { response.body()?.let { authResponse -> secureTokenManager.saveAuthToken(authResponse.accessToken) return true } } false } catch (e: Exception) { false } } fun logout() { secureTokenManager.clearTokens() currentUser = null // Optioneel: Firebase uitloggen // Firebase.auth.signOut() } } ``` ## 3. Authenticatie Interceptor voor Retrofit ```kotlin class AuthInterceptor( private val sessionRepository: SessionRepository ) : Interceptor { override fun intercept(chain: Interceptor.Chain): Response { val originalRequest = chain.request() // Voeg token alleen toe als beschikbaar val token = sessionRepository.getAuthToken() if (token == null) { return chain.proceed(originalRequest) } val authenticatedRequest = originalRequest.newBuilder() .header("Authorization", "Bearer $token") .build() val response = chain.proceed(authenticatedRequest) // Handle token verval if (response.code == 401) { // Probeer token te refreshen val newTokenRefreshed = runBlocking { sessionRepository.refreshToken() } if (newTokenRefreshed) { // Voer originele request opnieuw uit met nieuw token val newToken = sessionRepository.getAuthToken() val retryRequest = originalRequest.newBuilder() .header("Authorization", "Bearer $newToken") .build() return chain.proceed(retryRequest) } else { // Forceer logout bij falende refresh sessionRepository.logout() // Stuur broadcast voor logout LocalBroadcastManager.getInstance(context) .sendBroadcast(Intent("SESSION_EXPIRED")) } } return response } } ``` ## 4. Retrofit Setup met Authenticatie ```kotlin object ApiClient { private const val BASE_URL = "https://your-api.com/" fun createAuthService(sessionRepository: SessionRepository): AuthService { val okHttpClient = OkHttpClient.Builder() .addInterceptor(AuthInterceptor(sessionRepository)) .addInterceptor(HttpLoggingInterceptor().apply { level = HttpLoggingInterceptor.Level.BODY }) .build() return Retrofit.Builder() .baseUrl(BASE_URL) .client(okHttpClient) .addConverterFactory(GsonConverterFactory.create()) .build() .create(AuthService::class.java) } } interface AuthService { @POST("auth/login") suspend fun login(@Body request: LoginRequest): Response<AuthResponse> @POST("auth/refresh") suspend fun refreshToken(@Body request: RefreshTokenRequest): Response<AuthResponse> @POST("auth/logout") suspend fun logout(): Response<Unit> } ``` ## 5. Data Classes ```kotlin data class LoginRequest( val email: String, val password: String ) data class RefreshTokenRequest( val refreshToken: String ) data class AuthResponse( val accessToken: String, val refreshToken: String, val expiresIn: Int, val user: User ) data class User( val id: String, val email: String, val name: String ) ``` ## 6. Gebruik in ViewModel ```kotlin class AuthViewModel( private val sessionRepository: SessionRepository ) : ViewModel() { private val _loginState = MutableStateFlow<LoginState>(LoginState.Idle) val loginState: StateFlow<LoginState> = _loginState fun login(email: String, password: String) { viewModelScope.launch { _loginState.value = LoginState.Loading when (val result = sessionRepository.login(email, password)) { is Result.Success -> { _loginState.value = LoginState.Success } is Result.Failure -> { _loginState.value = LoginState.Error(result.exception.message ?: "Login failed") } } } } fun logout() { sessionRepository.logout() } } sealed class LoginState { object Idle : LoginState() object Loading : LoginState() object Success : LoginState() data class Error(val message: String) : LoginState() } ``` ## 7. Beveiligingsaanbevelingen ### In je `AndroidManifest.xml`: ```xml <application android:usesCleartextTraffic="false" android:networkSecurityConfig="@xml/network_security_config"> ``` ### `network_security_config.xml`: ```xml <?xml version="1.0" encoding="utf-8"?> <network-security-config> <domain-config cleartextTrafficPermitted="false"> <domain includeSubdomains="true">your-api.com</domain> </domain-config> </network-security-config> ``` ## 8. Sessie Verloop Afhandeling ```kotlin class MainActivity : AppCompatActivity() { private lateinit var sessionRepository: SessionRepository override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Registreer voor sessie verloop broadcasts LocalBroadcastManager.getInstance(this) .registerReceiver(sessionExpiredReceiver, IntentFilter("SESSION_EXPIRED")) } private val sessionExpiredReceiver = object : BroadcastReceiver() { override fun onReceive(context: Context?, intent: Intent?) { showSessionExpiredDialog() } } private fun showSessionExpiredDialog() { AlertDialog.Builder(this) .setTitle("Sessie Verlopen") .setMessage("Uw sessie is verlopen. Log opnieuw in.") .setPositiveButton("OK") { _, _ -> sessionRepository.logout() navigateToLogin() } .setCancelable(false) .show() } override fun onDestroy() { super.onDestroy() LocalBroadcastManager.getInstance(this) .unregisterReceiver(sessionExpiredReceiver) } } ``` ## Belangrijkste Veiligheidsmaatregelen: 1. **Gebruik altijd EncryptedSharedPreferences** voor tokenopslag 2. **Implementeer token refresh logic** met retry mechanisme 3. **Beperk token levensduur** (bijv. 15-30 minuten voor access tokens) 4. **Gebruik HTTPS** voor alle API communicatie 5. **Voer proper logout uit** door alle tokens te verwijderen 6. **Implementeer sessie timeout** op de client 7. **Gebruik BiometricPrompt** voor gevoelige acties Deze implementatie biedt een robuuste basis voor sessiebeheer met goede beveiligingspraktijken.