Secure Text Entry — ce este, protecția introducerii și parolele în Android

Ce este Secure Text Entry în Android

Secure Text Entry (introducerea protejată a textului) — este o funcție Android care înlocuiește afișarea fiecărui caracter introdus cu un simbol de mascare, de obicei un punct (•) sau un asterisc (*). Aceasta previne citirea parolei peste umăr (shoulder surfing) și ascunde datele introduse de privirile indiscrete. Funcția este cunoscută și sub numele de mascare a parolei și este o practică standard în aplicațiile mobile.

Spre deosebire de iOS, unde Secure Text Entry este o setare separată a UITextField, în Android această funcție se activează prin atributul inputType cu variația PASSWORD. Când EditText primește inputType="textPassword", aplică automat PasswordTransformationMethod — clasa responsabilă pentru înlocuirea caracterelor. La introducerea fiecărui caracter nou, EditText îl înlocuiește instantaneu cu un simbol de mascare prin mecanismul TransformationMethod al interfeței.

Conform Android Source Code (AOSP, 2026), implementarea PasswordTransformationMethod utilizează clasa TextPaint pentru redarea simbolurilor de mascare. Dimensiunea simbolului de mascare coincide cu dimensiunea fontului câmpului, ceea ce previne scurgerea informațiilor prin lungimea cuvântului — toate caracterele arată identic ca lățime. Acest lucru este important pentru protecția împotriva atacurilor bazate pe analiza lungimii datelor introduse.

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

Cum funcționează Secure Text Entry

Mecanismul Secure Text Entry în Android se bazează pe interfața TransformationMethod, definită în pachetul android.text.method. PasswordTransformationMethod — este o implementare încorporată care suprascrie metoda getTransformation(), returnând o secvență de caractere înlocuite pentru afișare. Între timp, textul original din Editable rămâne neschimbat — se modifică doar reprezentarea sa vizuală.

Când utilizatorul introduce un caracter, EditText apelează dispatchEvent și transmite caracterul către InputConnection, care îl adaugă în Editable. Apoi EditText apelează metoda getTransformation() a TransformationMethod curent, care primește CharSequence-ul original și returnează un SpannableString cu simboluri de mascare. Acest SpannableString este redat pe ecran în locul textului original. Caracteristica cheie — transformarea în sine nu modifică conținutul Editable, de aceea la apelarea getText().toString() se returnează textul real introdus.

Conform Android Developers Reference (2026), PasswordTransformationMethod adaugă la fiecare caracter un MetricAffectingSpan care înlocuiește gliful cu un punct. Aceste span-uri nu afectează lungimea textului, astfel încât cursorul și poziția de introducere se păstrează corect chiar și în cazul afișării ascunse. Există și VisiblePasswordTransformationMethod, care afișează ultimul caracter introdus pentru o scurtă perioadă (similar cu iOS).

// PasswordTransformationMethod - mascare încorporată
editText.transformationMethod = PasswordTransformationMethod.getInstance()

// VisiblePasswordTransformationMethod - arată ultimul caracter
editText.transformationMethod = VisiblePasswordTransformationMethod.getInstance()

Comutarea vizibilității parolei

Comutarea vizibilității (password visibility toggle) — este o funcție care permite utilizatorului să afișeze temporar parola introdusă pentru a o verifica înainte de trimiterea formularului. În Android, această funcție se realizează prin TextInputLayout cu atributul app:endIconMode="password_toggle". La apăsarea pictogramei ochiului, câmpul comută între textPassword și textVisiblePassword.

Implementarea password_toggle în TextInputLayout schimbă automat inputType-ul EditText-ului intern și animează pictograma (ochi deschis/închis). Este important de reținut că la această comutare, poziția cursorului se poate reseta, de aceea TextInputLayout salvează și restaurează poziția după schimbarea modului. De asemenea, la comutarea pe parola vizibilă, corectarea automată și sugestiile nu se activează — se utilizează TYPE_TEXT_VARIATION_VISIBLE_PASSWORD, nu text obișnuit.

Conform Material Design Guidelines (2025), pictograma de afișare a parolei trebuie să fie întotdeauna vizibilă, nu doar când câmpul este focalizat. Utilizatorul trebuie să aibă posibilitatea de a verifica parola în orice moment. Pictograma nu trebuie să ascundă automat parola după un anumit timp — ci doar la acțiunea utilizatorului.

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

Configurarea programatică a Secure Text Entry

Setarea programatică a Secure Text Entry în Kotlin se realizează prin stabilirea inputType sau prin setTransformationMethod(). Ambele abordări duc la același rezultat, dar diferă în detalii. Setarea inputType configurează suplimentar corectarea automată și sugestiile, în timp ce setTransformationMethod influențează doar afișarea caracterelor.

Exemplu de comutare a parolei prin TextInputLayout

// Comutarea programatică a vizibilității parolei
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
    }

    // Restaurarea poziției cursorului
    val cursorPos = editText.selectionStart
    editText.setSelection(maxOf(0, cursorPos))
}

TransformationMethod personalizat

// Mascare personalizată — arată doar ultimele 4 caractere
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?) {}
}

Aspecte de securitate ale introducerii ascunse

Secure Text Entry asigură protecție la mai multe niveluri. Mascarea vizuală previne citirea parolei peste umăr (shoulder surfing) — cea mai răspândită metodă de furt al parolelor în locuri publice. Dezactivarea corectării automate previne salvarea parolei în dicționarul utilizatorului, ceea ce exclude scurgerea acesteia prin introducerea predictivă. Protecția împotriva capturilor de ecran (dacă FLAG_SECURE este activat) nu permite altor aplicații să captureze conținutul câmpului.

Totuși Secure Text Entry nu este o protecție completă. Atacurile prin interceptarea introducerii (keylogging) la nivel de sistem pot obține caractere reale din InputConnection. Aplicațiile rău intenționate cu serviciu de accesibilitate pot citi conținutul EditText, chiar dacă caracterele sunt ascunse pe ecran. De asemenea, SSL-sniffing-ul la transmiterea datelor către server poate dezvălui parola dacă nu se utilizează HTTPS cu validarea corectă a certificatului.

Conform OWASP Mobile Security Testing Guide (2025), pentru protecția maximă a parolelor în Android se recomandă: utilizarea inputType="textPassword" + dezactivarea autofill pentru câmpurile critice; nu păstrați parola în memorie mai mult decât este necesar; goliți câmpul parolei la minimizarea aplicației (onPause/onStop); utilizați mascarea chiar și la afișarea temporară a parolei.

Cele mai bune practici Secure Text Entry

Dezvoltatorii Android ar trebui să respecte câteva practici cheie atunci când lucrează cu introducerea ascunsă. În primul rând, utilizați întotdeauna TextInputLayout cu endIconMode="password_toggle" pentru câmpurile de parolă — acesta este standardul modern Material Design. În al doilea rând, nu dezactivați posibilitatea de a afișa parola — utilizatorul trebuie să poată verifica ce a introdus, în special pe dispozitivele mobile cu tastatură mică.

Secure Text Entry necesită, de asemenea, configurarea corectă a completării automate. Pentru câmpurile de parolă, specificați neapărat autofillHints="password" sau autofillHints="newPassword" pentru ca managerii de parole să poată completa și salva corect datele. Pentru câmpul de confirmare a noii parole, utilizați autofillHints="newPassword" pentru ca sistemul să nu propună completarea acestuia cu parola curentă salvată.

• TextInputLayout — utilizați Material Design TextInputLayout cu endIconMode pentru comutatorul de vizibilitate.
• Autofill — adăugați autofillHints="password" și importantForAutofill="yes" pentru suportul managerilor.
• Golirea — goliți câmpul parolei la minimizarea aplicației (onPause/onStop).
• Lungimea — nu limitați prea strict lungimea parolei (minimum 8 caractere, fără un maxim rigid).
• Biometrie — oferiți autentificare biometrică (BiometricPrompt) ca alternativă la introducerea manuală a parolei.

// Câmp complet de parolă cu completare automată și curățare
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()
    }
}