Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions crates/gvm-client/tests/client_integration.rs
Original file line number Diff line number Diff line change
Expand Up @@ -5794,7 +5794,7 @@ async fn assert_partial_scanner_modify_preserves_fields(
.get_scanner(GetScannerRequest::new(scanner_id.clone()))
.await
.expect("get_scanner after partial modify should succeed");
assert_eq!(scanner.items[0].port, Some(9391));
assert_eq!(scanner.items[0].port, Some(0));
assert_eq!(scanner.items[0].ca_pub.as_deref(), Some("Replacement CA"));
assert_eq!(
scanner.items[0].relay_host.as_deref(),
Expand Down Expand Up @@ -5930,7 +5930,7 @@ async fn typed_scanner_lifecycle(client: &mut GmpClient<UnixSocketConnection>) {
&ScannerConnectionExpectation {
name: "Renamed Scanner",
host: "127.0.0.1",
port: 9391,
port: 0,
scanner_type: "5",
ca_pub: "Replacement CA",
credential_id: "credential-2",
Expand Down
91 changes: 87 additions & 4 deletions crates/gvm-gmp/src/commands/scanners.rs
Original file line number Diff line number Diff line change
Expand Up @@ -85,7 +85,7 @@ pub struct CreateScannerRequest {
pub comment: Option<String>,
/// Scanner hostname or IP address.
pub host: String,
/// Scanner service port.
/// Scanner service port; sensor scanners accept zero (gvmd normalizes their port).
pub port: u16,
/// Scanner protocol type.
pub scanner_type: ScannerType,
Expand Down Expand Up @@ -126,7 +126,7 @@ impl GmpRequestCodec for CreateScannerRequest {
fn validate(&self) -> Result<(), GmpRequestError> {
require_non_empty(&self.name, "name")?;
validate_host(&self.host, "host")?;
validate_port(self.port, "port")?;
validate_scanner_port(self.port, Some(self.scanner_type))?;
validate_create_relay(self.relay_host.as_deref(), self.relay_port)
}

Expand Down Expand Up @@ -200,7 +200,8 @@ pub struct ModifyScannerRequest {
pub comment: Option<String>,
/// Optional replacement hostname or IP address.
pub host: Option<String>,
/// Optional replacement service port.
/// Optional replacement service port. Zero is accepted for sensors; when the
/// type is omitted, gvmd validates against the existing scanner type.
pub port: Option<u16>,
/// Optional replacement scanner type.
pub scanner_type: Option<ScannerType>,
Expand Down Expand Up @@ -240,7 +241,7 @@ impl GmpRequestCodec for ModifyScannerRequest {
validate_host(host, "host")?;
}
if let Some(port) = self.port {
validate_port(port, "port")?;
validate_scanner_port(port, self.scanner_type)?;
}
validate_modify_relay(self.relay_host.as_deref(), self.relay_port)
}
Expand Down Expand Up @@ -353,6 +354,18 @@ fn validate_host(host: &str, field: &'static str) -> Result<(), GmpRequestError>
}
}

// With no replacement type, only the server knows whether an existing scanner
// is a sensor. Keep relay validation separate: network relays cannot use zero.
fn validate_scanner_port(
port: u16,
scanner_type: Option<ScannerType>,
) -> Result<(), GmpRequestError> {
match scanner_type {
None | Some(ScannerType::GreenBoneSensorType) => Ok(()),
Some(_) => validate_port(port, "port"),
}
}

fn validate_port(port: u16, field: &'static str) -> Result<(), GmpRequestError> {
if port == 0 {
Err(GmpRequestError::invalid_field(field, "must be non-zero"))
Expand Down Expand Up @@ -616,6 +629,76 @@ mod tests {
));
}

#[test]
fn sensor_zero_port_and_server_resolved_modify_are_encoded() {
let request = CreateScannerRequest::new(
"sensor",
"sensor.example",
0,
ScannerType::GreenBoneSensorType,
);
assert_eq!(request_xml(&request), "<create_scanner><name>sensor</name><host>sensor.example</host><port>0</port><type>5</type></create_scanner>");
let mut modify = ModifyScannerRequest::new(id("sensor-1"));
assert_eq!(
request_xml(&modify),
"<modify_scanner scanner_id=\"sensor-1\"/>"
);
modify.port = Some(0);
assert_eq!(
request_xml(&modify),
"<modify_scanner scanner_id=\"sensor-1\"><port>0</port></modify_scanner>"
);
modify.scanner_type = Some(ScannerType::GreenBoneSensorType);
assert_eq!(
request_xml(&modify),
"<modify_scanner scanner_id=\"sensor-1\"><port>0</port><type>5</type></modify_scanner>"
);
for kind in [
ScannerType::OpenVasScanner,
ScannerType::CveScannerType,
ScannerType::OpenVasdScannerType,
] {
modify.scanner_type = Some(kind);
assert!(modify.validate().is_err());
assert!(
CreateScannerRequest::new("ordinary", "scanner.example", 0, kind)
.validate()
.is_err()
);
}
}

#[test]
fn sensor_ports_do_not_relax_network_relay_validation() {
let mut create = CreateScannerRequest::new(
"sensor",
"sensor.example",
0,
ScannerType::GreenBoneSensorType,
);
create.relay_host = Some("relay.example".into());
create.relay_port = Some(0);
assert!(matches!(
create.validate(),
Err(GmpRequestError::InvalidField {
field: "relay_port",
..
})
));
create.relay_port = Some(443);
assert!(create.validate().is_ok());
let mut modify = ModifyScannerRequest::new(id("sensor-1"));
modify.port = Some(0);
modify.relay_port = Some(0);
assert!(matches!(
modify.validate(),
Err(GmpRequestError::InvalidField {
field: "relay_port",
..
})
));
}

#[test]
fn requests_keep_static_response_associations() {
fn associated<R, T>(_: &R)
Expand Down
34 changes: 33 additions & 1 deletion crates/gvm-mock-server/src/handler.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1292,7 +1292,10 @@ impl SessionHandler {
}
let Some(_) = parse_element_text(raw_xml, "port")
.and_then(|value| value.parse::<u16>().ok())
.filter(|port| *port != 0)
.filter(|port| {
*port != 0
|| is_sensor_scanner_type(parse_element_text(raw_xml, "type").as_deref())
})
else {
return error_response(&cmd.name, 400, "Invalid scanner port");
};
Expand Down Expand Up @@ -1664,6 +1667,9 @@ impl SessionHandler {
resource.set_attr(field, &value);
}
}
if is_sensor_scanner_type(resource.attr("type")) {
resource.set_attr("port", "0");
}
if let Some(credential_id) = cmd.child_attr("credential", "id") {
resource.set_attr("credential_id", credential_id);
}
Expand Down Expand Up @@ -2819,6 +2825,24 @@ impl SessionHandler {
}
}
}
if resource_type == "scanner" {
if let Some(existing) = store.get_typed(&uuid, "scanner") {
let effective_type = new_type.as_deref().or_else(|| existing.attr("type"));
let sensor = is_sensor_scanner_type(effective_type);
// gvmd normalizes only a supplied port; omission preserves the stored one.
let port = if sensor && new_port.is_some() {
Some(0)
} else {
new_port
.as_deref()
.or_else(|| existing.attr("port"))
.and_then(|port| port.parse::<u16>().ok())
};
if port.is_none_or(|port| if sensor { port != 0 } else { port == 0 }) {
return error_response(&cmd.name, 400, "Invalid scanner port");
}
}
}
let update_resource = |r: &mut Resource| {
if matches!(resource_type, "note" | "override") {
r.name.clone_from(
Expand Down Expand Up @@ -2940,6 +2964,9 @@ impl SessionHandler {
if let Some(ref scanner_type) = new_type {
r.set_attr("type", scanner_type);
}
if new_port.is_some() && is_sensor_scanner_type(r.attr("type")) {
r.set_attr("port", "0");
}
if let Some(ref ca_pub) = new_ca_pub {
if ca_pub.is_empty() {
r.remove_attr("ca_pub");
Expand Down Expand Up @@ -6087,6 +6114,11 @@ fn singularize_resource_type(plural: &str) -> &str {
}
}

// gvmd manage.h: OSP, OpenVASD and Agent Controller sensors.
fn is_sensor_scanner_type(scanner_type: Option<&str>) -> bool {
matches!(scanner_type, Some("5" | "8" | "9"))
}

#[cfg(test)]
mod tests {
use super::*;
Expand Down
85 changes: 85 additions & 0 deletions crates/gvm-mock-server/tests/stateful_command_surface_gaps.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1314,3 +1314,88 @@ async fn stateful_import_report_persists_task_and_in_assets() {

server.shutdown().await;
}

#[tokio::test]
async fn sensor_scanner_ports_normalize_and_modify_uses_existing_type() {
let Some((server, store)) = stateful_server_with_store().await else {
return;
};
let mut stream = connect(&server).await;
auth_admin(&mut stream).await;
for scanner_type in ["5", "8", "9"] {
for port in [0, 9390] {
let response = send_recv(&mut stream, format!("<create_scanner><name>sensor</name><host>sensor.example</host><port>{port}</port><type>{scanner_type}</type></create_scanner>").as_bytes()).await;
assert_eq!(response.status_code(), Some(201));
let id = extract_id(&response);
let uuid = uuid::Uuid::parse_str(&id).expect("scanner UUID");
assert_eq!(store.get(&uuid).expect("scanner").attr("port"), Some("0"));
let response = send_recv(
&mut stream,
format!("<modify_scanner scanner_id=\"{id}\"><port>0</port></modify_scanner>")
.as_bytes(),
)
.await;
assert_eq!(response.status_code(), Some(200));
let response = send_recv(
&mut stream,
format!(
"<modify_scanner scanner_id=\"{id}\"><name>renamed</name></modify_scanner>"
)
.as_bytes(),
)
.await;
assert_eq!(response.status_code(), Some(200));
assert_eq!(store.get(&uuid).expect("scanner").attr("port"), Some("0"));
// A type change to an ordinary scanner cannot retain its zero port.
let response = send_recv(
&mut stream,
format!("<modify_scanner scanner_id=\"{id}\"><type>2</type></modify_scanner>")
.as_bytes(),
)
.await;
assert_eq!(response.status_code(), Some(400));
assert_eq!(
store.get(&uuid).expect("scanner").attr("type"),
Some(scanner_type)
);
}
}
let response = send_recv(&mut stream, b"<create_scanner><name>normal</name><host>scanner.example</host><port>0</port><type>2</type></create_scanner>").await;
assert_eq!(response.status_code(), Some(400));
let response = send_recv(&mut stream, b"<create_scanner><name>normal</name><host>scanner.example</host><port>9390</port><type>2</type></create_scanner>").await;
let id = extract_id(&response);
let response = send_recv(
&mut stream,
format!("<modify_scanner scanner_id=\"{id}\"><port>0</port></modify_scanner>").as_bytes(),
)
.await;
assert_eq!(response.status_code(), Some(400));
server.shutdown().await;
}

#[tokio::test]
async fn scanner_type_change_preserves_omitted_port_and_rejects_invalid_transition() {
let Some((server, store)) = stateful_server_with_store().await else {
return;
};
let mut stream = connect(&server).await;
auth_admin(&mut stream).await;
for sensor in ["5", "8", "9"] {
let created = send_recv(&mut stream, b"<create_scanner><name>normal</name><host>scanner.example</host><port>9390</port><type>2</type></create_scanner>").await;
let id = extract_id(&created);
let uuid = uuid::Uuid::parse_str(&id).expect("scanner UUID");
let rejected = send_recv(&mut stream, format!("<modify_scanner scanner_id=\"{id}\"><type>{sensor}</type><name>must not change</name></modify_scanner>").as_bytes()).await;
assert_eq!(rejected.status_code(), Some(400));
let unchanged = store.get(&uuid).expect("scanner");
assert_eq!(unchanged.attr("type"), Some("2"));
assert_eq!(unchanged.attr("port"), Some("9390"));
assert_eq!(unchanged.name, "normal");
// An explicit port is normalized for the new sensor type.
let accepted = send_recv(&mut stream, format!("<modify_scanner scanner_id=\"{id}\"><type>{sensor}</type><port>9390</port></modify_scanner>").as_bytes()).await;
assert_eq!(accepted.status_code(), Some(200));
let updated = store.get(&uuid).expect("scanner");
assert_eq!(updated.attr("type"), Some(sensor));
assert_eq!(updated.attr("port"), Some("0"));
}
server.shutdown().await;
}
25 changes: 25 additions & 0 deletions docs/scanner-request-gvmd-evidence.md
Original file line number Diff line number Diff line change
Expand Up @@ -61,3 +61,28 @@ The stateful mock lifecycle covers exact XML, list/detail parsing, relay
persistence, partial-update preservation, clone overrides, explicit clearing,
verification, and deletion. These deterministic tests validate the canonical
contract but are not a claim of live-gvmd interoperability.

## Sensor port correction (#850)

Current gvmd [150a4cfad39d00f45ef147c35e1a5f27f415c8e9,
manage_sql.c](https://github.com/greenbone/gvmd/blob/150a4cfad39d00f45ef147c35e1a5f27f415c8e9/src/manage_sql.c#L21995)
normalizes OSP (5), OpenVASD (8), and Agent Controller (9) sensor ports to zero.
This supersedes the older blanket nonzero-primary-port assumption above.
The existing typed OSP sensor variant now accepts zero; nonzero sensor ports
remain accepted because the server normalizes them. Other typed scanner kinds
still require a nonzero port. This change does not add new scanner-type variants.

For modify requests with an omitted type, zero must reach gvmd: only the server
knows the existing scanner type. Explicit ordinary types still reject zero
locally. Network relay ports retain their independent nonzero validation.
The stateful mock resolves the stored type, normalizes all three sensor wire
codes, and rejects an ordinary scanner's zero port before mutating state.
Tests cover exact typed XML, modify omission, relay validation and stateful
normalization/atomic rejection. These are deterministic tests, not live gvmd
qualification.

When changing scanner type with an omitted port, gvmd preserves the stored port
before validating it against the new type. Thus an ordinary scanner with port
9390 cannot become a sensor without an explicit port update; it is rejected
atomically. Supplying a port lets gvmd normalize it for the new sensor type.
The mock and regression tests preserve this distinction in both directions.
Loading