Files
bsodfather 54ce770682
CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.

Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
  Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
  3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
  revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
  version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
  dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
  resources/list admission fix for bound template publications.

Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
  `just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
  a real MCP Inspector 2.12.0 client smoke.

Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
  runs only on main), story events run the changed packages, the full workspace suite
  stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
  release entry of the tag instead of dying with the runner workspace.

Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.

Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
2026-10-25 09:08:22 +00:00

617 lines
23 KiB
Rust

//! AC02 / AT-3.7-02: publication validator.
//!
//! Проверяется, что публикация повторно проверяет сохранённые URI/MIME и целостность
//! артефакта (defense-in-depth: строки БД могут пережить более строгую грамматику), а
//! secret-bearing content (raw credential, private key, access-bypassing reference) блокирует
//! публикацию. Любой отказ сохраняет Draft и не создаёт Published metadata.
//!
//! TL interface decision 4: синтетические канарейки, никаких реальных credentials; при
//! отсутствии конкретного secret-policy входа точный пробел возвращается TL вместе с готовым
//! RED (см. `.tmp/t_b132062a/STORY37-ATDD-REPORT.md`).
use super::super::helpers::{
DEFAULT_WORKSPACE_ID, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD, create_draft, draft_metadata,
login_client, spawn_authorized, table_row_count,
};
use super::{
create_fixture, overwrite_current_version_mime, overwrite_resource_uri, publish_expect_refusal,
replace_blob_with_tampered_bytes, spawn_with_storage, update_draft_expect_success,
};
use reqwest::StatusCode;
use serde_json::json;
use serial_test::serial;
// ---------------------------------------------------------------------------
// Defense-in-depth: сохранённые метаданные проверяются заново
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_publish_revalidates_stored_uri_and_mime_grammar() {
let (registry, server, client) = spawn_authorized("story37_publish_stored_grammar").await;
// (a) сохранённый URI больше не удовлетворяет грамматике D-10 (верхний регистр схемы),
// хотя ограничение длины и уникальность БД соблюдены.
let uri_fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/stored-uri",
"stored_uri",
"text",
"text/plain",
"internal",
),
b"stored uri body",
"story37-stored-uri.txt",
"text/plain",
)
.await;
overwrite_resource_uri(
registry.pool(),
&uri_fixture.resource_id,
"CRANK://story37/stored-uri",
)
.await;
let refusal = publish_expect_refusal(
&client,
&server,
&uri_fixture.resource_id,
&uri_fixture.updated_at,
StatusCode::BAD_REQUEST,
"AT-3.7-02 stored uri re-validation",
)
.await;
assert_eq!(
refusal["error"]["code"],
json!("resource_uri_invalid"),
"the stored uri grammar failure must keep the existing Resource code: {refusal}"
);
assert_eq!(refusal["error"]["context"]["field"], json!("uri"));
// (b) сохранённый MIME текущей версии больше не входит в allowlist kind.
let mime_fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/stored-mime",
"stored_mime",
"text",
"text/plain",
"internal",
),
b"stored mime body",
"story37-stored-mime.txt",
"text/plain",
)
.await;
overwrite_current_version_mime(
registry.pool(),
&mime_fixture.resource_id,
"application/zip",
)
.await;
let refusal = publish_expect_refusal(
&client,
&server,
&mime_fixture.resource_id,
&mime_fixture.updated_at,
StatusCode::BAD_REQUEST,
"AT-3.7-02 stored mime re-validation",
)
.await;
assert_eq!(
refusal["error"]["code"],
json!("resource_mime_not_allowed"),
"the stored mime allowlist failure must keep the existing Resource code: {refusal}"
);
assert_eq!(refusal["error"]["context"]["field"], json!("mime_type"));
// Оба Draft сохранены и остаются читаемыми: отказ не удалил и не переписал состояние.
assert_eq!(
table_row_count(registry.pool(), "resources").await,
2,
"both refused Drafts must still exist"
);
}
// ---------------------------------------------------------------------------
// Defense-in-depth: целостность сохранённого артефакта
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_publish_refuses_tampered_artifact_integrity() {
let (registry, server, client, storage_root) =
spawn_with_storage("story37_publish_integrity").await;
let bytes = b"integrity fixture body\n";
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/integrity",
"integrity_doc",
"text",
"text/plain",
"internal",
),
bytes,
"story37-integrity.txt",
"text/plain",
)
.await;
let digest = fixture.card["version"]["digest"]
.as_str()
.expect("Draft card must expose the stored digest")
.to_owned();
assert_eq!(
digest,
super::super::helpers::sha256_hex(bytes),
"the fixture digest must match the stored bytes"
);
let versions_before = table_row_count(registry.pool(), "resource_versions").await;
// Store-контракт сохраняется (обычный read-only файл с одной ссылкой), поэтому отказ
// обязан прийти именно из digest/размерной проверки.
replace_blob_with_tampered_bytes(&storage_root, &digest, b"story37-tampered-payload");
let refusal = publish_expect_refusal(
&client,
&server,
&fixture.resource_id,
&fixture.updated_at,
StatusCode::UNPROCESSABLE_ENTITY,
"AT-3.7-02 artifact integrity",
)
.await;
assert!(
!refusal
.to_string()
.contains(storage_root.to_str().unwrap_or_default()),
"an integrity refusal must not disclose the storage path: {refusal}"
);
assert_eq!(
table_row_count(registry.pool(), "resource_versions").await,
versions_before,
"a refused publication must not register a new version row"
);
}
// ---------------------------------------------------------------------------
// Secret-bearing content блокирует публикацию
// ---------------------------------------------------------------------------
/// Синтетический PEM-блок: заголовки реального формата, тело — очевидно неправдоподобная
/// строка, поэтому ни один настоящий ключ не используется (TL decision 4).
const SYNTHETIC_PRIVATE_KEY_PEM: &str = "-----BEGIN PRIVATE KEY-----\n\
c3ludGhldGljLXN0b3J5MzctcHJpdmF0ZS1rZXktYm9keS1ub3QtYS1yZWFsLWtleQ==\n\
-----END PRIVATE KEY-----\n";
/// Синтетическая raw credential: документированный AWS-пример (публичные, учебные значения),
/// а не рабочий секрет.
const SYNTHETIC_RAW_CREDENTIAL: &str = "aws_access_key_id = AKIAIOSFODNN7EXAMPLE\n\
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY\n";
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_publish_refuses_private_key_content() {
let (_registry, server, client) = spawn_authorized("story37_secret_private_key").await;
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/private-key",
"private_key_doc",
"text",
"text/plain",
"internal",
),
SYNTHETIC_PRIVATE_KEY_PEM.as_bytes(),
"story37-private-key.txt",
"text/plain",
)
.await;
let refusal = publish_expect_refusal(
&client,
&server,
&fixture.resource_id,
&fixture.updated_at,
StatusCode::UNPROCESSABLE_ENTITY,
"AT-3.7-02 private key publication refusal",
)
.await;
assert!(
!refusal.to_string().contains("BEGIN PRIVATE KEY")
&& !refusal.to_string().contains("c3ludGhldGlj"),
"the refusal must stay sanitized and must not echo the secret-bearing content: {refusal}"
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_publish_refuses_raw_credential_content() {
let (_registry, server, client) = spawn_authorized("story37_secret_raw_credential").await;
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/raw-credential",
"raw_credential_doc",
"text",
"text/plain",
"internal",
),
SYNTHETIC_RAW_CREDENTIAL.as_bytes(),
"story37-raw-credential.txt",
"text/plain",
)
.await;
let refusal = publish_expect_refusal(
&client,
&server,
&fixture.resource_id,
&fixture.updated_at,
StatusCode::UNPROCESSABLE_ENTITY,
"AT-3.7-02 raw credential publication refusal",
)
.await;
assert!(
!refusal.to_string().contains("AKIAIOSFODNN7EXAMPLE")
&& !refusal.to_string().contains("wJalrXUtnFEMI"),
"the refusal must stay sanitized and must not echo the credential: {refusal}"
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_publish_refuses_access_bypassing_reference() {
let (registry, server, _client) = spawn_authorized("story37_secret_bypass").await;
// WorkspaceB принадлежит тому же аккаунту (Owner membership), поэтому обе сущности
// доступны одной авторизации, но это разные workspace-скоупы: ссылка из WorkspaceA на
// секретную сущность WorkspaceB обошла бы scope публикуемого ресурса.
let owned_workspace = super::super::helpers::create_owned_workspace(&registry).await;
let workspace_b = server
.as_ref()
.replace(DEFAULT_WORKSPACE_ID, owned_workspace.as_str());
// Сессия логинится уже после выдачи membership.
let client = login_client(&server, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD).await;
let secret_meta = draft_metadata(
"crank://story37/secret-source",
"secret_source",
"text",
"text/plain",
"secret",
);
create_draft(
&client,
&workspace_b,
&secret_meta,
b"secret payload of another workspace",
"story37-secret-source.txt",
"text/plain",
)
.await;
let referencing_content = "include: crank://story37/secret-source\n";
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/bypassing-ref",
"bypassing_ref",
"text",
"text/plain",
"internal",
),
referencing_content.as_bytes(),
"story37-bypassing-ref.txt",
"text/plain",
)
.await;
let refusal = publish_expect_refusal(
&client,
&server,
&fixture.resource_id,
&fixture.updated_at,
StatusCode::UNPROCESSABLE_ENTITY,
"AT-3.7-02 access-bypassing reference refusal",
)
.await;
assert!(
!refusal.to_string().contains("secret_source")
&& !refusal
.to_string()
.contains("crank://story37/secret-source"),
"the refusal must not disclose the referenced secret entity: {refusal}"
);
}
/// Точность детектора: обычный текст, который лишь упоминает категории, не является секретом
/// и обязан публиковаться (TL decision 4: не считать любую ссылку secret, не вводить
/// universal scanner).
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_benign_mentions_are_not_treated_as_secrets() {
let (_registry, server, client) = spawn_authorized("story37_secret_precision").await;
let benign = "Инструкция: не коммитьте private key в репозиторий, \
используйте secret manager и переменные окружения.\n";
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/benign-mentions",
"benign_mentions",
"text",
"text/plain",
"internal",
),
benign.as_bytes(),
"story37-benign.txt",
"text/plain",
)
.await;
let (status, text, body) =
super::publish(&client, &server, &fixture.resource_id, &fixture.updated_at).await;
assert_eq!(
status,
StatusCode::OK,
"a merely descriptive text must stay publishable; observed {} body={text}",
super::super::helpers::error_signature(status, &body)
);
assert_eq!(super::published_metadata(&body)["version"], json!(1));
}
// ---------------------------------------------------------------------------
// Позитивный контроль: отказ не ломает существующий контракт обновления Draft
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_refusal_keeps_existing_draft_update_contract_intact() {
let (registry, server, client) = spawn_authorized("story37_refusal_then_update").await;
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/refusal-update",
"refusal_update",
"text",
"text/plain",
"internal",
),
b"first body",
"story37-refusal-update.txt",
"text/plain",
)
.await;
overwrite_current_version_mime(registry.pool(), &fixture.resource_id, "application/zip").await;
publish_expect_refusal(
&client,
&server,
&fixture.resource_id,
&fixture.updated_at,
StatusCode::BAD_REQUEST,
"AT-3.7-02 refusal has no side effects",
)
.await;
// Существующий PUT-контракт после отказа продолжает работать: precondition карточки
// не сдвинулся, обычное редактирование принимается и возвращает состояние Draft.
let updated = update_draft_expect_success(
&client,
&server,
&fixture.resource_id,
&json!({
"description": "правка после отказа",
"mime_type": "text/plain",
"sensitivity": "public",
"expected_updated_at": fixture.updated_at,
}),
b"second body",
"story37-refusal-update.txt",
"text/plain",
)
.await;
assert_eq!(updated["version"]["version"], json!(2));
assert_eq!(updated["version"]["mime_type"], json!("text/plain"));
}
// ---------------------------------------------------------------------------
// F2/F3/F1 (TL CODE-REVIEW): семантические raw credentials, реальные
// placeholders и безопасная инспекция malformed содержимого
// ---------------------------------------------------------------------------
/// F2: JSON-credential распознаётся независимо от позиции ключа и от JSON-экранирования;
/// отказ — тот же generic 422 `field=content` без новых строк публикации/source.
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_json_credentials_are_detected_semantically() {
let (registry, server, client) = spawn_authorized("story37_secret_json").await;
for (uri, name, content) in [
(
"crank://story37/json-later-key",
"json_later_key",
br#"{"name":"config","password":"synthetic-password-42"}"#.as_slice(),
),
(
"crank://story37/json-escaped-key",
"json_escaped_key",
br#"{"pass\u0077ord":"synthetic-password-42"}"#.as_slice(),
),
] {
let fixture = create_fixture(
&client,
&server,
&draft_metadata(uri, name, "json", "application/json", "internal"),
content,
"story37-secret.json",
"application/json",
)
.await;
// Счётчики берутся после создания Draft: сам Draft владеет одной active-ссылкой.
let publications_before = table_row_count(registry.pool(), "resource_publications").await;
let sources_before = table_row_count(registry.pool(), "artifact_sources").await;
let refusal = publish_expect_refusal(
&client,
&server,
&fixture.resource_id,
&fixture.updated_at,
StatusCode::UNPROCESSABLE_ENTITY,
"AT-3.7-02 JSON raw credential refusal",
)
.await;
assert_eq!(refusal["error"]["code"], json!("resource_secret_findings"));
assert_eq!(refusal["error"]["context"]["field"], json!("content"));
assert!(
!refusal.to_string().contains("synthetic-password-42"),
"the refusal must not echo the credential: {refusal}"
);
assert_eq!(
table_row_count(registry.pool(), "resource_publications").await,
publications_before,
"a refused JSON credential must not insert a publication row ({content:?})"
);
assert_eq!(
table_row_count(registry.pool(), "artifact_sources").await,
sources_before,
"a refused JSON credential must not insert an owning source ({content:?})"
);
}
}
/// F2: обычные text-assignment формы (bare `token`, произвольный размер значения) и
/// Bearer без цифр — те же raw credentials; ни одна не публикуется.
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_text_assignments_and_digit_free_bearer_are_refused() {
let (registry, server, client) = spawn_authorized("story37_secret_assignments").await;
for (index, content) in [
"token = synthetic-value-42\n",
"password = abc123\n",
"Bearer abcdefghijklmnopqrstuvwx\n",
]
.into_iter()
.enumerate()
{
let uri = format!("crank://story37/assignment-{index}");
let name = format!("assignment_{index}");
let fixture = create_fixture(
&client,
&server,
&draft_metadata(&uri, &name, "text", "text/plain", "internal"),
content.as_bytes(),
"story37-assignment.txt",
"text/plain",
)
.await;
// Счётчики берутся после создания Draft: сам Draft владеет одной active-ссылкой.
let publications_before = table_row_count(registry.pool(), "resource_publications").await;
let sources_before = table_row_count(registry.pool(), "artifact_sources").await;
let refusal = publish_expect_refusal(
&client,
&server,
&fixture.resource_id,
&fixture.updated_at,
StatusCode::UNPROCESSABLE_ENTITY,
"AT-3.7-02 text raw credential refusal",
)
.await;
assert_eq!(refusal["error"]["code"], json!("resource_secret_findings"));
assert_eq!(refusal["error"]["context"]["field"], json!("content"));
assert_eq!(
table_row_count(registry.pool(), "resource_publications").await,
publications_before,
"a refused raw credential must not insert a publication row ({content:?})"
);
assert_eq!(
table_row_count(registry.pool(), "artifact_sources").await,
sources_before,
"a refused raw credential must not insert an owning source ({content:?})"
);
}
}
/// F3: полная заглушка в реальной assignment-форме (`Authorization: Bearer ***`)
/// публикуется; положительный контроль — настоящий синтетический token по-прежнему
/// блокируется (`story37_at02_text_assignments_and_digit_free_bearer_are_refused`).
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_authorization_placeholder_is_publishable() {
let (_registry, server, client) = spawn_authorized("story37_secret_placeholder").await;
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/auth-placeholder",
"auth_placeholder",
"text",
"text/plain",
"internal",
),
b"Authorization: Bearer ***\n",
"story37-auth-placeholder.txt",
"text/plain",
)
.await;
let (status, text, body) =
super::publish(&client, &server, &fixture.resource_id, &fixture.updated_at).await;
assert_eq!(
status,
StatusCode::OK,
"a documented placeholder must stay publishable; observed {} body={text}",
super::super::helpers::error_signature(status, &body)
);
assert_eq!(super::published_metadata(&body)["version"], json!(1));
}
/// F1: malformed PEM-подобный префикс с многобайтовыми символами — обычный bounded
/// ответ (публикация проходит как обычный текст), а не паника/обрыв соединения.
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at02_malformed_key_prefix_is_a_normal_bounded_response() {
let (_registry, server, client) = spawn_authorized("story37_secret_malformed").await;
let content = format!("-----BEGIN a{}", "я".repeat(60));
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/malformed-key",
"malformed_key",
"text",
"text/plain",
"internal",
),
content.as_bytes(),
"story37-malformed-key.txt",
"text/plain",
)
.await;
let (status, text, body) =
super::publish(&client, &server, &fixture.resource_id, &fixture.updated_at).await;
assert_eq!(
status,
StatusCode::OK,
"a malformed non-key prefix must produce a normal bounded response; observed {} body={text}",
super::super::helpers::error_signature(status, &body)
);
assert_eq!(super::published_metadata(&body)["version"], json!(1));
}