Skip to content
Open
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
62 changes: 62 additions & 0 deletions crates/gvm-client/tests/result_canonical_integration.rs
Original file line number Diff line number Diff line change
Expand Up @@ -254,3 +254,65 @@ async fn both_facades_preserve_result_parse_context() {
}
server.shutdown().await;
}

#[tokio::test]
async fn report_filter_helper_executes_with_protected_scope_and_typed_counts() {
use gvm_gmp::{compose_report_results_filter, Pagination};
use gvm_mock_server::Resource;

let report = Resource::new("report", "Selected report");
let report_id = id(&report.id.to_string());
let other_report = Resource::new("report", "Other report");
let server = MockGmpServer::builder()
.mode(ServerMode::Stateful)
.version(MockVersion::V22_8)
.credentials("admin", "admin")
.seed(move |store| {
for (name, severity, selected_report) in [
("Selected high", "8.0", report.id),
("Selected medium", "5.0", report.id),
("Unrelated high", "9.0", other_report.id),
] {
let mut result = Resource::new("result", name);
result.set_attr("severity", severity);
result.set_attr("qod", "95");
result.set_attr("report_id", &selected_report.to_string());
store.seed(result);
}
store.seed(report.clone());
store.seed(other_report.clone());
})
.unix_socket_auto()
.build()
.await
.expect("server starts");
let mut client = client(&server).await;
client
.authenticate(gvm_gmp::commands::authentication::AuthenticateRequest::new(
"admin", "admin",
))
.await
.expect("authenticate");
for (page, expected_name) in [(1, "Selected high"), (2, "Selected medium")] {
let filter = compose_report_results_filter(
&report_id,
Some("severity>7"),
Some("OR severity<6 sort=name"),
Pagination::new(page, 1),
)
.expect("strict filter");
let response = client
.execute(GetResultsRequest {
filter_string: Some(filter),
get_counts: Some(true),
..GetResultsRequest::default()
})
.await
.expect("scoped result request");
assert_eq!(response.items.len(), 1);
assert_eq!(response.items[0].meta.name, expected_name);
assert_eq!(response.counts.filtered, Some(2));
assert_eq!(response.counts.page, Some(1));
}
server.shutdown().await;
}
174 changes: 173 additions & 1 deletion crates/gvm-gmp/src/filtering.rs
Original file line number Diff line number Diff line change
Expand Up @@ -110,6 +110,178 @@ pub enum FilterFragmentError {
},
}

/// Errors from strict report-result filter composition (legacy helpers remain permissive).
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum ReportResultsFilterError {
/// The report identifier is invalid (including unchecked deserialized values).
#[error("invalid report identifier: {0}")]
InvalidReportId(#[from] crate::types::EntityIdError),
/// A caller attempted to replace endpoint-owned scope or pagination.
#[error(transparent)]
Fragment(#[from] FilterFragmentError),
/// gvmd supports single-character relations, not inclusive or compound comparisons.
#[error("unsupported or malformed filter comparator near byte {offset}; use a single =, >, <, ~ or : relation (>= and <= are not supported by gvmd)")]
Comparator {
/// Byte offset of the invalid comparator.
offset: usize,
},
/// A quoted literal was not closed.
#[error("unterminated quoted filter literal")]
UnterminatedQuote,
}

/// Compose a strict, report-isolated result filter with endpoint-owned pagination.
///
/// `saved_filter` is resolved saved-filter **term text**, not its identifier. Pass
/// the returned text as `GetResultsRequest.filter_string` with `filter_id: None`:
/// gvmd otherwise replaces inline text with the saved filter. Both fragments are
/// validated independently. Boolean predicates retain gvmd's own semantics;
/// report isolation uses its independent report restriction, not a boolean term.
/// This is not a full filter grammar validator: unknown fields remain gvmd-owned.
///
/// # Errors
/// Rejects caller scope/pagination controls, unsupported compound comparators,
/// and unterminated quoted literals. Existing raw helpers remain unchanged.
pub fn compose_report_results_filter(
report_id: &crate::types::EntityId,
saved_filter: Option<&str>,
inline_filter: Option<&str>,
pagination: Pagination,
) -> Result<String, ReportResultsFilterError> {
crate::types::EntityId::new(report_id.as_str())?;
let mut clauses = Vec::new();
for fragment in [saved_filter, inline_filter].into_iter().flatten() {
let visible = strict_visible_filter(fragment)?;
FilterFragment::new(
visible.as_str(),
&[
"report_id",
"_report_id",
"_and_report_id",
"__and_report_id",
"_first",
"_rows",
"max",
"offset",
"limit",
"page",
"per_page",
"ignore_pagination",
"_ignore_pagination",
],
)?;
validate_strict_comparators(&visible)?;
if !fragment.trim().is_empty() {
clauses.push(fragment.trim().to_string());
}
}
let (first, rows) = pagination.gvmd_window();
clauses.push(format!(
"_and_report_id={report_id} first={first} rows={rows}"
));
Ok(clauses.join(" "))
}

// Mask only literals recognized by pinned gvmd split_filter. In particular,
// apostrophes and backslashes are ordinary bytes, and embedded double quotes
// are not openers. Keep byte offsets stable for comparator diagnostics. Do not
// change legacy FilterFragment's historical quoting/escaping contract.
fn strict_visible_filter(fragment: &str) -> Result<String, ReportResultsFilterError> {
let mut visible = fragment.as_bytes().to_vec();
let mut quoted = false;
let mut between = true;
let mut column = false;
let mut prefix = false;
let mut value_start = 0;
for (offset, byte) in fragment.bytes().enumerate() {
if quoted {
visible[offset] = b'x';
if byte == b'"' {
quoted = false;
between = true;
visible[offset] = b' ';
}
continue;
}
match byte {
b'"' => {
if between || ((column || prefix) && offset == value_start) {
quoted = true;
between = false;
column = false;
prefix = false;
}
visible[offset] = b'x';
}
b'\'' => {
visible[offset] = b'x';
if between {
between = false;
column = false;
prefix = false;
}
}
b' ' | b'\t' | b'\n' | b'\r' => between = true,
b'=' | b'~' if between => {
between = false;
column = false;
prefix = true;
value_start = offset + 1;
}
b'=' | b'~' | b':' | b'>' | b'<' => {
if between {
between = false;
column = false;
prefix = false;
} else if !column {
column = true;
value_start = offset + 1;
}
}
_ if between => {
between = false;
column = false;
prefix = false;
}
_ => {}
}
}
if quoted {
return Err(ReportResultsFilterError::UnterminatedQuote);
}
// Replacing entire quoted UTF-8 spans with ASCII preserves valid UTF-8.
Ok(String::from_utf8(visible).expect("masked UTF-8 filter"))
}

fn validate_strict_comparators(fragment: &str) -> Result<(), ReportResultsFilterError> {
let mut previous_nonspace = None;
let mut token_operator = false;
for (offset, byte) in fragment.bytes().enumerate() {
if byte.is_ascii_whitespace() {
token_operator = false;
continue;
}
if matches!(byte, b'=' | b'>' | b'<' | b'~' | b':' | b'!') {
if byte == b'!'
|| token_operator
|| previous_nonspace.is_some_and(|previous| {
matches!(previous, b'=' | b'>' | b'<' | b'~' | b':' | b'!')
})
{
return Err(ReportResultsFilterError::Comparator { offset });
}
token_operator = true;
}
previous_nonspace = Some(byte);
}
if previous_nonspace.is_some_and(|byte| matches!(byte, b'=' | b'>' | b'<' | b'~' | b':')) {
return Err(ReportResultsFilterError::Comparator {
offset: fragment.len().saturating_sub(1),
});
}
Ok(())
}

/// Builder for gvmd filter strings that append pagination terms centrally.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct PaginatedFilter {
Expand Down Expand Up @@ -291,7 +463,7 @@ fn skip_grouping_and_whitespace(bytes: &[u8], mut index: usize) -> usize {
}

fn is_operator_byte(byte: u8) -> bool {
matches!(byte, b'=' | b'<' | b'>' | b'~')
matches!(byte, b'=' | b'<' | b'>' | b'~' | b':')
}

#[cfg(test)]
Expand Down
5 changes: 4 additions & 1 deletion crates/gvm-gmp/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,10 @@ pub use execution::{
GmpStreamingResponse,
};
/// Re-exported gvmd filter helpers.
pub use filtering::{FilterFragment, FilterFragmentError, PaginatedFilter, Pagination};
pub use filtering::{
compose_report_results_filter, FilterFragment, FilterFragmentError, PaginatedFilter,
Pagination, ReportResultsFilterError,
};
/// Re-exported semantic GMP server-error classification.
pub use responses::GmpServerErrorKind;
/// Re-exported typed schedule values.
Expand Down
Loading
Loading