Откуда аутентификатор берёт шестизначный код и как проверить резервную копию
Телефон в режиме полёта продолжает показывать свежие коды двухфакторной аутентификации, хотя сети нет. Код не приходит с сервера: всё нужное для расчёта лежит в телефоне с того момента, как второй фактор подключали.
Это «всё нужное» — один секрет, короткая строка, выданная сервисом при подключении. Кто её скопировал, тот считает коды к аккаунту пока секрет действует, а вход с чужого устройства выглядит в журнале как обычный успешный вход с верным вторым фактором. Утёкший пароль меняют, а секрет второго фактора остаётся прежним, пока его не пересоздадут руками.
Код считается на телефоне из секрета и часов
Приложение-аутентификатор (Google Authenticator, Aegis, 2FAS и подобные) работает по алгоритму TOTP — одноразовый пароль, привязанный ко времени, описан в RFC 6238. На входе две вещи: общий секрет, который сервис и приложение получили при подключении второго фактора, и номер текущего отрезка времени. Формула из стандарта — T = (Current Unix time - T0) / X, где X по умолчанию равен 30 секундам, а T0 — начало эпохи Unix, то есть полночь 1 января 1970 года UTC. Unix-время — это число секунд, прошедших с того момента, так что номер отрезка получается делением его нацело на 30.
Дальше номер отрезка подписывается секретом через HMAC-SHA1 (подпись сообщения ключом; сообщение здесь — номер отрезка, ключ — секрет). У HMAC-SHA1 подпись длиной двадцать байт, и из них берутся четыре, начиная со смещения, которое записано в младших четырёх битах последнего байта. Приём называется динамическим усечением и описан в RFC 4226. Остаток от деления получившегося числа на миллион даёт шесть цифр на экране. У телефона есть и секрет, и часы, поэтому сеть ему для расчёта не нужна, а сервер в этот момент считает то же самое у себя из своей копии секрета.
Считаем один код сами
Секрет берётся не свой, а тестовый: в приложении B к RFC 6238 опубликованы контрольные векторы — наборы из секрета, времени и правильного ответа, по которым сверяют реализации. Секрет там задан ASCII-строкой «12345678901234567890», а в ссылку и в код он попадает в кодировке Base32. Base32 — это запись двоичных данных 32 печатными символами (латиница от A до Z и цифры от 2 до 7), чтобы секрет можно было напечатать, продиктовать и зашить в QR-код. Перевод делает та же стандартная библиотека:
python3 -c 'import base64; print(base64.b32encode(b"12345678901234567890").decode())'
GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ
Момент времени тоже из стандарта — 59 секунд от начала эпохи. Контрольные коды в приложении B восьмизначные, поэтому в последней строке остаток берётся не от миллиона, а от десяти в восьмой степени.
import base64, hashlib, hmac, struct
key = base64.b32decode("GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ")
counter = 59 // 30
mac = hmac.new(key, struct.pack(">Q", counter), hashlib.sha1).digest()
offset = mac[-1] & 0x0F
number = struct.unpack(">I", mac[offset:offset + 4])[0] & 0x7FFFFFFF
print(number % 10 ** 8)
По строкам это читается так. Номер отрезка (59 нацело на 30 даёт единицу) упаковывается в восемь байт старшим байтом вперёд, за это отвечает формат ">Q". От подписи берётся последний байт, и его младшие четыре бита дают смещение — маска 0x0F. Со смещения читаются четыре байта как одно целое число, формат ">I". Старший бит гасится маской 0x7FFFFFFF, чтобы число не оказалось отрицательным. Остаток от деления даёт сам код.
На выходе — 94287082, и ровно это число стоит в таблице приложения B для режима SHA1 и момента 59. Расчёт сошёлся со стандартом. Шестизначный код получается той же формулой с делением на миллион, только остаток бывает короче нужной длины, и тогда слева дописываются нули — в рабочем скрипте ниже это делает zfill.
Генератор на стандартной библиотеке
Готовые библиотеки для TOTP есть, и в рабочем коде их брать разумно. Здесь секрет попадёт в тот код, который его проверяет, поэтому код должен быть своим. Секрет второго фактора не отдаётся ни стороннему пакету, ни тем более онлайн-генератору — страница, куда его вставили, получает доступ к аккаунту наравне с владельцем. Хватает стандартной библиотеки Python, устанавливать нечего. Весь генератор — один файл totp_check.py:
#!/usr/bin/env python3
"""Генератор кодов TOTP и проверка резервных копий ссылок otpauth://."""
import argparse
import base64
import hashlib
import hmac
import struct
import sys
import time
from urllib.parse import parse_qs, unquote, urlparse
ALGOS = {"SHA1": hashlib.sha1, "SHA256": hashlib.sha256, "SHA512": hashlib.sha512}
def totp(secret_b32, moment, digits=6, period=30, algo="SHA1"):
"""Код длиной digits для секрета secret_b32 на момент moment (unix-время)."""
raw = secret_b32.upper().replace(" ", "").rstrip("=")
key = base64.b32decode(raw + "=" * (-len(raw) % 8))
counter = int(moment) // period
mac = hmac.new(key, struct.pack(">Q", counter), ALGOS[algo]).digest()
offset = mac[-1] & 0x0F
number = struct.unpack(">I", mac[offset:offset + 4])[0] & 0x7FFFFFFF
return str(number % 10 ** digits).zfill(digits)
def parse_uri(uri):
"""Разбирает ссылку otpauth://totp/... в набор параметров."""
parts = urlparse(uri.strip())
if parts.scheme != "otpauth" or parts.netloc.lower() != "totp":
raise ValueError("нужна ссылка вида otpauth://totp/...")
query = parse_qs(parts.query)
secret = query.get("secret", [""])[0]
if not secret:
raise ValueError("в ссылке нет параметра secret")
return {
"label": unquote(parts.path.lstrip("/")),
"issuer": unquote(query.get("issuer", [""])[0]),
"secret": secret,
"digits": int(query.get("digits", ["6"])[0]),
"period": int(query.get("period", ["30"])[0]),
"algo": query.get("algorithm", ["SHA1"])[0].upper(),
}
VECTORS = [
(b"12345678901234567890", "SHA1", 59, "94287082"),
(b"12345678901234567890", "SHA1", 1111111109, "07081804"),
(b"12345678901234567890", "SHA1", 1111111111, "14050471"),
(b"12345678901234567890", "SHA1", 1234567890, "89005924"),
(b"12345678901234567890", "SHA1", 2000000000, "69279037"),
(b"12345678901234567890", "SHA1", 20000000000, "65353130"),
(b"12345678901234567890123456789012", "SHA256", 59, "46119246"),
(b"1234567890123456789012345678901234567890123456789012345678901234",
"SHA512", 59, "90693936"),
]
def selftest():
"""Сверка с контрольными векторами из RFC 6238, приложение B."""
bad = 0
for seed, algo, moment, expected in VECTORS:
secret = base64.b32encode(seed).decode()
got = totp(secret, moment, digits=8, algo=algo)
mark = "ok" if got == expected else "ОШИБКА"
if got != expected:
bad += 1
print(f"{algo:<6} t={moment:<12} ждём {expected} получили {got} {mark}")
print("совпало всё" if not bad else f"расхождений: {bad}")
return 1 if bad else 0
def show(path, moment):
"""Печатает код для каждой ссылки otpauth:// из файла path."""
stamp = time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime(moment))
print(f"время проверки: {stamp}")
with open(path, encoding="utf-8") as fh:
for line in fh:
line = line.strip()
if not line or line.startswith("#"):
continue
try:
item = parse_uri(line)
except ValueError as err:
print(f"строка пропущена: {err}")
continue
code = totp(item["secret"], moment, item["digits"],
item["period"], item["algo"])
left = item["period"] - int(moment) % item["period"]
name = item["issuer"] or item["label"] or "без имени"
print(f"{name:<24} {code} ещё {left} с "
f"({item['algo']}, {item['digits']} знаков, {item['period']} с)")
return 0
def main():
ap = argparse.ArgumentParser(description="коды TOTP из резервной копии")
ap.add_argument("file", nargs="?", help="файл со ссылками otpauth://")
ap.add_argument("--at", type=int, help="unix-время вместо текущего")
ap.add_argument("--selftest", action="store_true",
help="сверка с контрольными векторами RFC 6238")
args = ap.parse_args()
if args.selftest:
return selftest()
if not args.file:
ap.error("укажите файл со ссылками или --selftest")
return show(args.file, args.at if args.at is not None else time.time())
if __name__ == "__main__":
sys.exit(main())
Base32-секрет в ссылке идёт без выравнивающих символов «=», так требует спецификация формата, а b32decode без них не работает — поэтому они дописываются обратно. Длина кода, шаг и алгоритм не зашиты константами, а читаются из самой ссылки: сервисы с нестандартными значениями встречаются.
Сверка с контрольными векторами
Сначала генератор проверяется на чужих секретах и только потом на своих. Флаг --selftest прогоняет восемь строк из приложения B к RFC 6238 и сравнивает результат с опубликованным.
python3 totp_check.py --selftest
SHA1 t=59 ждём 94287082 получили 94287082 ok
SHA1 t=1111111109 ждём 07081804 получили 07081804 ok
SHA1 t=1111111111 ждём 14050471 получили 14050471 ok
SHA1 t=1234567890 ждём 89005924 получили 89005924 ok
SHA1 t=2000000000 ждём 69279037 получили 69279037 ok
SHA1 t=20000000000 ждём 65353130 получили 65353130 ok
SHA256 t=59 ждём 46119246 получили 46119246 ok
SHA512 t=59 ждём 90693936 получили 90693936 ok
совпало всё
Секреты в векторах разной длины: для SHA1 — двадцать символов, для SHA256 — тридцать два, для SHA512 — шестьдесят четыре. Подставить во все три режима один короткий секрет не выйдет: коды не совпадут с опубликованными, а выглядеть это будет как ошибка в алгоритме.
Что зашито в QR-коде
Секрет попадает в приложение через QR-код, а внутри QR-кода лежит обычная текстовая строка. Формат описан в спецификации Key Uri Format, оттуда же пример:
otpauth://totp/ACME%20Co:john.doe@email.com?secret=HXDMVJECJJWSRB3HWIZR4IFUGFTMXBOZ&issuer=ACME%20Co&algorithm=SHA1&digits=6&period=30
Читается она слева направо. Сразу после otpauth:// стоит тип — здесь totp, бывает ещё hotp, где вместо времени работает счётчик нажатий. Дальше метка ACME%20Co:john.doe@email.com: название сервиса, двоеточие, имя аккаунта — в таком виде запись и подпишется в приложении, а %20 это закодированный пробел, метка проходит через обычное URL-кодирование. Всё после знака вопроса — параметры.
| Параметр | Что задаёт | По умолчанию |
|---|---|---|
| метка в пути | сервис и имя аккаунта, как они видны в приложении | нет |
| secret | сам секрет в кодировке Base32, без выравнивающих «=» | обязателен |
| issuer | название сервиса отдельным параметром | нет |
| algorithm | хеш внутри подписи: SHA1, SHA256 или SHA512 | SHA1 |
| digits | длина кода, 6 или 8 | 6 |
| period | сколько секунд живёт код | 30 |
В той же спецификации сказано, что параметр algorithm реализации Google Authenticator игнорируют, то есть считают по SHA1 независимо от написанного в ссылке. Скрипт выше его учитывает, и на нестандартном алгоритме коды с телефоном разойдутся именно поэтому.
Скриншот QR-кода, оставшийся в галерее телефона или пересланный в мессенджер, — это выданный наружу секрет второго фактора: из картинки строка читается обратно любым сканером, и по ней считаются те же самые коды.
Проверяем резервную копию
Резервная копия второго фактора — те же строки otpauth://, и сохранять их проще всего в момент подключения:
- QR-код на экране подключения читается любым сканером QR и отдаёт строку целиком;
- если рядом с QR-кодом сервис предлагает ручной ввод ключа, там показан тот же секрет текстом, и ссылка собирается из него по формату выше;
- часть аутентификаторов умеет выгружать записи готовыми строками otpauth:// — есть ли такая выгрузка, проверяется в своём приложении.
Отдельный случай — Google Authenticator. Перенос аккаунтов отдаёт там не набор строк, а одну ссылку вида otpauth-migration://offline?data=, внутри которой все записи упакованы в Base64 и protobuf (двоичный формат сериализации от Google); разбор формата лежит на GitHub. Скрипт выше такую строку не примет и напечатает «строка пропущена» — это его штатное поведение, а не поломка. Секрет для уже подключённого аккаунта Google Authenticator текстом не показывает, поэтому ссылка получается только переподключением второго фактора.
Файл ниже учебный: первая ссылка взята из спецификации, вторая собрана из контрольного секрета для SHA256 — Base32-форма получается той же командой, только от строки в тридцать два символа. Третья строка изображает выгрузку Google Authenticator. Боевых секретов здесь нет. Сохраняется как otpauth.txt.
# резервная копия: по одной ссылке otpauth:// на строку
otpauth://totp/ACME%20Co:john.doe@email.com?secret=HXDMVJECJJWSRB3HWIZR4IFUGFTMXBOZ&issuer=ACME%20Co&algorithm=SHA1&digits=6&period=30
otpauth://totp/RFC%206238:sha256?secret=GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQGEZA&issuer=RFC%206238&algorithm=SHA256&digits=8&period=60
otpauth-migration://offline?data=...
Ключ --at подставляет фиксированное unix-время вместо текущего: 1767225600 — это полночь 1 января 2026 года UTC. Нужен он только чтобы вывод совпал с показанным здесь.
python3 totp_check.py otpauth.txt --at 1767225600
время проверки: 2026-01-01 00:00:00 UTC
ACME Co 933865 ещё 30 с (SHA1, 6 знаков, 30 с)
RFC 6238 30962343 ещё 60 с (SHA256, 8 знаков, 60 с)
строка пропущена: нужна ссылка вида otpauth://totp/...
Первая строка вывода — время, на которое посчитаны коды. Дальше по строке на запись: имя из issuer, сам код, сколько секунд ему осталось жить и в скобках параметры, вычитанные из ссылки. Момент выбран на границе отрезка, поэтому у обеих записей стоит полный срок жизни кода. Вторая запись нестандартная во всём — SHA256, восемь цифр, шаг 60 секунд — и считается по своим параметрам, а не по умолчаниям. Последняя строка — та самая выгрузка Google Authenticator, которую скрипт пропустил.
Боевая проверка выглядит так: рядом лежит телефон, скрипт запускается на файле с настоящими ссылками уже без --at, коды сверяются глазами. Расхождение разбирается сразу, пока рабочий генератор ещё в руках, а не в день потери телефона.
Файл с настоящими ссылками — это второй фактор в открытом виде, и обращение с ним такое же, как с ключами. Лежит он в зашифрованном контейнере или в менеджере паролей, распаковывается на время проверки, права на распакованный файл — chmod 600, после сверки он удаляется. Хранить его рядом с паролями к тем же аккаунтам нельзя: один украденный архив отдаст оба фактора сразу. Сами пароли к этим аккаунтам проверяются отдельно, по базам утечек и без отправки наружу.
Где TOTP подводит: часы, SHA1 и фишинг
Первая причина отказа — часы. Код считается от времени, поэтому машина с убежавшими на минуту часами выдаёт коды от соседнего отрезка, и сервис их не принимает. Запас у проверяющей стороны невелик: RFC 6238 рекомендует закладывать на сетевую задержку не больше одного шага, а в разделе о ресинхронизации приводит пример настройки на два шага назад — это около 89 секунд дрейфа. Синхронизация времени проверяется раньше остальных причин.
Слово SHA1 рядом с безопасностью настораживает справедливо, но здесь оно стоит внутри HMAC, а на HMAC-SHA1 коллизионные атаки не переносятся. В RFC 6194 сказано прямо: «As of today, there is no indication that attacks on SHA-1 can be extended to HMAC-SHA-1» — на сегодня нет признаков того, что атаки на SHA-1 переносятся на HMAC-SHA-1. Менять алгоритм ради самой смены смысла нет, тем более что приложение может параметр проигнорировать.
Привязки к сайту у кода нет: шесть цифр подходят к аккаунту, а не к адресу страницы, на которой их спросили. Страница-посредник, которая передаёт введённое на настоящий сайт, примет код и использует его в те же тридцать секунд. Закрывают это аппаратные ключи по WebAuthn: в подписываемые данные там входит адрес запрашивающего сайта, и подпись с чужого домена не подойдёт.
Если секрет всё-таки утёк — скриншот ушёл в переписку, файл с копией попал не туда, — смена пароля не помогает: пароль в расчёте кода не участвует. Второй фактор в этом случае переподключается заново, сервис выдаёт новый секрет, старый перестаёт работать. А там, где чужой вход стоит дорого — почта, к которой привязано всё остальное, банк, доступ в продакшен, — второй фактор лучше брать аппаратный: от аккуратного фишинга шесть цифр не спасают.
Короткие разборы и практика, которые до статьи не дорастают, лежат в канале @azbukait_ru.