/

CVE-2025-71063

Severity:

HIGH RISK

(8.2)

Improper Certificate Validation in Errands CalDAV

CVE-2025-71063

Analyzed

Vulnerability type

Category:

Improper Certificate Validation

CWE:

CWE-295

Impact:

Man-in-the-Middle Attacks on Encrypted CalDAV Connections

Severity:

HIGH RISK

(8.2)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Errands versions before 46.2.10 fail to properly verify TLS certificates when connecting to CalDAV servers.

This can allow an attacker in a privileged network position to impersonate a CalDAV server, intercept calendar data, or tamper with traffic under otherwise encrypted connections.

Affected context

The vulnerability occurs when Errands connects to CalDAV servers over HTTPS but does not validate the server's TLS certificate.

This typically affects environments where Errands is configured to sync calendars with remote CalDAV endpoints, especially over untrusted or semi-trusted networks (public Wi-Fi, corporate guest networks, or ISP-controlled links).

The issue is most relevant when attackers can influence network routing or DNS resolution between the client and the intended CalDAV service.

Exploit preconditions

  • Attack surface: Network path between Errands clients and their configured CalDAV servers.
  • Required access: Ability to observe and manipulate network traffic (e.g., local network access, rogue access point, compromised router, or DNS poisoning capability).
  • Trigger point: A victim uses Errands to connect or sync with a CalDAV server over HTTPS while the attacker intercepts or redirects the connection.
  • Why exploitation is possible: Because TLS certificate verification is not enforced, the client accepts any certificate presented by the attacker-controlled server, treating it as the legitimate CalDAV endpoint.

Why this happens

This issue stems from improper or missing TLS certificate validation when establishing HTTPS connections to CalDAV servers.

Instead of verifying that the server's certificate is signed by a trusted authority, matches the expected hostname, and is otherwise valid (not expired or revoked), the client accepts the connection without sufficient checks.

This maps to CWE-295: Improper Certificate Validation, where applications either disable verification, ignore validation errors, or use APIs that skip hostname and trust checks, undermining the security guarantees of TLS.

Potential impact

  • An attacker on the network path can impersonate the CalDAV server (man-in-the-middle).
  • Calendar data, including event details and metadata, can be intercepted or monitored.
  • Calendar entries may be modified, injected, or deleted, potentially causing missed meetings, misleading events, or operational disruption.
  • Authentication credentials for the CalDAV account may be harvested if transmitted as part of the connection.
  • Sensitive organizational or personal scheduling information could be exposed or abused for further social engineering.

General mitigation guidance

Effective mitigation focuses on restoring strong TLS trust guarantees and reducing reliance on implicit trust:

  • Ensure that client connections to CalDAV servers perform full certificate validation, including trust chain verification and hostname checking.
  • Prefer secure defaults by using high-level HTTPS/TLS libraries that enable certificate verification by default, and avoid flags or options that disable verification.
  • Where custom or internal CAs are used, manage a dedicated trust store rather than skipping validation, and enforce strict hostname matching.
  • Apply least-privilege principles to stored credentials and calendar access to limit what an attacker could gain if interception occurs.
  • Where feasible, segment high-value calendar infrastructure onto more controlled networks, reducing exposure to untrusted network paths.

How teams detect issues like this

Detection generally involves reviewing client network and crypto usage patterns rather than observing a single exploit:

  • Use static analysis or code scanning to detect TLS/HTTPS calls that disable certificate verification, ignore hostname mismatches, or employ insecure client configurations.
  • During code review, flag patterns such as custom trust managers, "accept-all" certificate callbacks, or explicit disabling of TLS checks.
  • Employ dynamic testing (e.g., intercepting proxies or test MITM setups) in pre-production environments to verify that clients reject invalid or self-signed certificates unless explicitly trusted.
  • Define security policies for network-facing components requiring strict TLS verification, and integrate automated checks into CI/CD pipelines to enforce those policies.

Sources

SourceLink
bugs.debian.orgbugs.debian.org/cgi-bin/bugreport.cgi?bug=1123738
github.comgithub.com/mrvladus/Errands/commit/04e567b432083fc798ea2249363ea6c83ff01099
github.comgithub.com/mrvladus/Errands/compare/46.2.9...46.2.10
github.comgithub.com/mrvladus/Errands/issues/401
github.comgithub.com/mrvladus/Errands/releases/tag/46.2.10

Frequently asked

questions

Exploitability is constrained to attackers who can influence the network between Errands and the CalDAV server, such as those controlling a local Wi-Fi network, router, or DNS infrastructure. Over fully trusted and well-controlled networks, the practical risk is reduced but not eliminated.

No direct access to the device or credentials is required. The primary prerequisite is the ability to observe and modify network traffic or redirect Errands to an attacker-controlled endpoint.

The safest approach is to enforce strict TLS certificate validation for all HTTPS connections to CalDAV servers, relying on trusted CA stores and hostname verification, without using "accept all" or validation-bypassing configurations.

Always use HTTPS/TLS libraries with secure defaults, avoid disabling certificate verification even temporarily, mandate security-focused code reviews for network-related changes, and integrate automated checks that flag any use of insecure TLS options or custom trust managers that weaken validation.

Find out what's already
exploitable in your codebase.