Secure Text Entry — wat is het, invoerbeveiliging en wachtwoorden in Android

Wat is Secure Text Entry in Android

Secure Text Entry (beveiligde tekstinvoer) — is een Android-functie die de weergave van elk ingevoerd teken vervangt door een maskerend symbool, meestal een punt (•) of een sterretje (*). Dit voorkomt het lezen van wachtwoorden over de schouder (shoulder surfing) en verbergt ingevoerde gegevens voor nieuwsgierige ogen. De functie staat ook bekend als wachtwoordmaskering en is een standaardpraktijk in mobiele applicaties.

In tegenstelling tot iOS, waar Secure Text Entry een aparte instelling van UITextField is, wordt deze functie in Android geactiveerd via het attribuut inputType met de variatie PASSWORD. Wanneer EditText inputType="textPassword" ontvangt, past het automatisch PasswordTransformationMethod toe — de klasse die verantwoordelijk is voor het vervangen van tekens. Bij het invoeren van elk nieuw teken vervangt EditText het onmiddellijk door een maskerend symbool via het TransformationMethod-mechanisme van de interface.

Volgens Android Source Code (AOSP, 2026) gebruikt de implementatie van PasswordTransformationMethod de klasse TextPaint voor het tekenen van maskerende symbolen. De grootte van het maskerende symbool komt overeen met de lettergrootte van het veld, wat lekkage van informatie via de woordlengte voorkomt — alle tekens zien er identiek uit qua breedte. Dit is belangrijk voor bescherming tegen aanvallen gebaseerd op analyse van de lengte van ingevoerde gegevens.

<!-- Basic Secure Text Entry example -->
@+id/etPassword
android:layout_width="match_parent"
android:hint="Enter password"
android:inputType="textPassword"
android:maxLength="64"
android:importantForAutofill="yes" />

Hoe werkt Secure Text Entry

Het mechanisme van Secure Text Entry in Android is gebaseerd op de interface TransformationMethod, gedefinieerd in het pakket android.text.method. PasswordTransformationMethod — is een ingebouwde implementatie die de methode getTransformation() overschrijft en een vervangen reeks tekens voor weergave retourneert. De originele tekst in Editable blijft onveranderd — alleen de visuele weergave verandert.

Wanneer de gebruiker een teken invoert, roept EditText dispatchEvent aan en geeft het teken door aan InputConnection, die het toevoegt aan Editable. Vervolgens roept EditText de methode getTransformation() van de huidige TransformationMethod aan, die de originele CharSequence ontvangt en een SpannableString met maskerende symbolen retourneert. Deze SpannableString wordt op het scherm weergegeven in plaats van de originele tekst. Het belangrijkste kenmerk — de transformatie zelf verandert de inhoud van Editable niet, daarom wordt bij aanroep van getText().toString() de werkelijk ingevoerde tekst geretourneerd.

Volgens Android Developers Reference (2026) voegt PasswordTransformationMethod aan elk teken een MetricAffectingSpan toe die de glyph vervangt door een punt. Deze spans hebben geen invloed op de tekstlengte, waardoor de cursor en invoerpositie correct blijven, zelfs bij verborgen weergave. Er bestaat ook VisiblePasswordTransformationMethod, die het laatst ingevoerde teken kort weergeeft (vergelijkbaar met iOS).

// PasswordTransformationMethod - ingebouwde maskering
editText.transformationMethod = PasswordTransformationMethod.getInstance()

// VisiblePasswordTransformationMethod - toont laatste teken
editText.transformationMethod = VisiblePasswordTransformationMethod.getInstance()

Wachtwoordzichtbaarheid schakelen

Zichtbaarheid schakelen (password visibility toggle) — is een functie waarmee de gebruiker het ingevoerde wachtwoord tijdelijk kan tonen om het te controleren voordat het formulier wordt verzonden. In Android wordt deze functie geïmplementeerd via TextInputLayout met het attribuut app:endIconMode="password_toggle". Bij het klikken op het oogpictogram schakelt het veld tussen textPassword en textVisiblePassword.

De implementatie van password_toggle in TextInputLayout verandert automatisch de inputType van de interne EditText en animeert het pictogram (oog open/gesloten). Het is belangrijk om te onthouden dat bij deze schakeling de cursorpositie kan worden gereset, daarom slaat TextInputLayout de positie op en herstelt deze na moduswijziging. Ook worden bij het overschakelen naar zichtbaar wachtwoord automatische correctie en suggesties niet ingeschakeld — TYPE_TEXT_VARIATION_VISIBLE_PASSWORD wordt gebruikt, niet gewone text.

Volgens Material Design Guidelines (2025) moet het pictogram voor het tonen van het wachtwoord altijd zichtbaar zijn, niet alleen wanneer het veld in focus is. De gebruiker moet te allen tijde het wachtwoord kunnen controleren. Het pictogram moet het wachtwoord niet automatisch verbergen na een bepaalde tijd — alleen door gebruikersactie.

<!-- TextInputLayout with password toggle -->
@+id/tilPassword
android:layout_width="match_parent"
app:endIconMode="password_toggle"
app:passwordToggleTint="@color/primary">

    @+id/etPassword
    android:inputType="textPassword"
    android:hint="Password" />

</com.google.android.material.textfield.TextInputLayout>

Programmatische configuratie van Secure Text Entry

Programmatische instelling van Secure Text Entry in Kotlin gebeurt via het instellen van inputType of via setTransformationMethod(). Beide benaderingen leiden tot hetzelfde resultaat, maar verschillen in details. Het instellen van inputType configureert ook automatische correctie en suggesties, terwijl setTransformationMethod alleen de weergave van tekens beïnvloedt.

Voorbeeld van wachtwoordschakelaar via TextInputLayout

// Programmatisch schakelen van wachtwoordzichtbaarheid
fun togglePasswordVisibility(til: TextInputLayout) {
    val editText = til.editText ?: return
    val currentType = editText.inputType
    val isPassword = (currentType and
        InputType.TYPE_TEXT_VARIATION_PASSWORD) != 0

    if (isPassword) {
        editText.inputType = InputType.TYPE_CLASS_TEXT or
            InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
    } else {
        editText.inputType = InputType.TYPE_CLASS_TEXT or
            InputType.TYPE_TEXT_VARIATION_PASSWORD
    }

    // Cursorpositie herstellen
    val cursorPos = editText.selectionStart
    editText.setSelection(maxOf(0, cursorPos))
}

Aangepaste TransformationMethod

// Aangepaste maskering — toont alleen laatste 4 tekens
class PartialPasswordTransformation : TransformationMethod {
    override fun getTransformation(source: CharSequence?,
        view: View?): CharSequence {
        val text = source?.toString() ?: ""
        if (text.length <= 4) return text

        val dots = "\u2022".repeat(text.length - 4)
        return dots + text.substring(text.length - 4)
    }

    override fun onFocusChanged(view: View?,
        sourceText: CharSequence?,
        focused: Boolean,
        direction: Int,
        previouslyFocusedRect: android.graphics.Rect?) {}
}

Beveiligingsaspecten van verborgen invoer

Secure Text Entry biedt bescherming op meerdere niveaus. Visuele maskering voorkomt het lezen van wachtwoorden over de schouder (shoulder surfing) — de meest voorkomende methode van wachtwoorddiefstal op openbare plaatsen. Het uitschakelen van automatische correctie voorkomt opslag van het wachtwoord in het gebruikerswoordenboek, wat lekkage via voorspellende invoer uitsluit. Bescherming tegen schermafbeeldingen (als FLAG_SECURE is ingeschakeld) voorkomt dat andere applicaties de inhoud van het veld kunnen vastleggen.

Secure Text Entry is echter geen volledige bescherming. Aanvallen via invoeronderschepping (keylogging) op systeemniveau kunnen echte tekens uit InputConnection verkrijgen. Kwaadaardige applicaties met een toegankelijkheidsservice kunnen de inhoud van EditText lezen, zelfs als tekens op het scherm verborgen zijn. Ook SSL-sniffing bij gegevensoverdracht naar de server kan het wachtwoord onthullen als HTTPS niet met correcte certificaatvalidatie wordt gebruikt.

Volgens OWASP Mobile Security Testing Guide (2025) wordt voor maximale bescherming van wachtwoorden in Android aanbevolen: gebruik inputType="textPassword" + schakel autofill uit voor kritieke velden; bewaar het wachtwoord niet langer in het geheugen dan nodig; maak het wachtwoordveld leeg bij het minimaliseren van de app (onPause/onStop); gebruik maskering zelfs bij kortstondige weergave van het wachtwoord.

Beste praktijken voor Secure Text Entry

Android-ontwikkelaars moeten enkele belangrijke praktijken volgen bij het werken met verborgen invoer. Ten eerste, gebruik altijd TextInputLayout met endIconMode="password_toggle" voor wachtwoordvelden — dit is de moderne standaard van Material Design. Ten tweede, schakel de mogelijkheid om het wachtwoord te tonen niet uit — de gebruiker moet kunnen controleren wat hij heeft ingevoerd, vooral op mobiele apparaten met een klein toetsenbord.

Secure Text Entry vereist ook een correcte configuratie van automatisch aanvullen. Specificeer voor wachtwoordvelden altijd autofillHints="password" of autofillHints="newPassword", zodat wachtwoordmanagers gegevens correct kunnen invullen en opslaan. Gebruik voor het bevestigingsveld van een nieuw wachtwoord autofillHints="newPassword" om te voorkomen dat het systeem voorstelt het in te vullen met het huidige opgeslagen wachtwoord.

• TextInputLayout — gebruik Material Design TextInputLayout met endIconMode voor de zichtbaarheidsschakelaar.
• Autofill — voeg autofillHints="password" en importantForAutofill="yes" toe voor ondersteuning van managers.
• Leegmaken — maak het wachtwoordveld leeg bij het minimaliseren van de app (onPause/onStop).
• Lengte — beperk de wachtwoordlengte niet te streng (minimaal 8 tekens, zonder hard maximum).
• Biometrie — bied biometrische aanmelding (BiometricPrompt) aan als alternatief voor handmatige wachtwoordinvoer.

// Volledig wachtwoordveld met automatisch aanvullen en opschonen
class SecurePasswordField {
    private fun setupPasswordField(til: TextInputLayout) {
        val editText = til.editText ?: return
        editText.inputType = InputType.TYPE_CLASS_TEXT or
            InputType.TYPE_TEXT_VARIATION_PASSWORD
        editText.setAutofillHints(View.AUTOFILL_HINT_PASSWORD>)
        editText.importantForAutofill = View.IMPORTANT_FOR_AUTOFILL_YES
    }

    fun clearOnPause(editText: EditText) {
        editText.text?.clear()
    }
}