Secure Text Entry — o que é, proteção de entrada e senhas no Android

O que é Secure Text Entry no Android

Secure Text Entry (entrada de texto protegida) é um recurso do Android que substitui a exibição de cada caractere digitado por um caractere de mascaramento, geralmente um ponto (•) ou asterisco (*). Isso impede a leitura de senhas por cima do ombro (shoulder surfing) e oculta os dados digitados de olhares indiscretos. Esse recurso também é conhecido como mascaramento de senha e é uma prática padrão em aplicativos móveis.

Ao contrário do iOS, onde o Secure Text Entry é uma configuração separada do UITextField, no Android esse recurso é ativado através do atributo inputType com a variação PASSWORD. Quando um EditText recebe inputType="textPassword", ele aplica automaticamente o PasswordTransformationMethod — uma classe responsável pela substituição de caracteres. Ao digitar cada novo caractere, o EditText o substitui instantaneamente por um caractere de mascaramento através do mecanismo da interface TransformationMethod.

De acordo com Android Source Code (AOSP, 2026), a implementação do PasswordTransformationMethod usa a classe TextPaint para renderizar os caracteres de mascaramento. O tamanho do caractere de mascaramento corresponde ao tamanho da fonte do campo, evitando vazamento de informação através do comprimento da palavra — todos os caracteres têm a mesma largura. Isso é importante para proteção contra ataques baseados na análise do comprimento dos dados inseridos.

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

Como funciona o Secure Text Entry

O mecanismo de Secure Text Entry no Android é baseado na interface TransformationMethod, definida no pacote android.text.method. O PasswordTransformationMethod é uma implementação embutida que sobrescreve o método getTransformation(), retornando uma sequência de caracteres substituída para exibição. O texto original no Editable permanece inalterado — apenas sua representação visual é modificada.

Quando um usuário digita um caractere, o EditText chama dispatchEvent e passa o caractere para o InputConnection, que o adiciona ao Editable. Em seguida, o EditText chama o método getTransformation() do TransformationMethod atual, que recebe o CharSequence original e retorna um SpannableString com caracteres de mascaramento. Este SpannableString é renderizado na tela em vez do texto original. A principal característica é que a transformação em si não altera o conteúdo do Editable, então chamar getText().toString() retorna o texto real digitado.

De acordo com Android Developers Reference (2026), o PasswordTransformationMethod adiciona um MetricAffectingSpan a cada caractere, que substitui o glifo por um ponto. Esses spans não afetam o comprimento do texto, portanto o cursor e a posição de entrada são preservados corretamente mesmo com exibição oculta. Existe também o VisiblePasswordTransformationMethod, que exibe o último caractere digitado por um curto período (semelhante ao iOS).

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

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

Alternância de visibilidade de senha

Alternância de visibilidade (password visibility toggle) é um recurso que permite ao usuário mostrar temporariamente a senha digitada para verificá-la antes de enviar o formulário. No Android, esse recurso é implementado através do TextInputLayout com o atributo app:endIconMode="password_toggle". Ao tocar no ícone de olho, o campo alterna entre textPassword e textVisiblePassword.

A implementação de password_toggle no TextInputLayout altera automaticamente o inputType do EditText interno e anima o ícone (olho aberto/fechado). É importante lembrar que durante essa alternância a posição do cursor pode ser redefinida, então o TextInputLayout salva e restaura a posição após a mudança de modo. Além disso, ao alternar para senha visível, a autocorreção e as sugestões não são ativadas — é usado TYPE_TEXT_VARIATION_VISIBLE_PASSWORD, não texto comum.

De acordo com Material Design Guidelines (2025), o ícone de mostrar senha deve estar sempre visível, não apenas quando o campo está em foco. O usuário deve ser capaz de verificar a senha a qualquer momento. O ícone não deve ocultar automaticamente a senha após um determinado tempo — apenas por ação do usuário.

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

Configuração programática do Secure Text Entry

A configuração programática do Secure Text Entry em Kotlin é feita definindo inputType ou através de setTransformationMethod(). Ambas as abordagens levam ao mesmo resultado, mas diferem em detalhes. Definir inputType também configura a autocorreção e as sugestões, enquanto setTransformationMethod afeta apenas a exibição de caracteres.

Exemplo de alternância de senha 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 personalizado

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

Aspectos de segurança da entrada oculta

O Secure Text Entry fornece proteção em vários níveis. O mascaramento visual impede a leitura de senhas por cima do ombro (shoulder surfing) — o método mais comum de roubo de senhas em locais públicos. Desabilitar a autocorreção impede que a senha seja salva no dicionário do usuário, eliminando vazamentos através de entrada preditiva. A proteção contra capturas de tela (se FLAG_SECURE estiver ativado) impede que outros aplicativos capturem o conteúdo do campo.

No entanto, o Secure Text Entry não é uma proteção completa. Ataques através de interceptação de entrada (keylogging) em nível de sistema podem obter caracteres reais do InputConnection. Aplicativos maliciosos com serviços de acessibilidade podem ler o conteúdo do EditText mesmo que os caracteres estejam ocultos na tela. Além disso, a interceptação SSL durante a transmissão de dados para o servidor pode expor a senha se HTTPS com validação adequada de certificado não for usado.

De acordo com OWASP Mobile Security Testing Guide (2025), para máxima proteção de senhas no Android é recomendado: usar inputType="textPassword" + desativar autofill para campos críticos; não armazenar em cache a senha na memória por mais tempo que o necessário; limpar o campo de senha ao minimizar o aplicativo (onPause/onStop); usar mascaramento mesmo durante a exibição breve da senha.

Melhores práticas do Secure Text Entry

Os desenvolvedores Android devem seguir várias práticas essenciais ao trabalhar com entrada oculta. Primeiro, sempre use TextInputLayout com endIconMode="password_toggle" para campos de senha — este é o padrão moderno do Material Design. Segundo, não desabilite a capacidade de mostrar a senha — o usuário deve poder verificar o que digitou, especialmente em dispositivos móveis com teclados pequenos.

O Secure Text Entry também requer configuração adequada de preenchimento automático. Para campos de senha, sempre especifique autofillHints="password" ou autofillHints="newPassword" para que gerenciadores de senhas possam preencher e salvar dados corretamente. Para o campo de confirmação de nova senha, use autofillHints="newPassword" para que o sistema não sugira preenchê-lo com a senha salva atual.

• TextInputLayout — use Material Design TextInputLayout com endIconMode para alternância de visibilidade.
• Autofill — adicione autofillHints="password" e importantForAutofill="yes" para suporte a gerenciadores.
• Limpeza — limpe o campo de senha ao minimizar o aplicativo (onPause/onStop).
• Comprimento — não restrinja o comprimento da senha muito estritamente (mínimo 8 caracteres, sem máximo rígido).
• Biometria — ofereça login biométrico (BiometricPrompt) como alternativa à digitação manual de senha.

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