Secure Text Entry — qu'est-ce que c'est, protection de la saisie et mots de passe dans Android

Qu'est-ce que Secure Text Entry dans Android

Secure Text Entry (saisie de texte protégée) est une fonctionnalité Android qui remplace l'affichage de chaque caractère saisi par un caractère de masquage, généralement un point (•) ou un astérisque (*). Cela empêche la lecture du mot de passe par-dessus l'épaule (shoulder surfing) et cache les données saisies aux regards indiscrets. Cette fonctionnalité est également connue sous le nom de masquage de mot de passe et est une pratique standard dans les applications mobiles.

Contrairement à iOS, où Secure Text Entry est un paramètre séparé d'UITextField, dans Android, cette fonctionnalité est activée via l'attribut inputType avec la variante PASSWORD. Lorsqu'un EditText reçoit inputType="textPassword", il applique automatiquement PasswordTransformationMethod — une classe responsable du remplacement des caractères. Lors de la saisie de chaque nouveau caractère, EditText le remplace instantanément par un caractère de masquage via le mécanisme de l'interface TransformationMethod.

Selon Android Source Code (AOSP, 2026), l'implémentation de PasswordTransformationMethod utilise la classe TextPaint pour rendre les caractères de masquage. La taille du caractère de masquage correspond à la taille de police du champ, ce qui empêche les fuites d'informations via la longueur du mot — tous les caractères ont la même largeur. Ceci est important pour la protection contre les attaques basées sur l'analyse de la longueur des données saisies.

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

Comment fonctionne Secure Text Entry

Le mécanisme de Secure Text Entry dans Android est basé sur l'interface TransformationMethod, définie dans le paquetage android.text.method. PasswordTransformationMethod est une implémentation intégrée qui remplace la méthode getTransformation(), retournant une séquence de caractères remplacée pour l'affichage. Le texte original dans Editable reste inchangé — seule sa représentation visuelle est modifiée.

Lorsqu'un utilisateur saisit un caractère, EditText appelle dispatchEvent et transmet le caractère à InputConnection, qui l'ajoute à Editable. Ensuite, EditText appelle la méthode getTransformation() du TransformationMethod actuel, qui prend le CharSequence original et retourne un SpannableString avec des caractères de masquage. Ce SpannableString est rendu à l'écran à la place du texte original. La caractéristique clé est que la transformation elle-même ne modifie pas le contenu d'Editable, donc appeler getText().toString() retourne le texte réellement saisi.

Selon Android Developers Reference (2026), PasswordTransformationMethod ajoute un MetricAffectingSpan à chaque caractère, qui remplace le glyphe par un point. Ces spans n'affectent pas la longueur du texte, donc le curseur et la position de saisie sont correctement préservés même avec un affichage masqué. Il existe également VisiblePasswordTransformationMethod, qui affiche le dernier caractère saisi pendant une courte période (similaire à iOS).

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

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

Basculement de visibilité du mot de passe

Basculement de visibilité (password visibility toggle) est une fonctionnalité qui permet à l'utilisateur d'afficher temporairement le mot de passe saisi pour le vérifier avant d'envoyer le formulaire. Dans Android, cette fonctionnalité est implémentée via TextInputLayout avec l'attribut app:endIconMode="password_toggle". En touchant l'icône de l'œil, le champ bascule entre textPassword et textVisiblePassword.

L'implémentation de password_toggle dans TextInputLayout change automatiquement le inputType de l'EditText interne et anime l'icône (œil ouvert/fermé). Il est important de se rappeler que lors de ce basculement, la position du curseur peut se réinitialiser, donc TextInputLayout sauvegarde et restaure la position après le changement de mode. De plus, lors du basculement vers un mot de passe visible, la correction automatique et les suggestions ne sont pas activées — TYPE_TEXT_VARIATION_VISIBLE_PASSWORD est utilisé, pas le texte normal.

Selon Material Design Guidelines (2025), l'icône d'affichage du mot de passe doit toujours être visible, pas seulement lorsque le champ est actif. L'utilisateur doit pouvoir vérifier le mot de passe à tout moment. L'icône ne doit pas masquer automatiquement le mot de passe après un certain temps — seulement par action de l'utilisateur.

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

Configuration programmatique de Secure Text Entry

La configuration programmatique de Secure Text Entry dans Kotlin s'effectue en définissant inputType ou via setTransformationMethod(). Les deux approches mènent au même résultat mais diffèrent dans les détails. Définir inputType configure également la correction automatique et les suggestions, tandis que setTransformationMethod n'affecte que l'affichage des caractères.

Exemple de basculement de mot de passe via 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 personnalisé

// 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?) {}
}

Aspects de sécurité de la saisie masquée

Secure Text Entry offre une protection à plusieurs niveaux. Le masquage visuel empêche la lecture du mot de passe par-dessus l'épaule (shoulder surfing) — la méthode la plus courante de vol de mots de passe dans les lieux publics. La désactivation de la correction automatique empêche l'enregistrement du mot de passe dans le dictionnaire de l'utilisateur, éliminant les fuites via la saisie prédictive. La protection contre les captures d'écran (si FLAG_SECURE est activé) empêche d'autres applications de capturer le contenu du champ.

Cependant, Secure Text Entry n'est pas une protection complète. Les attaques par interception de saisie (keylogging) au niveau système peuvent obtenir les caractères réels depuis InputConnection. Les applications malveillantes avec des services d'accessibilité peuvent lire le contenu d'EditText même si les caractères sont masqués à l'écran. De plus, l'interception SSL lors de la transmission des données au serveur peut exposer le mot de passe si HTTPS avec validation appropriée du certificat n'est pas utilisé.

Selon OWASP Mobile Security Testing Guide (2025), pour une protection maximale des mots de passe dans Android, il est recommandé de : utiliser inputType="textPassword" + désactiver autofill pour les champs critiques ; ne pas mettre en cache le mot de passe en mémoire plus longtemps que nécessaire ; effacer le champ de mot de passe lors de la minimisation de l'application (onPause/onStop) ; utiliser le masquage même lors de l'affichage bref du mot de passe.

Bonnes pratiques de Secure Text Entry

Les développeurs Android doivent suivre plusieurs pratiques essentielles lorsqu'ils travaillent avec la saisie masquée. Premièrement, utilisez toujours TextInputLayout avec endIconMode="password_toggle" pour les champs de mot de passe — c'est la norme moderne de Material Design. Deuxièmement, ne désactivez pas la possibilité d'afficher le mot de passe — l'utilisateur doit pouvoir vérifier ce qu'il a saisi, surtout sur les appareils mobiles avec de petits claviers.

Secure Text Entry nécessite également une configuration appropriée du remplissage automatique. Pour les champs de mot de passe, spécifiez toujours autofillHints="password" ou autofillHints="newPassword" afin que les gestionnaires de mots de passe puissent remplir et sauvegarder correctement les données. Pour le champ de confirmation du nouveau mot de passe, utilisez autofillHints="newPassword" pour que le système ne suggère pas de le remplir avec le mot de passe actuel enregistré.

• TextInputLayout — utilisez Material Design TextInputLayout avec endIconMode pour le basculement de visibilité.
• Autofill — ajoutez autofillHints="password" et importantForAutofill="yes" pour la prise en charge des gestionnaires.
• Nettoyage — effacez le champ de mot de passe lors de la minimisation de l'application (onPause/onStop).
• Longueur — ne limitez pas trop strictement la longueur du mot de passe (minimum 8 caractères, sans maximum strict).
• Biométrie — proposez la connexion biométrique (BiometricPrompt) comme alternative à la saisie manuelle du mot de passe.

// 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()
    }
}