security - todas - Deshabilitar la funcionalidad ''Guardar contraseña'' del navegador
como olvidar contraseña (30)
Una de las alegrías de trabajar para una agencia gubernamental de atención médica es tener que lidiar con toda la paranoia relacionada con el tratamiento de la PHI (información de salud protegida). No me malinterprete, estoy a favor de hacer todo lo posible para proteger la información personal de las personas (salud, finanzas, hábitos de navegación, etc.), pero a veces las personas se ponen demasiado nerviosas.
Caso en cuestión: uno de nuestros clientes del estado descubrió recientemente que el navegador ofrece la característica útil para guardar su contraseña. Todos sabemos que ha estado allí por un tiempo y que es completamente opcional y que el usuario final es quien decide si es una decisión inteligente o no. Sin embargo, hay un poco de alboroto en este momento y se nos exige encontrar una manera de deshabilitar esa funcionalidad para nuestro sitio.
Pregunta : ¿Hay una manera para que un sitio le diga al navegador que no ofrezca recordar las contraseñas? He estado alrededor del desarrollo web durante mucho tiempo, pero no sé que he encontrado eso antes.
Cualquier ayuda es apreciada.
¿Hay una manera para que un sitio le diga al navegador que no ofrezca recordar las contraseñas?
El sitio web le dice al navegador que es una contraseña usando <input type="password">. Entonces, si debe hacer esto desde la perspectiva de un sitio web, entonces tendría que cambiar eso. (Obviamente no lo recomiendo).
La mejor solución sería que el usuario configure su navegador para que no recuerde las contraseñas.
Bueno, es un post muy antiguo, pero aún así daré mi solución, que mi equipo había estado tratando de lograr durante mucho tiempo. Acabamos de agregar un nuevo campo de entrada de tipo = "contraseña" dentro del formulario y lo envolvimos en div e hicimos el div oculto. Asegúrese de que esta div es antes de la entrada de contraseña real. Esto funcionó para nosotros y no dio ninguna opción de Guardar contraseña
Plunk - http://plnkr.co/edit/xmBR31NQMUgUhYHBiZSg?p=preview
HTML:
<form method="post" action="yoururl">
<div class="hidden">
<input type="password"/>
</div>
<input type="text" name="username" placeholder="username"/>
<input type="password" name="password" placeholder="password"/>
</form>
CSS:
.hidden {display:none;}
Debido a que autocomplete = "off" no funciona para los campos de contraseña, uno debe confiar en javascript. Aquí hay una solución simple basada en las respuestas que se encuentran aquí.
Agregue el atributo data-password-autocomplete = "off" a su campo de contraseña:
<input type="password" data-password-autocomplete="off">
Incluya los siguientes JS:
$(function(){
$(''[data-password-autocomplete="off"]'').each(function() {
$(this).prop(''type'', ''text'');
$(''<input type="password"/>'').hide().insertBefore(this);
$(this).focus(function() {
$(this).prop(''type'', ''password'');
});
});
});
Esta solución funciona tanto para Chrome como para FF.
El problema real es mucho más profundo que simplemente agregar atributos a su HTML: este es un problema de seguridad común, por eso la gente inventó las claves de hardware y otras cosas locas para la seguridad.
Imagina que tienes autocompletado = "off" funcionando perfectamente en todos los navegadores. ¿Eso ayudaría con la seguridad? Claro que no. Los usuarios escribirán sus contraseñas en los libros de texto, en las pegatinas pegadas en su monitor, donde cada visitante de la oficina puede verlas, guardarlas en archivos de texto en el escritorio, etc.
En general, la aplicación web y el desarrollador web no son responsables de ninguna manera por la seguridad del usuario final. Los usuarios finales solo pueden protegerse a sí mismos. Idealmente, DEBEN mantener todas las contraseñas en su cabeza y usar la función de restablecimiento de contraseña (o contactar al administrador) en caso de que la hayan olvidado. De lo contrario, siempre habrá un riesgo de que la contraseña pueda ser vista y robada de alguna manera.
Entonces, o bien tiene una política de seguridad loca con claves de hardware (como, algunos bancos ofrecen servicios de banca por Internet que básicamente emplean autenticación de dos factores) o Básicamente NO HAY SEGURIDAD. Bueno, esto es un poco exagerado, por supuesto. Es importante entender contra qué está tratando de protegerse:
- Acceso no autorizado. Básicamente el formulario de inicio de sesión más simple. A veces se toman medidas adicionales, como preguntas de seguridad aleatorias, CAPTCHA, endurecimiento de la contraseña, etc.
- Credencial sniffing. HTTPS es OBLIGATORIO si las personas acceden a su aplicación web desde puntos de acceso Wi-Fi públicos, etc. Mencione que incluso con HTTPS, sus usuarios necesitan cambiar sus contraseñas regularmente.
- Ataque interno. Hay dos muchos ejemplos de esto, comenzando por el simple robo de sus contraseñas del navegador o las que ha anotado en algún lugar de la mesa (no requiere ninguna habilidad de TI) y termina con la falsificación de sesiones e intercepción del tráfico de la red local (incluso encriptado) y además acceder a la aplicación web como si fuera otro usuario final.
En esta publicación en particular, puedo ver los requisitos inadecuados que el desarrollador no puede resolver debido a la naturaleza del problema: la seguridad del usuario final. Mi punto subjetivo es que el desarrollador básicamente debería decir NO y señalar el problema de los requisitos en lugar de perder el tiempo en esas tareas, honestamente. Esto no hace que su sistema sea más seguro, sino que conducirá a los estuches con adhesivos en los monitores. Desafortunadamente, algunos jefes solo escuchan lo que quieren escuchar. Sin embargo, si fuera usted, trataría de explicar de dónde proviene el problema real, y que autocomplete = "off" no lo resolvería a menos que obligue a los usuarios a mantener todas sus contraseñas exclusivamente en su cabeza. El desarrollador en su extremo no puede proteger completamente a los usuarios, los usuarios necesitan saber cómo usar el sistema y al mismo tiempo no exponen su información sensible / segura y esto va más allá de la autenticación.
En realidad, no: lo único que podría hacer es ofrecer consejos sobre el sitio; quizás, antes de iniciar sesión por primera vez, podría mostrarles un formulario con información que indique que no se recomienda que permitan que el navegador almacene la contraseña.
Luego, el usuario seguirá inmediatamente el consejo, anotará la contraseña en una nota post-it y la pegará en su monitor.
Enfrentando el mismo problema de HIPAA y encontré una solución relativamente fácil,
Cree un campo de contraseña oculto con el nombre del campo como una matriz.
<input type="password" name="password[]" style="display:none" />Utilice la misma matriz para el campo de contraseña real.
<input type="password" name="password[]" />
El navegador (Chrome) puede pedirle que "Guardar contraseña", pero sin importar si el usuario selecciona guardar, la próxima vez que inicie sesión, la contraseña completará automáticamente el campo de contraseña oculta, la ranura cero en la matriz, dejando la primera ranura en blanco.
Intenté definir la matriz, como "contraseña [parte 2]", pero aún así lo recordaba. Creo que lo tira fuera si es una matriz no indexada porque no tiene más remedio que dejarla caer en el primer lugar.
Luego, utiliza el lenguaje de programación de su elección para acceder a la matriz, PHP por ejemplo,
echo $_POST[''password''][1];
Había estado luchando con este problema por un tiempo, con un giro único al problema. Los usuarios privilegiados no podían hacer que las contraseñas guardadas funcionaran para ellos, pero los usuarios normales lo necesitaban. Esto significaba que los usuarios privilegiados tenían que iniciar sesión dos veces, la segunda vez que no se hacían contraseñas guardadas.
Con este requisito, el método estándar autocomplete="off" no funciona en todos los navegadores, ya que la contraseña puede haberse guardado desde el primer inicio de sesión. Un colega encontró una solución para reemplazar el campo de contraseña cuando estaba enfocado con un nuevo campo de contraseña, y luego enfocarse en el nuevo campo de contraseña (luego conectar el mismo controlador de eventos). Esto funcionó (excepto que causó un bucle infinito en IE6). Tal vez había una forma de evitar eso, pero me estaba causando una migraña.
Finalmente, intenté tener el nombre de usuario y la contraseña fuera del formulario. Para mi sorpresa, esto funcionó! Funcionó en IE6, y las versiones actuales de Firefox y Chrome en Linux. No lo he probado más, pero sospecho que funciona en la mayoría si no en todos los navegadores (pero no me sorprendería si hubiera un navegador por ahí que no importara si no existía un formulario).
Aquí hay un código de ejemplo, junto con algunos jQuery para que funcione:
<input type="text" id="username" name="username"/>
<input type="password" id="password" name="password"/>
<form id="theForm" action="/your/login" method="post">
<input type="hidden" id="hiddenUsername" name="username"/>
<input type="hidden" id="hiddenPassword" name="password"/>
<input type="submit" value="Login"/>
</form>
<script type="text/javascript" language="JavaScript">
$("#theForm").submit(function() {
$("#hiddenUsername").val($("#username").val());
$("#hiddenPassword").val($("#password").val());
});
$("#username,#password").keypress(function(e) {
if (e.which == 13) {
$("#theForm").submit();
}
});
</script>
He intentado por encima de autocomplete="off" y, sin embargo, todo éxito. Si está usando js angular, mi recomendación es ir con el botón y hacer clic con el botón derecho.
<button type="button" class="" ng-click="vm.login()" />
Esto ya tiene una respuesta aceptada. Si agrego esto, si alguien no puede resolver el problema con la respuesta aceptada, puede usar mi mecanismo.
Gracias por la pregunta y las respuestas.
He probado muchas soluciones. Nombre de campo de contraseña dinámica, campos de contraseña múltiple (invisibles para falsos), cambio de tipo de entrada de "texto" a "contraseña", autocompletar = "apagado", autocompletar = "nueva-contraseña", ... pero nada lo resolvió con reciente navegador.
Para deshacerse de la contraseña, recuerde que finalmente traté la contraseña como un campo de entrada y "difuminé" el texto escrito.
Es menos "seguro" que un campo de contraseña nativo ya que seleccionar el texto escrito lo mostraría como texto claro, pero no se recuerda la contraseña. También depende de tener Javascript activado.
Tendrá que estimar el riesgo de utilizar la opción de recordar propuesta y contraseña a continuación del navegador.
Si bien el usuario puede administrar (recordar por sitio) la contraseña recordada, está bien para una computadora personal, no para una computadora "pública" o compartida.
En mi caso, es para un ERP que se ejecuta en computadoras compartidas, así que intentaré mi solución a continuación.
<input style="background-color: rgb(239, 179, 196); color: black; text-shadow: none;" name="password" size="10" maxlength="30" onfocus="this.value='''';this.style.color=''black''; this.style.textShadow=''none'';" onkeypress="this.style.color=''transparent''; this.style.textShadow=''1px 1px 6px green'';" autocomplete="off" type="text">
He probado que agregar autocomplete = "off" en la etiqueta de formulario en todos los navegadores principales. De hecho, la mayoría de los pueblos de EE. UU. Utilizan IE8 hasta el momento.
- IE8, IE9, IE10, Firefox, Safari funcionan bien.
El navegador no pregunta "guardar contraseña". Además, el nombre de usuario y la contraseña previamente guardados no están completos.
- Chrome e IE 11 no admiten la función autocompletar = "off"
- FF soportando el autocompletado = "off". pero a veces las credenciales guardadas existentes se llenan.
Actualizado el 11 de junio de 2014
Finalmente, a continuación se muestra una solución de navegador cruzado que usa javascript y funciona bien en todos los navegadores.
Necesidad de eliminar la etiqueta "formulario" en el formulario de inicio de sesión. Después de la validación del lado del cliente, ponga esas credenciales en forma oculta y envíelas.
Además, agregue dos métodos. una para la validación "validateLogin ()" y otra para escuchar el evento ingrese mientras hace clic en ingresar en el cuadro de texto / contraseña / botón "checkAndSubmit ()". porque ahora el formulario de inicio de sesión no tiene una etiqueta de formulario, así que ingrese el evento que no funciona aquí.
HTML
<form id="HiddenLoginForm" action="" method="post">
<input type="hidden" name="username" id="hidden_username" />
<input type="hidden" name="password" id="hidden_password" />
</form>
Username: <input type="text" name="username" id="username" onKeyPress="return checkAndSubmit(event);" />
Password: <input type="text" name="password" id="password" onKeyPress="return checkAndSubmit(event);" />
<input type="button" value="submit" onClick="return validateAndLogin();" onKeyPress="return checkAndSubmit(event);" />
Javascript
//For validation- you can modify as you like
function validateAndLogin(){
var username = document.getElementById("username");
var password = document.getElementById("password");
if(username && username.value == ''''){
alert("Please enter username!");
return false;
}
if(password && password.value == ''''){
alert("Please enter password!");
return false;
}
document.getElementById("hidden_username").value = username.value;
document.getElementById("hidden_password").value = password.value;
document.getElementById("HiddenLoginForm").submit();
}
//For enter event
function checkAndSubmit(e) {
if (e.keyCode == 13) {
validateAndLogin();
}
}
¡¡¡Buena suerte!!!
La forma más limpia es usar el atributo de etiqueta autocomplete="off" pero Firefox no lo obedece correctamente cuando cambias los campos con Tab.
La única forma en que podría detener esto es agregar un campo de contraseña oculta falsa que engaña al navegador para rellenar la contraseña allí.
<input type="text" id="username" name="username"/>
<input type="password" id="prevent_autofill" autocomplete="off" style="display:none" tabindex="-1" />
<input type="password" id="password" autocomplete="off" name="password"/>
Es un truco feo, porque cambias el comportamiento del navegador, lo que debería considerarse una mala práctica. Úsalo solo si realmente lo necesitas.
Nota: esto detendrá la autocompletar automáticamente la contraseña, ya que FF "guardará" el valor de #prevent_autofill (que está vacío) e intentará rellenar las contraseñas guardadas allí, ya que siempre usa la primera entrada type="password" que encuentra en DOM después de la respectiva entrada de "nombre de usuario".
La forma más sencilla de resolver este problema es colocar los campos de ENTRADA fuera de la etiqueta FORM y agregar dos campos ocultos dentro de la etiqueta FORM. Luego, en un detector de eventos de envío antes de que los datos del formulario se envíen al servidor, copie los valores de la entrada visible a los invisibles.
Aquí hay un ejemplo (no puede ejecutarlo aquí, ya que la acción de formulario no está configurada para un script de inicio de sesión real):
<!doctype html>
<html>
<head>
<title>Login & Save password test</title>
<meta charset="utf-8">
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js"></script>
</head>
<body>
<!-- the following fields will show on page, but are not part of the form -->
<input class="username" type="text" placeholder="Username" />
<input class="password" type="password" placeholder="Password" />
<form id="loginForm" action="login.aspx" method="post">
<!-- thw following two fields are part of the form, but are not visible -->
<input name="username" id="username" type="hidden" />
<input name="password" id="password" type="hidden" />
<!-- standard submit button -->
<button type="submit">Login</button>
</form>
<script>
// attache a event listener which will get called just before the form data is sent to server
$(''form'').submit(function(ev) {
console.log(''xxx'');
// read the value from the visible INPUT and save it to invisible one
// ... so that it gets sent to the server
$(''#username'').val($(''.username'').val());
$(''#password'').val($(''.password'').val());
});
</script>
</body>
</html>
Lo que he estado haciendo es una combinación de autocomplete = "off" y borrar los campos de contraseña usando un javascript / jQuery.
jQuery Ejemplo:
$(function() {
$(''#PasswordEdit'').attr("autocomplete", "off");
setTimeout(''$("#PasswordEdit").val("");'', 50);
});
Al usar setTimeout() , puede esperar a que el navegador complete el campo antes de borrarlo, de lo contrario, el navegador siempre se completará automáticamente una vez que haya borrado el campo.
Markus planteó un gran punto. Decidí buscar el atributo autocomplete y obtuve lo siguiente:
El único inconveniente de usar este atributo es que no es estándar (funciona en los navegadores IE y Mozilla) y causaría que la validación de XHTML fallara. Sin embargo, creo que este es un caso en el que es razonable romper la validación. ( source )
Así que debo decir que, aunque no funciona al 100% en general, se maneja en los principales navegadores, por lo que es una gran solución.
Mi solución js (jquery) es cambiar el tipo de ingreso de contraseña al texto en el formulario enviado . La contraseña podría hacerse visible por un segundo, así que también oculto la entrada justo antes de eso. Preferiría no usar esto para formularios de inicio de sesión , pero es útil (junto con autocomplete = "off"), por ejemplo, dentro de la parte de administración del sitio web.
Intente colocar esto dentro de una consola (con jquery), antes de enviar el formulario.
$(''form'').submit(function(event) {
$(this).find(''input[type=password]'').css(''visibility'', ''hidden'').attr(''type'', ''text'');
});
Probado en Chrome 44.0.2403.157 (64 bits).
No estoy seguro de si funcionará en todos los navegadores, pero debería intentar configurar autocomplete = "off" en el formulario.
<form id="loginForm" action="login.cgi" method="post" autocomplete="off">
La forma más fácil y sencilla de deshabilitar los avisos de almacenamiento de Formulario y Contraseña y evitar que los datos del formulario se almacenen en caché en el historial de la sesión es utilizar el atributo de elemento de formulario autocompletado con el valor "desactivado".
De http://developer.mozilla.org/En/How_to_Turn_Off_Form_Autocompletion
Algunas investigaciones menores muestran que esto funciona en IE pero no dejaré garantías;)
@Joseph : si es un requisito estricto pasar la validación XHTML con el marcado real (aunque no sé por qué lo sería), teóricamente podría agregar este atributo con javascript pero luego los usuarios con js deshabilitados (probablemente una cantidad despreciable de su base de usuarios) o cero si su sitio requiere js) todavía se guardarán sus contraseñas.
Ejemplo con jQuery:
$(''#loginForm'').attr(''autocomplete'', ''off'');
Puede evitar que el navegador coincida con los formularios al azar el nombre utilizado para el campo de contraseña en cada programa. Luego, el navegador ve una contraseña para la misma URL, pero no puedo estar seguro de que sea la misma contraseña . Tal vez es controlar algo más.
Actualización: tenga en cuenta que esto debe ser además del uso de autocompletar u otras tácticas, no un reemplazo para ellos, por las razones indicadas por otros.
También tenga en cuenta que esto solo evitará que el navegador complete automáticamente la contraseña. No evitará que almacene la contraseña en cualquier nivel de seguridad arbitraria que el navegador elija utilizar.
Solo para que la gente se dé cuenta: el atributo "autocompletar" funciona la mayor parte del tiempo, pero los usuarios avanzados pueden sortearlo utilizando un bookmarklet.
Tener un navegador que guarde sus contraseñas en realidad aumenta la protección contra el registro de teclas, por lo que posiblemente la opción más segura es guardar las contraseñas en el navegador pero protegerlas con una contraseña maestra (al menos en Firefox).
Solo usa
readonly onfocus = "this.removeAttribute (''readonly'');"
además de
autocompletar = "apagado"
a la (s) entrada (s) que no desea recordar los datos del formulario ( username , password , etc.) como se muestra a continuación:
<input type="text" name="UserName" autocomplete="off" readonly
onfocus="this.removeAttribute(''readonly'');" >
<input type="password" name="Password" autocomplete="off" readonly
onfocus="this.removeAttribute(''readonly'');" >
Probado en las últimas versiones de los principales navegadores, como Google Chrome , Mozilla Firefox , Microsoft Edge , etc., y funciona como un encanto. Espero que esto ayude...
Tengo un trabajo alrededor, que puede ayudar.
Podrías hacer un hack de fuente personalizado. Entonces, haz una fuente personalizada, con todos los caracteres como un punto / círculo / estrella, por ejemplo. Utilice esto como una fuente personalizada para su sitio web. Compruebe cómo hacer esto en inkscape: cómo hacer su propia fuente
Luego en su sesión en forma de uso:
<form autocomplete=''off'' ...>
<input type="text" name="email" ...>
<input type="text" name="password" class="password" autocomplete=''off'' ...>
<input type=submit>
</form>
Luego agrega tu css:
@font-face {
font-family: ''myCustomfont'';
src: url(''myCustomfont.eot'');
src: url(''myCustomfont?#iefix'') format(''embedded-opentype''),
url(''myCustomfont.woff'') format(''woff''),
url(''myCustomfont.ttf'') format(''truetype''),
url(''myCustomfont.svg#myCustomfont'') format(''svg'');
font-weight: normal;
font-style: normal;
}
.password {
font-family:''myCustomfont'';
}
Bastante cross browser compatible. He probado IE6 +, FF, Safari y Chrome. Solo asegúrese de que la fuente oet que convierte no se corrompa. ¿Espero eso ayude?
Una forma que conozco es usar (por ejemplo) JavaScript para copiar el valor fuera del campo de contraseña antes de enviar el formulario.
El principal problema con esto es que la solución está vinculada a JavaScript.
Por otra parte, si puede vincularse a JavaScript, también puede enviar la contraseña en el lado del cliente antes de enviar una solicitud al servidor.
Utilice la autenticación real de dos factores para evitar la dependencia exclusiva de las contraseñas que pueden almacenarse en muchos más lugares que la memoria caché del navegador del usuario.
si autocomplete = "off" no funciona ... elimine la etiqueta del formulario y use una etiqueta div en su lugar, luego pase los valores del formulario usando jquery al servidor. Esto funcionó para mí.
No he tenido ningún problema con este método:
Use autocomplete = "off", agregue un campo de contraseña oculta y luego otro no oculto. El navegador intenta completar automáticamente el oculto si no respeta autocompletar = "off"
autocomplete = "off" no funciona para deshabilitar el administrador de contraseñas en Firefox 31 y probablemente tampoco en algunas versiones anteriores.
Consulte la discusión en mozilla sobre este tema: bugzilla.mozilla.org/show_bug.cgi?id=956906
Queríamos usar un segundo campo de contraseña para ingresar una contraseña de un solo uso generada por un token. Ahora estamos usando una entrada de texto en lugar de una entrada de contraseña. :-(
Dado que la mayoría de las autocompletesugerencias, incluyendo la respuesta aceptada, no funcionan en los navegadores web de hoy en día (es decir, administradores de contraseñas del navegador ignoran autocomplete), una solución más novedosa es intercambiar entre passwordy texttipos y hacer que el color de fondo que coincida con el color del texto cuando el campo es un campo de texto sin formato, que continúa ocultando la contraseña mientras es un campo de contraseña real cuando el usuario (o un programa como KeePass) ingresa una contraseña. Los navegadores no solicitan guardar contraseñas que se almacenan en campos de texto sin formato.
La ventaja de este enfoque es que permite una mejora progresiva y, por lo tanto, no requiere Javascript para que un campo funcione como un campo de contraseña normal (también podría comenzar con un campo de texto sin formato y aplicar el mismo enfoque, pero eso no es realmente HIPAA Compatible con PHI / PII). Este enfoque tampoco depende de formularios / campos ocultos que no necesariamente se envíen al servidor (porque están ocultos) y algunos de esos trucos tampoco funcionan en varios navegadores modernos.
plugin jQuery:
Código fuente relevante del enlace anterior:
(function($) {
$.fn.StopPasswordManager = function() {
return this.each(function() {
var $this = $(this);
$this.addClass(''no-print'');
$this.attr(''data-background-color'', $this.css(''background-color''));
$this.css(''background-color'', $this.css(''color''));
$this.attr(''type'', ''text'');
$this.attr(''autocomplete'', ''off'');
$this.focus(function() {
$this.attr(''type'', ''password'');
$this.css(''background-color'', $this.attr(''data-background-color''));
});
$this.blur(function() {
$this.css(''background-color'', $this.css(''color''));
$this.attr(''type'', ''text'');
$this[0].selectionStart = $this[0].selectionEnd;
});
$this.on(''keydown'', function(e) {
if (e.keyCode == 13)
{
$this.css(''background-color'', $this.css(''color''));
$this.attr(''type'', ''text'');
$this[0].selectionStart = $this[0].selectionEnd;
}
});
});
}
}(jQuery));
Manifestación:
https://barebonescms.com/demos/admin_pack/admin.php
Haga clic en "Agregar entrada" en el menú y luego desplácese hasta la parte inferior de la página hasta "Módulo: Detener el Administrador de contraseña".
Descargo de responsabilidad: si bien este enfoque funciona para personas videntes, puede haber problemas con el software del lector de pantalla. Por ejemplo, un lector de pantalla puede leer la contraseña del usuario en voz alta porque ve un campo de texto sin formato. También puede haber otras consecuencias imprevistas de usar el complemento anterior. La modificación de la funcionalidad incorporada del navegador web debe hacerse con moderación al probar una amplia variedad de condiciones y casos extremos.
Otra solución es hacer que el POST utilice un formulario oculto donde todas las entradas sean de tipo oculto. La forma visible utilizará la entrada de tipo "contraseña". La última forma nunca se enviará y, por lo tanto, el navegador no puede interceptar en absoluto la operación de inicio de sesión.
Se me asignó una tarea similar para deshabilitar el autocompletado del nombre de inicio de sesión y las contraseñas en el navegador, después de muchas pruebas y errores, encontré que la solución a continuación es óptima. Simplemente agregue los controles a continuación antes de sus controles originales.
<input type="text" style="display:none">
<input type="text" name="OriginalLoginTextBox">
<input type="password" style="display:none">
<input type="text" name="OriginalPasswordTextBox">
Esto funciona bien para IE11 y Chrome 44.0.2403.107
Si no desea confiar en el indicador de autocompletar, puede asegurarse de que el usuario escribe en el cuadro usando el evento onchange. El siguiente código es un simple formulario HTML. El elemento de formulario oculto password_edited comienza establecido en 0. Cuando se cambia el valor de la contraseña, el JavaScript en la parte superior (función pw_edited) cambia el valor a 1. Cuando se presiona el botón, verifica el código del centro de valor aquí antes de enviar el formulario . De esa manera, incluso si el navegador lo ignora y autocompleta el campo, el usuario no puede pasar la página de inicio de sesión sin escribir el campo de contraseña. Además, asegúrese de dejar en blanco el campo de contraseña cuando se establece el enfoque. De lo contrario, puede agregar un carácter al final, luego retroceder y eliminarlo para engañar al sistema. Recomiendo agregar autocomplete = "off" a la contraseña además, pero este ejemplo muestra cómo funciona el código de respaldo.
<html>
<head>
<script>
function pw_edited() {
document.this_form.password_edited.value = 1;
}
function pw_blank() {
document.this_form.password.value = "";
}
function submitf() {
if(document.this_form.password_edited.value < 1) {
alert("Please Enter Your Password!");
}
else {
document.this_form.submit();
}
}
</script>
</head>
<body>
<form name="this_form" method="post" action="../../cgi-bin/yourscript.cgi?login">
<div style="padding-left:25px;">
<p>
<label>User:</label>
<input name="user_name" type="text" class="input" value="" size="30" maxlength="60">
</p>
<p>
<label>Password:</label>
<input name="password" type="password" class="input" size="20" value="" maxlength="50" onfocus="pw_blank();" onchange="pw_edited();">
</p>
<p>
<span id="error_msg"></span>
</p>
<p>
<input type="hidden" name="password_edited" value="0">
<input name="submitform" type="button" class="button" value="Login" onclick="return submitf();">
</p>
</div>
</form>
</body>
</html>
autocomplete = "off" funciona para la mayoría de los navegadores modernos, pero otro método que utilicé que funcionó exitosamente con Epiphany (un navegador WebKit para GNOME) es almacenar un prefijo generado aleatoriamente en el estado de la sesión (o un campo oculto, sucedió que tenía una variable adecuada en estado de sesión ya), y use esto para alterar el nombre de los campos. Epiphany aún desea guardar la contraseña, pero al volver al formulario no llenará los campos.