Authentication
Tags: security, authentication, usability, ux
Published: 2021-02-06 09:57:36

---
title: Authentication
published: true
date: 2021-02-03 11:26:09 UTC
tags: security,authentication,usability,ux
canonical_url: https://adactio.com/journal/17794
---

Two-factor authentication is generally considered A Good Thing™️ when you’re logging in to some online service.

The word “factor” here basically means “kind” so you’re doing two _kinds_ of authentication. Typical factors are:

- Something you know (like a password),
- Something you have (like a phone or a USB key),
- Something you are (biometric Black Mirror shit).

Asking for a password and an email address isn’t two-factor authentication. They’re two pieces of identification, but they’re the same kind (something you know). Same goes for supplying your fingerprint and your face: two pieces of information, but of the same kind (something you are).

None of these kinds of authentication are foolproof. All of them can change. All of them can be spoofed. But when you combine factors, it gets a lot harder for an attacker to breach both _kinds_ of authentication.

The most common kind of authentication on the web is password-based (something you know). When a second factor is added, it’s often connected to your phone (something you have).

Every security bod I’ve talked to recommends using an authenticator app for this if that option is available. Otherwise there’s SMS—short message service, or text message to most folks—but SMS has a weakness. Because it’s tied to a phone number, technically you’re only proving that you have access to a SIM (subscriber identity module), not a specific phone. In the US in particular, it’s all too easy for an attacker to use social engineering to get a number transferred to a different SIM card.

Still, authenticating with SMS is an option as a second factor of authentication. When you first sign up to a service, as well as providing the first-factor details (a password and a username or email address), you also verify your phone number. Then when you subsequently attempt to log in, you input your password and on the next screen you’re told to input a string that’s been sent by text message to your phone number (I say “string” but it’s usually a string of numbers).

There’s an inevitable friction for the user here. But then, there’s a fundamental tension between security and user experience.

In the world of security, vigilance is the watchword. Users need to be aware of their surroundings. Is this web page being served from the right domain? Is this email coming from the right address? Friction is an ally.

But in the world of user experience, the opposite is true. “Don’t make me think” is the rallying cry. Friction is an enemy.

With SMS authentication, the user has to manually copy the numbers from the text message (received in a messaging app) into a form on a website (in a different app—a web browser). But if the messaging app and the browser are on the same device, it’s possible to improve the user experience without sacrificing security.

If you’re building a form that accepts a passcode sent via SMS, you can use the `autocomplete` attribute with a value of “one-time-code”. For a six-digit passcode, your `input` element might look something like this:

```
<input type="text" maxlength="6" inputmode="numeric" autocomplete="one-time-code">

```

With one small addition to one HTML element, you’ve saved users some tedious drudgery.

There’s one more thing you can do to improve security, but it’s not something you add to the HTML. It’s something you add to the text message itself.

Let’s say your website is example.com and the text message you send reads:

```
Your one-time passcode is 123456.

```

Add this to the end of the text message:

```
@example.com #123456

```

So the full message reads:

```
Your one-time passcode is 123456.

@example.com #123456

```

The first line is for humans. The second line is for machines. Using the @ symbol, you’re telling the device to only pre-fill the passcode for URLs on the domain example.com. Using the # symbol, you’re telling the device the value of the passcode. Combine this with `autocomplete="one-time-code"` in your form and the user shouldn’t have to lift a finger.

I’m fascinated by these kind of emergent conventions in text messages. Remember that the @ symbol and # symbol in Twitter messages weren’t ideas from Twitter—they were conventions that users started and the service then adopted.

It’s a bit different with the one-time code convention as there is [a specification brewing](https://wicg.github.io/sms-one-time-codes/) from representatives of both [Google](https://web.dev/sms-otp-form/) and [Apple](https://developer.apple.com/news/?id=z0i801mg).

[Tess](https://tess.oconnor.cx/) is leading from the Apple side and she’s got another iron in the fire to make security and user experience play nicely together using the convention of [the `/.well-known` directory](https://www.iana.org/assignments/well-known-uris/well-known-uris.xhtml) on web servers.

You can add [a URL for `/.well-known/change-password`](https://github.com/w3c/webappsec-change-password-url) which redirects to the form a user would use to update their password. Browsers and password managers can then use this information if they need to prompt a user to update their password after a breach. I’ve added this to [The Session](https://thesession.org/).

Oh, and on that page where users can update their password, the `autocomplete` attribute is your friend again:

```
<input type="password" autocomplete="new-password">

```

If you want them to enter their current password first, use this:

```
<input type="password" autocomplete="current-password">

```

All of the things I’ve mentioned—[the `autocomplete` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete), [origin-bound one-time codes in text messages](https://wicg.github.io/sms-one-time-codes/), and [a well-known URL for changing passwords](https://github.com/w3c/webappsec-change-password-url)—have good browser support. But even if they were only supported in one browser, they’d still be worth adding. These additions do absolutely no harm to browsers that don’t yet support them. That’s progressive enhancement.