Skip to content

CookieRadar 2026.43

Choose a tag to compare

@github-actions github-actions released this 08 Oct 15:25
· 62 commits to main since this release
v2026.43
2f2e395

Added

  • CVE-2026-77214 recorded in SECURITY-EXCEPTIONS.toml. Docker Scout and Snyk
    report the heap over-read in expat's XML_ParseBuffer; patchradar debian on
    2026-10-08 says fixed in sid only (2.9.0-1), open in trixie, bookworm and forky, no
    Debian bug yet. Recorded the way the other expat entries are, to be reviewed by
    2026-11-30, with who loads the system libexpat1 in the image: fontconfig and Mesa,
    for their own configuration files. CPython's pyexpat carries its own copy, and
    cookieradar parses no XML.

  • The files the build is told to include are checked to be there. apkradar lost its
    LICENSE out of the working tree on 2026-10-04 and the loss reached main: pyproject
    names the file, so python -m build failed with License file does not exist: LICENSE,
    and the PyPI publish and the image went down with it. cookieradar lost its own a few
    hours later, during a run of the suite. Neither suite noticed, because neither looked.

    What removes them is still not known, and these cases do not explain it. They stop it
    reaching a commit, which is the part that can be fixed without knowing.

    The expectation is read out of the declarations rather than written down as LICENSE,
    because the five Radar do not declare it the same way: patchradar states its licence as
    text and only its Dockerfile names the file, the other four name it in pyproject, and of
    those apkradar and mailradar do not copy it into the image. So two cases — every file
    pyproject names, and every path the Dockerfile copies — and between them each repository
    is covered, three of them twice.

    Checked by moving the file aside in all five: it fails where it should and passes where
    the declaration genuinely does not name it, and pointing pyproject at a file that is not
    there fails too.

Fixed

  • Two defences in release.sh that the tests did not actually measure. Found by
    mutating the script rather than by reading it.

    Replacing the existing-tag check's fail with an echo of the same words left every
    case green: the script carried on, bumped, committed, and only then did git tag
    refuse the tag that already existed. The release was still refused — one commit too
    late, which is the opposite of what the script promises, that a refusal leaves the
    version file modified and nothing else. The cases now check that it did not commit on
    its way to refusing.

    And git push --atomic was not measured at all; two separate pushes passed. With two
    pushes main arrives and the tag does not, so the repository carries a version bump
    that no release and no published artifact corresponds to — and the tag that would
    produce them cannot be pushed afterwards either, because the version it would be
    given is by then "already the current version". A pre-receive hook on the test
    remote now refuses tags, which is the way to make the second half fail on demand.

    Both mutations fail now, along with the three that already did.

  • The PyPI wait allows a margin once the index answers. apkradar's Docker build
    failed on 2026-10-03 with No matching distribution found fifteen seconds after
    the wait had reported the version available — 16:31:21 against 16:31:36. The poll is
    not wrong and not enough: it establishes that the file is reachable from the runner,
    while the build container, multi-platform through buildx, resolves the index again
    and can reach an edge still serving the old one.

    This is not the sleep 60 that stood in that step before polling and lost the race
    twice. That was a guess about how long publishing takes, made before knowing
    anything; this waits for the fact first and then allows a bounded margin for it to
    propagate, and says so in the log when it uses one.

    It narrows the window; it does not close it. What closes it is not asking the index
    during the build at all — which is what exeradar's Dockerfile already does, with
    pip install /app/src, and why exeradar has no wait script and did not hit this.
    cookieradar and patchradar are one word from that (_SOURCE=local); apkradar and
    mailradar would need the build argument added. That is the follow-up.

    Three cases hold the margin, and they were needed twice over. The two cases that
    already drove this script pass the retry interval as zero so they stay fast, and the
    new default made every success wait 45 seconds past their timeout — so the suite was
    red in all four repositories until those two were told to ask for no grace. Telling
    them that alone would have left the margin itself unmeasured, which is the shape of
    defect this script was written to fix in the first place. So: one case times a
    two-second grace and checks the log says why it waited, one checks that no grace
    waits for nothing and claims nothing, and one measures the default without the
    suite paying 45 seconds for it — started with no grace argument, the script must
    still be running three seconds after the index answered. All four ways of undoing
    the margin were checked against them: the default set to zero, the wait removed
    while the log still claims it, the log removed while the wait still happens, and the
    guard removed so zero waits anyway.

  • batch no longer crashes on a site it could not see. The verdict was turned into
    a label through a table with no entry for ERROR, so a site answering 403, or a
    bot-management challenge answering 200, ended in ❌ Error: <ExitCode.ERROR: 3>, and
    the report asked for with -o was never written. It now reads ⛔ NOT MEASURED with
    the reason and no tracker counts — as audit already did — and the report is saved.

  • Auditing a site that is itself on the tracker list no longer finds it a tracker of
    itself.
    linkedin.com, facebook.com, bing.com, tiktok.com: the site's own
    document was counted as the tracker linkedin.com in every session, so the verdict
    was always VIOLATION "persists from pre-consent". Requests to the audited site are
    first-party, which the README already put out of scope, and trackers is again the
    subset of external that its own comment says it is.

  • The accept selector button[id*='agree'] no longer clicks "disagree". A substring
    match: Didomi's didomi-notice-disagree-button sits next to its agree button, and
    the selectors are tried before the labels, so the post-accept session rejected and
    was recorded as accepted.

  • The site is the one the browser landed on, spelled as the browser spells it. The
    host compared against every request came from the address typed: müller.de against
    requests to xn--mller-kva.de, or example.com against a redirect to example.it,
    and every resource of the site came out as an unknown external host. The typed host
    is now converted to IDNA, and the main frame's navigation — redirects included —
    decides the site, in Chromium's own spelling (which also covers ß, where Python's
    IDNA 2003 codec and Chromium disagree). Checked against real Chromium on local pages.

  • No provision is cited for a challenge page. notes_of knew that an error page is
    not the site and did not know the same of a challenge served with 200, so the report
    said NOT MEASURED and, under the provisions, "no cookie banner was found". Both now get
    their own NOT MEASURED note, and findings_of draws no finding from either: a reject
    button on a page that is not the site no longer leads to citing a violation.

  • normalize_url refuses an address with no host. https:// passed, the browser
    refused to navigate, and an invalid address exited 2 (UNVERIFIED) instead of 3.

  • An unreadable --trackers database exits 3, not 1. Only ValueError was caught,
    so a .eno that could not be read escaped as a traceback with exit status 1 — which
    a pipeline reads as VIOLATION.

  • batch -o report names no longer collide where the filesystem ignores case.
    Example.com.txt and example.com.txt are one file on Windows and macOS, and the
    second report overwrote the first.

  • A trackerdb block left open is kept when another block follows it, not only at the
    end of the file, as the parser's docstring already promised.

  • Shell scripts are checked out with LF everywhere (.gitattributes). With
    core.autocrlf=true a Windows checkout wrote release.sh and wait_for_pypi.sh with
    CRLF, and bash stopped at set: pipefail\r: invalid option name.

  • pytest, as the README says to run it, no longer ends in three errors. The
    benchmarks need the CodSpeed runner, which only codspeed.yml installs; without it
    they are now skipped with that reason. And pyproject.toml no longer sends the reader
    to tests/test_benchmark_contract.py, a file that never existed.

  • README: audit --trackers is in the command reference, the version examples use
    the current scheme, and batch's NOT MEASURED is described.

Changed

  • The race with PyPI is closed rather than narrowed: the released image no longer asks
    the index.
    docker.yml installed cookieradar==<the new version> from PyPI and
    polled the index first to make that work. The poll is not wrong and not enough: it runs
    on the runner, while the multi-platform build resolves the index again, per platform,
    from whichever edge answers — apkradar lost that race on 2026-10-03 fifteen seconds
    after
    its poll had succeeded. Nothing that waits can close it. Not asking does, so the
    image is built from the source the tag points at.

    local is also the branch tests.yml already builds on every run, with the smoke test
    behind it, so the release moves onto the better exercised of the two paths rather than
    onto an untried one. This repository is the only one of the five where that was already
    true; in the other four the only thing that built the image automatically was the
    workflow that publishes it.

    Two things follow. A dispatched rebuild now checks out the tag it was given: while the
    image installed that version from the index, where the job stood in the tree did not
    matter, and built from the checkout it decides what ships. And that the file on PyPI can
    be installed, which the old arrangement proved by accident, is now checked on purpose in
    publish.yml after the upload — where a slow index delays a check instead of failing a
    build that had nothing to do with it, and with no margin, because there is a single
    resolver there.

    Five mutations hold it, and all five fail: the image back on the index, the checkout off
    the tag, a wait returning before the build, the published file unchecked, and a margin
    where there is one resolver.

    Not included, and worth doing separately: neither branch of this Dockerfile passes
    --only-binary :all:, so a dependency without an aarch64 wheel would be compiled under
    QEMU. patchradar's pypi branch had that guarantee and keeping it was part of its move;
    here there is nothing to keep, and adding it is a change of its own.

  • The scanner no longer guards against a service-worker request it never receives.
    _is_main_document caught the error that request.frame raises for a service
    worker's request, which has no frame. Playwright hands those to the context alone,
    never to page.on("request"), the scanner's only listener, and none is a navigation,
    so the check stopped before asking for the frame anyway. Measured with Playwright 1.63
    on Windows and Linux; an integration test with a fetching service worker, on real
    Chromium, keeps it so. The tests that #23 had written against mocks of the scanner,
    Playwright and the law fetcher run on real inputs now as well: local sites scanned by
    Chromium with the host resolver mapped to 127.0.0.1.

  • release.sh runs the suite after the bump, and refuses before committing.
    The version is written as the script's first act, so a suite run before a
    release cannot see what the bump breaks. Twice — apkradar 2026.42 on 2026-10-03
    and 2026.43 on 2026-10-04 — test_the_readme_states_the_version_it_was_captured_with
    failed in CI, on main, with the tag already pushed, and was fixed by hand after
    the fact.

    The gate sits between writing the version and committing it, not after: a refusal
    then leaves the version file modified and nothing else touched, which is what
    somebody needs to see, and git checkout undoes it. A gate after the commit would
    have to undo a commit, and undoing is worse than not doing. A repository with no
    tests/ is not held up by a suite it does not have.

    Three cases hold it, and the first was checked against the script without the gate:
    a failing suite stops the release with nothing committed, tagged or pushed; a
    passing one lets it through; and no tests/ is not a failure.

Full Changelog: v2026.42...v2026.43