Secure Text Entry — che cos'è, protezione dell'inserimento e password in Android

Cos'è Secure Text Entry in Android

Secure Text Entry (inserimento testo protetto) è una funzionalità Android che sostituisce la visualizzazione di ogni carattere inserito con un carattere di mascheratura, solitamente un punto (•) o un asterisco (*). Ciò impedisce la lettura della password sopra la spalla (shoulder surfing) e nasconde i dati inseriti da occhi indiscreti. Questa funzionalità è anche nota come mascheratura della password ed è una pratica standard nelle applicazioni mobili.

A differenza di iOS, dove Secure Text Entry è un'impostazione separata di UITextField, in Android questa funzionalità viene attivata tramite l'attributo inputType con la variazione PASSWORD. Quando un EditText riceve inputType="textPassword", applica automaticamente PasswordTransformationMethod — una classe responsabile della sostituzione dei caratteri. All'inserimento di ogni nuovo carattere, EditText lo sostituisce istantaneamente con un carattere di mascheratura attraverso il meccanismo dell'interfaccia TransformationMethod.

Secondo Android Source Code (AOSP, 2026), l'implementazione di PasswordTransformationMethod utilizza la classe TextPaint per renderizzare i caratteri di mascheratura. La dimensione del carattere di mascheratura corrisponde alla dimensione del carattere del campo, prevenendo perdite di informazioni attraverso la lunghezza della parola — tutti i caratteri appaiono identici in larghezza. Ciò è importante per la protezione contro attacchi basati sull'analisi della lunghezza dei dati inseriti.

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

Come funziona Secure Text Entry

Il meccanismo di Secure Text Entry in Android si basa sull'interfaccia TransformationMethod, definita nel pacchetto android.text.method. PasswordTransformationMethod è un'implementazione integrata che sovrascrive il metodo getTransformation(), restituendo una sequenza di caratteri sostituita per la visualizzazione. Il testo originale in Editable rimane invariato — solo la sua rappresentazione visiva viene modificata.

Quando un utente inserisce un carattere, EditText chiama dispatchEvent e passa il carattere a InputConnection, che lo aggiunge a Editable. Quindi EditText chiama il metodo getTransformation() del TransformationMethod corrente, che prende il CharSequence originale e restituisce uno SpannableString con caratteri di mascheratura. Questo SpannableString viene renderizzato sullo schermo invece del testo originale. La caratteristica principale è che la trasformazione stessa non modifica il contenuto di Editable, quindi chiamare getText().toString() restituisce il testo effettivamente inserito.

Secondo Android Developers Reference (2026), PasswordTransformationMethod aggiunge un MetricAffectingSpan a ogni carattere, che sostituisce il glifo con un punto. Questi span non influenzano la lunghezza del testo, quindi il cursore e la posizione di inserimento vengono preservati correttamente anche con visualizzazione nascosta. Esiste anche VisiblePasswordTransformationMethod, che mostra l'ultimo carattere inserito per un breve periodo (simile a iOS).

// PasswordTransformationMethod - built-in masking
editText.transformationMethod = PasswordTransformationMethod.getInstance()

// VisiblePasswordTransformationMethod - shows last char
editText.transformationMethod = VisiblePasswordTransformationMethod.getInstance()

Attivazione/disattivazione visibilità password

Attivazione/disattivazione visibilità (password visibility toggle) è una funzionalità che permette all'utente di mostrare temporaneamente la password inserita per verificarla prima di inviare il modulo. In Android, questa funzionalità è implementata tramite TextInputLayout con l'attributo app:endIconMode="password_toggle". Tocando l'icona dell'occhio, il campo passa tra textPassword e textVisiblePassword.

L'implementazione di password_toggle in TextInputLayout cambia automaticamente l'inputType dell'EditText interno e anima l'icona (occhio aperto/chiuso). È importante ricordare che durante questo passaggio la posizione del cursore potrebbe reimpostarsi, quindi TextInputLayout salva e ripristina la posizione dopo il cambio di modalità. Inoltre, quando si passa alla password visibile, la correzione automatica e i suggerimenti non vengono attivati — viene utilizzato TYPE_TEXT_VARIATION_VISIBLE_PASSWORD, non testo normale.

Secondo Material Design Guidelines (2025), l'icona di visualizzazione della password dovrebbe essere sempre visibile, non solo quando il campo è attivo. L'utente dovrebbe poter verificare la password in qualsiasi momento. L'icona non dovrebbe nascondere automaticamente la password dopo un certo tempo — solo su azione dell'utente.

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

Configurazione programmatica di Secure Text Entry

L'impostazione programmatica di Secure Text Entry in Kotlin viene effettuata impostando inputType o tramite setTransformationMethod(). Entrambi gli approcci portano allo stesso risultato ma differiscono nei dettagli. Impostare inputType configura anche la correzione automatica e i suggerimenti, mentre setTransformationMethod influisce solo sulla visualizzazione dei caratteri.

Esempio di attivazione/disattivazione password tramite TextInputLayout

// Programmatic password visibility toggle
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
    }

    // Restore cursor position
    val cursorPos = editText.selectionStart
    editText.setSelection(maxOf(0, cursorPos))
}

TransformationMethod personalizzato

// Custom masking — shows only last 4 chars
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?) {}
}

Aspetti di sicurezza dell'inserimento nascosto

Secure Text Entry fornisce protezione a più livelli. La mascheratura visiva impedisce la lettura della password sopra la spalla (shoulder surfing) — il metodo più comune di furto di password in luoghi pubblici. La disattivazione della correzione automatica impedisce il salvataggio della password nel dizionario dell'utente, eliminando le perdite attraverso l'input predittivo. La protezione dagli screenshot (se FLAG_SECURE è abilitato) impedisce ad altre applicazioni di catturare il contenuto del campo.

Tuttavia, Secure Text Entry non è una protezione completa. Gli attacchi tramite intercettazione dell'input (keylogging) a livello di sistema possono ottenere caratteri reali da InputConnection. Le applicazioni dannose con servizi di accessibilità possono leggere il contenuto di EditText anche se i caratteri sono nascosti sullo schermo. Inoltre, lo sniffing SSL durante la trasmissione dei dati al server può esporre la password se non viene utilizzato HTTPS con una corretta validazione del certificato.

Secondo OWASP Mobile Security Testing Guide (2025), per la massima protezione delle password in Android si raccomanda di: utilizzare inputType="textPassword" + disabilitare autofill per i campi critici; non memorizzare nella cache la password in memoria più del necessario; cancellare il campo password quando si minimizza l'applicazione (onPause/onStop); utilizzare la mascheratura anche durante la breve visualizzazione della password.

Best practice di Secure Text Entry

Gli sviluppatori Android dovrebbero seguire diverse pratiche chiave quando lavorano con l'input nascosto. Primo, usa sempre TextInputLayout con endIconMode="password_toggle" per i campi password — questo è lo standard moderno di Material Design. Secondo, non disabilitare la possibilità di mostrare la password — l'utente dovrebbe poter verificare ciò che ha inserito, specialmente su dispositivi mobili con tastiere piccole.

Secure Text Entry richiede anche una corretta configurazione del riempimento automatico. Per i campi password, specifica sempre autofillHints="password" o autofillHints="newPassword" in modo che i gestori di password possano compilare e salvare correttamente i dati. Per il campo di conferma della nuova password, usa autofillHints="newPassword" in modo che il sistema non suggerisca di compilarlo con la password salvata corrente.

• TextInputLayout — utilizza Material Design TextInputLayout con endIconMode per l'attivazione/disattivazione della visibilità.
• Autofill — aggiungi autofillHints="password" e importantForAutofill="yes" per il supporto dei gestori.
• Cancellazione — cancella il campo password quando minimizzi l'applicazione (onPause/onStop).
• Lunghezza — non limitare la lunghezza della password troppo rigidamente (minimo 8 caratteri, senza massimo rigido).
• Biometria — offri l'accesso biometrico (BiometricPrompt) come alternativa all'inserimento manuale della password.

// Full password field with autofill and cleanup
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()
    }
}