scantarget 0.1.0

Target parsing and expansion library for security scanners
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

# scantarget — Target parsing and expansion

[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT) [![Tests](https://img.shields.io/badge/tests-39%20passing-brightgreen.svg)](https://img.shields.io/badge/tests-39%20passing-brightgreen.svg) [![Crates.io](https://img.shields.io/crates/v/scantarget.svg)](https://crates.io/crates/scantarget)

## Why
Scanning workflows fail when target input is inconsistent (`https://`, plain domain, IP, CIDR, mixed formats). `scantarget` standardizes target ingestion and normalization so scanners process a stable target model instead of parsing strings repeatedly.

It gives you parse utilities, list loaders, and CIDR expansion in one place, reducing scanner-specific parsing bugs and input edge-case drift.

## Quick Start
```rust
use scantarget::{parse, parse_many, Target, TargetList, TargetListError};

fn main() -> Result<(), TargetListError> {
    let one = parse("https://example.com")
        .expect("valid target");

    let many = parse_many("example.org,10.0.0.1/30");
    let mut list = TargetList {
        targets: TargetList::parse_str("https://example.com,203.0.113.10"),
    };

    for t in &many {
        println!("{}", t);
    }

    list.targets.push(one);
    Ok(())
}
```

## Features
- Parse URLs, domains, IPs, and CIDR values with strong validation.
- `TargetList` and `TargetListError` for ingest workflows.
- Expand CIDR ranges into concrete targets.
- Parse from args, strings, files, and stdin.
- Optional trait adapter with `TargetSource`.

## TOML Configuration
`scantarget` supports TOML target lists in this shape:

```toml
targets = ["https://example.com", "example.org", "203.0.113.0/30"]
```

```rust
use scantarget::TargetList;

let targets = TargetList::from_toml(
    r#"targets = ["https://example.com", "example.org"]"#
).unwrap();
```

## API Overview
- `Target` enum: `Url`, `Domain`, `Ip`, `Cidr`.
- `TargetParseError`: parse error model.
- `parse`, `parse_many`: convenience parsing helpers.
- `TargetList` / `TargetListError`: grouped targets and loaders.
- `expand_cidr`, `expand_all`: CIDR expansion helpers.
- `TargetSource`: trait for custom target providers.

## Examples
### 1) Parse mixed user input
```rust
use scantarget::parse_many;

let targets = parse_many("https://api.internal:8443,example.test,198.51.100.0/31");
assert_eq!(targets.len(), 3);
```

### 2) Expand CIDR before dispatch
```rust
use scantarget::{expand_all, parse, Target};

let cidr = parse("10.0.0.0/30").unwrap();
let expanded = expand_all(&[cidr]);
for t in expanded {
    println!("{}", t);
}
```

### 3) Implement `TargetSource` for a custom feed
```rust
use scantarget::{Target, TargetSource};

struct QueueSource {
    items: Vec<Target>,
}

impl TargetSource for QueueSource {
    fn targets(&self) -> Vec<Target> {
        self.items.clone()
    }

    fn count(&self) -> usize {
        self.items.len()
    }
}
```

## Traits
`scantarget` defines `TargetSource` when you need to feed scanner targets from a queue, API, or custom database instead of CLI/file text.

## Related Crates
- [scanclient](https://docs.rs/scanclient)
- [scanstate](https://docs.rs/scanstate)
- [codewalk](https://docs.rs/codewalk)

## License
MIT, Corum Collective LLC

Docs: https://docs.rs/scantarget

Santh ecosystem: https://santh.io