К содержимому

← Блог

01.09.2026 · обновлено 18.10.2026 · сделай сам · 12 просмотров

Откуда аутентификатор берёт шестизначный код и как проверить резервную копию

Телефон в режиме полёта продолжает показывать свежие коды двухфакторной аутентификации, хотя сети нет. Код не приходит с сервера: всё нужное для расчёта лежит в телефоне с того момента, как второй фактор подключали.

Это «всё нужное» — один секрет, короткая строка, выданная сервисом при подключении. Кто её скопировал, тот считает коды к аккаунту пока секрет действует, а вход с чужого устройства выглядит в журнале как обычный успешный вход с верным вторым фактором. Утёкший пароль меняют, а секрет второго фактора остаётся прежним, пока его не пересоздадут руками.

Код считается на телефоне из секрета и часов

Приложение-аутентификатор (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 или SHA512SHA1
digitsдлина кода, 6 или 86
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.