//! 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(®istry).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)); }