Secure Text Entry — mi ez, bevitelvédelem és jelszavak Androidban

Mi az a Secure Text Entry Androidban

Secure Text Entry (védett szövegbevitel) — egy Android funkció, amely minden beírt karakter megjelenítését egy maszkoló szimbólumra, általában pontra (•) vagy csillagra (*) cseréli. Ez megakadályozza a jelszó váll fölötti elolvasását (shoulder surfing) és elrejti a beírt adatokat a kíváncsi szemek elől. A funkció jelszómaszkolásként is ismert, és szabványos gyakorlat a mobilalkalmazásokban.

Az iOS-szel ellentétben, ahol a Secure Text Entry az UITextField külön beállítása, Androidban ez a funkció az inputType attribútumon keresztül aktiválódik PASSWORD variációval. Amikor az EditText inputType="textPassword"-t kap, automatikusan alkalmazza a PasswordTransformationMethod-ot — a karakterek cseréjéért felelős osztályt. Minden új karakter beírásakor az EditText azonnal lecseréli azt egy maszkoló szimbólumra a TransformationMethod interfész mechanizmusán keresztül.

A Android Source Code (AOSP, 2026) szerint a PasswordTransformationMethod megvalósítása a TextPaint osztályt használja a maszkoló szimbólumok rajzolásához. A maszkoló szimbólum mérete megegyezik a mező betűméretével, ami megakadályozza az információ szivárgását a szóhosszon keresztül — minden karakter azonos szélességűnek tűnik. Ez fontos a beírt adatok hosszának elemzésén alapuló támadások elleni védelemhez.

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

Hogyan működik a Secure Text Entry

A Secure Text Entry mechanizmusa Androidban az android.text.method csomagban definiált TransformationMethod interfészen alapul. A PasswordTransformationMethod — egy beépített megvalósítás, amely felülírja a getTransformation() metódust, és egy lecserélt karaktersorozatot ad vissza megjelenítésre. Eközben az eredeti szöveg az Editable-ben változatlan marad — csak a vizuális megjelenítése változik.

Amikor a felhasználó beír egy karaktert, az EditText meghívja a dispatchEvent-et és továbbítja a karaktert az InputConnection-nek, amely hozzáadja azt az Editable-hez. Ezután az EditText meghívja az aktuális TransformationMethod getTransformation() metódusát, amely megkapja az eredeti CharSequence-t és visszaad egy SpannableString-et maszkoló szimbólumokkal. Ez a SpannableString jelenik meg a képernyőn az eredeti szöveg helyett. A kulcsfontosságú jellemző — maga az átalakítás nem változtatja meg az Editable tartalmát, ezért a getText().toString() hívásakor a ténylegesen beírt szöveg kerül visszaadásra.

A Android Developers Reference (2026) szerint a PasswordTransformationMethod minden karakterhez hozzáad egy MetricAffectingSpan-t, amely a glifet pontra cseréli. Ezek a span-ok nem befolyásolják a szöveg hosszát, így a kurzor és a beviteli pozíció helyesen megmarad még rejtett megjelenítés esetén is. Létezik VisiblePasswordTransformationMethod is, amely az utolsó beírt karaktert rövid ideig megjeleníti (hasonlóan az iOS-hez).

// PasswordTransformationMethod - beépített maszkolás
editText.transformationMethod = PasswordTransformationMethod.getInstance()

// VisiblePasswordTransformationMethod - utolsó karaktert mutatja
editText.transformationMethod = VisiblePasswordTransformationMethod.getInstance()

Jelszó láthatóságának váltása

Láthatóság váltása (password visibility toggle) — egy funkció, amely lehetővé teszi a felhasználó számára, hogy ideiglenesen megjelenítse a beírt jelszót az űrlap elküldése előtti ellenőrzéshez. Androidban ez a funkció a TextInputLayout-on keresztül valósul meg az app:endIconMode="password_toggle" attribútummal. A szem ikonra kattintva a mező textPassword és textVisiblePassword között vált.

A password_toggle megvalósítása a TextInputLayout-ban automatikusan megváltoztatja a belső EditText inputType-ját és animálja az ikont (nyitott/csukott szem). Fontos megjegyezni, hogy ekkor a kurzor pozíciója visszaállhat, ezért a TextInputLayout elmenti és visszaállítja a pozíciót a módváltás után. Továbbá a látható jelszóra váltáskor az automatikus javítás és javaslatok nem kapcsolódnak be — TYPE_TEXT_VARIATION_VISIBLE_PASSWORD használatos, nem sima text.

A Material Design Guidelines (2025) szerint a jelszó megjelenítésére szolgáló ikonnak mindig láthatónak kell lennie, nem csak amikor a mező fókuszban van. A felhasználónak bármikor lehetősége kell legyen ellenőrizni a jelszót. Az ikon nem rejtheti el automatikusan a jelszót egy bizonyos idő után — csak a felhasználó műveletére.

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

A Secure Text Entry programozói beállítása

A Secure Text Entry programozói beállítása Kotlinban az inputType beállításán vagy a setTransformationMethod()-on keresztül történik. Mindkét megközelítés ugyanarra az eredményre vezet, de a részletekben különböznek. Az inputType beállítása továbbá konfigurálja az automatikus javítást és javaslatokat, míg a setTransformationMethod csak a karakterek megjelenítésére hat.

Példa jelszóváltóra TextInputLayout-on keresztül

// Programozói jelszó láthatóság váltás
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
    }

    // Kurzor pozíció visszaállítása
    val cursorPos = editText.selectionStart
    editText.setSelection(maxOf(0, cursorPos))
}

Egyéni TransformationMethod

// Egyéni maszkolás — csak az utolsó 4 karaktert mutatja
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?) {}
}

A rejtett bevitel biztonsági szempontjai

A Secure Text Entry több szinten nyújt védelmet. A vizuális maszkolás megakadályozza a jelszó váll fölötti elolvasását (shoulder surfing) — a jelszólopás legelterjedtebb módszerét nyilvános helyeken. Az automatikus javítás kikapcsolása megakadályozza a jelszó mentését a felhasználói szótárba, ami kizárja annak szivárgását prediktív bevitelen keresztül. A képernyőképek elleni védelem (ha FLAG_SECURE be van kapcsolva) nem engedi más alkalmazásoknak a mező tartalmának rögzítését.

Azonban a Secure Text Entry nem teljes védelem. A bevitel lehallgatásán (keylogging) alapuló támadások rendszer szinten valódi karaktereket szerezhetnek az InputConnection-ből. A kártékony alkalmazások akadálymentesítési szolgáltatással olvashatják az EditText tartalmát, még akkor is, ha a karakterek rejtve vannak a képernyőn. Továbbá az SSL-sniffing az adatok szerverre történő továbbításakor felfedheti a jelszót, ha nem HTTPS-t használnak megfelelő tanúsítványellenőrzéssel.

Az OWASP Mobile Security Testing Guide (2025) szerint a jelszavak maximális védelméhez Androidban ajánlott: használjon inputType="textPassword" + kapcsolja ki az autofill-t a kritikus mezőkhöz; ne tárolja a jelszót a memóriában a szükségesnél tovább; ürítse ki a jelszómezőt az alkalmazás minimalizálásakor (onPause/onStop); használjon maszkolást akár a jelszó rövid idejű megjelenítésekor is.

Secure Text Entry legjobb gyakorlatok

Az Android fejlesztőknek néhány kulcsfontosságú gyakorlatot be kell tartaniuk a rejtett bevitellel való munka során. Először is, mindig használjon TextInputLayout-ot endIconMode="password_toggle"-val a jelszómezőkhöz — ez a Material Design modern szabványa. Másodszor, ne kapcsolja ki a jelszó megjelenítésének lehetőségét — a felhasználónak ellenőriznie kell tudnia, mit írt be, különösen kis billentyűzettel rendelkező mobil eszközökön.

A Secure Text Entry az automatikus kitöltés helyes beállítását is megköveteli. A jelszómezőkhöz mindenképpen adja meg az autofillHints="password" vagy autofillHints="newPassword" értéket, hogy a jelszókezelők helyesen tölthessék ki és menthessék az adatokat. Az új jelszó megerősítő mezőjéhez használja az autofillHints="newPassword" értéket, hogy a rendszer ne javasolja annak kitöltését a jelenlegi mentett jelszóval.

• TextInputLayout — használjon Material Design TextInputLayout-ot endIconMode-mal a láthatóság váltásához.
• Autofill — adjon hozzá autofillHints="password" és importantForAutofill="yes" értékeket a kezelők támogatásához.
• Ürítés — ürítse ki a jelszómezőt az alkalmazás minimalizálásakor (onPause/onStop).
• Hossz — ne korlátozza túl szigorúan a jelszó hosszát (minimum 8 karakter, kemény maximum nélkül).
• Biometria — kínáljon biometrikus bejelentkezést (BiometricPrompt) alternatívaként a kézi jelszóbevitelhez.

// Teljes jelszómező autofill-lel és tisztítással
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()
    }
}