Add reCAPTCHA v3 and bump panel to v110
This commit is contained in:
1 parent
5414eb6c4f
commit
9aa6b9daf9
10 files changed
+966
-53
No files matched your search
@@ -0,0 +1,82 @@
|
||||
# reCAPTCHA v3 в OpenWrt Remote Hub v110
|
||||
|
||||
В меню владельца, в блоке «Капча на экране входа», доступны цифры,
|
||||
Google reCAPTCHA v2 Checkbox и Google reCAPTCHA v3. Установка обновления
|
||||
сохраняет текущий режим и ключи. Для включения v3 выберите этот режим,
|
||||
введите Site Key и Secret Key для **v3** и домена панели, затем сохраните
|
||||
настройки с текущим паролем Hub.
|
||||
|
||||
При смене режима поля ключей очищаются. Для цифровой капчи они скрыты,
|
||||
а после сохранения ключи удаляются из настроек на сервере. Для v2/v3
|
||||
нужно ввести ключи выбранной версии; сервер не подставляет ключи другой
|
||||
версии и отклоняет сохранение Google reCAPTCHA с пустыми ключами.
|
||||
Удалённый текст полей больше не восстанавливается из-за обработки пустых
|
||||
значений формы. Простое обновление формы сохраняет несохранённый ввод.
|
||||
|
||||
Порог оценки по умолчанию — 0.5, его можно изменить от 0 до 1.
|
||||
Сервер отклоняет ответ с недостаточной оценкой, неверным доменом,
|
||||
действием, отличным от `login`, отсутствующим или некорректным score.
|
||||
Пароль и настроенная 2FA проверяются после капчи. При недоступности
|
||||
Google вход по паролю показывает ошибку; другие способы входа остаются
|
||||
доступны. Secret Key не попадает на публичную страницу входа.
|
||||
|
||||
Токен получается при отправке формы, а не при загрузке страницы.
|
||||
Повторная попытка получает новый токен; повторный клик во время запроса
|
||||
не отправляет второй вход. При ошибке или недоступности Google кнопка
|
||||
снова становится доступной. На загрузку/ответ Google в браузере отведено
|
||||
12 секунд, затем на запрос входа — 20 секунд.
|
||||
|
||||
Интеграция следует [документации Google v3](https://developers.google.com/recaptcha/docs/v3)
|
||||
и [проверке токенов](https://developers.google.com/recaptcha/docs/verify).
|
||||
Ключи v3 регистрируются в [консоли reCAPTCHA](https://www.google.com/recaptcha/admin/create).
|
||||
Стандартный Google badge не скрывается.
|
||||
|
||||
## Проверки
|
||||
|
||||
```powershell
|
||||
python -m unittest discover -s tests -v
|
||||
python tests/test_recaptcha.py --export-js .test-output/recaptcha
|
||||
node --check .test-output/recaptcha/login.js
|
||||
node --check .test-output/recaptcha/dashboard.js
|
||||
node tests/test_recaptcha_login.cjs .test-output/recaptcha/login.js
|
||||
```
|
||||
|
||||
Python проверяет настройки, проверки ответа Google, совместимость v2/цифр,
|
||||
отсутствие Secret Key в странице входа и настоящий HTTP `/login`
|
||||
с разрешением/отказом до создания сессии. Ответы Google подменены;
|
||||
настоящие ключи не нужны. Node проверяет получение свежего токена,
|
||||
повторный вход, ошибки, timeout, двойной клик и сохранение настроек.
|
||||
Реальную выдачу токена Google нужно проверить на домене VPS с ключами v3.
|
||||
|
||||
## Установка локальных изменений и откат
|
||||
|
||||
Из PowerShell Windows 11, находясь в корне репозитория:
|
||||
|
||||
```powershell
|
||||
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "vps\deploy-recaptcha-v3.ps1" -Vps "root@YOUR_VPS_IP" -Action Install
|
||||
```
|
||||
|
||||
Скрипт загружает локальный Python файл и тесты, проверяет их до замены
|
||||
рабочего файла, сохраняет резервную копию, перезапускает `owrt-remote`
|
||||
и проверяет health. База роутеров не заменяется. Установка не меняет
|
||||
режим капчи: после неё v3 включается через настройки панели.
|
||||
|
||||
Откат при необходимости:
|
||||
|
||||
```powershell
|
||||
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "vps\deploy-recaptcha-v3.ps1" -Vps "root@YOUR_VPS_IP" -Action Rollback
|
||||
```
|
||||
|
||||
Откат восстанавливает Python файл и **только настройки капчи**, сохраняя
|
||||
актуальный пароль, пользователей и другие параметры авторизации.
|
||||
Это позволяет вернуть v2 вместе с прежними ключами после тестирования v3.
|
||||
При неудачном запуске после установки/отката возвращается состояние
|
||||
непосредственно перед попыткой. Резервные копии при повторном запуске
|
||||
не перезаписываются:
|
||||
|
||||
* `/opt/owrt-remote/owrt-remote-hub.py.bak-before-recaptcha-v3-v110`
|
||||
* `/opt/owrt-remote/captcha-before-recaptcha-v3-v110.json` (режим 0600).
|
||||
|
||||
Скрипт рассчитан на стандартные пути установленного Hub:
|
||||
`/opt/owrt-remote/owrt-remote-hub.py`, `/var/lib/owrt-remote/hub-auth.json`
|
||||
и health на `http://127.0.0.1:8088/health`.
|
||||
@@ -1,6 +1,6 @@
|
||||
# Аудит ресурсов OpenWrt Remote Hub v109
|
||||
# Аудит ресурсов OpenWrt Remote Hub v110
|
||||
|
||||
Исправления внесены поверх `7f809fd`. Версия панели остаётся v109.
|
||||
Исправления внесены поверх `7f809fd`. Версия панели остаётся v110.
|
||||
|
||||
## SQLite
|
||||
|
||||
@@ -115,7 +115,7 @@ powershell.exe -NoProfile -ExecutionPolicy Bypass -File "vps\deploy-resource-fix
|
||||
|
||||
Установщик загружает локальный файл без Git, запускает изолированные тесты,
|
||||
сохраняет исходный серверный файл:
|
||||
`/opt/owrt-remote/owrt-remote-hub.py.bak-before-resource-fix-v109`,
|
||||
`/opt/owrt-remote/owrt-remote-hub.py.bak-before-resource-fix-v110`,
|
||||
атомарно заменяет Python файл, перезапускает `owrt-remote` и проверяет health.
|
||||
Существующая резервная копия не перезаписывается. При ошибке установки
|
||||
восстанавливается файл, работавший непосредственно перед текущей попыткой.
|
||||
|
||||
@@ -0,0 +1,278 @@
|
||||
"""Login/settings regression tests. Google responses are mocked; no real keys.
|
||||
|
||||
Run: python -m unittest discover -s tests -v
|
||||
The deployment helper can load a staged hub via OWRT_RECAPTCHA_HUB_SOURCE.
|
||||
"""
|
||||
import importlib.util
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from unittest import mock
|
||||
|
||||
|
||||
SOURCE = Path(os.environ.get("OWRT_RECAPTCHA_HUB_SOURCE", Path(__file__).resolve().parents[1] / "vps" / "owrt-remote-hub.py"))
|
||||
STATE = tempfile.TemporaryDirectory(prefix="owrt-recaptcha-tests-")
|
||||
spec = importlib.util.spec_from_file_location("recaptcha_test_hub", SOURCE)
|
||||
hub = importlib.util.module_from_spec(spec)
|
||||
sys.modules[spec.name] = hub
|
||||
with mock.patch.dict(os.environ, {"OWRT_REMOTE_STATE_DIR": STATE.name}):
|
||||
spec.loader.exec_module(hub)
|
||||
|
||||
|
||||
def configured_auth(mode=hub.CAPTCHA_MODE_RECAPTCHA_V3, score=0.5):
|
||||
return hub.normalize_auth_state({
|
||||
"username": "test-owner",
|
||||
"captcha": {"mode": mode, "site_key": "test-site", "secret_key": "test-secret", "min_score": score},
|
||||
})
|
||||
|
||||
|
||||
class RecaptchaTests(unittest.TestCase):
|
||||
def verify(self, result, **kwargs):
|
||||
with mock.patch.object(hub, "oauth_fetch_json", return_value=result) as google:
|
||||
answer = hub.verify_recaptcha_token("test-secret", "test-token", expected_hostname="hub.example", expected_action="login", **kwargs)
|
||||
return answer, google
|
||||
|
||||
def test_modes_and_old_v2_settings_are_preserved(self):
|
||||
self.assertEqual(hub.sanitize_captcha_mode("recaptcha"), hub.CAPTCHA_MODE_RECAPTCHA)
|
||||
self.assertEqual(hub.sanitize_captcha_mode("recaptcha_v3"), hub.CAPTCHA_MODE_RECAPTCHA_V3)
|
||||
self.assertEqual(hub.sanitize_captcha_mode("unknown"), hub.CAPTCHA_MODE_DIGITS)
|
||||
old = hub.sanitize_captcha_state({"mode": "recaptcha", "site_key": "old-site", "secret_key": "old-secret"})
|
||||
self.assertEqual(old["mode"], "recaptcha")
|
||||
self.assertEqual(old["min_score"], 0.5)
|
||||
self.assertEqual(hub.effective_captcha_state({"captcha": {"mode": "recaptcha_v3"}})["effective_mode"], "digits")
|
||||
|
||||
def test_invalid_thresholds_are_rejected(self):
|
||||
for value in (True, None, "", "nan", "inf", -0.1, 1.1):
|
||||
with self.subTest(value=value), self.assertRaises(ValueError):
|
||||
hub.parse_recaptcha_score(value)
|
||||
self.assertEqual(hub.parse_recaptcha_score("0"), 0)
|
||||
self.assertEqual(hub.parse_recaptcha_score("1"), 1)
|
||||
self.assertEqual(hub.sanitize_captcha_state({"min_score": "nan"})["min_score"], 0.5)
|
||||
|
||||
def test_v3_checks_success_action_hostname_and_score(self):
|
||||
good = {"success": True, "hostname": "hub.example", "action": "login", "score": 0.5}
|
||||
self.assertTrue(self.verify(good)[0][0])
|
||||
for patch in ({"score": 0.49}, {"score": None}, {"score": True}, {"score": "0.9"}, {"score": float("nan")},
|
||||
{"score": 1.1}, {"action": "other"}, {"action": ""}, {"hostname": "other.example"},
|
||||
{"hostname": ""}, {"success": False}, {"success": "true"}):
|
||||
with self.subTest(patch=patch):
|
||||
self.assertFalse(self.verify({**good, **patch})[0][0])
|
||||
self.assertFalse(self.verify({k: v for k, v in good.items() if k != "score"})[0][0])
|
||||
self.assertFalse(self.verify(good, min_score=0.6)[0][0])
|
||||
self.assertFalse(self.verify([])[0][0])
|
||||
|
||||
def test_v2_does_not_require_v3_fields(self):
|
||||
with mock.patch.object(hub, "oauth_fetch_json", return_value={"success": True, "hostname": "hub.example"}):
|
||||
self.assertTrue(hub.verify_recaptcha_token("secret", "token", expected_hostname="hub.example")[0])
|
||||
|
||||
def test_empty_expired_and_network_error_fail_closed(self):
|
||||
with mock.patch.object(hub, "oauth_fetch_json") as google:
|
||||
self.assertFalse(hub.verify_recaptcha_token("secret", "")[0])
|
||||
google.assert_not_called()
|
||||
self.assertFalse(self.verify({"success": False, "error-codes": ["timeout-or-duplicate"]})[0][0])
|
||||
with mock.patch.object(hub, "oauth_fetch_json", side_effect=TimeoutError("unavailable")):
|
||||
self.assertFalse(hub.verify_recaptcha_token("secret", "token")[0])
|
||||
|
||||
def test_google_receives_secret_token_and_optional_ip(self):
|
||||
with mock.patch.object(hub, "oauth_fetch_json", return_value={"success": True}) as google:
|
||||
hub.verify_recaptcha_token("secret", "token", remote_ip="192.0.2.1")
|
||||
google.assert_called_once_with(hub.RECAPTCHA_VERIFY_URL, method="POST", data={"secret": "secret", "response": "token", "remoteip": "192.0.2.1"})
|
||||
|
||||
def test_handler_uses_server_action_and_threshold(self):
|
||||
handler = object.__new__(hub.Handler)
|
||||
handler.client_ip = lambda: "192.0.2.1"
|
||||
handler.request_host_name = lambda: "hub.example"
|
||||
with mock.patch.object(hub, "verify_recaptcha_token", return_value=(True, "")) as verify:
|
||||
self.assertTrue(handler.verify_login_captcha({"g-recaptcha-response": "token", "action": "evil", "score": 1}, configured_auth(score=0.7))[0])
|
||||
self.assertEqual(verify.call_args.kwargs["expected_action"], "login")
|
||||
self.assertEqual(verify.call_args.kwargs["min_score"], 0.7)
|
||||
|
||||
def test_digits_still_work(self):
|
||||
handler = object.__new__(hub.Handler)
|
||||
with mock.patch.object(hub, "verify_captcha", return_value=True) as verify:
|
||||
self.assertTrue(handler.verify_login_captcha({"captcha_token": "token", "captcha_answer": "12345"}, configured_auth("digits"))[0])
|
||||
verify.assert_called_once_with("token", "12345")
|
||||
|
||||
def test_login_pages_and_public_meta_hide_secret(self):
|
||||
auth = configured_auth()
|
||||
self.assertNotIn("secret_key", hub.public_auth_meta(auth)["captcha"])
|
||||
self.assertEqual(hub.admin_auth_meta(auth)["captcha"]["min_score"], 0.5)
|
||||
with mock.patch.object(hub, "load_auth", return_value=auth):
|
||||
page = hub.login_html()
|
||||
self.assertIn("api.js?render=test-site", page)
|
||||
self.assertIn('data-recaptcha-action="login"', page)
|
||||
self.assertIn('name="g-recaptcha-response"', page)
|
||||
self.assertNotIn('name="captcha_answer"', page)
|
||||
self.assertNotIn('class="g-recaptcha"', page)
|
||||
self.assertNotIn("test-secret", page)
|
||||
self.assertNotIn("test-secret", hub.modern_login_captcha_html(auth))
|
||||
for mode in ("digits", "recaptcha"):
|
||||
with mock.patch.object(hub, "load_auth", return_value=configured_auth(mode)):
|
||||
page = hub.login_html()
|
||||
if mode == "digits":
|
||||
self.assertIn('name="captcha_answer"', page)
|
||||
self.assertNotIn('src="https://www.google.com/recaptcha', page)
|
||||
else:
|
||||
self.assertIn('class="g-recaptcha"', page)
|
||||
self.assertNotIn("api.js?render=", page)
|
||||
|
||||
def test_untrusted_site_key_is_escaped_in_markup_and_url(self):
|
||||
auth = configured_auth()
|
||||
auth["captcha"]["site_key"] = '"><script>bad</script>'
|
||||
self.assertNotIn('"><script>bad', hub.modern_login_captcha_html(auth))
|
||||
self.assertIn("%3Cscript%3E", hub.login_recaptcha_script(auth))
|
||||
|
||||
def test_settings_validate_and_preserve_other_auth(self):
|
||||
handler = object.__new__(hub.Handler)
|
||||
handler.send_text = mock.Mock()
|
||||
auth = configured_auth("recaptcha")
|
||||
payload = {"current_password": "fake-password", "captcha_mode": "recaptcha_v3", "captcha_min_score": "0.7", "captcha_site_key": "new-site", "captcha_secret_key": "new-secret"}
|
||||
handler.read_payload = lambda **kwargs: payload
|
||||
with mock.patch.object(hub, "load_auth", return_value=auth), mock.patch.object(hub, "verify_login", return_value=True), mock.patch.object(hub, "save_auth_state") as save:
|
||||
handler.update_auth()
|
||||
self.assertEqual(handler.send_text.call_args.args[0], 200)
|
||||
self.assertEqual(save.call_args.args[0]["captcha"]["mode"], "recaptcha_v3")
|
||||
self.assertEqual(save.call_args.args[0]["captcha"]["min_score"], 0.7)
|
||||
for bad in ("nan", "", "2"):
|
||||
save.reset_mock()
|
||||
payload["captcha_min_score"] = bad
|
||||
handler.update_auth()
|
||||
self.assertEqual(handler.send_text.call_args.args[0], 400)
|
||||
save.assert_not_called()
|
||||
payload.update(captcha_min_score="0.5", captcha_site_key="")
|
||||
handler.update_auth()
|
||||
self.assertEqual(handler.send_text.call_args.args[0], 400)
|
||||
save.assert_not_called()
|
||||
payload = {"current_password": "fake-password", "username": "renamed"}
|
||||
handler.read_payload = lambda **kwargs: payload
|
||||
handler.update_auth()
|
||||
self.assertEqual(save.call_args.args[0]["captcha"]["mode"], "recaptcha")
|
||||
with mock.patch.object(hub, "load_auth", return_value=auth), mock.patch.object(hub, "verify_login", return_value=False), mock.patch.object(hub, "save_auth_state") as save:
|
||||
handler.update_auth()
|
||||
self.assertEqual(handler.send_text.call_args.args[0], 403)
|
||||
save.assert_not_called()
|
||||
|
||||
def test_digits_remove_keys_even_if_old_browser_sends_them(self):
|
||||
handler = object.__new__(hub.Handler)
|
||||
handler.send_text = mock.Mock()
|
||||
payload = {"current_password": "fake-password", "captcha_mode": "digits", "captcha_site_key": "old-site", "captcha_secret_key": "old-secret"}
|
||||
handler.read_payload = lambda **kwargs: payload
|
||||
with mock.patch.object(hub, "load_auth", return_value=configured_auth()), mock.patch.object(hub, "verify_login", return_value=True), mock.patch.object(hub, "save_auth_state") as save:
|
||||
handler.update_auth()
|
||||
self.assertEqual(handler.send_text.call_args.args[0], 200)
|
||||
captcha = save.call_args.args[0]["captcha"]
|
||||
self.assertEqual(captcha["mode"], "digits")
|
||||
self.assertEqual(captcha["site_key"], "")
|
||||
self.assertEqual(captcha["secret_key"], "")
|
||||
|
||||
def test_switching_versions_cannot_reuse_old_keys(self):
|
||||
handler = object.__new__(hub.Handler)
|
||||
handler.send_text = mock.Mock()
|
||||
for before, after in (("recaptcha_v3", "recaptcha"), ("recaptcha", "recaptcha_v3")):
|
||||
with self.subTest(before=before, after=after):
|
||||
handler.read_payload = lambda **kwargs: {"current_password": "fake-password", "captcha_mode": after}
|
||||
with mock.patch.object(hub, "load_auth", return_value=configured_auth(before)), mock.patch.object(hub, "verify_login", return_value=True), mock.patch.object(hub, "save_auth_state") as save:
|
||||
handler.update_auth()
|
||||
self.assertEqual(handler.send_text.call_args.args[0], 400)
|
||||
save.assert_not_called()
|
||||
|
||||
def test_empty_form_fields_are_not_restored_from_old_keys(self):
|
||||
handler = object.__new__(hub.Handler)
|
||||
handler.send_text = mock.Mock()
|
||||
handler.headers = {"Content-Type": "application/x-www-form-urlencoded"}
|
||||
handler.read_body = lambda: b"current_password=fake-password&captcha_mode=recaptcha&captcha_site_key=&captcha_secret_key="
|
||||
self.assertEqual(handler.read_payload(keep_blank_values=True)["captcha_site_key"], "")
|
||||
with mock.patch.object(hub, "load_auth", return_value=configured_auth("recaptcha")), mock.patch.object(hub, "verify_login", return_value=True), mock.patch.object(hub, "save_auth_state") as save:
|
||||
handler.update_auth()
|
||||
self.assertEqual(handler.send_text.call_args.args[0], 400)
|
||||
save.assert_not_called()
|
||||
|
||||
def test_digits_key_removal_persists_after_auth_reload(self):
|
||||
with tempfile.TemporaryDirectory(prefix="owrt-key-reset-") as temp, mock.patch.object(hub, "AUTH_FILE", Path(temp) / "hub-auth.json"):
|
||||
hub.save_auth_state(configured_auth())
|
||||
handler = object.__new__(hub.Handler)
|
||||
handler.send_text = mock.Mock()
|
||||
handler.headers = {"Content-Type": "application/x-www-form-urlencoded"}
|
||||
handler.read_body = lambda: b"current_password=fake-password&captcha_mode=digits&captcha_site_key=&captcha_secret_key="
|
||||
with mock.patch.object(hub, "verify_login", return_value=True):
|
||||
handler.update_auth()
|
||||
self.assertEqual(handler.send_text.call_args.args[0], 200)
|
||||
reloaded = hub.load_auth()["captcha"]
|
||||
self.assertEqual(reloaded["mode"], "digits")
|
||||
self.assertEqual(reloaded["site_key"], "")
|
||||
self.assertEqual(reloaded["secret_key"], "")
|
||||
meta = hub.admin_auth_meta(hub.load_auth())["captcha"]
|
||||
self.assertFalse(meta["configured"])
|
||||
self.assertEqual(meta["site_key"], "")
|
||||
self.assertEqual(meta["secret_key"], "")
|
||||
|
||||
|
||||
class QuietHandler(hub.Handler):
|
||||
def log_message(self, *args):
|
||||
pass
|
||||
|
||||
|
||||
class LoginHttpTests(unittest.TestCase):
|
||||
def test_real_login_http_checks_v3_before_creating_cookie(self):
|
||||
auth = configured_auth()
|
||||
with mock.patch.object(hub, "load_auth", return_value=auth):
|
||||
server = hub.HubHTTPServer(("127.0.0.1", 0), QuietHandler)
|
||||
server.app = hub.App(Path(STATE.name) / "hub.db", "fake-session", "fake-agent", "")
|
||||
server.is_tls = False
|
||||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
base = f"http://127.0.0.1:{server.server_port}"
|
||||
try:
|
||||
result = {"success": True, "action": "login", "score": 0.9, "hostname": "127.0.0.1"}
|
||||
payload = {"username": "test-owner", "password": "fake-password", "g-recaptcha-response": "token"}
|
||||
request = urllib.request.Request(base + "/login", data=json.dumps(payload).encode(), headers={"Content-Type": "application/json"})
|
||||
# Use an opener that exposes 302 and its Set-Cookie header.
|
||||
class NoRedirect(urllib.request.HTTPRedirectHandler):
|
||||
def redirect_request(self, *args):
|
||||
return None
|
||||
opener = urllib.request.build_opener(NoRedirect())
|
||||
with mock.patch.object(hub, "oauth_fetch_json", return_value=result), mock.patch.object(hub, "verify_password_login", return_value=(True, "", auth, "password")) as password, mock.patch.object(hub.Handler, "create_login_session", return_value=("new-session", {})) as session:
|
||||
with self.assertRaises(urllib.error.HTTPError) as caught:
|
||||
opener.open(request, timeout=5)
|
||||
with caught.exception as response:
|
||||
self.assertEqual(response.code, 302)
|
||||
self.assertIn("new-session", response.headers["Set-Cookie"])
|
||||
password.assert_called_once()
|
||||
session.assert_called_once()
|
||||
result["score"] = 0.1
|
||||
password.reset_mock()
|
||||
session.reset_mock()
|
||||
with self.assertRaises(urllib.error.HTTPError) as caught:
|
||||
opener.open(request, timeout=5)
|
||||
with caught.exception as response:
|
||||
self.assertEqual(response.code, 401)
|
||||
password.assert_not_called()
|
||||
session.assert_not_called()
|
||||
finally:
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
thread.join(timeout=5)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) == 3 and sys.argv[1] == "--export-js":
|
||||
output = Path(sys.argv[2])
|
||||
output.mkdir(parents=True, exist_ok=True)
|
||||
auth = configured_auth()
|
||||
with mock.patch.object(hub, "load_auth", return_value=auth):
|
||||
pages = {
|
||||
"login": hub.login_html(),
|
||||
"dashboard": hub.dashboard_html([], "test-owner", auth_bootstrap={**hub.admin_auth_meta(auth), "is_owner": True}),
|
||||
}
|
||||
for name, page in pages.items():
|
||||
(output / f"{name}.js").write_text("\n".join(re.findall(r"<script>(.*?)</script>", page, re.S)), encoding="utf-8")
|
||||
print(f"JavaScript exported to {output}")
|
||||
else:
|
||||
unittest.main()
|
||||
@@ -0,0 +1,187 @@
|
||||
// Run after: python tests/test_recaptcha.py --export-js .test-output/recaptcha
|
||||
// Then: node tests/test_recaptcha_login.cjs .test-output/recaptcha/login.js
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const vm = require('node:vm');
|
||||
const source = fs.readFileSync(process.argv[2], 'utf8').replace(/\r\n/g, '\n');
|
||||
const prepareStart = source.indexOf('async function prepareLoginRecaptcha()');
|
||||
const prepareEnd = source.indexOf('\nfunction setActiveAuthTab', prepareStart);
|
||||
const submitStart = source.indexOf("if (passwordLoginForm) {\n passwordLoginForm.addEventListener('submit'");
|
||||
const submitEnd = source.indexOf('\nasync function loadLoginMeta', submitStart);
|
||||
assert(prepareStart >= 0 && prepareEnd > prepareStart && submitStart >= 0 && submitEnd > submitStart);
|
||||
|
||||
function fixture(kind = 'v3') {
|
||||
const tokenField = {value: 'stale-token', dataset: {recaptchaV3SiteKey: 'test-site', recaptchaAction: 'login'}};
|
||||
const button = {disabled: false};
|
||||
const posts = [], status = [], timers = new Map();
|
||||
let submitted, timerId = 0, generation = 0, resetCount = 0;
|
||||
const form = {
|
||||
action: '/login',
|
||||
querySelector() { return kind === 'v3' ? tokenField : null; },
|
||||
reportValidity() { return true; },
|
||||
addEventListener(event, callback) { submitted = callback; },
|
||||
submit() { posts.push({native: true, token: tokenField.value}); },
|
||||
};
|
||||
const google = {
|
||||
ready(callback) { callback(); },
|
||||
async execute(site, options) {
|
||||
assert.equal(site, 'test-site');
|
||||
assert.equal(options.action, 'login');
|
||||
return 'fresh-token-' + ++generation;
|
||||
},
|
||||
reset() { resetCount++; },
|
||||
};
|
||||
const window = {
|
||||
grecaptcha: google, FormData: true, fetch: true, AbortController: true,
|
||||
setTimeout(callback, delay) { const id = ++timerId; timers.set(id, {callback, delay}); return id; },
|
||||
clearTimeout(id) { timers.delete(id); },
|
||||
location: {assign() { throw new Error('Unexpected redirect in rejection test'); }},
|
||||
};
|
||||
const context = {
|
||||
window, passwordLoginForm: form, passwordLoginSubmitBtn: button,
|
||||
loginSubmitInFlight: false, loginAuthMeta: {}, hubOtp: null,
|
||||
setLoginRuntimeStatus(text) { status.push(text); },
|
||||
FormData: class { constructor() { this.token = tokenField.value; } },
|
||||
AbortController: class { constructor() { this.signal = {}; } abort() {} },
|
||||
extractLoginError() { return 'Incorrect password'; },
|
||||
async fetch(url, options) {
|
||||
posts.push({url, token: options.body.token});
|
||||
return {ok: false, status: 401, async text() { return 'Incorrect password'; }};
|
||||
},
|
||||
};
|
||||
vm.createContext(context);
|
||||
vm.runInContext(source.slice(prepareStart, prepareEnd) + '\n' + source.slice(submitStart, submitEnd), context);
|
||||
return {
|
||||
context, window, google, tokenField, button, posts, status, timers,
|
||||
submit: () => submitted({preventDefault() {}}),
|
||||
resetCount: () => resetCount,
|
||||
};
|
||||
}
|
||||
|
||||
(async () => {
|
||||
const retry = fixture();
|
||||
assert.equal(retry.posts.length, 0, 'v3 must run on submission, not page load');
|
||||
await retry.submit();
|
||||
await retry.submit();
|
||||
assert.deepEqual(retry.posts.map(p => p.token), ['fresh-token-1', 'fresh-token-2']);
|
||||
assert.equal(retry.tokenField.value, '');
|
||||
assert.equal(retry.button.disabled, false);
|
||||
assert.equal(retry.context.loginSubmitInFlight, false);
|
||||
assert.equal(retry.timers.size, 0);
|
||||
|
||||
const failure = fixture();
|
||||
failure.google.execute = async () => { throw new Error('blocked'); };
|
||||
await failure.submit();
|
||||
assert.equal(failure.posts.length, 0, 'a failed CAPTCHA must not send login');
|
||||
assert.equal(failure.button.disabled, false);
|
||||
assert.equal(failure.tokenField.value, '');
|
||||
|
||||
const blocked = fixture();
|
||||
delete blocked.window.grecaptcha;
|
||||
const pending = blocked.submit();
|
||||
const timeout = [...blocked.timers.values()].find(timer => timer.delay === 12000);
|
||||
assert(timeout, 'missing Google script needs a finite timeout');
|
||||
timeout.callback();
|
||||
await pending;
|
||||
assert.equal(blocked.posts.length, 0);
|
||||
assert.equal(blocked.timers.size, 0);
|
||||
assert.equal(blocked.button.disabled, false);
|
||||
|
||||
const doubleClick = fixture();
|
||||
let release;
|
||||
doubleClick.google.execute = () => new Promise(resolve => { release = resolve; });
|
||||
const first = doubleClick.submit();
|
||||
await doubleClick.submit();
|
||||
release('only-once');
|
||||
await first;
|
||||
assert.equal(doubleClick.posts.length, 1, 'double click must not duplicate login');
|
||||
|
||||
const native = fixture();
|
||||
native.window.fetch = false;
|
||||
await native.submit();
|
||||
assert.deepEqual(native.posts, [{native: true, token: 'fresh-token-1'}]);
|
||||
|
||||
for (const kind of ['v2', 'digits']) {
|
||||
const previous = fixture(kind);
|
||||
await previous.submit();
|
||||
assert.equal(previous.posts.length, 1);
|
||||
assert.equal(previous.button.disabled, false);
|
||||
assert.equal(previous.resetCount(), 1);
|
||||
}
|
||||
console.log('RECAPTCHA_LOGIN_JS_OK: fresh tokens, retry, failure, timeout, double click, native POST and old modes');
|
||||
|
||||
const dashboard = fs.readFileSync(path.join(path.dirname(process.argv[2]), 'dashboard.js'), 'utf8');
|
||||
const start = dashboard.indexOf('function updateCaptchaSettingsMode(');
|
||||
const end = dashboard.indexOf('\nfunction authB64urlToBytes', start);
|
||||
const scoreLabel = {hidden: true};
|
||||
const settings = {
|
||||
authCaptchaModeField: {value: 'recaptcha_v3'}, authCaptchaMinScoreField: {},
|
||||
authCaptchaSiteKeyField: {value: 'v3-site'}, authCaptchaSecretKeyField: {value: 'v3-secret'},
|
||||
authCaptchaDraftDirty: false,
|
||||
authForm: {querySelector() { return scoreLabel; }},
|
||||
};
|
||||
vm.createContext(settings);
|
||||
vm.runInContext(dashboard.slice(start, end), settings);
|
||||
settings.updateCaptchaSettingsMode();
|
||||
assert.equal(scoreLabel.hidden, false);
|
||||
assert.equal(settings.authCaptchaMinScoreField.disabled, false);
|
||||
assert.equal(settings.authCaptchaSiteKeyField.placeholder, 'reCAPTCHA v3 Site Key');
|
||||
assert.equal(settings.authCaptchaSiteKeyField.value, 'v3-site', 'rendering must preserve keys of the saved mode');
|
||||
settings.authCaptchaModeField.value = 'recaptcha';
|
||||
settings.updateCaptchaSettingsMode(true);
|
||||
assert.equal(scoreLabel.hidden, true);
|
||||
assert.equal(settings.authCaptchaMinScoreField.disabled, true);
|
||||
assert.equal(settings.authCaptchaSiteKeyField.value, '');
|
||||
assert.equal(settings.authCaptchaSecretKeyField.value, '');
|
||||
assert.equal(settings.authCaptchaSiteKeyField.required, true);
|
||||
assert.equal(settings.authCaptchaDraftDirty, true);
|
||||
settings.authCaptchaSiteKeyField.value = 'v2-site';
|
||||
settings.authCaptchaSecretKeyField.value = 'v2-secret';
|
||||
settings.updateCaptchaSettingsMode();
|
||||
assert.equal(settings.authCaptchaSiteKeyField.value, 'v2-site');
|
||||
settings.authCaptchaModeField.value = 'digits';
|
||||
settings.updateCaptchaSettingsMode(true);
|
||||
assert.equal(settings.authCaptchaSiteKeyField.value, '');
|
||||
assert.equal(settings.authCaptchaSecretKeyField.value, '');
|
||||
assert.equal(settings.authCaptchaSiteKeyField.hidden, true);
|
||||
assert.equal(settings.authCaptchaSiteKeyField.disabled, true);
|
||||
assert.equal(settings.authCaptchaSiteKeyField.required, false);
|
||||
settings.authCaptchaModeField.value = 'recaptcha_v3';
|
||||
settings.updateCaptchaSettingsMode(true);
|
||||
assert.equal(settings.authCaptchaSiteKeyField.value, '');
|
||||
assert.equal(settings.authCaptchaSecretKeyField.value, '');
|
||||
assert.equal(settings.authCaptchaSiteKeyField.hidden, false);
|
||||
assert.equal(settings.authCaptchaSiteKeyField.disabled, false);
|
||||
console.log('RECAPTCHA_SETTINGS_JS_OK: v2/v3/digits switching clears incompatible keys and keeps edited drafts');
|
||||
|
||||
const saveStart = dashboard.indexOf("authForm.addEventListener('submit', async (ev) => {");
|
||||
const saveEnd = dashboard.indexOf('\nif (delegatedUserReset)', saveStart);
|
||||
assert(saveStart >= 0 && saveEnd > saveStart);
|
||||
let saveCallback, posted, reloaded = false;
|
||||
const savedForm = {
|
||||
password: {value: ''}, password_confirm: {value: ''}, current_password: {value: 'fake-password'},
|
||||
addEventListener(type, fn) { saveCallback = fn; },
|
||||
};
|
||||
const saving = {
|
||||
authForm: savedForm, authUsernameDraftDirty: true, authCaptchaDraftDirty: true,
|
||||
setAuthMessage() {}, ownerPasswordRememberEnabled() { return false; }, restoreOwnerPasswordInput() {},
|
||||
FormData: class {
|
||||
constructor(form) { assert.equal(form, savedForm); }
|
||||
*[Symbol.iterator]() { yield ['captcha_mode', 'recaptcha_v3']; yield ['captcha_min_score', '0.7']; }
|
||||
},
|
||||
URLSearchParams,
|
||||
async fetch(url, options) { posted = options.body.toString(); return {ok: true, async text() { return 'Saved'; }}; },
|
||||
async loadAuthMeta() { reloaded = true; },
|
||||
};
|
||||
vm.createContext(saving);
|
||||
vm.runInContext(dashboard.slice(saveStart, saveEnd), saving);
|
||||
const event = {currentTarget: savedForm, preventDefault() {}, stopImmediatePropagation() {}};
|
||||
const saved = saveCallback(event);
|
||||
event.currentTarget = null; // Browsers clear currentTarget after dispatch.
|
||||
await saved;
|
||||
assert.equal(posted, 'captcha_mode=recaptcha_v3&captcha_min_score=0.7');
|
||||
assert.equal(saving.authCaptchaDraftDirty, false);
|
||||
assert.equal(reloaded, true);
|
||||
console.log('RECAPTCHA_SETTINGS_SAVE_JS_OK: v3 persisted and currentTarget expiry handled');
|
||||
})().catch(error => { console.error(error); process.exitCode = 1; });
|
||||
@@ -131,7 +131,7 @@ class HubFixture:
|
||||
assert "groups" in json.loads(self.request("/api/router-groups"))
|
||||
assert "notifications" in json.loads(self.request("/api/notifications"))
|
||||
assert self.request("/access/test-router/") == b"router proxy fixture"
|
||||
assert b"v109" in self.request("/")
|
||||
assert b"v110" in self.request("/")
|
||||
self.app.snapshot_router_states()
|
||||
|
||||
def __exit__(self, *args):
|
||||
|
||||
Reference in new issue
Block a user