Secure Text Entry — vad är det, skydd av inmatning och lösenord i Android

Vad är Secure Text Entry i Android

Secure Text Entry (skyddad textinmatning) — är en Android-funktion som ersätter visningen av varje inskrivet tecken med en maskeringssymbol, vanligtvis en punkt (•) eller en asterisk (*). Detta förhindrar att lösenord läses över axeln (shoulder surfing) och döljer inmatad data från obehöriga ögon. Funktionen är också känd som lösenordsmaskering och är standardpraxis i mobila applikationer.

Till skillnad från iOS, där Secure Text Entry är en separat inställning för UITextField, aktiveras denna funktion i Android via attributet inputType med variationen PASSWORD. När EditText får inputType="textPassword" tillämpar det automatiskt PasswordTransformationMethod — klassen som ansvarar för att ersätta tecken. Vid varje inskrivet nytt tecken ersätter EditText det omedelbart med en maskeringssymbol genom TransformationMethod-gränssnittets mekanism.

Enligt Android Source Code (AOSP, 2026) använder implementeringen av PasswordTransformationMethod klassen TextPaint för att rita maskeringssymboler. Storleken på maskeringssymbolen matchar fältets teckenstorlek, vilket förhindrar informationsläckage via ordlängd — alla tecken ser identiska ut i bredd. Detta är viktigt för skydd mot attacker baserade på analys av längden på inmatad data.

<!-- 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" />

Hur Secure Text Entry fungerar

Mekanismen för Secure Text Entry i Android är baserad på gränssnittet TransformationMethod, definierat i paketet android.text.method. PasswordTransformationMethod — är en inbyggd implementering som åsidosätter metoden getTransformation() och returnerar en ersatt teckensekvens för visning. Under tiden förblir den ursprungliga texten i Editable oförändrad — endast dess visuella representation ändras.

När användaren anger ett tecken anropar EditText dispatchEvent och skickar tecknet till InputConnection, som lägger till det i Editable. Därefter anropar EditText metoden getTransformation() för aktuell TransformationMethod, som tar emot den ursprungliga CharSequence och returnerar en SpannableString med maskeringssymboler. Denna SpannableString visas på skärmen istället för den ursprungliga texten. Nyckelfunktionen — själva transformationen ändrar inte innehållet i Editable, därför returneras den faktiskt inskrivna texten vid anrop av getText().toString().

Enligt Android Developers Reference (2026) lägger PasswordTransformationMethod till en MetricAffectingSpan till varje tecken som ersätter glyfen med en punkt. Dessa span påverkar inte textlängden, så markören och inmatningspositionen bibehålls korrekt även vid dold visning. Det finns också VisiblePasswordTransformationMethod som visar det senast inskrivna tecknet under en kort tid (liknande iOS).

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

// VisiblePasswordTransformationMethod - visar sista tecknet
editText.transformationMethod = VisiblePasswordTransformationMethod.getInstance()

Växla lösenordssynlighet

Växla synlighet (password visibility toggle) — är en funktion som gör att användaren tillfälligt kan visa det inskrivna lösenordet för att kontrollera det innan formuläret skickas. I Android implementeras denna funktion via TextInputLayout med attributet app:endIconMode="password_toggle". När man klickar på ögonikonen växlar fältet mellan textPassword och textVisiblePassword.

Implementeringen av password_toggle i TextInputLayout ändrar automatiskt inputType för den interna EditText och animerar ikonen (öppet/stängt öga). Det är viktigt att komma ihåg att vid denna växling kan markörpositionen återställas, därför sparar och återställer TextInputLayout positionen efter lägesändringen. Vid växling till synligt lösenord aktiveras inte heller autokorrigering och förslag — TYPE_TEXT_VARIATION_VISIBLE_PASSWORD används, inte vanlig text.

Enligt Material Design Guidelines (2025) bör ikonen för att visa lösenordet alltid vara synlig, inte bara när fältet är i fokus. Användaren ska kunna kontrollera lösenordet när som helst. Ikonen bör inte automatiskt dölja lösenordet efter en viss tid — endast genom användarens handling.

<!-- 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>

Programmatisk konfiguration av Secure Text Entry

Programmatisk inställning av Secure Text Entry i Kotlin görs genom att ställa in inputType eller via setTransformationMethod(). Båda metoderna leder till samma resultat men skiljer sig i detaljer. Att ställa in inputType konfigurerar även autokorrigering och förslag, medan setTransformationMethod endast påverkar visningen av tecken.

Exempel på lösenordsväxlare via TextInputLayout

// Programmatisk växling av lösenordssynlighet
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
    }

    // Återställ markörposition
    val cursorPos = editText.selectionStart
    editText.setSelection(maxOf(0, cursorPos))
}

Anpassad TransformationMethod

// Anpassad maskering — visar endast de 4 sista tecknen
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?) {}
}

Säkerhetsaspekter av dold inmatning

Secure Text Entry ger skydd på flera nivåer. Visuell maskering förhindrar att lösenord läses över axeln (shoulder surfing) — den vanligaste metoden för lösenordsstöld på offentliga platser. Att stänga av autokorrigering förhindrar att lösenordet sparas i användarens ordbok, vilket utesluter läckage via prediktiv inmatning. Skydd mot skärmbilder (om FLAG_SECURE är aktiverat) hindrar andra applikationer från att fånga fältets innehåll.

Secure Text Entry är dock inte ett fullständigt skydd. Attacker via inmatningsavlyssning (keylogging) på systemnivå kan få verkliga tecken från InputConnection. Skadliga applikationer med tillgänglighetstjänst kan läsa innehållet i EditText, även om tecknen är dolda på skärmen. Även SSL-sniffing vid dataöverföring till servern kan avslöja lösenordet om HTTPS inte används med korrekt certifikatvalidering.

Enligt OWASP Mobile Security Testing Guide (2025) rekommenderas följande för maximalt skydd av lösenord i Android: använd inputType="textPassword" + stäng av autofill för kritiska fält; lagra inte lösenordet i minnet längre än nödvändigt; rensa lösenordsfältet vid minimering av applikationen (onPause/onStop); använd maskering även vid tillfällig visning av lösenordet.

Bästa praxis för Secure Text Entry

Android-utvecklare bör följa flera viktiga metoder när de arbetar med dold inmatning. För det första, använd alltid TextInputLayout med endIconMode="password_toggle" för lösenordsfält — detta är den moderna standarden för Material Design. För det andra, stäng inte av möjligheten att visa lösenordet — användaren måste kunna kontrollera vad den har skrivit in, särskilt på mobila enheter med litet tangentbord.

Secure Text Entry kräver också korrekt konfiguration av autofyll. För lösenordsfält, ange alltid autofillHints="password" eller autofillHints="newPassword" så att lösenordshanterare kan fylla i och spara data korrekt. För bekräftelsefältet för nytt lösenord, använd autofillHints="newPassword" så att systemet inte föreslår att fylla i det med det aktuella sparade lösenordet.

• TextInputLayout — använd Material Design TextInputLayout med endIconMode för synlighetsväxlaren.
• Autofill — lägg till autofillHints="password" och importantForAutofill="yes" för stöd av hanterare.
• Rensning — rensa lösenordsfältet vid minimering av applikationen (onPause/onStop).
• Längd — begränsa inte lösenordslängden alltför strikt (minst 8 tecken, utan hårt maximum).
• Biometri — erbjud biometrisk inloggning (BiometricPrompt) som alternativ till manuell lösenordsinmatning.

// Fullt lösenordsfält med autofyll och rensning
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()
    }
}