Tested

RUSTSEC-2026-0543: chrono is unmaintained. What fails, what only warns, how to clear it

RUSTSEC-2026-0543 is an informational notice that chrono is unmaintained. It is not a vulnerability, and no chrono release is listed as patched, so no upgrade clears it. RustSec published it on 17 November 2026 together with matching entries for humantime (RUSTSEC-2026-0542) and chrono-tz (RUSTSEC-2026-0555). What your job did depends on the tool. cargo audit exits 0 and prints a warning unless you pass --deny warnings. The RustSec audit action, version 2.0.0, opens an issue titled RUSTSEC-2026-0543: chrono is unmaintained; its code fails the job for it only if one of its GitHub calls fails, for example creating that issue when the token is not allowed to. cargo-deny 0.22.0 fails when your own crate depends on chrono directly and passes when only a dependency does. 0.21.0 failed on both. There are three ways out: ignore the advisory with a reason, set cargo-deny's unmaintained scope, or replace chrono.

Next step. Check your repository for other dated changes. The Breakage Calendar checker reads a repository folder for other dated changes, including scripts that read rustc's version. It does not read Cargo.lock advisories, so use the cargo tree command below for this one.

What each tool does with the notice

We ran each row on two Linux fixture crates: one that lists chrono in its own Cargo.toml, and one that gets chrono only through a dependency. cargo-audit reads Cargo.lock and gave the same result for both.

Tool and settingchrono in your own Cargo.tomlchrono only through a dependency
cargo audit 0.23.0Exit 0. Prints a warning block, then warning: 1 allowed warning foundSame
cargo audit --deny warnings, or --deny unmaintainedExit 1. error: 1 denied warning found!Same
cargo deny check advisories 0.22.0, with no deny.toml or with [advisories] left at its defaultsExit 1. error[unmaintained]: chrono is unmaintainedExit 0. advisories ok, nothing printed about chrono
Same, unmaintained = "all"Exit 1Exit 1
Same, unmaintained = "workspace"Exit 1Exit 0
Same, unmaintained = "transitive"Exit 0Exit 1
Same, unmaintained = "none"Exit 0Exit 0
cargo deny check advisories 0.21.0, with no deny.toml or with [advisories] left at its defaultsExit 1Exit 1

Both fixtures were single crates. In a workspace whose root is also a package, with chrono used only by a member that the root package does not depend on, plain cargo deny check advisories exited 0, even with unmaintained = "all". cargo deny --workspace check advisories exited 1, and so did the plain command run from the member's directory. A virtual workspace, with no root package, exited 1 without the flag. cargo-deny 0.21.0 behaved the same.

The audit action is not in the table because we read it and did not run it. Its code (v2.0.0, src/reporter.ts) behaves as follows. On a scheduled run it creates one issue per advisory, titled with the ID, a colon and the advisory title, which is how RUSTSEC-2026-0543: chrono is unmaintained is made. It does not create one when an issue or pull request in the repository already has the ID in its title, and that search has no open or closed filter. On other events it publishes a check run named Security audit that concludes success unless the report holds a vulnerability, meaning an advisory with no informational category such as unmaintained; the summary reads 1 unmaintained. Neither path fails the step because of an unmaintained notice. The step does fail if one of its GitHub calls fails, because the code does not catch that error. On a scheduled run those calls are the search for an earlier issue and the one that creates the issue, so a token that is not allowed to create issues turns the job red. On other events they are the calls that create and complete the check run, with one exception: on a pull_request or pull_request_target event, from a fork or not, if creating the check run fails, the code prints the report in the log instead and fails the step only if the report holds a vulnerability. A run with nothing to report makes none of these calls. The JSON it reads from cargo audit --json listed chrono under warnings.unmaintained with vulnerabilities.found false, and exited 0.

Four things that can turn the same notice red:

  • The audit action on a scheduled run, when its token cannot create issues, as described above. We read this in the code and did not run it.
  • cargo-deny 0.22.0 changed the default for unmaintained from all to workspace on 19 November 2026, after RustSec published the advisory. A job pinned to 0.21.0, or one that sets unmaintained = "all", fails on any copy of chrono in the tree.
  • cargo deny check with no configuration runs every check. In our run it exited 5 with advisories FAILED and licenses FAILED. Run cargo deny check advisories to see this one on its own.
  • A .cargo/audit.toml with deny = ["warnings"] or deny = ["unmaintained"] under [output] makes cargo audit exit 1, the same as the flag. In 0.23.0 an [output] table with only deny stopped cargo audit with a parse error that said the quiet field was missing. With deny and quiet = false it worked.

The advisory's own date field reads 2026-09-14, and cargo audit prints it as Date: 2026-09-14. The database commit that assigned the ID is from 17 November 2026.

Find what pulls chrono in

Run this in the workspace the failing job scans.

cargo tree --locked --workspace --target all -i chrono

The inverted tree puts chrono at the top and lists the crates that depend on it, down to your own. --workspace matters. On a workspace whose root is also a package, the same command without it exited 101 with a did not match any packages error when only a member used chrono. If you get that error with --workspace, chrono is not in the Cargo.lock you ran it against. If your job reported chrono, the scan may be reading another lockfile, such as a separate example or fuzz workspace. If it reported only humantime, see the humantime section below. Cargo tree reference

To see which feature switches chrono on, add the features edge kind.

cargo tree --locked --workspace --target all -e features -i chrono

In our fixture this printed lines such as serde_with feature "chrono_0_4" under chrono feature "serde".

If the command exits 0 and prints only warning: nothing to print., chrono is in Cargo.lock but no enabled feature builds it. cargo audit still reports it then, because it reads the lockfile. This command lists the packages whose lockfile entry names chrono as a dependency.

awk '/^name = /{n=$3} /^ "chrono[ "]/{print n}' Cargo.lock

It prints each name in quotes. It gave the same parents as a TOML parser with mawk on 36 lockfiles, and with gawk, busybox awk and BWK awk (the base of the macOS and BSD awk) on 29. We ran it on Linux, not on a Mac.

Who pulls it in, in 20 real projects. On 21 November 2026 we read the Cargo.lock at the default branch of 20 projects where the audit bot had opened an issue with the title RUSTSEC-2026-0543: chrono is unmaintained. They are the first 20 owners in a GitHub issue search for that title whose repository has a lockfile in its root, so they are not a random sample. All 20 still listed chrono.

  • In 15, one of the project's own crates (a workspace member or path crate, with no registry source in Cargo.lock) lists chrono as a dependency.
  • In the other 5, chrono comes only through registry crates.
  • Apart from the projects' own crates, 23 different crates list chrono. None appears in more than 2 of the 20 lockfiles. Five appear in 2: chrono-tz, pyo3, rmcp, schemars and serde_with. The other 18 appear in 1 each.

Does a feature switch drop chrono? We resolved a fresh lockfile for a crate that depends only on the parent, with and without the switch.

  • schemars 1.2.3 with its chrono04 feature, and pyo3 0.30.1 with its chrono feature: chrono was in the lockfile with the feature on. With it off, chrono was absent from Cargo.lock, and neither cargo audit nor cargo deny reported it.
  • serde_with 3.25.0: the chrono_0_4 feature puts chrono in the build. With it off and the default features on, cargo tree printed nothing and cargo deny with unmaintained = "all" passed, but Cargo.lock still listed chrono, so cargo audit still warned. With default-features = false, chrono was absent from Cargo.lock and neither tool reported it, and adding back only the macros feature kept it absent. Adding std or alloc put it back in Cargo.lock. We only resolved the lockfile; we did not compile code with these features off, so check that your crate still builds.
  • rmcp 3.11.0 and chrono-tz 0.10.4: chrono is a regular dependency. default-features = false did not remove it. No switch found.

Other versions of these crates, and other parents, were not tested.

Way out A: ignore this advisory, with a reason

An ignore names one advisory ID. Each tool reads its own file.

For cargo-deny, add the ID with a reason to deny.toml.

[advisories]
ignore = [
    { id = "RUSTSEC-2026-0543", reason = "chrono is unmaintained, not vulnerable; revisit when we replace it" },
]

For cargo-audit, add it to .cargo/audit.toml. The example config that ships with cargo-audit shows ignore as a list of advisory IDs, so the reason goes in a comment.

[advisories]
# chrono is unmaintained, not vulnerable; revisit when we replace it
ignore = ["RUSTSEC-2026-0543"]

cargo audit --ignore RUSTSEC-2026-0543 does the same for one run. The audit action passes each ID in its ignore input to cargo audit as --ignore, and its description calls the input a comma-separated list.

      - uses: rustsec/audit-check@v2.0.0
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          ignore: RUSTSEC-2026-0543

With that argument, the JSON report in our fixture listed no warnings, and the action's code stops at No warnings were found. We did not run the action. An issue the action already opened stays until you close it, and closing it does not bring it back: the action's search for the ID in issue and pull request titles finds closed ones too, so it does not open a second issue for the same ID.

cargo audit reads .cargo/audit.toml from the directory you run it in. When we ran it from another directory with --file pointing at a lockfile, the ignore in the config next to that lockfile was not applied: with --deny warnings the run exited 1. Keep the file in the directory the job runs cargo audit from.

What happens when chrono goes away. We ran both tools with the ignore in place, first with chrono present and then with it removed from the dependencies.

Statecargo-deny 0.22.0cargo-audit 0.23.0
chrono presentExit 0, advisories okExit 0, no warning printed. Exit 0 with --deny warnings too
chrono removedExit 0, warning[advisory-not-detected]: advisory was not encountered, with no crate matched advisory criteria under the IDExit 0, nothing printed

To make cargo-deny fail when the entry stops matching, set unused-ignored-advisory = "deny". In our run that exited 1 with error[advisory-not-detected] once chrono was removed. We found no such setting in cargo-audit's example config, and a stale entry there stays silent.

[advisories]
unused-ignored-advisory = "deny"
ignore = [
    { id = "RUSTSEC-2026-0543", reason = "chrono is unmaintained, not vulnerable; revisit when we replace it" },
]

cargo-deny can also end an ignore with expiry. It takes an ISO date, or a duration counted from the advisory's own date field (2026-09-14 here), not from the day you add the entry. On 21 November, expiry = "P30D" and "P60D" failed at once, and "P90D" and "P180D" passed; 90 days from 14 September is 13 December. With expiry = "2027-06-30" our run exited 0. With a date already past, expiry = "2026-11-20", it exited 1 and printed the unmaintained error again.

[advisories]
ignore = [
    { id = "RUSTSEC-2026-0543", reason = "chrono is unmaintained, not vulnerable; revisit when we replace it", expiry = "2027-06-30" },
]

If chrono comes only through a dependency, cargo-deny 0.22.0 at its defaults does not report it, and the same entry printed advisory-not-detected even though chrono was in the lockfile. With unused-ignored-advisory = "deny" that line is an error and the check fails. Such a project needs the entry for cargo-audit, and in deny.toml only if it sets a wider scope. The block with unused-ignored-advisory = "deny" also failed in a workspace whose root is a package, when only a member the root does not depend on used chrono and the command had no --workspace; with the flag it passed.

Way out B: set cargo-deny's unmaintained scope

cargo-deny's unmaintained setting decides which crates can fail the check. The 0.22.0 documentation lists four values: all, workspace (the default), transitive and none. The table above shows what each did to the two fixtures. For chrono through a dependency, workspace and none pass.

[advisories]
unmaintained = "workspace"

workspace is already the 0.22.0 default. Writing it down keeps that behaviour on a job still pinned to 0.21.0, whose documentation lists the same four values; with this line, 0.21.0 passed the fixture that gets chrono only through a dependency.

none also switches off every other unmaintained advisory for every crate, which is wider than an ignore for one ID. To keep the notice in the output without failing, cargo deny check -W unmaintained advisories exited 0 and printed warning[unmaintained]: chrono is unmaintained for the fixture with chrono in its own Cargo.toml.

Way out C: replace chrono

The advisory recommends two crates: jiff and time. It links to chrono's issue Soft-deprecating chrono and chrono-tz. How to move your code is outside this page. When you have, run the cargo tree command above. If it stops with cannot update the lock file, run it once without --locked; in our run Cargo then updated Cargo.lock to match the edited Cargo.toml. An exit 101 with did not match any packages means chrono is gone from that lockfile, and the ignore can come out.

humantime and chrono-tz

RustSec published two more entries with the same link and the same unmaintained category.

  • RUSTSEC-2026-0542 says: "Because chrono is now unmaintained and humantime wraps chrono, it is also unmaintained; all versions are affected." To find who pulls humantime in, run cargo tree --locked --workspace --target all -i humantime. In our fixture, a crate that depended only on humantime 2.4.0 had no chrono in its Cargo.lock, and cargo audit reported RUSTSEC-2026-0542 alone. On such a tree, the chrono command above exits 101.
  • RUSTSEC-2026-0555 says: "The chrono-tz crate is unmaintained; all versions are affected." In the crates.io index, every chrono-tz version lists chrono as a regular dependency, so a lockfile with chrono-tz also lists chrono and cargo audit reports both IDs. In our fixture it printed both warnings and exited 0.

Ways out A and B apply to both. In our fixtures a crate that depends directly on humantime 2.4.0, or on chrono-tz 0.10.4, failed cargo-deny 0.22.0 at its defaults (exit 1) and passed cargo audit with warnings (exit 0). For chrono-tz, the default scope flagged chrono-tz and not the chrono it brings in. We did not test humantime as a transitive dependency. List the IDs your tree has.

[advisories]
ignore = [
    { id = "RUSTSEC-2026-0542", reason = "humantime is unmaintained, not vulnerable; revisit when we replace it" },
    { id = "RUSTSEC-2026-0543", reason = "chrono is unmaintained, not vulnerable; revisit when we replace it" },
    { id = "RUSTSEC-2026-0555", reason = "chrono-tz is unmaintained, not vulnerable; revisit when we replace it" },
]

In cargo-deny, an entry for an ID that your tree does not have printed advisory-not-detected in our run, as for a removed chrono, so with unused-ignored-advisory = "deny" list only the IDs your tree has. In cargo-audit it printed nothing.

[advisories]
ignore = ["RUSTSEC-2026-0542", "RUSTSEC-2026-0543", "RUSTSEC-2026-0555"]

What we ran

We ran the tools in the official Rust Docker image for Linux, pinned by digest, with Cargo 1.99.1, cargo-audit 0.23.0 and cargo-deny 0.22.0. The default-setting rows for cargo-deny 0.21.0 used that release. Both scanners read the same copy of the RustSec database at commit 55e1c3dfbd83 from 21 November 2026, which includes the 17 November commit 233155b402 that published these IDs. The fixtures were small crates with no code, resolved on 21 November 2026 to chrono 0.4.45: one with chrono = "0.4", one with serde_with 3.25.0 and its chrono_0_4 feature, one each with humantime 2.4.0 and chrono-tz 0.10.4, one with none of them, and a workspace whose root package does not use chrono and whose member does. A second run, with separately downloaded tool binaries and its own clone of the database at the same commit, repeated the cargo-audit and cargo-deny results above on Cargo 1.99.1 and on Cargo 1.100.0 with the same exit codes. That run added serde_with with default features off, the expiry durations, a virtual workspace, the cargo-deny results for the root-package workspace and the cannot update the lock file step. Each result is one run per Cargo version. We did not run Windows, macOS, shells other than bash, cargo-audit older than 0.23.0, or the audit action itself.

Sources

Check your repository for other dated changes

Corrections can be sent to hello@cybernative.ai. We publish dated corrections.

Check your repository for other dated changes