#authy

authy's desktop app is being discontinued on March 19, 2024-- apparently moved up from an initially-planned date of August 19 for some reason

i think authy gets recommended a lot specifically for having a desktop option, and the EOL announcement email ended up in my spam folder, so i figured i should try to spread the word.

as far as potential alternatives go, so far i've found ente Authenticator, which has apps for Android and iOS and apparently allows you to access your 2FA codes on web as well. there's also 2FAS, which is open source and has a browser extension, but it sounds like the extension still requires your phone and they recently launched an NFT project(???) so... ymmv!

Today, we are announcing two new ways to protect your npm account. Please read on to learn how you can use these security features to keep your code safe and increase everyone’s trust in the more than 550,000 packages of code in the npm Registry.

Two-factor authentication (2FA)

Now, you can sync your npm account with an authentication application like Google Authenticator or Authy. When you log in, you’ll be prompted for a single-use numeric code generated by the app.

2FA is another layer of defense for your account, preventing third parties from altering your code even if they steal or guess your credentials. This is one of the easiest and most important ways to ensure that only you can access to your npm account.

Read-only tokens

If your continuous integration / continuous deployment (CI/CD) workflow includes linking your npm account to tools like Travis CI with authentication tokens, you can now create read-only tokens for tools that don’t need to publish. You can also restrict tokens to work from only specified ranges of IP addresses.

Even if your token is compromised — for example, if you accidentally commit it to GitHub — no one else can alter your code, and only authorized CI servers will be able to download your code.

Learn more about tokens in this doc: 

Working with Tokens

Set these up now (please)

The npm community is now larger than the population of New York City, so it’s never been more important to reinforce trust and encourage collaboration. Every developer who secures their npm account with these new methods helps ensure the safety and integrity of the code we all discover, share, and reuse to build amazing things.

Learn how to activate 2FA in this doc:

Using Two-Factor Authentication

Watch this space

There has never been a major security incident caused by leaked npm credentials, but our security work is never finished. We work continuously to protect the npm Registry and detect and remove malicious code, and we try to keep you informed of our efforts.

If you ever believe you’ve encountered any malicious code on the Registry or in npm itself, contact us right away [using the npm website](lgt security contact form) or by emailing [email protected]. If you have any feedback or questions about what we’ve rolled out today, just contact [email protected].

Thanks for helping keep the npm community safe.

Two-factor authentication protects billions of accounts. Most people interact with it daily without knowing the names of the underlying standards. They scan QR codes, enter six-digit codes, and move on. But behind those codes sit two distinct technologies — and understanding the difference matters if you're building security systems, evaluating authentication options, or simply want to understand what's actually protecting your accounts.

This guide covers HOTP — what it is, how it works, where it differs from its more widely-used sibling TOTP, and when it makes sense to use it.

What Is HOTP?

HOTP stands for HMAC-based One-Time Password. It's an algorithm that generates one-time passwords using a cryptographic hash function (HMAC-SHA1) combined with a shared secret key and an incrementing counter. Each time a password is generated, the counter increases by one — making each code unique and ensuring it can never be reused.

HOTP was standardized by the IETF in RFC 4226, published in December 2005. It forms the foundation of the OATH (Initiative for Open Authentication) framework — which is why you'll frequently encounter the term OATH HOTP in security documentation, vendor specifications, and authentication system requirements.

Before TOTP existed, HOTP was the primary standard for software-based one-time password generation. Many physical hardware tokens — RSA SecurID, Yubico OTP, and similar devices — are built on HOTP's counter-based architecture.

HOTP Meaning: Breaking Down the Acronym

H — HMAC-based: The algorithm uses HMAC (Hash-based Message Authentication Code) to combine the secret key and counter into a cryptographically secure output. HMAC-SHA1 is the default hash function specified in RFC 4226, though implementations can use stronger variants.

O — One-Time: Each code can only be used once. After a code is verified, the counter increments and that specific code becomes permanently invalid. Even within the validity window, replay attacks fail because the server tracks which counter value was last used.

T — hmac-based one-Time: (see above)

P — Password: The output is a numeric password — typically six to eight digits — that the user enters to prove possession of the shared secret key without revealing the key itself.

Together, HOTP creates a system where both parties — your device and the authentication server — can independently generate identical codes by sharing the same secret key and maintaining synchronized counters, without ever transmitting the key itself over any network.

How HOTP Works: The Technical Process

Understanding HOTP at a technical level reveals why it's both elegant and occasionally problematic in practice. The algorithm runs through three distinct phases.

Phase 1: Generating the HMAC Value

The algorithm takes two inputs: the shared secret key (K) and the current counter value (C). These are fed into the HMAC-SHA1 function:

HMAC-SHA1(K, C)

This produces a 20-byte (160-bit) hash value. The hash output changes completely with every counter increment — a property called the avalanche effect — meaning even a counter change of 1 produces a completely different hash.

Phase 2: Dynamic Truncation

A 20-byte value contains too much information to present as a usable password. Dynamic truncation extracts a 4-byte portion from the hash using an offset derived from the last byte of the HMAC output:

offset = HMAC_result & 0xf P = HMAC_result & 0x7fffffff

The bitwise AND with 0x7fffffff removes the most significant bit to avoid signed integer complications across different programming environments.

Phase 3: Computing the Final Code

The truncated integer is reduced to the desired number of digits (typically 6 or 8) using modulo arithmetic:

HOTP value = P mod 10^Digit // For 6-digit codes: HOTP value = P mod 1000000

The result is zero-padded to the specified length if necessary — producing the familiar six-digit code that users enter during authentication.

HOTP Example: Walking Through a Real Calculation

Let's work through a concrete HOTP example to make this tangible. RFC 4226 itself includes test vectors using the following parameters:

Parameter Value Secret Key (K) 12345678901234567890 Counter (C) = 0 → HOTP = 755224 Counter (C) = 1 → HOTP = 287082 Counter (C) = 2 → HOTP = 359152 Counter (C) = 3 → HOTP = 969429 Counter (C) = 4 → HOTP = 338314

Notice that each counter value produces a completely different six-digit code. The relationship between counter values and output codes is cryptographically unpredictable — knowing codes at counter 0 through 4 gives you zero information about the code at counter 5.

This predictable test vector serves a critical purpose in development: if your HOTP implementation produces these exact codes for this exact secret and counter sequence, you know your implementation is correct. Developers use known test vectors to validate their code before deploying to production.

For testing TOTP implementations (the time-based variant), our free online TOTP code generator lets you verify codes against known secrets without setting up full authenticator infrastructure.

OATH HOTP: Understanding the Standard Framework

The term OATH HOTP appears frequently in enterprise security documentation. OATH — the Initiative for Open Authentication — is an industry consortium that developed open standards for strong authentication. HOTP (RFC 4226) and TOTP (RFC 6238) are both OATH standards.

When vendors describe their products as "OATH HOTP compliant," they mean:

- The device or software implements HOTP exactly as specified in RFC 4226 - It will interoperate with any other OATH HOTP compliant system - The vendor accepts third-party security validation against the published specification

This standardization is genuinely valuable. An OATH HOTP hardware token from one manufacturer works with authentication servers from completely different vendors. No proprietary lock-in. No compatibility issues. Just a published standard that any implementation can follow.

HOTP vs TOTP: The Critical Difference

TOTP (Time-based One-Time Password) is a direct evolution of HOTP. The core algorithm is identical — HMAC-SHA1 truncated to six digits — with one critical change: the counter is replaced by the current timestamp.

Feature HOTP TOTP Counter Type Event counter (increments on use) Time counter (increments every 30s) Code Validity Until used (no expiry) 30 seconds from generation Offline Use ✅ Full offline support ✅ Full offline support Sync Requirement Counter sync between device and server Clock sync (automatic on most devices) Replay Attack Risk Low (used codes invalidated immediately) Very low (30-second window closes fast) Counter Drift High risk if tokens pressed without logging in No counter drift (time-synchronized) Best Use Case Hardware tokens, YubiKey OTP Software authenticator apps RFC Standard RFC 4226 (2005) RFC 6238 (2011)

The counter drift problem deserves special attention. In HOTP, both the token and server maintain synchronized counters. If a user generates several codes without logging in — pressing the hardware token button multiple times accidentally or testing it — the token's counter advances while the server's counter stays at the last verified value.

Most HOTP implementations handle this by allowing a "look-ahead" window — verifying codes not just for the current counter but for the next N counter values. If the user's token is 10 presses ahead, the server accepts any code within the next 10-50 counter values and re-syncs. But if drift becomes too large, manual re-synchronization is required.

TOTP eliminated this problem entirely by anchoring both sides to the current time. Clock drift on modern networked devices is typically under one second — easily handled by accepting codes from the previous and next 30-second windows.

When HOTP Makes Sense Today

Given that TOTP solves HOTP's counter drift problem, you might wonder whether HOTP still has a role. It does — in specific contexts where its counter-based nature is actually an advantage.

Hardware Security Tokens

Physical hardware tokens that don't have real-time clocks benefit from HOTP's counter-based approach. The token generates a code on button press. The server validates it and increments its expected counter. No time synchronization required. No battery drain from maintaining a real-time clock. This is why devices like classic Yubico OTP (not FIDO2) use counter-based HOTP under the hood.

Environments Without Reliable Time Sources

Embedded systems, industrial controllers, and offline devices that can't reliably access time servers benefit from HOTP's independence from time synchronization. The counter is maintained locally and doesn't require network time protocol (NTP) access.

Single-Use Link Tokens

Email verification links, one-time login codes, and magic links often use HOTP-style counter-based single-use tokens. Each link contains a specific counter value. Once verified, that counter is invalidated. The "use once and expire" property maps naturally to HOTP's design.

Compliance with Legacy Systems

Enterprise environments running authentication infrastructure built when HOTP was the primary standard often maintain HOTP support to avoid disrupting existing hardware token deployments. Migrating thousands of physical tokens across an organization is expensive and disruptive — HOTP support in modern systems maintains backward compatibility.

Implementing HOTP: Code Examples

For developers implementing HOTP in applications, here are reference implementations in common languages that follow RFC 4226 exactly:

Python Implementation:

import hmac import hashlib import struct def hotp(secret: bytes, counter: int, digits: int = 6) -> str: # Step 1: Generate HMAC-SHA1 counter_bytes = struct.pack('>Q', counter) hmac_hash = hmac.new(secret, counter_bytes, hashlib.sha1).digest() # Step 2: Dynamic truncation offset = hmac_hash & 0x0f truncated = struct.unpack('>I', hmac_hash) truncated &= 0x7fffffff # Step 3: Compute OTP otp = truncated % (10 ** digits) return str(otp).zfill(digits) # Example usage secret = b'12345678901234567890' for counter in range(5): print(f"Counter {counter}: {hotp(secret, counter)}")

Node.js Implementation:

You log into your bank. Your email. Your work systems. Your crypto exchange. Every one of these accounts represents something valuable — and every one of them is a target.

A password alone stopped being enough years ago. Data breaches expose millions of credentials monthly. Password reuse turns one leaked database into dozens of compromised accounts. The solution that security professionals have standardized on isn't complicated. It's a TOTP application — and if you don't have one installed right now, this guide will help you choose the right one.

This review covers what makes a TOTP app genuinely good, compares the leading options across security, usability, and backup features, and gives you a clear recommendation based on your specific situation.

What Is a TOTP Application and Why Do You Need One?

A TOTP application generates time-based one-time passwords — six-digit codes that change every 30 seconds and expire immediately after use. When you enable two-factor authentication on any service, the TOTP app acts as your second layer of verification beyond your password.

If you want to understand the cryptographic mechanism behind how these codes are generated and verified, our complete guide on how TOTP works explains the full technical process. For now, the practical point is this: even if someone knows your password, they cannot log into your account without the current code from your specific TOTP app on your specific device.

That time-limited, device-bound nature is what makes TOTP so effective. Phishing pages, credential-stuffing attacks, and brute-force attempts all fail against properly implemented two-factor authentication.

What Separates a Good TOTP App from a Bad One?

Not every TOTP authenticator is created equal. Before we review specific apps, here's what the evaluation criteria look like for anyone serious about security.

Secret Key Protection

Your TOTP app stores secret keys that generate your codes. These need AES-256 encryption at rest and strict access controls. The best apps require biometric authentication — fingerprint or face recognition — before showing any codes. If someone picks up your phone, they shouldn't be able to open your authenticator and see your accounts.

Backup and Recovery Architecture

The most common complaint from users switching phones: "I lost all my 2FA codes." This happens when apps store secrets only locally without any backup mechanism. Quality TOTP applications provide encrypted cloud backup — protecting you from device loss without creating security vulnerabilities. The encryption should be end-to-end, meaning not even the app company can access your secrets.

Cross-Platform Availability

Your phone gets replaced. You might use iOS today and Android next year. Some users want codes accessible on desktop or tablet. Cross-platform support with synchronized accounts eliminates the pain of reconfiguring 2FA on every service during device transitions.

Open Source Verification

The gold standard for security software is public code. When an app's source code is openly available for review, independent security researchers can verify there are no backdoors, unexpected data collection, or implementation vulnerabilities. Closed-source apps require trust in the company's claims about their security practices.

Usability Under Pressure

You're often entering TOTP codes quickly — before a 30-second window expires. The interface needs to surface the right account fast, display codes clearly, and copy them with minimal taps. A technically secure app that frustrates users into disabling 2FA entirely defeats the purpose.

The Best TOTP Applications Reviewed

1. Aegis Authenticator — Best for Android Users Who Want Full Control

Aegis is the TOTP app that security-conscious Android users consistently recommend. It's fully open source, independently audited, locally encrypted, and completely free. No accounts required. No telemetry. No cloud services unless you explicitly configure your own backup destination.

The vault uses AES-256-GCM encryption with a password or biometric unlock. You can export your entire vault as an encrypted file and store it wherever you trust — a USB drive, your own cloud storage, or printed on paper. This level of control over your security data is rare among consumer apps.

✅ Strengths

- Fully open source - AES-256 local encryption - No cloud dependency - Encrypted manual export - Clean Material Design UI - Completely free

❌ Limitations

- Android only - No automatic cloud sync - Manual backup management - No desktop app

Best for: Android users, privacy advocates, open source supporters, anyone who wants maximum control over their authentication data.

2. Authy — Best Cross-Platform TOTP Authenticator

Authy solves the problem most users actually face: what happens when you get a new phone? With Authy, the answer is simple — your codes are already there when you sign in on the new device.

The multi-device sync uses AES-256 encryption with a backup password that only you know. Authy never has access to your decrypted secrets. The app runs on iOS, Android, Windows, Mac, and as a Chrome extension — covering virtually every platform combination.

✅ Strengths

- True multi-device sync - Encrypted cloud backup - Cross-platform (iOS, Android, desktop) - Biometric protection - Completely free - Clean modern interface

❌ Limitations

- No manual secret export - Closed source - Requires phone number registration - Ecosystem lock-in

Best for: Most users — anyone who values convenience alongside security and uses multiple devices.

⭐ Editor's Choice: Authy is our recommended TOTP authenticator for the majority of users who want security without sacrificing convenience.

3. Google Authenticator — The Simple Standard

Google Authenticator defined what most people think of when they picture a TOTP application. It's the app that most setup guides show QR codes for. It works reliably, supports every TOTP-compatible service, and requires no account beyond your existing Google account for optional sync.

Google added cloud backup in 2023, finally addressing the biggest historical criticism. That said, the backup isn't as configurable as Authy's, and the overall feature set remains minimal compared to competitors.

✅ Strengths

- Extremely simple UI - No learning curve - Now includes Google account backup - Available on iOS and Android - Free

❌ Limitations

- Backup requires Google account - No multi-device sync control - Minimal security features - No biometric app lock (historically limited)

Best for: Users who want absolute simplicity and are already in Google's ecosystem.

4. Microsoft Authenticator — Best for Microsoft Ecosystem

Microsoft Authenticator goes beyond TOTP to support passwordless sign-in for Microsoft accounts. You approve a push notification on your phone instead of typing a password and code. For heavy Microsoft 365, Azure, or Outlook users, this integration is genuinely useful.

The app also handles standard TOTP codes for non-Microsoft services, making it a complete solution for users already within the Microsoft ecosystem.

✅ Strengths

- Passwordless Microsoft login - Works for any TOTP service - Encrypted cloud backup - Password autofill feature - Free

❌ Limitations

- Backup tied to Microsoft account - Interface can feel cluttered - Best value only within Microsoft ecosystem

Best for: Microsoft 365 users, enterprise users on Azure AD, anyone who frequently signs into Microsoft services.

5. Bitwarden Authenticator — Best for Open Source + Password Manager Integration

Bitwarden split its TOTP feature into a dedicated standalone app (Bitwarden Authenticator) separate from its password manager. This is a significant choice — it means your passwords and 2FA codes live in separate apps by default, which many security professionals prefer for defense-in-depth.

The app is fully open source, works offline, and provides encrypted local vault storage. It's a newer entry compared to Authy or Google Authenticator, but its open source pedigree and Bitwarden's reputation for transparent security practices make it worth considering.

✅ Strengths

- Fully open source - Separated from password manager - Encrypted local storage - iOS and Android - Free

❌ Limitations

- Newer app, smaller community - Limited backup options vs. Authy - No desktop app yet

Best for: Bitwarden password manager users, open source advocates who want iOS support (Aegis is Android-only).

6. Raivo OTP — Best for iOS Privacy-Focused Users

Raivo fills the gap that Aegis leaves on iOS. It's open source, iCloud-backed (encrypted), and specifically designed for the Apple ecosystem. The interface is clean and distinctly iOS-native, feeling right at home alongside Apple's own apps.

✅ Strengths

- Open source - Encrypted iCloud backup - Native iOS design - Apple Watch support - Free

❌ Limitations

- iOS only - iCloud dependency for backup - No Android version

Best for: Privacy-focused iPhone users who want an open source alternative to Google Authenticator.

Side-by-Side Comparison: All Six TOTP Apps

TOTP App Platform Open Source Cloud Backup Price Best For Aegis Android ✅ Manual Free Privacy/control Authy ⭐ iOS/Android/Desktop ❌ ✅ Encrypted Free Most users Google Authenticator iOS/Android ❌ ✅ Google Free Simplicity Microsoft Authenticator iOS/Android ❌ ✅ Microsoft Free Microsoft users Bitwarden Authenticator iOS/Android ✅ Limited Free Open source iOS Raivo OTP iOS only ✅ ✅ iCloud Free iOS privacy users

Choosing the Right TOTP Application for Your Situation

The "best" TOTP application isn't universal — it depends on what you value and how you use your devices. Here's the decision tree that leads most users to the right choice.

If You Use Android and Prioritize Privacy

Choose Aegis. No other app matches its combination of open source transparency, strong local encryption, and complete independence from any cloud service.

If You Use Multiple Devices or Switch Phones Regularly

Choose Authy. The multi-device sync removes the pain of device transitions without compromising encryption quality. It's the pragmatic choice for most people.

If You're Deep in the Microsoft Ecosystem

Choose Microsoft Authenticator. The passwordless sign-in feature alone is worth it for heavy Microsoft users, and having your backup tied to your existing Microsoft account simplifies recovery.

If You Use iPhone and Care About Open Source

Choose Raivo OTP. It fills the iOS gap that Aegis leaves, with open source code, encrypted iCloud backup, and native Apple design.

If You Already Use Bitwarden for Passwords

Consider Bitwarden Authenticator — but understand that keeping it separate from your Bitwarden password vault maintains better defense-in-depth than combining both in one app.

Setting Up Your TOTP Application: What to Expect

Every TOTP authenticator follows the same basic setup flow across all services:

- Go to the security or two-factor authentication settings on the service you want to protect - Select "authenticator app" as your 2FA method - The service displays a QR code containing your secret key - Open your TOTP app and scan the QR code - Your app immediately begins generating codes for that account - Enter the current 6-digit code to verify the setup worked - Save the backup codes provided by the service in a secure location

If you're building an application that uses TOTP and want to verify your implementation produces correct codes, a free TOTP code generator lets you test against known secrets without setting up a full test account in an authenticator app.

For a deeper comparison of authenticator apps with more detail on features like push notifications and enterprise options, our full authenticator app review covers six apps including Duo Mobile and 1Password integration.

Critical Security Habits Alongside Your TOTP App

Installing a TOTP application is only the first step. These habits ensure your 2FA setup actually protects you:

Save backup codes during setup. Every service provides one-time recovery codes when you enable 2FA. Store them somewhere secure and separate from your phone — not in your notes app, not in an email draft, not in a folder called "passwords." A physical printout in a secure location is a legitimate option.

Enable app lock on your TOTP authenticator. Require biometric authentication to open the app itself. If your phone is unlocked but your authenticator requires a fingerprint, a thief who swipes your phone can't trivially access your codes.

Enable 2FA on your most valuable accounts first. Primary email, banking, and any account containing financial information should be protected before social media and less critical services. Your primary email is the master key — every other account can be reset through it.

Test your backup before you need it. Before your device breaks or gets lost, verify that your backup codes work and that you can restore your TOTP app from backup. Discovering your backup is corrupt during an actual emergency is not the learning experience you want.

Frequently Asked Questions

What is a TOTP application?A TOTP application is software that generates Time-based One-Time Passwords — six-digit codes that change every 30 seconds and are used as the second factor in two-factor authentication. The app stores secret keys shared with the services you use, and calculates codes using those keys combined with the current timestamp. Both the app and the service independently calculate the same code, allowing verification without transmitting sensitive data.Are all TOTP apps compatible with each other?Yes. All TOTP applications implement the same open standard (RFC 6238), so they generate identical codes for the same secret key at the same moment. You can use any TOTP app with any service that supports authenticator-based 2FA. You can even use multiple different TOTP apps simultaneously for the same account — they'll all produce the same code. This interoperability is by design and one of TOTP's major strengths over proprietary authentication solutions.What happens to my TOTP codes if I lose my phone?It depends on your TOTP app. Apps with encrypted cloud backup (Authy, Microsoft Authenticator, Google Authenticator with sync enabled) restore your codes on a new device after authentication. Apps without cloud sync (Aegis without manual backup) result in code loss — you'd need to use backup codes or account recovery options to regain access to each service individually. This is why saving the one-time backup codes provided during 2FA setup is critical regardless of which TOTP app you use.Is a TOTP authenticator safer than SMS verification?Yes, significantly. SMS codes can be intercepted through SIM swapping attacks, SS7 protocol vulnerabilities, and phishing. They also require cellular connectivity and expire slowly (often minutes). TOTP codes are generated locally on your device without network transmission, expire in 30 seconds, and are immune to SIM swapping attacks since they don't involve your phone number. Security guidelines from NIST and most security researchers recommend TOTP over SMS for two-factor authentication.Can I use a TOTP app on multiple devices?Yes, depending on the app. Authy explicitly supports multiple devices simultaneously — install it on your phone, tablet, and desktop and all show the same codes. Other apps like Google Authenticator sync through your cloud account, letting you access codes after signing in on a new device. Some apps like Aegis are single-device only, requiring manual export and import to use on multiple devices. Check the specific app's documentation before assuming multi-device capability.Do TOTP apps work without internet?Yes, every TOTP application generates codes completely offline. The algorithm only needs the stored secret key and your device's clock — no internet connection, no cellular service, and no server communication during code generation. This is one of TOTP's significant advantages over push-notification 2FA methods that require connectivity. Your codes work on planes, in areas with no signal, and during network outages as long as your device's time is reasonably accurate.

The Final Recommendation

There's no single TOTP application that wins for everyone. The right choice depends on your platform, privacy priorities, and how much you value convenience versus control.

For most people reading this guide, Authy is the answer. It's free, secure, works across every platform, and solves the "I got a new phone" problem that causes most users to abandon 2FA entirely. That's the app we'd hand to a non-technical friend and feel confident they'd stay protected.

For Android users with strong privacy preferences, Aegis is the answer. For iOS users who want open source transparency, Raivo OTP fills that role.

If you're unsure which category you fall into, start with Authy. You can always migrate later once you've developed a clearer sense of your security preferences and workflow.

Patrick Jensen (Owner) Is Your Data Breached? What To Do – 1/27/2023 News of data breaches is all too common. This company apologizes for six million accounts breached. That company acknowledges hackers accessed 35,000 users’ personal identifiable information. But the question that probably matters most: Is your data breached, too? The company should contact you if your information is in a data…