Struct VerificationEngine 

pub struct VerificationEngine { /* private fields */ }

Live-verification engine with shared client, cache, and concurrency limits.

Examples

use keyhog_core::{DetectorSpec, PatternSpec, Severity};
use keyhog_verifier::{VerificationEngine, VerifyConfig};

let detectors = vec![DetectorSpec {
    id: "demo-token".into(),
    name: "Demo Token".into(),
    service: "demo".into(),
    severity: Severity::High,
    patterns: vec![PatternSpec {
        regex: "demo_[A-Z0-9]{8}".into(),
        description: None,
        group: None,
    }],
    companion: None,
    verify: None,
    keywords: vec!["demo_".into()],
}];

let engine = VerificationEngine::new(&detectors, VerifyConfig::default()).unwrap();
let _ = engine;

Implementations

impl VerificationEngine

pub fn new( detectors: &[DetectorSpec], config: VerifyConfig, ) -> Result<Self, VerifyError>

Create a verifier with shared HTTP client, cache, and concurrency controls.

Examples

use keyhog_core::{DetectorSpec, PatternSpec, Severity};
use keyhog_verifier::{VerificationEngine, VerifyConfig};

let engine = VerificationEngine::new(
    &[DetectorSpec {
        id: "demo-token".into(),
        name: "Demo Token".into(),
        service: "demo".into(),
        severity: Severity::High,
        patterns: vec![PatternSpec {
            regex: "demo_[A-Z0-9]{8}".into(),
            description: None,
            group: None,
        }],
        companion: None,
        verify: None,
        keywords: vec!["demo_".into()],
    }],
    VerifyConfig::default(),
)
.unwrap();

let _ = engine;

pub async fn verify_all( &self, groups: Vec<DedupedMatch>, ) -> Vec<VerifiedFinding>

Verify a batch of deduplicated raw matches in parallel. Returns one VerifiedFinding per unique (detector_id, credential).

Examples

use keyhog_core::{DetectorSpec, MatchLocation, PatternSpec, RawMatch, Severity};
use keyhog_verifier::{DedupScope, VerificationEngine, VerifyConfig, dedup_matches};

let detector = DetectorSpec {
    id: "demo-token".into(),
    name: "Demo Token".into(),
    service: "demo".into(),
    severity: Severity::High,
    patterns: vec![PatternSpec {
        regex: "demo_[A-Z0-9]{8}".into(),
        description: None,
        group: None,
    }],
    companion: None,
    verify: None,
    keywords: vec!["demo_".into()],
};
let engine = VerificationEngine::new(&[detector], VerifyConfig::default()).unwrap();
let findings = engine
    .verify_all(dedup_matches(vec![RawMatch {
        detector_id: "demo-token".into(),
        detector_name: "Demo Token".into(),
        service: "demo".into(),
        severity: Severity::High,
        credential: "demo_ABC12345".into(),
        companion: None,
        location: MatchLocation {
            source: "filesystem".into(),
            file_path: Some(".env".into()),
            line: Some(1),
            offset: 0,
            commit: None,
            author: None,
            date: None,
        },
        entropy: None,
        confidence: None,
    }], &DedupScope::Credential))
    .await;
assert_eq!(findings.len(), 1);