Skip to content

Commit 951432d

Browse files
committed
Allow for installing unsigned baseline with warning
1 parent 8eeff21 commit 951432d

6 files changed

Lines changed: 293 additions & 59 deletions

File tree

‎docs/result-schema.md‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,12 @@ Top-level fields:
2020
| `cleanup` | Cleanup status, bounded error, and packages not present in the initial snapshot. |
2121
| `errors` | Bounded typed run errors with the phase where each occurred. |
2222

23+
If Dappmanager rejects the baseline package signature, the harness retries that
24+
baseline mutation with the signed-package restriction bypass. A successful
25+
retry continues the comparison, changes an otherwise passing verdict to
26+
`warning` with reason code `baseline_signature_invalid`, and preserves the
27+
original rejection in `errors`.
28+
2329
Representative successful result:
2430

2531
```json

‎src/model/error.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@ pub enum ReasonCode {
99
CandidateInstallFailed,
1010
BaselineContainersUnstable,
1111
BaselineInstallFailed,
12+
BaselineSignatureInvalid,
1213
BaselineUnavailable,
1314
UnsupportedRequiredSetup,
1415
CorePackageRefused,

‎src/package_manager/dappmanager.rs‎

Lines changed: 108 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -144,6 +144,70 @@ impl DappmanagerPackageManager {
144144
}
145145
unreachable!("mutation attempts are validated to be non-zero")
146146
}
147+
148+
async fn install_package_with_options(
149+
&self,
150+
dnp_name: &DnpName,
151+
version: Option<&PackageRef>,
152+
bypass_signature: bool,
153+
) -> Result<(), PackageManagerError> {
154+
let options = install_options(version, bypass_signature);
155+
let user_settings = serde_json::Map::new();
156+
match self
157+
.retry_mutation(
158+
"dappnode_install_package",
159+
dnp_name,
160+
version.map(PackageRef::as_str),
161+
|| {
162+
self.mutation_client
163+
.install_package(dnp_name, version, &user_settings, options)
164+
},
165+
|| async { self.client.get_package_details(dnp_name).await.is_ok() },
166+
)
167+
.await
168+
{
169+
Ok(()) => Ok(()),
170+
Err(error) if required_setup_error(&error.to_string()) => {
171+
Err(PackageManagerError::RequiredSetup)
172+
}
173+
Err(error) if operation_in_progress_error(&error.to_string()) => Ok(()),
174+
Err(error) => Err(package_error(error)),
175+
}
176+
}
177+
178+
async fn update_package_with_options(
179+
&self,
180+
dnp_name: &DnpName,
181+
version: &PackageRef,
182+
bypass_signature: bool,
183+
) -> Result<(), PackageManagerError> {
184+
let options = install_options(Some(version), bypass_signature);
185+
self.retry_mutation(
186+
"dappnode_update_package",
187+
dnp_name,
188+
Some(version.as_str()),
189+
|| {
190+
self.mutation_client
191+
.update_package(dnp_name, Some(version), options)
192+
},
193+
|| async {
194+
self.client
195+
.get_package_details(dnp_name)
196+
.await
197+
.ok()
198+
.and_then(|details| details.version)
199+
.is_some_and(|installed| installed.to_string() == version.as_str())
200+
},
201+
)
202+
.await
203+
.or_else(|error| {
204+
if operation_in_progress_error(&error.to_string()) {
205+
Ok(())
206+
} else {
207+
Err(package_error(error))
208+
}
209+
})
210+
}
147211
}
148212

149213
#[async_trait]
@@ -269,61 +333,35 @@ impl PackageManager for DappmanagerPackageManager {
269333
dnp_name: &DnpName,
270334
version: Option<&PackageRef>,
271335
) -> Result<(), PackageManagerError> {
272-
let options = install_options(version);
273-
let user_settings = serde_json::Map::new();
274-
match self
275-
.retry_mutation(
276-
"dappnode_install_package",
277-
dnp_name,
278-
version.map(PackageRef::as_str),
279-
|| {
280-
self.mutation_client
281-
.install_package(dnp_name, version, &user_settings, options)
282-
},
283-
|| async { self.client.get_package_details(dnp_name).await.is_ok() },
284-
)
336+
self.install_package_with_options(dnp_name, version, false)
337+
.await
338+
}
339+
340+
async fn install_package_bypassing_signature(
341+
&self,
342+
dnp_name: &DnpName,
343+
version: Option<&PackageRef>,
344+
) -> Result<(), PackageManagerError> {
345+
self.install_package_with_options(dnp_name, version, true)
285346
.await
286-
{
287-
Ok(()) => Ok(()),
288-
Err(error) if required_setup_error(&error.to_string()) => {
289-
Err(PackageManagerError::RequiredSetup)
290-
}
291-
Err(error) if operation_in_progress_error(&error.to_string()) => Ok(()),
292-
Err(error) => Err(package_error(error)),
293-
}
294347
}
295348

296349
async fn update_package(
297350
&self,
298351
dnp_name: &DnpName,
299352
version: &PackageRef,
300353
) -> Result<(), PackageManagerError> {
301-
let options = install_options(Some(version));
302-
self.retry_mutation(
303-
"dappnode_update_package",
304-
dnp_name,
305-
Some(version.as_str()),
306-
|| {
307-
self.mutation_client
308-
.update_package(dnp_name, Some(version), options)
309-
},
310-
|| async {
311-
self.client
312-
.get_package_details(dnp_name)
313-
.await
314-
.ok()
315-
.and_then(|details| details.version)
316-
.is_some_and(|installed| installed.to_string() == version.as_str())
317-
},
318-
)
319-
.await
320-
.or_else(|error| {
321-
if operation_in_progress_error(&error.to_string()) {
322-
Ok(())
323-
} else {
324-
Err(package_error(error))
325-
}
326-
})
354+
self.update_package_with_options(dnp_name, version, false)
355+
.await
356+
}
357+
358+
async fn update_package_bypassing_signature(
359+
&self,
360+
dnp_name: &DnpName,
361+
version: &PackageRef,
362+
) -> Result<(), PackageManagerError> {
363+
self.update_package_with_options(dnp_name, version, true)
364+
.await
327365
}
328366

329367
async fn remove_package(
@@ -390,12 +428,17 @@ fn container_state(state: ContainerState) -> String {
390428
.to_owned()
391429
}
392430

393-
fn install_options(version: Option<&PackageRef>) -> InstallOptions {
394-
match version {
431+
fn install_options(version: Option<&PackageRef>, bypass_signature: bool) -> InstallOptions {
432+
let options = match version {
395433
Some(version) if version.is_ipfs() => {
396434
InstallOptions::default().with_bypass_signed_restriction()
397435
}
398436
_ => InstallOptions::default(),
437+
};
438+
if bypass_signature {
439+
options.with_bypass_signed_restriction()
440+
} else {
441+
options
399442
}
400443
}
401444

@@ -506,7 +549,7 @@ mod tests {
506549
#[test]
507550
fn ipfs_update_bypasses_signed_restriction() -> Result<(), Box<dyn Error>> {
508551
let request = request_with_candidate("/ipfs/QmCandidate")?;
509-
let options = install_options(Some(&request.package.candidate_ref));
552+
let options = install_options(Some(&request.package.candidate_ref), false);
510553
assert!(options.bypass_signed_restriction);
511554
assert!(!options.bypass_core_restriction);
512555
assert!(!options.bypass_resolver);
@@ -516,20 +559,32 @@ mod tests {
516559
#[test]
517560
fn registry_update_does_not_bypass_signed_restriction() -> Result<(), Box<dyn Error>> {
518561
let request = request_with_candidate("0.1.56")?;
519-
assert!(install_options(Some(&request.package.candidate_ref)).is_empty());
562+
assert!(install_options(Some(&request.package.candidate_ref), false).is_empty());
563+
Ok(())
564+
}
565+
566+
#[test]
567+
fn signature_retry_explicitly_bypasses_registry_restriction() -> Result<(), Box<dyn Error>> {
568+
let request = request_with_candidate("0.1.56")?;
569+
let options = install_options(Some(&request.package.candidate_ref), true);
570+
assert!(options.bypass_signed_restriction);
571+
assert!(!options.bypass_core_restriction);
572+
assert!(!options.bypass_resolver);
520573
Ok(())
521574
}
522575

523576
#[test]
524577
fn ipfs_install_bypasses_signed_restriction() -> Result<(), Box<dyn Error>> {
525578
let request = request_with_candidate("ipfs://QmCandidate")?;
526-
assert!(install_options(Some(&request.package.candidate_ref)).bypass_signed_restriction);
579+
assert!(
580+
install_options(Some(&request.package.candidate_ref), false).bypass_signed_restriction
581+
);
527582
Ok(())
528583
}
529584

530585
#[test]
531586
fn latest_install_does_not_bypass_signed_restriction() {
532-
assert!(install_options(None).is_empty());
587+
assert!(install_options(None, false).is_empty());
533588
}
534589

535590
fn request_with_candidate(candidate_ref: &str) -> Result<RunRequest, Box<dyn Error>> {

‎src/package_manager/mod.rs‎

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,24 @@ impl PackageManagerError {
9999
Self::InvalidResponse { .. } | Self::RequiredSetup | Self::NotFound => false,
100100
}
101101
}
102+
103+
/// Whether DAppManager rejected a package because its signature was not safe.
104+
pub fn is_signature_rejection(&self) -> bool {
105+
let message = self.to_string().to_ascii_lowercase();
106+
let mentions_signature = message.contains("signature")
107+
|| message.contains("signed restriction")
108+
|| message.contains("not signed")
109+
|| message.contains("unsigned");
110+
let indicates_rejection = message.contains("invalid")
111+
|| message.contains("bad")
112+
|| message.contains("unsafe")
113+
|| message.contains("not signed")
114+
|| message.contains("unsigned")
115+
|| message.contains("restriction")
116+
|| message.contains("reject")
117+
|| message.contains("bypass_signed_restriction");
118+
mentions_signature && indicates_rejection
119+
}
102120
}
103121

104122
pub(crate) fn retryable_transport_message(message: &str) -> bool {
@@ -165,17 +183,60 @@ pub trait PackageManager: Send + Sync {
165183
version: Option<&PackageRef>,
166184
) -> Result<(), PackageManagerError>;
167185

186+
/// Installs a baseline after its signature rejection has been reported.
187+
async fn install_package_bypassing_signature(
188+
&self,
189+
dnp_name: &DnpName,
190+
version: Option<&PackageRef>,
191+
) -> Result<(), PackageManagerError> {
192+
self.install_package(dnp_name, version).await
193+
}
194+
168195
/// Updates an installed package to the candidate reference.
169196
async fn update_package(
170197
&self,
171198
dnp_name: &DnpName,
172199
version: &PackageRef,
173200
) -> Result<(), PackageManagerError>;
174201

202+
/// Updates to a baseline after its signature rejection has been reported.
203+
async fn update_package_bypassing_signature(
204+
&self,
205+
dnp_name: &DnpName,
206+
version: &PackageRef,
207+
) -> Result<(), PackageManagerError> {
208+
self.update_package(dnp_name, version).await
209+
}
210+
175211
/// Removes the package after a run.
176212
async fn remove_package(
177213
&self,
178214
dnp_name: &DnpName,
179215
delete_volumes: bool,
180216
) -> Result<(), PackageManagerError>;
181217
}
218+
219+
#[cfg(test)]
220+
mod tests {
221+
use super::PackageManagerError;
222+
223+
#[test]
224+
fn identifies_signature_rejections_without_matching_unrelated_errors() {
225+
let invalid_signature = PackageManagerError::Tool {
226+
tool: "dappnode_install_package".to_owned(),
227+
message: "unsafe origin, bad signature".to_owned(),
228+
};
229+
let unsigned = PackageManagerError::Tool {
230+
tool: "dappnode_install_package".to_owned(),
231+
message: "package is not signed; set BYPASS_SIGNED_RESTRICTION".to_owned(),
232+
};
233+
let invalid_manifest = PackageManagerError::Tool {
234+
tool: "dappnode_install_package".to_owned(),
235+
message: "package manifest is invalid".to_owned(),
236+
};
237+
238+
assert!(invalid_signature.is_signature_rejection());
239+
assert!(unsigned.is_signature_rejection());
240+
assert!(!invalid_manifest.is_signature_rejection());
241+
}
242+
}

‎src/runner/controller.rs‎

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -308,6 +308,23 @@ impl RunController {
308308
phase: ExecutionPhase::Cleanup,
309309
});
310310
}
311+
if record
312+
.errors
313+
.iter()
314+
.any(|error| error.code == ReasonCode::BaselineSignatureInvalid)
315+
{
316+
match verdict {
317+
Verdict::Passed => {
318+
verdict = Verdict::Warning;
319+
reason = ReasonCode::BaselineSignatureInvalid;
320+
summary = format!("{summary}; baseline signature validation was bypassed");
321+
}
322+
Verdict::Warning => {
323+
summary = format!("{summary}; baseline signature validation was bypassed");
324+
}
325+
Verdict::Failed | Verdict::Inconclusive | Verdict::InfrastructureError => {}
326+
}
327+
}
311328

312329
let finished = Utc::now();
313330
record.status = ExecutionStatus::Completed;
@@ -536,6 +553,46 @@ impl RunController {
536553
.await
537554
}
538555
};
556+
let install_result = match install_result {
557+
Err(error) if error.is_signature_rejection() => {
558+
let warning = truncate_utf8(
559+
&format!("baseline signature validation failed and was bypassed: {error}"),
560+
500,
561+
);
562+
warn!(
563+
event = "baseline_signature_bypassed",
564+
run_id = %record.request.run_id,
565+
dnp_name = %package.dnp_name,
566+
error = %warning,
567+
"Baseline signature was rejected; retrying with the signed-package restriction bypass"
568+
);
569+
let retry = match (installed_baseline, package.baseline_ref.as_ref()) {
570+
(Some(_), Some(baseline_ref)) => {
571+
self.package_manager
572+
.update_package_bypassing_signature(&package.dnp_name, baseline_ref)
573+
.await
574+
}
575+
_ => {
576+
self.package_manager
577+
.install_package_bypassing_signature(
578+
&package.dnp_name,
579+
package.baseline_ref.as_ref(),
580+
)
581+
.await
582+
}
583+
};
584+
if retry.is_ok() {
585+
record.errors.push(RunError {
586+
code: ReasonCode::BaselineSignatureInvalid,
587+
message: warning,
588+
phase: ExecutionPhase::BaselineInstall,
589+
});
590+
self.save_failure(record).await?;
591+
}
592+
retry
593+
}
594+
result => result,
595+
};
539596
match install_result {
540597
Ok(()) => {}
541598
Err(PackageManagerError::RequiredSetup) => {

0 commit comments

Comments
 (0)