kingfisher-rules 3.2.1

Rule definitions and database for Kingfisher secret scanner
use super::{Confidence, RawRules, Rules, RulesError, Validation, load_yaml_file};
use crate::rule::{HttpRequest, Revocation, RuleSyntax};

// Keep these inputs and expectations fixed across YAML implementations. They
// describe the legacy YAML contract, not merely a parser round-trip.
const LEGACY_YAML: &str = r#"rules:
  - id: acme.legacy
    name: yes
    pattern: |-
      (token_[a-z]+)
    tags: [on, off, yes, '0123']
    confidence: MeDiUm
    validation:
      type: Http
      content:
        request:
          method: GET
          url: https://legacy.example.invalid/{{ TOKEN }}
          headers: &headers
            X-Token: '{{ TOKEN }}'
          body: >-
            first line
            second line
          response_matcher: &matchers
            - type: StatusMatch
              status: [200]
    revocation:
      type: Http
      content:
        request:
          method: DELETE
          url:
            - https://legacy.example.invalid/{{ TOKEN }}
            - https://backup.example.invalid/{{ TOKEN }}
          headers: *headers
          response_matcher: *matchers
  - id: acme.defaults
    name: Defaults
    pattern: '(secret_[a-z]+)'
"#;

struct YamlTestFile(std::path::PathBuf);

impl YamlTestFile {
    fn new(content: &[u8]) -> Self {
        use std::io::Write;
        let path = std::env::temp_dir()
            .join(format!("kingfisher-yaml-loader-{}.yml", uuid::Uuid::new_v4()));
        let mut file =
            std::fs::OpenOptions::new().write(true).create_new(true).open(&path).unwrap();
        file.write_all(content).unwrap();
        drop(file);
        Self(path)
    }
}

impl Drop for YamlTestFile {
    fn drop(&mut self) {
        std::fs::remove_file(&self.0).ok();
    }
}

#[test]
fn yaml_file_loader_supports_owned_generic_values() {
    #[derive(Debug, serde::Deserialize, PartialEq)]
    struct Settings {
        name: String,
        bytes: Vec<u16>,
        empty: Option<String>,
    }
    let file = YamlTestFile::new("name: clé\nbytes: [0, 255, 65535]\nempty: null\n".as_bytes());
    assert_eq!(
        load_yaml_file::<Settings, _>(&file.0).unwrap(),
        Settings { name: "clé".into(), bytes: vec![0, 255, 65535], empty: None }
    );
    let file = YamlTestFile::new(b"");
    assert_eq!(load_yaml_file::<Option<String>, _>(&file.0).unwrap(), None);
}

#[test]
fn yaml_file_loader_preserves_open_error_context() {
    let file = YamlTestFile::new(b"{}");
    std::fs::remove_file(&file.0).unwrap();
    let error = load_yaml_file::<serde_json::Value, _>(&file.0).unwrap_err();
    assert_eq!(error.to_string(), format!("Failed to open YAML file: {}", file.0.display()));
    assert_eq!(
        error.downcast_ref::<std::io::Error>().unwrap().kind(),
        std::io::ErrorKind::NotFound
    );
}

#[test]
fn yaml_file_loader_preserves_parse_error_context_and_sources() {
    for input in [b"name: [\n".as_slice(), b"\xff", b"---\n1\n---\n2\n"] {
        let file = YamlTestFile::new(input);
        let error = load_yaml_file::<serde_json::Value, _>(&file.0).unwrap_err();
        assert_eq!(
            error.to_string(),
            format!("Failed to parse YAML from file: {}", file.0.display())
        );
        let cause = error.downcast_ref::<yaml_serde::Error>().unwrap();
        assert!(!cause.to_string().is_empty());
        if input.starts_with(b"---") {
            assert_eq!(
                cause.to_string(),
                "deserializing from YAML containing more than one document is not supported"
            );
        }
    }
    let file = YamlTestFile::new(b"- 999999999999999999999999999999999999999999");
    let error = load_yaml_file::<Vec<u8>, _>(&file.0).unwrap_err();
    assert_eq!(error.to_string(), format!("Failed to parse YAML from file: {}", file.0.display()));
    assert!(error.downcast_ref::<yaml_serde::Error>().is_some());
}

#[test]
fn legacy_yaml_entrypoints_preserve_defaults_anchors_and_block_scalars() {
    let file = YamlTestFile::new(LEGACY_YAML.as_bytes());
    let raw: RawRules = load_yaml_file(&file.0).unwrap();
    let syntax = RuleSyntax::from_yaml_file(&file.0).unwrap();
    assert_eq!(raw.rules, syntax);
    let memory = Rules::from_paths_and_contents(
        [(file.0.as_path(), LEGACY_YAML.as_bytes())],
        Confidence::Low,
    )
    .unwrap();
    let loaded = Rules::from_yaml_file(&file.0, Confidence::Low).unwrap();
    assert_eq!(memory.rules, loaded.rules);
    assert_eq!(syntax.len(), 2);
    assert_eq!(syntax[0].name, "yes");
    assert_eq!(syntax[0].pattern, "(token_[a-z]+)");
    assert_eq!(syntax[0].tags, ["on", "off", "yes", "0123"]);
    assert_eq!(syntax[0].confidence, Confidence::Medium);
    assert!(syntax[0].fallbacks.is_empty());
    assert_eq!(syntax[1], RuleSyntax::new("acme.defaults", "Defaults", "(secret_[a-z]+)"));
    let Some(Validation::Http(validation)) = &syntax[0].validation else {
        panic!("expected legacy HTTP validation");
    };
    let Some(Revocation::Http(revocation)) = &syntax[0].revocation else {
        panic!("expected legacy HTTP revocation");
    };
    assert_eq!(validation.request.body.as_deref(), Some("first line second line"));
    assert_eq!(validation.request.headers, revocation.request.headers);
    assert_eq!(validation.request.headers["X-Token"], "{{ TOKEN }}");
    assert_eq!(validation.request.response_matcher, revocation.request.response_matcher);
    assert_eq!(validation.request.fallback_urls, Vec::<String>::new());
    assert!(!validation.request.response_is_html);
    assert_eq!(
        revocation.request.urls().collect::<Vec<_>>(),
        [
            "https://legacy.example.invalid/{{ TOKEN }}",
            "https://backup.example.invalid/{{ TOKEN }}"
        ]
    );
}

#[test]
fn legacy_yaml_rule_sequence_and_mapping_documents_still_load() {
    let rule = "id: acme.sequence\nname: Sequence\npattern: '(secret_[a-z]+)'\n";
    let sequence = format!("- {}", rule.replace('\n', "\n  ").trim_end());
    let mapping = format!("rules:\n  - {}", rule.replace('\n', "\n    ").trim_end());
    let expected = vec![RuleSyntax::new("acme.sequence", "Sequence", "(secret_[a-z]+)")];
    for contents in [sequence, mapping] {
        let file = YamlTestFile::new(contents.as_bytes());
        assert_eq!(RuleSyntax::from_yaml_file(&file.0).unwrap(), expected);
    }
}

#[test]
fn legacy_yaml_http_url_serialization_preserves_scalar_and_ordered_list_shapes() {
    for (url, expected) in [
        (
            "https://one.example.invalid",
            yaml_serde::Value::String("https://one.example.invalid".into()),
        ),
        (
            "[https://one.example.invalid, https://two.example.invalid]",
            yaml_serde::Value::Sequence(vec![
                yaml_serde::Value::String("https://one.example.invalid".into()),
                yaml_serde::Value::String("https://two.example.invalid".into()),
            ]),
        ),
    ] {
        let request: HttpRequest =
            yaml_serde::from_str(&format!("method: GET\nurl: {url}\n")).unwrap();
        let value = yaml_serde::to_value(&request).unwrap();
        assert_eq!(value["url"], expected);
        let emitted = yaml_serde::to_string(&request).unwrap();
        assert_eq!(yaml_serde::from_str::<HttpRequest>(&emitted).unwrap(), request);
    }
    for url in ["[]", "['']", "[https://one.example.invalid, '  ']"] {
        let error =
            yaml_serde::from_str::<HttpRequest>(&format!("method: GET\nurl: {url}\n")).unwrap_err();
        assert!(error.to_string().contains("HTTP url list"));
    }
}

#[test]
fn legacy_yaml_scalar_resolution_and_emission_remain_unchanged() {
    let value: yaml_serde::Value = yaml_serde::from_str(
        "yes: no\nswitch: on\ntruth: true\nnothing: ~\ncode: '0123'\nint: 0x10\nliteral: |-\n  line one\n  line two\n",
    )
    .unwrap();
    assert_eq!(value["yes"].as_str(), Some("no"));
    assert_eq!(value["switch"].as_str(), Some("on"));
    assert_eq!(value["truth"].as_bool(), Some(true));
    assert!(value["nothing"].is_null());
    assert_eq!(value["code"].as_str(), Some("0123"));
    assert_eq!(value["int"].as_i64(), Some(16));
    assert_eq!(value["literal"].as_str(), Some("line one\nline two"));
    let emitted = yaml_serde::to_string(&value).unwrap();
    assert_eq!(
        emitted,
        "yes: no\nswitch: on\ntruth: true\nnothing: null\ncode: '0123'\nint: 16\nliteral: |-\n  line one\n  line two\n"
    );
    for non_boolean in ["yes", "no", "on", "off"] {
        assert!(yaml_serde::from_str::<bool>(non_boolean).is_err());
    }
}

#[test]
fn legacy_yaml_tagged_enums_keep_their_wire_format() {
    #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
    enum LegacyEnum {
        Unit,
        Text(String),
        Fields { enabled: bool },
    }
    let input = "- Unit\n- !Text 'yes'\n- !Fields\n  enabled: true\n";
    let parsed: Vec<LegacyEnum> = yaml_serde::from_str(input).unwrap();
    assert_eq!(
        parsed,
        [LegacyEnum::Unit, LegacyEnum::Text("yes".into()), LegacyEnum::Fields { enabled: true }]
    );
    assert_eq!(
        yaml_serde::to_string(&parsed).unwrap(),
        "- Unit\n- !Text yes\n- !Fields\n  enabled: true\n"
    );
    let value: yaml_serde::Value = yaml_serde::from_str("!Text hello\n").unwrap();
    assert!(matches!(value, yaml_serde::Value::Tagged(_)));
    assert_eq!(yaml_serde::to_string(&value).unwrap(), "!Text hello\n");
}

#[test]
fn legacy_yaml_parse_errors_keep_locations_paths_and_duplicate_key_rejection() {
    let error =
        yaml_serde::from_str::<yaml_serde::Value>("name: first\nname: second\n").unwrap_err();
    assert_eq!(error.to_string(), "duplicate entry with key \"name\"");
    let input = "rules:\n  - id: acme.bad\n    name: Bad\n    pattern: 'unterminated\n";
    let file = YamlTestFile::new(input.as_bytes());
    let parser_error = yaml_serde::from_str::<RawRules>(input).err().unwrap();
    let location = parser_error.location().unwrap();
    let memory =
        Rules::from_paths_and_contents([(file.0.as_path(), input.as_bytes())], Confidence::Low)
            .err()
            .unwrap();
    match memory.downcast_ref::<RulesError>().unwrap() {
        RulesError::InvalidResponseMatcherVariant(path, line, column) => {
            assert_eq!(path, &file.0.display().to_string());
            assert_eq!((*line, *column), (location.line(), location.column()));
        }
        error => panic!("unexpected legacy error category: {error}"),
    }
    let syntax = RuleSyntax::from_yaml_file(&file.0).unwrap_err().to_string();
    assert!(syntax.starts_with(&format!(
        "Failed to parse YAML from {} at line {} column {}:",
        file.0.display(),
        location.line(),
        location.column()
    )));
}