Difference between revisions of "Authentication Cheat Sheet"

Jump to: navigation, search
Line 531: Line 531:
U2F aumenta la autenticación basada en contraseñas mediante un token de hardware (típicamente un USB) que almacena llaves de autenticación criptográficas y las utiliza para firmar. El usuario puede utilizar el mismo token como un segundo factor para múltiples aplicaciones. U2F trabaja con aplicaciones Web. Provee '''protección contra phishing''' utilizando la URL del sitio Web para buscar la llave de autentificación almacenada.
U2F aumenta la autenticación basada en contraseñas mediante un token de hardware (típicamente un USB) que almacena llaves de autenticación criptográficas y las utiliza para firmar. El usuario puede utilizar el mismo token como un segundo factor para múltiples aplicaciones. U2F trabaja con aplicaciones Web. Provee '''protección contra phishing''' utilizando la URL del sitio Web para buscar la llave de autentificación almacenada.
== Directrices generales para el manejo de sesiones ==
El manejo de sesiones está directamente relacionado a la autentificación. Las '''Directrices generales para el manejo de sesiones''' previamente disponibles en esta Hoja de referencias de Autentificación de OWASP han sido integradas en [[Session Management Cheat Sheet]] (NdT: hoja en proceso de traducción).
== Gestión de contraseñas ==
Los gestores de contraseñas son programas, complementos para el navegador o servicios Web que automatizan el manejo de un gran número de diferentes credenciales, incluyendo la memorización y rellenado automático, generando contraseñas aleatorias en diferentes sitios, etc. La aplicación Web puede ayudar a los administradores de contraseñas:
* usando formularios HTML estándar para los campos de ingreso de nombres de usuario y contraseñas,
* no deshabilitando el ''"copy & paste"'' en los campos de los formularios HTML,
* permitiendo contraseñas muy largas,
* no usando esquemas de inicio de sesión en múltiples etapas (nombre de usuario en la primera pantalla, luego la contraseña),
* no usando esquemas de autentificación con largos scripts (JavaScript).
== Recursos adicionales ==
Un PDF del Cheatsheet en inglés puede obtenerse aquí: https://magic.piktochart.com/output/7003174-authentication-cheat-sheet
== Autores y Editores principales  ==
Eoin Keary eoinkeary[at]owasp.org <br/>
Jim Manico<br/>
Timo Goosen<br/>
Pawel Krawczyk<br/>
Sven Neuhaus<br/>
Manuel Aude Morales
Traducción al idioma Español:<br/>
Eugenia Bahit
<headertabs />
<headertabs />

Revision as of 20:35, 11 August 2015


Last revision (mm/dd/yy): 08/11/2015


Authentication is the process of verification that an individual, entity or website is who it claims to be. Authentication in the context of web applications is commonly performed by submitting a user name or ID and one or more items of private information that only a given user should know.

Session Management is a process by which a server maintains the state of an entity interacting with it. This is required for a server to remember how to react to subsequent requests throughout a transaction. Sessions are maintained on the server by a session identifier which can be passed back and forward between the client and server when transmitting and receiving requests. Sessions should be unique per user and computationally very difficult to predict.

Authentication General Guidelines

User IDs

Make sure your usernames/userids are case insensitive. User 'smith' and user 'Smith' should be the same user.

Email address as a User ID

Many sites use email addresses as a user id, which is a good mechanism for ensuring a unique identifier for each user without adding the burden of remembering a new username. However, many web applications do not treat email addresses correctly due to common misconceptions about what constitutes a valid address.

Specifically, it is completely valid to have an mailbox address which:

  • Is case sensitive in the local-part
  • Has non-alphanumeric characters in the local-part (including + and @)
  • Has zero or more labels (though zero is admittedly not going to occur)

The local-part is the part of the mailbox address to the left of the rightmost @ character. The domain is the part of the mailbox address to the right of the rightmost @ character and consists of zero or more labels joined by a period character.

At the time of writing, RFC 5321 is the current standard defining SMTP and what constitutes a valid mailbox address.

Please note, email addresses should be consider to be public data. For high security applications usernames could be assigned and secret instead of user-defined public data.


Many web applications contain computationally expensive and inaccurate regular expressions that attempt to validate email addresses.

Recent changes to the landscape mean that the number of false-negatives will increase, particularly due to:

  • Increased popularity of sub-addressing by providers such as Gmail (commonly using + as a token in the local-part to affect delivery)
  • New gTLDs with long names (many regular expressions check the number and length of each label in the domain)

Following RFC 5321, best practice for validating an email address would be to:

  • Check for presence of at least one @ symbol in the address
  • Ensure the local-part is no longer than 64 octets
  • Ensure the domain is no longer than 255 octets
  • Ensure the address is deliverable

To ensure an address is deliverable, the only way to check this is to send the user an email and have the user take action to confirm receipt. Beyond confirming that the email address is valid and deliverable, this also provides a positive acknowledgement that the user has access to the mailbox and is likely to be authorised to use it. This does not mean that other users cannot access this mailbox, for example when the user makes use of a service that generates a throw away email address.

Address Normalization

As the local-part of email addresses are, in fact - case sensitive, it is important to store and compare email addresses correctly. To normalise an email address input, you would convert the domain part ONLY to lowercase.

Unfortunately this does and will make input harder to normalise and correctly match to a users intent.

It is reasonable to only accept one unique capitalisation of an otherwise identical address, however in this case it is critical to:

  • Store the user-part as provided and verified by user verification
  • Perform comparisons by lowercase(provided)==lowercase(persisted)

Implement Proper Password Strength Controls

A key concern when using passwords for authentication is password strength. A "strong" password policy makes it difficult or even improbable for one to guess the password through either manual or automated means. The following characteristics define a strong password:


The following advice is disputed. Please view the OWASP presentation, "Your Password Complexity Requirements are Worthless - OWASP AppSecUSA 2014" for more information.

Password Length

Longer passwords provide a greater combination of characters and consequently make it more difficult for an attacker to guess.

  • Minimum length of the passwords should be enforced by the application.
    • Passwords shorter than 10 characters are considered to be weak ([1]).

While minimum length enforcement may cause problems with memorizing passwords among some users, applications should encourage them to set passphrases (sentences or combination of words) that can be much longer than typical passwords and yet much easier to remember.

  • Maximum password length should not be set too low, as it will prevent users from creating passphrases. Typical maximum length is 128 characters.
    • Passphrases shorter than 20 characters are usually considered weak if they only consist of lower case Latin characters.

Password Complexity

Applications should enforce password complexity rules to discourage easy to guess passwords. Password mechanisms should allow virtually any character the user can type to be part of their password, including the space character. Passwords should, obviously, be case sensitive in order to increase their complexity. Occasionally, we find systems where passwords aren't case sensitive, frequently due to legacy system issues like old mainframes that didn't have case sensitive passwords.

The password change mechanism should require a minimum level of complexity that makes sense for the application and its user population. For example:

  • Password must meet at least 3 out of the following 4 complexity rules
    • at least 1 uppercase character (A-Z)
    • at least 1 lowercase character (a-z)
    • at least 1 digit (0-9)
    • at least 1 special character (punctuation) — do not forget to treat space as special characters too
  • at least 10 characters
  • at most 128 characters
  • not more than 2 identical characters in a row (e.g., 111 not allowed)

Password Topologies

  • Ban commonly used password topologies
  • Force multiple users to use different password topologies
  • Require a minimum topology change between old and new passwords

Additional Information

  • Make sure that every character the user types in is actually included in the password. We've seen systems that truncate the password at a length shorter than what the user provided (e.g., truncated at 15 characters when they entered 20).
    • This is usually handled by setting the length of ALL password input fields to be exactly the same length as the maximum length password. This is particularly important if your max password length is short, like 20-30 characters.

As application's require more complex password policies, they need to be very clear about what these policies are.

  • The required policy needs to be explicitly stated on the password change page
    • be sure to list every special character you allow, so it's obvious to the user


  • Ideally, the application would indicate to the user as they type in their new password how much of the complexity policy their new password meets
    • In fact, the submit button should be grayed out until the new password meets the complexity policy and the 2nd copy of the new password matches the 1st. This will make it far easier for the user to understand and comply with your complexity policy.

Regardless of how the UI behaves, when a user submits their password change request:

  • If the new password doesn't comply with the complexity policy, the error message should describe EVERY complexity rule that the new password does not comply with, not just the 1st rule it doesn't comply with.

Implement Secure Password Recovery Mechanism

It is common for an application to have a mechanism that provides a means for a user to gain access to their account in the event they forget their password. Please see Forgot Password Cheat Sheet for details on this feature.

Store Passwords in a Secure Fashion

It is critical for a application to store a password using the right cryptographic technique. Please see Password Storage Cheat Sheet for details on this feature.

Transmit Passwords Only Over TLS or Other Strong Transport

See: Transport Layer Protection Cheat Sheet

The login page and all subsequent authenticated pages must be exclusively accessed over TLS or other strong transport. The initial login page, referred to as the "login landing page", must be served over TLS or other strong transport. Failure to utilize TLS or other strong transport for the login landing page allows an attacker to modify the login form action, causing the user's credentials to be posted to an arbitrary location. Failure to utilize TLS or other strong transport for authenticated pages after the login enables an attacker to view the unencrypted session ID and compromise the user's authenticated session.

Require Re-authentication for Sensitive Features

In order to mitigate CSRF and session hijacking, it's important to require the current credentials for an account before updating sensitive account information such as the user's password, user's email, or before sensitive transactions, such as shipping a purchase to a new address. Without this countermeasure, an attacker may be able to execute sensitive transactions through a CSRF or XSS attack without needing to know the user's current credentials. Additionally, an attacker may get temporary physical access to a user's browser or steal their session ID to take over the user's session.

Utilize Multi-Factor Authentication

Multi-factor authentication (MFA) is using more than one authentication factor to logon or process a transaction:

  • Something you know (account details or passwords)
  • Something you have (tokens or mobile phones)
  • Something you are (biometrics)

Authentication schemes such as One Time Passwords (OTP) implemented using a hardware token can also be key in fighting attacks such as CSRF and client-side malware. A number of hardware tokens suitable for MFA are available in the market that allow good integration with web applications. See: [2].

TLS Client Authentication

TLS Client Authentication, also known as two-way TLS authentication, consists of both, browser and server, sending their respective TLS certificates during the TLS handshake process. Just as you can validate the authenticity of a server by using the certificate and asking a well known Certificate Authority (CA) if the certificate is valid, the server can authenticate the user by receiving a certificate from the client and validating against a third party CA or its own CA. To do this, the server must provide the user with a certificate generated specifically for him, assigning values to the subject so that these can be used to determine what user the certificate should validate. The user installs the certificate on a browser and now uses it for the website.

It is a good idea to do this when:

  • It is acceptable (or even preferred) that the user only has access to the website from only a single computer/browser.
  • The user is not easily scared by the process of installing TLS certificates on his browser or there will be someone, probably from IT support, that will do this for the user.
  • The website requires an extra step of security.
  • It is also a good thing to use when the website is for an intranet of a company or organization.

It is generally not a good idea to use this method for widely and publicly available websites that will have an average user. For example, it wouldn't be a good idea to implement this for a website like Facebook. While this technique can prevent the user from having to type a password (thus protecting against an average keylogger from stealing it), it is still considered a good idea to consider using both a password and TLS client authentication combined.

For more information, see: Client-authenticated TLS handshake

Authentication and Error Messages

Incorrectly implemented error messages in the case of authentication functionality can be used for the purposes of user ID and password enumeration. An application should respond (both HTTP and HTML) in a generic manner.

Authentication Responses

An application should respond with a generic error message regardless of whether the user ID or password was incorrect. It should also give no indication to the status of an existing account.

Incorrect Response Examples
  • "Login for User foo: invalid password"
  • "Login failed, invalid user ID"
  • "Login failed; account disabled"
  • "Login failed; this user is not active"
Correct Response Example
  • "Login failed; Invalid userID or password"

The correct response does not indicate if the user ID or password is the incorrect parameter and hence inferring a valid user ID.

Error Codes and URLs

The application may return a different HTTP Error code depending on the authentication attempt response. It may respond with a 200 for a positive result and a 403 for a negative result. Even though a generic error page is shown to a user, the HTTP response code may differ which can leak information about whether the account is valid or not.

Prevent Brute-Force Attacks

If an attacker is able to guess passwords without the account becoming disabled due to failed authentication attempts, the attacker has an opportunity to continue with a brute force attack until the account is compromised. Automating brute-force/password guessing attacks on web applications is a trivial challenge. Password lockout mechanisms should be employed that lock out an account if more than a preset number of unsuccessful login attempts are made. Password lockout mechanisms have a logical weakness. An attacker that undertakes a large number of authentication attempts on known account names can produce a result that locks out entire blocks of user accounts. Given that the intent of a password lockout system is to protect from brute-force attacks, a sensible strategy is to lockout accounts for a period of time (e.g., 20 minutes). This significantly slows down attackers, while allowing the accounts to reopen automatically for legitimate users.

Also, multi-factor authentication is a very powerful deterrent when trying to prevent brute force attacks since the credentials are a moving target. When multi-factor is implemented and active, account lockout may no longer be necessary.

Use of authentication protocols that require no password

While authentication through a user/password combination and using multi-factor authentication is considered generally secure, there are use cases where it isn't considered the best option or even safe. An example of this are third party applications that desire connecting to the web application, either from a mobile device, another website, desktop or other situations. When this happens, it is NOT considered safe to allow the third party application to store the user/password combo, since then it extends the attack surface into their hands, where it isn't in your control. For this, and other use cases, there are several authentication protocols that can protect you from exposing your users' data to attackers.


Open Authorization (OAuth) is a protocol that allows an application to authenticate against a server as a user, without requiring passwords or any third party server that acts as an identity provider. It uses a token generated by the server, and provides how the authorization flows most occur, so that a client, such as a mobile application, can tell the server what user is using the service.

The recommendation is to use and implement OAuth 1.0a or OAuth 2.0, since the very first version (OAuth1.0) has been found to be vulnerable to session fixation.

OAuth 2.0 relies on HTTPS for security and is currently used and implemented by API's from companies such as Facebook, Google, Twitter and Microsoft. OAuth1.0a is more difficult to use because it requires the use of cryptographic libraries for digital signatures, however does not rely on HTTPS for security and can therefore be more suited for higher risk transactions.


OpenId is an HTTP-based protocol that uses identity providers to validate that a user is who he says he is. It is a very simple protocol which allows a service provider initiated way for single sign-on (SSO). This allows the user to re-use a single identity given to a trusted OpenId identity provider and be the same user in multiple websites, without the need to provide any website the password, except for the OpenId identity provider.

Due to its simplicity and that it provides protection of passwords, OpenId has been well adopted. Some of the well known identity providers for OpenId are Stack Exchange, Google, Facebook and Yahoo!

For non-enterprise environment, OpenId is considered a secure and often better choice, as long as the identity provider is of trust.


Security Assertion Markup Language (SAML) is often considered to compete with OpenId. The most recommended version is 2.0, since it is very feature complete and provides a strong security. Like with OpenId, SAML uses identity providers, but unlike it, it is XML-based and provides more flexibility. SAML is based on browser redirects which send XML data. Unlike SAML, it isn't only initiated by a service provider, but it can also be initiated from the identity provider. This allows the user to navigate through different portals while still being authenticated without having to do anything, making the process transparent.

While OpenId has taken most of the consumer market, SAML is often the choice for enterprise applications. The reason for this is often that there are few OpenId identity providers which are considered of enterprise class (meaning that the way they validate the user identity doesn't have high standards required for enterprise identity). It is more common to see SAML being used inside of intranet websites, sometimes even using a server from the intranet as the identity provider.

In the past few years, applications like SAP ERP and SharePoint (SharePoint by using Active Directory Federation Services 2.0) have decided to use SAML 2.0 authentication as an often preferred method for single sign-on implementations whenever enterprise federation is required for web services and web applications.

See also: SAML Security Cheat Sheet


The Fast Identity Online (FIDO) Alliance has created two protocols to facilitate online authentication : the Universal Authentication Framework (UAF) protocol and the Universal Second Factor (U2F) protocol. While UAF focuses on passwordless authentication, U2F allows the addition of a second factor to existing password-based authentication. Both protocols are based on a public key cryptography challenge-response model.

UAF takes advantage of existing security technologies present on devices for authentication including fingerprint sensors, cameras(face biometrics), microphones(voice biometrics), Trusted Execution Environments(TEEs), Secure Elements(SEs) and others. The protocol is designed to plug-in these device capabilities into a common authentication framework. UAF works with both native applications and web applications.

U2F augments password-based authentication using a hardware token (typically USB) that stores cryptographic authentication keys and uses them for signing. The user can use the same token as a second factor for multiple applications. U2F works with web applications. It provides protection against phishing by using the URL of the website to lookup the stored authentication key.

Session Management General Guidelines

Session management is directly related to authentication. The Session Management General Guidelines previously available on this OWASP Authentication Cheat Sheet have been integrated into the Session Management Cheat Sheet.

Password Managers

Password managers are programs, browser plugins or web services that automate management of large number of different credentials, including memorizing and filling-in, generating random passwords on different sites etc. The web application can help password managers by:

  • using standard HTML forms for username and password input,
  • not disabling copy and paste on HTML form fields,
  • allowing very long passwords,
  • not using multi-stage login schemes (username on first screen, then password),
  • not using highly scripted (JavaScript) authentication schemes.

Additional Resources

A PDF of this cheatsheet has been created here. https://magic.piktochart.com/output/7003174-authentication-cheat-sheet

Authors and Primary Editors

Eoin Keary eoinkeary[at]owasp.org
Jim Manico
Timo Goosen
Pawel Krawczyk
Sven Neuhaus
Manuel Aude Morales

Other Cheatsheets


La autentificación es el proceso de verificar que un individuo, entidad o sitio Web es quien dice ser. En el contexto de una aplicación Web, la autentificación, comúnmente es realizada mediante el envío de un nombre de usuario o ID y, uno o más datos de información privada que solo un determinado usuario debe conocer.

El manejo de sesiones es un proceso por el cual un servidor mantiene el estado de una entidad interactuando con él. Esto es requerido por un servidor para recordar como debe reaccionar a las peticiones posteriores a lo largo de una transacción. Las sesiones son mantenidas en el servidor por un identificador de sesión el cual puede ser pasado y devuelto entre el cliente y el servidor al transmitir y recibir solicitudes. Las sesiones deben ser únicas por usuario e informáticamente, muy difíciles de predecir.

Reglas generales de autentificación

ID de usuario

Asegúrese de que sus nombres/identificadores de usuarios no sean sensibles a mayúsculas y minúsculas. El usuario 'smith' y el usuario 'Smith' deberían ser el mismo usuario.

Dirección de correo electrónico como ID de usuario

Muchos sitios utilizan la dirección de correo electrónico como identificador de usuario, lo cual es un buen mecanismo para asegurar un identificador único por cada usuario sin agregarle a éstos la carga de tener que recordar un nuevo nombre de usuario. Sin embargo, muchas aplicaciones Web no tratan correctamente las direcciones de correo electrónico, debido a conceptos equivocados sobre lo que constituye una dirección de correo electrónico válida.

En concreto, es completamente válido tener una dirección correo electrónico que:

  • Es sensible a mayúsculas y minúsculas en la parte local
  • Tiene caracteres no alfanuméricos en la parte local (incluyendo + y @)
  • Tiene cero o más etiquetas (aunque ciertamente cero no va a ocurrir)

La parte local es la parte de la dirección de correo electrónico que se encuentra a la izquierda del caracter '@'. El dominio es la parte de la dirección de correo electrónico que se encuentra a la derecha del caracter '@' y consiste en cero o más etiquetas unidas por el caracter de punto.

Al momento de estar escribir este artículo, el RFC 5321 es el estándar actual que define el protocolo SMTP y lo que constituye una dirección de correo electrónico válida.

Por favor, tenga en cuenta que las direcciones de correo electrónico deberían ser consideradas datos públicos. En aplicaciones de alta seguridad, podrían asignarse los nombres de usuario y ser secretos en lugar de ser datos públicos definidos por el usuario.


Muchas aplicaciones Web contienen expresiones regulares informáticamente muy costosas e inexactas para intentar validar las direcciones de correo electrónico.

Cambios recientes generaron que el número de falsos negativos se viera incrementado, particularmente debido a:

  • El aumento de popularidad de las sub-direcciones de proveedores como Gmail (comúnmente usando + como token en la parte local para afectar la entrega)
  • Nuevos gTLDs con nombres largos (muchas expresiones regulares comprueban el número y longitud de cada etiqueta en el dominio)

Siguiendo el RFC 5321, las mejores prácticas para la validación de una dirección de correo electrónico deberían ser:

  • Comprobar la presencia de al menos un símbolo de @ en la dirección
  • Asegurarse de que la parte local no es de más de 64 bytes
  • Asegurarse de que el dominio no es de más de 255 bytes
  • Asegurarse que sea una dirección de entrega verídica (NdT: se refiere a que el correo pueda ser entregado)

Para asegurarse que una dirección de entrega sea verídica, la única forma es enviar un correo electrónico al usuario y que éste deba tomar alguna acción para confirmar que lo ha recibido. Más allá de confirmar que la dirección de correo electrónico es válida y reciba los mensajes, esto también proporciona una confirmación positiva de que el usuario tiene acceso al buzón de correo y es probable que esté autorizado a usarlo. Esto no significa que otros usuarios no tengan acceso al mismo buzón de correo, cuando por ejemplo el usuario utiliza un servicio que genera una dirección de correo electrónico desechable.


Como la parte local de las direcciones de correo electrónico son, de hecho, sensibles a mayúsculas y minúsculas, es importante almacenar y comparar las direcciones de correo electrónico correctamente. Para normalizar la entrada de una dirección de correo electrónico, debería convertir la parte del dominio SOLO a minúsculas.

Desafortunadamente, esto hace y hará a la entrada, más difícil de normalizar y de coincidir correctamente con los intentos del usuario.

Es razonable aceptar solo una única capitalización de diferentes alternativas para direcciones de correo electrónico idénticas. Sin embargo, en este caso es crítico para:

  • Almacenar la parte del usuario tal y como fue provista y verificada por el usuario en el proceso de verificación
  • Realizar comparaciones lowercase(provista) == lowercase(almacenada)

Implementar controles adecuados de fortaleza de contraseña

Una de las principales preocupaciones cuando se utilizan contraseñas para la autentificación, es la fortaleza de las contraseñas. Una política de contraseñas "fuertes" hace que sea difícil o incluso improbable adivinar la contraseña a través de medios manuales o automatizados. Las siguientes características definen una contraseña fuerte:


Las siguientes indicaciones están disputadas. Por favor, vea la presentación de OWASP (en inglés), "Your Password Complexity Requirements are Worthless - OWASP AppSecUSA 2014" para más información.

Longitud de la contraseña

Las contraseñas más largas proporcionan una mayor combinación de caracteres y en consecuencia hacen que sea más difícil de adivinar para un atacante.

  • La longitud mínima de las contraseñas debería ser forzada por la aplicación.
    • Las contraseñas menores a 10 caracteres son consideradas débiles ([3]).

Mientras que la longitud mínima forzada puede causar problemas para la memorización de la contraseña en algunos usuarios, las aplicaciones deberían alentarlos a establecer frases de paso o passphrases (frases o combinaciones de palabras) que pueden ser mucho más largas que las contraseñas típicas y mucho más fáciles de recordar.

  • La longitud máxima de la contraseña no debería establecerse demasiado baja, ya que evitará que los usuarios puedan crear frases de paso (passphrases). La longitud máxima típica es de 128 caracteres.
    • Frases de paso de menos de 20 caracteres usualmente son consideradas ebiles si solo se emplean letras minúsculas.

Complejidad de la contraseña

Las aplicaciones deberían imponer reglas de complejidad de contraseñas para evitar las contraseñas fáciles de adivinar. Los mecanismos de contraseñas deberían permitir al usuario, poder tipear casi cualquier caracter como parte de su contraseña, incluyendo el caracter de espacio. Las contraseñas deberían, obviamente, ser sensibles a mayúsculas y minúsculas a fin de incrementar la complejidad de las mismas. Ocasionalmente, encontramos sistemas donde las contraseñas no son sensibles a mayúsculas y minúsculas, frecuentemente debido a problemas de sistemas heredados como los viejos ordenadores centrales que no tenían contraseñas sensibles a mayúsculas y minúsculas.

El mecanismo de cambio de contraseña debería requerir un nivel mínimo de complejidad que tenga sentido para la aplicación y su población de usuarios. Por ejemplo:

  • La contraseña debe reunir al menos 3 de las siguientes 4 reglas de complejidad
    • al menos 1 mayúscula (A-Z)
    • al menos 1 minúscula (a-z)
    • al menos 1 dígito (0-9)
    • al menos 1 caracter especial (puntuación) — no olvidar de tratar también, a los espacios en blanco como un caracter especial
  • al menos 10 caracteres
  • no más de 128 caracteres
  • no más de 2 caracteres idénticos consecutivos (ej., 111 no está permitido)

Topologías de contraseña

  • Prohibir topologías de contraseñas de uso común
  • Forzar a varios usuarios a utilizar diferentes topologías de contraseña
  • Exigir un cambio mínimo de topología entre viejas y nuevas contraseñas

Información adicional

  • Asegúrese de que todos los caracteres que el usuario escribe están realmente incluidos en la contraseña. Hemos visto sistemas que truncan la contraseña a una longitud inferior de la que el usuario provee (ej., truncada a los 15 caracteres cuando se han ingresado 20).
    • Esto es manejado usualmente al establecer la longitud de TODOS los campos de contraseña exactamente como la longitud máxima de la contraseña. Esto es particularmente importante si su longitud máxima de contraseña es corta, como 20-30 caracteres.

Si la aplicación requiere políticas de contraseña más complejas, será necesario ser muy claro sobre cuáles son esas políticas.

  • La política requerida necesita ser indicada explícitamente en la página de cambio de contraseña
    • asegúrese de enumerar cada caracter especial que permite, para que sea evidente para el usuario


  • Lo ideal, sería que la aplicación indicara al usuario cómo escribir su nueva contraseña y cuánto de la directiva de complejidad de su nueva contraseña cumple
    • De hecho, el botón de envío debería verse atenuado hasta que la nueva contraseña reúna los requisitos establecidos en la política de complejidad de contraseña y la segunda copia de la nueva contraseña coincida con la primera. Esto hará que sea mucho más fácil, para el usuario, entender la política de complejidad y cumplirla.

Independientemente de cómo se comporte la UI, cuando un usuario envía su solicitud de cambio de contraseña:

  • Si la nueva contraseña no cumple con la política de complejidad de contraseña, el mensaje de error debería describir TODAS las reglas de complejidad con las cuáles la nueva contraseña no cumple y no sola la primera regla con la que no cumpla.

Implementar un mecanismo seguro de recuperación de contraseña

Es común que una aplicación tenga un mecanismo que provea al usuario un medio para acceder a su cuenta en caso de que olvide su contraseña. Por favor, para más detalles sobre esta característica, vea Forgot Password Cheat Sheet (en inglés).

Almacenar contraseñas de forma segura

Es fundamental para una aplicación, almacenar contraseñas usando la técnica criptográfica correcta. Para conocer más sobre este mecanismo, vea Password Storage Cheat Sheet (en inglés).

Transmitir contraseñas sólo sobre TLS u otro transporte fuerte

Ver: Transport Layer Protection Cheat Sheet (en inglés)

La página de inicio de sesión y todas las páginas autentificadas subsiguientes, deberían ser accedidas exclusivamente sobre TLS u otro transporte fuerte. La página de inicio de sesión principal, conocida como "landing page", debe ser servida sobre TLS u otro transporte fuerte.

Si no se utiliza TLS u otro transporte fuerte para la landing page de inicio de sesión, se permite a un atacante modificar el action del formulario de inicio de sesión, generando que las credenciales del usuario sean enviadas a una ubicación arbitraria.

Si no se utiliza TLS u otro transporte fuerte para las páginas autentificadas que se habilitan luego del inicio de sesión, un atacante puede ver la ID de sesión sin cifrar y comprometer la sesión autentificada del usuario.

Solicitar volver a autentificarse para funciones sensibles

Con el fin de mitigar ataques CSRF y de secuestro de sesión (hijacking), es importante solicitar las credenciales actuales de una cuenta en los siguientes casos:

  • Antes de modificar información sensible (como la contraseña del usuario, la dirección de correo electrónico del usuario)
  • Antes de transacciones sensibles (como enviar una compra a una nueva dirección).

Sin esta contramedida, un atacante puede ser capaz de ejecutar transacciones sensibles a través de un ataques CSRF o XSS sin necesidad de conocer las credenciales actuales del usuario. Adicionalmente, un atacante puede obtener, temporalmente, acceso físico al navegador del usuario o robar su ID de sesión para tomar el control de la sesión del usuario.

Utilizar la autentificación por múltiples factores

La autentificación por múltiples factores (MFA por las siglas en ingles de "Multi-factor authentication") es el uso de más de un factor de autentificación para iniciar sesión o procesar una transacción, mediante:

  • Algo que se conoce (detalles de la cuenta o contraseñas)
  • Algo que se tiene (tokens o teléfonos móviles)
  • Algo que se es (factores biométricos)

Los esquemas de autentificación como las contraseñas de un solo uso (OTP por las siglas en inglés de "One Time Passwords") implementadas utilizando un token físico (hardware) también pueden ser un factor clave en la lucha contra ataques tales como los ataques CSRF y malware del lado del cliente. Un considerable número de los token de hardware para MFA disponibles en el mercado, permiten una buena integración con las aplicaciones Web. Ver: [4] (en inglés).

Autentificación TLS

La autentificación TLS, también conocida como autentificación TLS mutua, consiste en que ambos, navegador y servidor, envíen sus respectivos certificados TLS durante el proceso de negociación TLS (handshaking). Así como se puede validar la autenticidad de un servidor mediante el certificado y, preguntar a una Autoridad de Certificación conocida (CA, por las siglas en inglés de "Certificate Authority") si la certificación es válida, el servidor puede autentificar al usuario recibiendo un certificado desde el cliente y validándolo contra una CA o su propia CA. Para hacer esto, el servidor debe proveer al usuario de un certificado generado específicamente para él, asignando valores que puedan ser usados para determinar que el usuario debe validar el certificado. El usuario instala los certificados en el navegador y los usa para el sitio Web.

Es una buena idea hacer esto cuando:

  • Es aceptable (o incluso preferido) que el usuario sólo tenga acceso a la página web desde una sola computadora/navegador.
  • El usuario no se asusta fácilmente por el proceso de instalación de certificados TLS en su navegador o habrá alguien, probablemente de soporte de TI, que hará esto para el usuario.
  • El sitio web requiere un paso adicional de seguridad.
  • El sitio Web es de la intranet de una compañía, empresa u organización.

Por lo general, no es una buena idea utilizar este método para la mayor parte de los sitios Web de acceso público que tendrán un usuario promedio. Por ejemplo, no será una buena idea implementar esto en un sitio Web como Facebook. Si bien esta técnica puede evitar que el usuario tenga que escribir una contraseña (protegiéndola así contra el robo desde un keylogger promedio), aún se considera una buena idea emplear el uso de una contraseña combinada con la autentificación TLS.

Para más información, ver: Client-authenticated TLS handshake

Autentificación y mensajes de error

En el caso de las funcionalidades de autentificación, los mensajes de error implementados de forma incorrecta pueden ser utilizados con el propósito de obtener y almacenar identificadores de usuario y contraseñas. Una aplicación, debería responder (tanto en los encabezados HTTP como en el contenido HTML) de forma genérica.

Respuestas de autentificación

Una aplicación debería responder mensajes de error genéricos independientemente de si era incorrecto el identificador de usuario o la contraseña. Tampoco debería dar información sobre el estado de una cuenta existente.

Ejemplo de respuestas incorrectas
  • "Inicio de sesión para el usuario foo: contraseña incorrecta"
  • "Falló el inicio de sesión: usuario no válido"
  • "Falló el inicio de sesión: cuenta deshabilitada"
  • "Falló el inicio de sesión: usuario inactivo"

Ejemplo de respuestas correctas
  • "Falló el inicio de sesión: Usuario o contraseña incorrectos"

La respuesta correcta no debería indicar si el identificador de usuario o la contraseña es el parámetro incorrecto y por lo tanto, inferir un identificador de usuario válido.

Códigos de error y URLs

La aplicación puede retornar un código de error HTTP diferente dependiendo del resultado del intento de autentificación. Puede responder con un 200 para un resultado positivo y con un 403 para un resultado negativo. Aunque una página de error genérico sea mostrada al usuario, el código de respuesta HTTP puede ser diferente, permitiendo filtrar la información sobre si la cuenta es válida o no.

Prevenir ataques por fuerza bruta

Si un atacante es capaz de adivinar una contraseña sin ser deshabilitada debido a intentos de autentificación fallidos, el atacante tiene la oportunidad de continuar con un ataque de fuerza bruta hasta que la cuenta se vea comprometida. La automatización de los ataques de fuerza bruta para adivinar contraseñas en aplicaciones Web son un desafío muy usual.

Los mecanismos de bloqueo de contraseña deberían ser empleados para bloquear una cuenta si se realiza más de un número predeterminado de intentos fallidos de autentificación.

Los mecanismos de bloqueo de contraseña tienen una debilidad lógica. Un atacante que emprende un gran número de intentos de autentificación sobre nombres de cuentas conocidas puede producir como resultado, el bloqueo de bloques enteros de cuentas de usuario. Teniendo en cuenta que la intención de un sistema de bloqueo de contraseña es proteger de ataques por fuerza bruta, una estrategia sensata es bloquear las cuentas por un período de tiempo (ej., 20 minutos). Esto ralentiza considerablemente a los atacantes mientras que permite automáticamente, reabrir las cuentas para los usuarios legítimos.

Además, la autenticación de múltiples factores es un muy poderoso elemento de disuasión cuando se trata de prevenir los ataques de fuerza bruta ya que las credenciales son un blanco móvil. Cuando la autenticación de múltiples factores se implementa y activa, el bloqueo de cuentas ya no es necesario.

Uso de protocolos de autentificación que no requieren contraseña

Mientras que la autentificación a través de una combinación usuario/contraseña y el uso de la autentificación de factores múltiples es generalmente considerada segura, hay casos de uso en los que no se considera la mejor opción o incluso seguro. Un ejemplo de esto son las aplicaciones de terceros que desean conectarse a la aplicación Web, ya sean desde un dispositivo móvil, algún otro sitio web, aplicaciones de escritorio u otras situaciones. Cuando esto sucede, NO es considerado seguro permitir a la aplicación de terceros almacenar la combinación de usuario/contraseña, ya que se amplía la superficie de ataque a sus manos, donde queda fuera de su control. Por esto y por otros casos de uso, hay varios protocolos de autentificación que pueden protegerlo de exponer los datos de sus usuarios a los atacantes.


Open Authorization (OAuth) es un protocolo que permite a una aplicación autentificar a un usuario contra un servidor, sin requerir contraseñas o algún servidor externo que actúe como proveedor de identidad. Utiliza un token generado por el servidor, ofreciendo un flujo de autorización sostenido, para que un cliente tal como una aplicación móvil, pueda llamar al servidor que el usuario está utilizando el servicio.

La recomendación es usar e implementar OAuth 1.0a o OAuth 2.0, ya que a la primera versión (OAuth1.0) se la ha encontrado vulnerable a los ataques de fijación de sesión (session fixation).

OAuth 2.0 se basa en HTTPS para la seguridad y actualmente es usado e implementado por las API de empresas como Facebook, Google, Twitter y Microsoft. OAuth1.0a es más difícil de usar porque requiere de bibliotecas criptográficas para las firmas digitales. Sin embargo, no se basa en HTTPS para la seguridad y, por lo tanto, puede ser más adecuado para las transacciones de mayor riesgo.


OpenId un protocolo basado en HTTP que utiliza proveedores de identidad para validar que un usuario es quien dice ser. Es un protocolo muy simple que permite a un proveedor de servicios de identidad un camino para el inicio de sesión único (SSO, por las siglas en inglés de "single sign-on"). Esto permite a los usuarios reutilizar una sola identidad dada a un proveedor de identidad OpenId de confianza y ser el mismo usuario en múltiples sitios web, sin la necesidad de proveer la contraseña a ningún sitio Web, exceptuando al proveedor de identidad OpenId.

Debido a su simplicidad y a que proporciona protección de contraseñas, OpenId ha sido bien aceptado. Algunos de los proveedores de identidad OpenId bien conocidos son Stack Exchange, Google, Facebook y Yahoo!

Para entornos no empresariales, OpenId es considerado seguro y frecuentemente, la mejor opción, siempre y cuando el proveedor de identidad sea de confianza.


El lenguaje de marcado para confirmaciones de seguridad (SAML, siglas en inglés de "Security Assertion Markup Language") a menudo se considera la competencia de OpenId. La versión más recomendada es la 2.0, ya que posee características muy completas y proporciona gran seguridad. Como con OpenId, SAML utiliza proveedores de identidad, pero a diferencia de éste, está basado en XML y proporciona mayor flexibilidad. SAML está basado en redirecciones del navegador las cuales envían los datos en formato XML. A diferencia de SAML, OpenId no solo es iniciado por un proveedor de servicios, sino que también puede ser iniciado desde el proveedor de identidad. Esto permite al usuario navegar entre diferentes portales mientras que se mantienen autentificado sin tener que hacer nada, haciendo que el proceso sea transparente.

Mientras que OpenId ha tomado la mayor parte del mercado de consumo, SAML es a menudo la opción para aplicaciones empresariales. La razón de esto, frecuentemente, es que hay pocos proveedores OpenId que son considerados de clase empresarial (lo que significa que la forma en la que validan la identidad del usuario no tiene los altos estándares requeridos para la identidad de la empresa). Es más común ver SAML siendo usado dentro de la intranet de un sitio Web, a veces incluso, utilizando un servidor desde la internet como el proveedor de identidad.

En los últimos años, las aplicaciones como SAP ERP y SharePoint (SharePoint utilizando Active Directory Federation Services 2.0) deciden usar la autentificación SAML 2.0, a menudo como un método preferido para las implementaciones de inicios de sesión únicos siempre que se requiera la federación empresarial para servicios Web y aplicaciones.

Ver también: SAML Security Cheat Sheet


La Fast Identity Online (FIDO) Alliance ha creado dos protocolos para facilitar la autentificación online: los protocolos Universal Authentication Framework (UAF) y Universal Second Factor (U2F). Mientras que el protocolo UAF se enfoca en la autentificación sin contraseña, U2F permite la adición de un segundo factor de autenticación basado en contraseñas existentes. Ambos protocolos están basados en una llave pública de modelo criptográfico desafío-respuesta.

UAF toma ventaja de las tecnologías de seguridad existentes presentes en los dispositivos de autenticación, incluyendo sensores de huellas digitales, cámaras (biométrica facil), micrófonos (biométrica de voz), Entornos de ejecución de confianza (TEE, siglas en inglés de Trusted Execution Environment), Elementos seguros (SE, siglas en inglés de Secure Elements) y otros. El protocolo está diseñado para conectar las capacidades de este dispositivo en un marco de autenticación común. UAF trabaja con ambas aplicaciones nativas y Web.

U2F aumenta la autenticación basada en contraseñas mediante un token de hardware (típicamente un USB) que almacena llaves de autenticación criptográficas y las utiliza para firmar. El usuario puede utilizar el mismo token como un segundo factor para múltiples aplicaciones. U2F trabaja con aplicaciones Web. Provee protección contra phishing utilizando la URL del sitio Web para buscar la llave de autentificación almacenada.