This is a terrifying and sobering write-up by Retool on so many levels. It's about about a recent spear-phishing via SMS attack on employees, followed by voice phishing attack that deepfaked an employee's voice.

Retool said just one of its employees fell for it, which is of course all it takes. Here's the scary part:

"The voice was familiar with the floor plan of the office, coworkers, and internal processes of the company. Throughout the conversation, the employee grew more and more suspicious, but unfortunately did provide the attacker one additional multi-factor authentication (MFA) code.

The additional OTP token shared over the call was critical, because it allowed the attacker to add their own personal device to the employee’s Okta account, which allowed them to produce their own Okta MFA from that point forward. This enabled them to have an active GSuite session on that device. Google recently released the Google Authenticator synchronization feature that syncs MFA codes to the cloud. As Hacker News noted, this is highly insecure, since if your Google account is compromised, so now are your MFA codes.

Unfortunately Google employs dark patterns to convince you to sync your MFA codes to the cloud, and our employee had indeed activated this “feature”. If you install Google Authenticator from the app store directly, and follow the suggested instructions, your MFA codes are by default saved to the cloud. If you want to disable it, there isn’t a clear way to “disable syncing to the cloud”, instead there is just a “unlink Google account” option. In our corporate Google account, there is also no way for an administrator to centrally disable Google Authenticator’s sync “feature”. We will get more into this later."

https://retool.com/blog/mfa-isnt-mfa/

When MFA isn't actually MFA

Due to a recent Google change, MFA isn't truly MFA.

Retool Blog
Also this part: "The fact that access to a Google account immediately gave access to all MFA tokens held within that account is the major reason why the attacker was able to get into our internal systems."
@briankrebs I'm starting to get the sense that we're in the beginning stages of conventional wisdom switching from "TOTP MFA makes you secure" to "TOTP MFA is too phishable, only use hardware keys and passkeys". It'll probably be another decade before it's mainstream (see SMS as a second factor), but maybe?
@wjohnston @briankrebs Except that hardware keys can still be very cumbersome, so we'll see that shift into passkeys, which for portability, get support from password managers, which for simplicity, get integrated into your OS and other primary login systems, which just puts us back where we started.
@darthnull @briankrebs I mostly agree… We finished switching my company of roughly 150 folks over to using Yubikeys for our core systems a few months ago. So in a business setting, it doesn't seem terribly bad (especially for the folks who can do more damage, like engineers). In general though, I think that moving to a single non-phishable (or at least quite difficult to phish) factor with passkeys will be far better than the current phishable password + phishable TOTP.
@darthnull @briankrebs With all that said, my last assertion (single passkey factor is more secure than passwords plus totp) will probably be the center of the debate in the next decade, methinks.
@wjohnston @briankrebs I think there still needs to be a second factor — a strong PIN on the key. Because (again, convenience) a lot of them will be the little nubs that barely stick out of the USB port, always installed. And easy to steal from a momentarily unattended laptop.
@wjohnston But generally, yes, I’m excited to see where this sort of active cryptographic auth leads.

@wjohnston @darthnull @briankrebs Anybody who disputes that misunderstands how digital authentication actually works. “Something you know” has never been meaningfully different from “something you have”.

TOTP is ultimately just another symmetric token, like having a second password. It’s a little better than a password in that the token isn’t sent to the authenticating entity in cleartext, but it’s still symmetric. Passkeys are asymmetric. Asymmetric tokens are objectively more secure for authentication, which is why we have had computers use them to authenticate to each other for decades.