Skip to content

Releases

ExeRadar 2026.45

Choose a tag to compare

@github-actions github-actions released this 24 Oct 10:21
v2026.45
d65ad8a

Security

  • certifi 2026.10.19 in uv.lock, from 2026.7.22. The older bundle trusts emSign root CAs whose
    intermediate CA keys were compromised (GHSA-6q48-6c7w-9gw2, critical, published 2026-10-20);
    2026.10.19 is the release the advisory names as fixed. The Security Posture gate stopped every pull
    request on it.

Fixed

  • An unsigned binary, an invalid signature and known vulnerabilities now cite art. 24(2)(d) and
    24(2)(e) of d.lgs. 138/2024, not art. 21(2)(d) and (e) of the NIS2 directive.
    The directive binds
    the Member States; in Italy the duty of essential and important entities to take security measures is
    art. 24 of the decree that transposes it, with the same letters: (d) supply chain security, (e)
    security in acquisition, development and maintenance, vulnerability handling included. The text is
    downloaded from Normattiva; the scope note points to art. 3 of the decree and comes with it.
    ARCHITECTURE.md's mapping table says the same.
  • The law check records the source a verified text came from (Cellar, the EUR-Lex fallback or
    Normattiva), as the other Radar tools now print it; law_checker.check takes an optional HTTP
    client, so the path is tested on recorded answers.

ExeRadar 2026.44

Choose a tag to compare

@github-actions github-actions released this 17 Oct 21:45
v2026.44
ca62e91

Added

  • docs/nis2-compliance.md: the answers to the seven questions a customer subject to NIS2
    asks a software supplier, with only what the repository can back.
    Written in Italian, for
    customers under d.lgs. 138/2024. Where the answer is "no" it says no: there is no penetration
    test, no second reviewer, no pull request rule on main and no access control, because a
    CLI has no users. It says what leaves the machine: nothing about the analysed file, ever;
    the organisation searched to api.first.org with psirt; the cited acts to EUR-Lex and
    Normattiva with analyze --online; and, on Windows, whatever the operating system fetches
    from the CA while Get-AuthenticodeSignature checks a signature.
    tests/test_nis2_evidence.py compares the host list with the hosts named in the modules
    that can reach the network, and holds the offline default, the image user, the cache path,
    the release files and the scanners to what the document says. It refuses "NIS2-ready",
    "no data sent to third parties" and similar claims in the document, in SECURITY.md and in
    the README.
  • Every release carries SBOMs and dated scans (.github/workflows/sbom.yml): CycloneDX 1.5
    of the image, Debian packages included (Syft), and of the Python environment
    (cyclonedx-py), plus Trivy reports of the image and of the repository at the tag, and a
    note saying which commit and image digest they describe and that a CVE scan is not a
    penetration test. It runs after the image of the tag has been pushed, and on demand for a
    release that is already out.
  • SECURITY.md, which ExeRadar did not have: how vulnerabilities are found, how fast they
    are answered, how customers are told and how to roll back. A fix ships with the next
    release; for CVSS 9.0 or more, customers who gave a security contact hear within 48 hours.
  • uv.lock, written with uv 0.12.18, and a Quality step that fails when it falls behind
    pyproject.toml.

Fixed

  • A certificate LIEF could not find or that had expired made a valid file signature_invalid.
    LIEF's verify_signature() adds BAD_SIGNATURE whenever the signature check does not pass, for
    any reason, and BAD_SIGNATURE is read as "not valid": Steam's WriteMiniDump.exe
    (CERT_NOT_FOUND|BAD_SIGNATURE, its one certificate unparsed by LIEF 1.0.0) and ASMedia's
    Usb4HR64.sys (BAD_SIGNATURE|CERT_EXPIRED, not timestamped) got the high finding and its
    citations, although Windows and signtool validate both and their digests are the ones signed.
    The verdict is now assembled from its parts: the digest alone (HASH_ONLY, keeping BAD_DIGEST) and
    the signature's own flags (Signature.check()). Both files are now "not checked to a conclusion",
    exit 2; a changed byte is still bad_digest, and only it is reported as "the file does not match
    what was signed" — another failure now reads "the signature does not verify". Found among 1,500
    PE files compared with Get-AuthenticodeSignature on 2026-10-17.
  • Started from PowerShell 7, every catalog-signed file was reported unsigned. exeradar verify C:\Windows\System32\notepad.exe answered unsigned, exit 1, and analyze cited CRA Annex I,
    CRA art. 13(1), NIS2 art. 21(2)(d) and GDPR art. 32(1) against it, from pwsh 7.6.7. The same
    command from Git Bash said catalog. The Windows PowerShell that path B starts inherited pwsh's
    PSModulePath, found PowerShell 7's Microsoft.PowerShell.Security first, could not load it and
    exited 1, and that failure was read as "no catalog entry". The variable is no longer passed on.
    Underneath it was a wider rule broken: any failure of path B — PowerShell missing, timing out,
    exiting non-zero, answering nothing, or answering anything but NotSigned or a valid catalog
    signature — became UNSIGNED. It is now UNKNOWN with the reason (catalog check could not conclude: …), which cites nothing and makes verify exit 2; only Windows saying NotSigned
    leads to unsigned. From pwsh the suite went from 29 failures to the 16 environmental ones.
  • On a pull request, Security Posture called live exceptions unused. CodeQL reports only what
    the change introduces on a pull request ref, so when it reported anything, an exception for a
    finding still open on main in an untouched file matched nothing and failed the gate
    (cookieradar #37, 2026-10-12). main's open alerts now count as history the record may match,
    like the closed ones; blocking is still decided on the pull request's own alerts. Simulated on
    #37's real alerts: the false "unused" goes, the real new alert stays.
  • Security Posture judged every pull request by main's alerts. It listed the alerts without
    a ref, so GitHub answered for main, and its wait compared the scanners' runs with the merge
    commit, which none of them carries: on mailradar #39 it waited two seconds. It now waits for
    the runs of the branch head, Bandit included, and reads the open alerts of refs/pull/N/merge;
    the closed ones come from that ref and from main, so an exception main holds as settled is not
    called unused on a ref with no history. Checked against a recent pull request of each Radar
    with the real tool: the same verdict as main in all six.
  • The texts of the law arrived in clear. Cellar answers its https:// URL with a 303 to an
    http:// one (recorded on 2026-10-11 for the GDPR), and fetch_html followed it, so the act
    travelled without TLS and the SHA-256 printed beside a citation described bytes nothing had
    protected. Redirects are now followed by hand and a hop to http:// is taken over https://,
    which serves the same document byte for byte; if that fails, the fallback to EUR-Lex applies.
    Checked live: the GDPR came back whole over two HTTPS requests. The test replays Cellar's
    recorded 303.
  • The release evidence describes what ships, and says when a scan saw nothing. The
    source SBOM listed the build venv's own pip, which the image removes, and, the version
    being dynamic, named the package without a version: both are fixed, and a tag that
    disagrees with the installed version is refused. An empty trivy-fs report, as at a tag
    with no lockfile, is now called what it is in the note and in the document. CodSpeed is
    listed among the checks of question 5.
  • The Saturday mutation run would have died on the NIS2 tests. mutmut copies only the
    paths in also_copy into mutants/, and tests/test_nis2_evidence.py reads docs/, which
    was not among them. Listed now, with a test that checks every file those tests read.
  • The licence gate had never refused anything. pip-licenses --fail-on="GPL;AGPL;LGPL"
    compares whole licence strings, and no package declares just "GPL": they declare "GNU
    Lesser General Public License v2 or later (LGPLv2+)" and the like. Measured on 2026-10-11
    with chardet 5.2.0 installed: exit 0 without --partial-match, exit 1 with it. The flag is
    there now; ExeRadar's own dependencies pass it.

Changed

  • SECURITY-EXCEPTIONS.toml: the settled entries that stay now say why. Docker Scout and Snyk
    stopped reporting the gcc-14 advisories (CVE-2026-102010 and CVE-2026-95619, and their Snyk ids)
    on 2026-10-07 and 2026-10-08, so the gate lists them as settled. patchradar debian on 2026-10-15
    still reports gcc-14 no-dsa in trixie at 14.2.0-19, with the fix only in sid, so the package is
    still unfixed and only the reporting changed. The entries are kept, and each now records when the
    scanner fell silent and what Debian said, as this file's CVE-2026-82560 entry already did.
    Deleting a flaw that is demonstrably present because a scanner fell silent is the one direction
    the file must not drift in.

  • The NIS2 document describes the branch rules as they are since 2026-10-12. The ruleset on
    main lost the owner's bypass and requires a pull request for every change, the version bump
    included; the document said the maintainer could bypass the rules and that no rule required a pull request. A test holds the new
    wording and refuses the old.

  • release.sh falls back to a rebase merge when the ruleset refuses a squash, as apkradar's
    does, and says to enable auto-merge when it cannot be turned on.

  • release.sh goes through a pull request. main now takes pull requests only, the owner
    included, after a cloud session pushed straight to it with the owner's account. The script
    commits the bump on release/vX and pushes that branch only; with gh and a GitHub origin it
    opens the pull request with auto-merge, waits for the merge and tags the merge commit.
    ./release.sh --tag X is that last step alone. The guarantees stay: nothing is committed when
    the suite fails, and the tag is made before anything is pushed. Ported from mailradar.

ExeRadar 2026.43

Choose a tag to compare

@github-actions github-actions released this 10 Oct 09:20
v2026.43
8356ccb

Fixed

  • The file's own version is not an address. C:\Dev-Cpp\devcpp.exe (Dev-C++
    4.9.9.2, Delphi, UPX-packed, unsigned, measured 2026-10-09) was reported with
    hardcoded_ip: 4.9.9.2 and cited against the CRA. 4.9.9.2 is what its
    VERSIONINFO resource declares, twice: as the fixed numbers of VS_FIXEDFILEINFO and
    as the StringFileInfo value under FileVersion — and that value is the very string
    the strings pass reads, standing a few padding bytes away from the key that names
    it, so the Version= corroboration never saw the pair. The PE parser now reads the
    resource into the result (version, printed as version 4.9.9.2, product 5 and
    carried in the JSON), and a dotted quad equal to anything it declares is the
    version, not an address: no finding, no citation. Only what the resource says —
    ICU's 78.2.0.0 in node.exe is a third party's version the file never names as
    one, and it is still reported.

  • An object identifier is not an IP address. Run on 2026-10-09 against the
    binaries on a Windows 11 workstation, gpg.exe 2.5.24 was reported with four
    hardcoded addresses — 1.3.101.110 to 1.3.101.113, RFC 8410's X25519, X448,
    Ed25519 and Ed448 — and node.exe with 189, the whole of OpenSSL's X.520 and X.509
    object table (2.5.4.3 is commonName). Both raised hardcoded_ip and cited the CRA.
    A dotted quad under one of the arcs the registries assign at four components
    (1.3.6.1, 1.3.14.3, 1.3.36, 1.3.101, 1.3.132.0, 2.5, 2.23) is now
    read as an identifier when the same file carries an identifier no address can be —
    five arcs, or an arc past 255. Corroboration inside the file, as for versions: the
    arcs are also allocated address blocks, so the arc alone decides nothing, and
    Cloudflare's 1.1.1.1 beside Chromium's OpenSSL table is still reported.

  • An address in 0.0.0.0/8 is not an endpoint. 0.0.0.0 was already how a
    program binds rather than somewhere it calls; the rest of the block was not, and
    Code.exe (VS Code 1.105, Microsoft) was reported with 0.0.10.0, 0.0.100.0,
    0.1.0.0 as hardcoded addresses out of a resource table. RFC 1122 reserves the
    whole block for "this network" and nothing is routed to it, so it is treated as
    the loopback is: reported as a string, raised as nothing.

  • The evidence of a finding is a line, not a wall. hardcoded_ip on node.exe
    listed 191 addresses in one evidence string — nine lines of console, nine of
    ticket. The first ten are named and the rest are counted (…and 181 more); the
    whole list stays in the JSON under strings.ips, where a tool reads it.

  • A function imported by ordinal is counted. It has no name, and was dropped:
    powershell.exe was shown importing 0 functions from ATL.DLL, and Code.exe
    29 from WS2_32.dll when it asks for 54, 25 of them by number. An ordinal is now a
    function named #7, the way dumpbin writes one; the category rules read nothing
    from it, since a number carries no verb.

  • A section name longer than eight bytes is read from the string table.
    docker.exe (Go) showed eight sections called /4, /19, /32 … /112, five of
    them at entropy 8.00 and coloured as packed. /N is the PE/COFF convention for a
    name kept in the COFF string table at offset N; resolved, they are .zdebug_info,
    .zdebug_line and their siblings — compressed DWARF, which is what 8.00 means
    once the name can be read. A /N with no table behind it is kept as written.

  • Section entropy is read from LIEF, not recomputed byte by byte. Code.exe
    (VS Code, 238 MB) took 24 s to analyse; six of them were Counter() walking the
    186 MB of its .text for a number LIEF had computed in 70 ms. The parser reads
    LIEF's figure and puts its sign right (-0.0 for a section of one repeated byte
    is what the old wiring existed to avoid); entropy() stays as the reference the
    tests hold it to. 14 s on the same file.

  • A scheme is a URL only when a host follows it. Go writes its string literals
    back to back, so go.exe and docker.exe reported https://,, https://H and
    http://); as URLs, and Node's templates http://${input} and http://%s:80 came
    out of node.exe and Code.exe the same way — 139 of Code.exe's 1,508. Two labels
    or an address make a host; one label does with a path or a port after it
    (http://wpad/wpad.dat, http://localhost:8000) and does not without
    (http://An). The punctuation of the sentence a URL was quoted in is no longer
    part of it: https://www.python.org/psf/license/) out of python314.dll loses
    its bracket, Go_(programming_language) keeps the one it opened, and
    https://proxy.golang.org. keeps its root dot.

  • An identifier that ends in a delegated word is not a host. powershell.exe
    reported eleven hosts and all were .NET namespaces (System.Net.Ping,
    System.IO); docker.exe 103, of which 89 were Go symbols (bytes.Compare,
    errors.As) or debris (0y.nf, LG.HK); python314.dll had StreamReader.read.
    A label written in both cases is an identifier — DNS is case-insensitive and
    nobody writes a hostname in CamelCase — and a host needs one label of three
    characters, where it needed two (t.co joins x.co as the cost). .cat is a
    Windows catalog before it is Catalonia: WIREGUARD.CAT is a file.

  • A path names a directory somewhere along it. /1/4, /./u, /o/O, /-/S/k/,
    /s/s/s/s/s/s were reported as paths — four printable bytes with slashes in them,
    which is what the minimum string length lets through: eleven of docker.exe's
    2,218, sixteen of node.exe's 250, thirty-two of Code.exe's 87. A Unix path now
    needs one segment of three characters, anywhere — /go/src/github.com/docker/cli/…,
    Docker's GOPATH, opens with two and stays, as do the other 2,207 source paths of
    docker.exe, every one of them real.

  • The import column is as wide as the longest name shown. It was 34 characters,
    and api-ms-win-core-libraryloader-l1-2-0.dll is 40: on notepad.exe, cmd.exe and
    git.exe one count sat six places to the right of the others.

  • The timestamp authority is spelled as the signer is. The signer comes from LIEF
    as C=US, O=…, CN=… and the authority came from asn1crypto as Common Name: …; Organization: …; Country: US: two spellings of a distinguished name three lines
    apart in the same report (gpg.exe, docker.exe, Code.exe). One spelling now, in
    the order the certificate stores it.

  • psirt names a candidate by what the directory searches. exeradar psirt Microsoft answered "no exact match; the directory returned Microsoft Corporation.
    Choose by name", and psirt "Microsoft Corporation" then found no member at all:
    FIRST's directory searches team names, not host organisations. A candidate is now
    Microsoft Security PSIRT (Microsoft Corporation), the reason says to ask again
    with the team's name, and an empty answer says what was searched. Both bodies are
    recorded as the API answered on 2026-10-09.

Changed

  • The suite also runs on Python 3.15-dev, as an experimental matrix row that may
    fail without failing the check. 3.15.0 final ships on 2026-10-09 (PEP 790); the row
    is there to learn before the classifier moves, and it becomes a stable row when it
    does. The stable rows must now equal the Programming Language :: Python :: 3.x
    classifiers in pyproject.toml, and tests/test_codecov_contract.py enforces both.

ExeRadar 2026.42

Choose a tag to compare

@github-actions github-actions released this 08 Oct 15:22
v2026.42
bd5396d

Security

  • A filename can no longer run PowerShell. The catalog check (path B, Windows only)
    put the path into the script as a single-quoted literal and doubled the ASCII quote,
    and PowerShell closes that literal on U+2018, U+2019, U+201A and U+201B as well: a
    file named a’; <command>; ’b.exe, legal on NTFS, ran <command> with the user's
    rights when analyze, batch or verify reached it — one name in a downloaded folder
    was enough for batch. The path now travels in the EXERADAR_TARGET environment
    variable and is never part of the script, so there is no escaping left to get wrong.
    Checked against PowerShell's own parser, and on Windows by running it: a name that
    carries ni pwned is analysed as the catalog-signed file it is, and no pwned appears.

  • Strings out of the binary are printed, not obeyed. The console report passed
    them to Rich as markup: http://evil.example/[/x] in a PE ended analyze with a
    MarkupError, and a well-formed tag such as [link=…] was followed. Every value that
    comes out of the file — its name, strings, section and DLL names, the signer, errors —
    is escaped, in analyze and in the batch table.

  • The Markdown report cannot carry HTML from the binary. A path such as
    C:\y\`<img src=x onerror=alert(1)>` closed its code span and reached the ticket it
    was pasted into as raw HTML; a section named a|b added a column to the table. Code
    spans now use a fence longer than any run of backticks inside them, pipes are escaped
    in table cells, and free text — the file name, the signature sentence, library
    evidence, notes — has & < > [ ] written as entities, which cannot turn back into
    markup whatever precedes them.

  • A forged certificate table no longer hides the file's strings. The range the
    header declares for the certificate table was left out of string extraction even when
    LIEF found no signature in it and even when it covered the sections: pointed at
    0x400..EOF, it removed every URL, address and path from the report, and the
    hardcoded_ip finding with them. It is skipped now only when a signature was read
    there, and only past the last section.

Fixed

  • A file whose path is not ASCII is analysed on Windows. LIEF opens a path through
    the narrow API there, so caffè.exe, or anything under C:\Users\José, came back as
    "not a PE file", verify answered 2 for a validly signed file, and batch dropped it.
    Python reads the bytes and LIEF parses them (pe.parse), on every platform.

  • A countersignature time with an offset is converted to UTC. +0200 was printed as
    local time with " UTC" after it, two hours off on the date that decides whether an
    expired certificate is covered. A time with no zone at all says so instead of being
    given one.

  • A catalog signer whose Subject contains | keeps its name. PowerShell's answer was
    four fields joined by |, so O=Contoso|Fabrikam lost half of itself to the
    timestamper. The script now answers in JSON.

  • --output into a directory that is not there is refused before the scan, with exit
    code 2, instead of a FileNotFoundError traceback after it; a write that fails anyway
    (permissions, a full disk) is reported the same way.

  • batch does not follow NTFS junctions. Path.rglob skips symlinks and follows
    junctions, and one pointing back at its parent — mklink /J, no privilege needed —
    listed the same PE 64 times. batch -o with nothing to report now says that no file
    was written, instead of saying nothing.

  • tlp.subject compares the first word, not a prefix: "TLP:REDACTED minutes" was
    taken as already marked TLP:RED, and "TLP:AMBER+STRICT" as TLP:AMBER.

  • first_teams.resolve does not choose between two exact matches. An organisation
    can have more than one member team — a product PSIRT and a corporate CERT, with
    different addresses and keys — and the first in the response was returned. Both are
    now candidates, and psirt exits 2.

  • PyPI is published from a tag only, and after the suite. publish.yml compared tag
    and version for tags alone, so a dispatch from a branch published that branch; and it
    waited for no test. A test job, without the publishing token, now comes first.

  • The README examples say what the tool prints: "2 matching their signature" and
    the signature sentences of verify, which had changed since they were written.

  • .gitattributes keeps shell scripts LF. With core.autocrlf=true a Windows
    checkout turned release.sh into CRLF and bash stopped at set -euo pipefail.

  • Five tests no longer assert the author's installed DLL versions (OpenSSL 3.5.8,
    curl 8.13.0, pcre2 10.48): they failed on any machine that had updated Git for
    Windows or Windows. The expected version is read from the library's own statement in
    the same bytes; which library, and nothing else, is still asserted exactly.

  • A dispatched rebuild now stands on the tag it was given. docker.yml can be run by
    hand with the tag of an already published release to rebuild it, and it checked out the
    default branch — while the image is built from that checkout.

    The consequence was milder than it sounds, which is why it survived: the smoke test
    compares the version inside the image against the tag and runs on a push: false
    build, before the login and before anything is pushed, so a rebuild of v2026.40 from
    a main holding 2026.41 failed rather than publishing the wrong code. What it meant is
    that rebuilding an older release could not work at all, and failed with a version
    mismatch that reads like a packaging problem rather than like a checkout standing in
    the wrong place. patchradar had the same omission on 2026-10-04 with no comparison
    behind it, where it would have tagged main's code with an old release's number.

  • The image is built on every push and pull request, not only when asked.
    docker-build-check.yml was reachable by hand alone, so the only thing that built this
    image automatically was docker.yml — on a tag, pushing as it went. The first attempt
    at a build was the one that published it. Nothing stopped it from running on every
    change: this image is built from the checkout with no version to resolve, unlike
    apkradar's and mailradar's, whose build check has to be handed a published version
    because their Dockerfiles install from the index.

  • Three comments that said "the other four Radar install from PyPI". patchradar
    stopped on 2026-10-04 and builds from the tag's source, as this one always has. Three
    of four now, and the difference matters, because those comments are what somebody will
    read when deciding what to do about the remaining ones.

    Four mutations hold the two new cases. One of them did not fail at first: the case read
    a fixed 400-character window after actions/checkout, which reaches into the step that
    extracts the version and names inputs.version for its own reasons — so a checkout
    that ignored the input looked like one that used it. The window now ends where the step
    ends.

Added

  • Findings in the analyze report. ARCHITECTURE.md section 7 separates facts from
    findings, and the console and Markdown reports showed only the facts: a
    signature_invalid of severity high reached the JSON and the count in batch and
    nobody reading analyze. Both now end with the findings, title and severity first.

  • "Provisions applied", as README and ARCHITECTURE.md section 5 describe.
    law_checker.check was called by nothing, so no report carried a citation or the notes
    that qualify them (the CRA applies from 11 December 2027; it binds a manufacturer).
    analyze now cites, in the console and in Markdown. The JSON is unchanged: it
    carries the findings, not the citations.

  • analyze --online, and offline by default. analyze cites from the local cache
    in ~/.exeradar and downloads nothing; --online downloads the texts the findings
    need and refreshes the cache. A provision the cache does not hold is cited without a
    hash, and the run says so and suggests --online, instead of failing. A clean file
    touches no network either way.

  • 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.

  • A release script, which this repository never had. The other four Radar release
    through release.sh or scripts/bump_version.py; here __version__ was edited by
    hand, committed, tagged and pushed. That is why the suite gate the other four were
    given had nowhere to live: there was nothing to put it in. Ported from cookieradar,
    where the script and its cases were written, with the version file and the product
    name changed and nothing ...

Read more

v2026.41

Choose a tag to compare

@maksimtech maksimtech released this 03 Oct 14:33
01cc29a

Added

  • Library versions, read out of the strings: a new libraries.py and a
    libraries field on every report.
    A statically linked zlib is invisible to
    every dependency scanner that reads a manifest, because there is no manifest —
    the code is inside the executable and the only place it says so is a string.
    System32's curl.exe is the case in one line: it reports curl 8.13.0 and
    zlib 1.3.1, and nothing else in that file mentions zlib at all.

    Four claims, and they are deliberately not the same claim:

    source what it means
    banner the library states its own version and the code is here — OpenSSL 3.5.8 25 Aug 2026, libcurl/8.22.0, expat_2.8.5
    build path the source directory it was compiled in, left behind by an assert's __FILE__ — ../openssl-3.5.8/crypto/asn1/a_int.c
    assembly reference a version this file asks another file for at run time, not one it carries
    import used, and the version is in that DLL and not in this file — so the row names the DLL

    Every rule came out of running a loose version against a corpus of DLLs that are
    each one known library — the Git for Windows ucrt64 tree plus
    C:\Windows\System32\curl.exe, fifteen libraries, measured 2026-10-02 — so that
    each answer could be checked against something true rather than against a
    plausible shape.

    What it refuses matters more than what it finds. Four of those fifteen carry
    their version as a bare number with no name beside it: pcre2 as
    10.48 2026-08-31, zstd as 1.5.7, idn2 as 2.3.8, and the committed
    python.exe as 3.14.7. None is reported. That shape is also an OID
    (1.2.840.113549.1.1.1) and four bytes of debris (8.9.:.), both out of the
    same corpus, and being right about pcre2 by accident is not worth being wrong
    about those. Nor is a protocol version a library version: http/1.1,
    RTSP/1.0, TLS 1.2 (1.1, 1.0) ciphers to use and TLSv1.3 are fourteen of
    the sixteen name-then-number strings in curl.exe, and libssh2's handshake
    banner SSH-2.0-libssh2_1.11.1 holds both numbers at once with only the second
    belonging to the library.

    Because silence is the common answer, libraries.CAVEAT is printed next to the
    list whether or not there are rows: a library missing from this list is not
    absent
    . An empty list is the answer most often misread.

    Two decisions were wrong first and are recorded in the code as such. One row per
    library hid the file that matters — Git's curl.exe states curl 8.22.0 in its
    own banner and imports libcurl-4.dll, which is where the code is and what
    somebody patching curl would have to replace — so a library stated here and
    imported now gets a row for each. And a comment claimed the banner's anchoring
    was the rule doing the work; a mutation showed it changes no answer anywhere in
    the corpus, so the comment now says what is true and the rule is kept for the
    reason it actually has.

    JSON keeps "version": null rather than dropping the key, which is the opposite
    of what tlp does and deliberately: an absent tlp means nobody chose a label,
    while a null version means the file was asked and did not say.

    The scanner now extracts the strings once and gives both passes the same list —
    the library pass needs the raw runs, since a release directory is a path and
    OpenSSL 3.5.8 25 Aug 2026 is in none of the four buckets. A second call would
    have read a 25 MB DLL twice, which test_the_file_is_read_for_strings_exactly_once
    now prevents.

    54 tests, of which eight run against the corpus itself. ARCHITECTURE.md gains
    section 8 for the module, and its layout list is brought back in line — four
    modules added in earlier commits were missing from it and one that does not exist
    was in it.

Removed

  • Four settled entries out of SECURITY-EXCEPTIONS.toml, and the fifth kept on
    purpose.
    The gate has been reporting five exceptions whose finding nobody
    reports any more, and the difference between them is the whole decision.

    CVE-2025-47273, CVE-2026-57585, GHSA-6v7p-g79w-8964 and CVE-2026-84782
    were all closed by GitHub at 2026-09-30T19:26:53Z — one timestamp, which is
    the republish — and Docker Scout has run six times since without mentioning any
    of them. The absence is explained in both cases: the first three were copies
    vendored under pip/_vendor/, which the Dockerfile removes along with the rest
    of the build tooling, and the fourth was openssl, which
    patchradar debian CVE-2026-84782 reports resolved in trixie at
    3.5.7-1~deb13u3 and which apt-get upgrade picked up at the rebuild. Each was
    written as "closes when the next image is published"; it was published, so they
    are gone. Their return would mean a fix regressed, which is worth a build
    failing over.

    CVE-2026-82560 stays, and not because its silence is shorter — it is
    longer. That alert closed at 2026-09-29T15:08:22Z, a different and earlier
    moment, with nothing done to the image in between, and the absence has held
    across eleven Scout runs over three days against the other four's six. The
    deciding fact is elsewhere: patchradar debian CVE-2026-82560 on 2026-10-02
    still reports perl no-dsa in trixie at 5.40.1-6+deb13u1, no fix in any
    suite, Debian bug 1148455. perl-base is still installed and still unfixed; only
    the reporting changed, and Scout has already changed its mind about this exact
    id once — which is why the gate reads closed alerts at all. Deleting a flaw that
    is demonstrably present because a scanner fell silent is the one direction this
    file must not drift in, so the entry now says so in writing.

    tests/docker/inspect.sh keeps its pip/setuptools probe and gains the reason:
    with those three entries gone, that probe is the only thing that would notice
    the removal regressing.

    Fourteen entries down to ten. The gate still passes, which was checked by
    running it locally against this repository's live alerts and not by inference.

Changed

  • The CI runners are pinned to ubuntu-26.04, and the benchmarks job is pinned
    to ubuntu-24.04 because CodSpeed cannot run on 26.04.
    ubuntu-latest was
    Ubuntu 24.04 — read off a live run on 2026-10-02, image ubuntu24/20260927.320 —
    and GitHub moves that label on its own schedule, so the choice was between finding
    out what breaks on a branch or finding out later on main at a moment nobody
    picked.

    Something did break, which is the whole value of having asked: CodSpeedHQ/action
    v5 fails on 26.04 with ##[error]Unsupported system. mode: simulation was
    already set and the action was pinned, so it is the image and nothing else. Every
    one of the five Radar runs CodSpeed, so every one of them would have broken the
    same way the day the label moved by itself.

    That job is pinned to 24.04 rather than left on ubuntu-latest: left there it
    keeps working right up to the day the label moves and then fails on main. 24.04
    is supported until April 2029, and a comment beside it says to try 26.04 again now
    and then, because nothing here will notice when CodSpeed adds support.

    The risk surface was measured before anything changed — no apt-get and no sudo
    in any workflow, Python from actions/setup-python at explicit versions, no
    container: or services: jobs — and the Docker path was checked on its own by
    dispatching docker-build-check.yml against the branch, which succeeded on image
    ubuntu26/20260927.149.

    What pinning costs: nothing bumps it for you. Dependabot updates action versions,
    not runs-on.

  • ruff now lints tools/ as well, because it never did. Every one of the five
    Radar lints its package and its tests and stops there, which left
    tools/security_exceptions.py outside the check — the script that refuses a build
    over an unexplained alert had never been seen by the linter that gates the build.
    Found on 2026-10-02 by running ruff over the whole tree by hand while working on
    something else, which is not a way of finding things that scales.

  • README.md's analyze transcript is regenerated from the tool. It was a
    claim about what gets printed, and three things had drifted out of it: the
    overlay line, the signature sentence — which stopped saying "valid" when it
    stopped being able to mean it — and now the Libraries block. python.exe turns
    out to be the best example of the new refusal, so the three things in that output
    that are the tool declining to overclaim are now four.

  • A report can carry its own distribution terms: --tlp on analyze and
    batch.
    This is the case FIRST's Traffic Light Protocol exists for — a finding
    sent to a vendor's PSIRT before it is public, where whether the recipient may
    forward it is the whole question. exeradar is the Radar whose reports go to a
    PSIRT, and since exeradar psirt now finds the address and the key, the document
    needed a way to say its own terms.

    Where the label goes differs by format, and that is the one new decision here:

    format where why
    Markdown a quoted block above the heading it is read by a person, and that is where they meet it
    JSON a tlp field, first it is read by a tool; a banner in a string would have to be parsed back out, and a consumer that cannot see a marking cannot respect it

    A batch report is marked once in Markdown — one document, and repeating the
    block between headings teaches the eye to skip it — and on every object in
    JSON, because a consumer can read a single row out of the array and must still see
    the terms it came under. test_both_formats_carry_the_same_label holds the two
    forms to the same answer for all five labels.

    ...

Read more

v2026.40.1

Choose a tag to compare

@github-actions github-actions released this 26 Sep 14:28
v2026.40.1
a8e801b

Full Changelog: v2026.40...v2026.40.1

v2026.40

Choose a tag to compare

@github-actions github-actions released this 26 Sep 12:33
v2026.40
ca28f5e

Full Changelog: v2026.09.3...v2026.40

v2026.09.2

Choose a tag to compare

@maksimtech maksimtech released this 22 Sep 21:23
v2026.09.2
16ab355

Three bugs, all found by pointing ExeRadar at a real third-party binary —
BIOSdump2license.exe, a BIOS-dump tool — rather than at the test fixture.

Fixed

  • Register* functions no longer claim the registry category.
    RegisterClassW registers a window class, which every program with a GUI
    does, so every GUI program was reported as touching the registry — through
    USER32, which exports no registry function at all. The rule is now "starts
    with Reg but not with Register": kernel32 exports 41 real registry
    functions and advapi32 82, and none of them begins with Register. Leaving
    the system DLLs out of the category would have hidden those 41, so a test
    guards that RegOpenKeyExW and friends are still recognised through
    KERNEL32.
  • Section entropy no longer prints as -0.00. The textbook
    −Σ p·log₂(p) negates its sum, and for a section of one repeated byte that
    sum is 0.0, so it returned −0.0. It is now written Σ p·log₂(1/p), which
    cannot produce a negative zero.
  • …and the report now actually uses that function. Sections were measured
    with LIEF's own section.entropy, which has the same flaw, so fixing
    ExeRadar's function changed nothing a user saw; only rerunning the tool on
    the binary showed it. The values agree with LIEF's to within 1.2 × 10⁻¹⁴.
  • URLs stored back to back are reported separately. A font's name table
    keeps its strings with no separator, and three URLs came out as one. A URL
    now ends where another scheme begins; each part is still trimmed of the
    DER debris certificates leave around theirs.

Notes

  • Two existing tests could not have caught the entropy bug: both compared
    values (== approx(0.0), 0.0 <= entropy), and −0.0 equals 0.0. The new
    test checks the sign.
  • A URL followed directly by ordinary text keeps that text
    (…/licenseNK57): with no separator in the data there is nothing honest to
    cut on.
  • 255 tests pass, 28 more than 2026.09.1.

ExeRadar 2026.09.1

Choose a tag to compare

@maksimtech maksimtech released this 21 Sep 17:24
v2026.09.1
42ce5d7

First release. Static analysis of PE binaries: headers, imports, strings, code
signing, and the legal provisions the findings concern.

Added

  • analyze FILE: one binary in full — PE headers, sections with entropy, the
    import table and its categories, classified strings, and the signature.
    --output picks its format from the extension, .json or .md, and refuses
    an extension it does not know rather than guessing. The name is checked
    before the scan starts, so a rejected filename never costs the work.
  • batch DIR: walks a directory recursively and analyses every PE in it,
    chosen by magic bytes rather than by extension, sorted by path so two runs
    produce comparable reports. Prints a row per file — name, short hash,
    signature state, number of findings — and --output writes the whole run as
    a JSON array or one Markdown section per file.
  • verify FILE: reads the signature and nothing else, with no hashing, no
    imports and no strings, so it stays fast on a large binary. Meant as a gate
    in a script, and its exit code carries the answer: 0 signed and verified,
    1 unsigned or signed with a signature that does not verify, 2 could not
    be determined — unreadable, not a PE, or no way to check on this platform.
  • Signature checking by three paths, which is the design this tool exists
    around. A spike against Windows' own notepad.exe found LIEF reporting zero
    embedded signatures for a file Windows reports as validly signed: the
    signature is in a catalog under CatRoot, which no PE parser can see. So an
    embedded Authenticode blob is read and verified (path A), a catalog entry is
    confirmed through Windows (path B), and only when both have run and found
    nothing is a file called unsigned (path C).
  • SignatureState.UNKNOWN, distinct from UNSIGNED. On Linux and macOS the
    catalog cannot be consulted, so the absence of an embedded signature proves
    nothing and is never reported as unsigned. Calling a catalog-signed Microsoft
    binary unsigned would be the worst false positive this tool could ship.
  • RFC3161 countersignature decoding, so an expired signing certificate is not
    mistaken for a bad signature when the file was signed while the certificate
    was valid.
  • String extraction in ASCII and UTF-16LE, classified into URLs, IP addresses,
    hostnames and paths, with the certificate table excluded: everything in there
    belongs to whoever signed the file, not to the program. On the repository's
    own fixture that took the URLs found from 11 to 1, removing ten Microsoft CRL
    and OCSP endpoints.
  • Import categorisation into network, filesystem, registry, process and crypto,
    decided from the imported functions and not from the library alone —
    ADVAPI32.dll covers three of the five, and KERNEL32.dll claims none by
    itself.
  • Section entropy, which marks a packed or encrypted section above roughly 7.0.
  • law_checker: findings mapped to the provisions they concern, each cited
    with the SHA-256 of the exact wording applied and the date of that wording.
    The acts are downloaded on every run and cached in ~/.exeradar/law_cache.json
    (EXERADAR_HOME moves the folder).
    • Unsigned, invalid signature, expired certificate → Cyber Resilience Act,
      regulation (EU) 2024/2847, Annex I, Part I(2)(f), which requires products
      to protect the integrity of programs against unauthorised modification, and
      art. 13(1), which puts that duty on the manufacturer. Also NIS2 art.
      21(2)(d) and GDPR art. 32(1).
    • A hardcoded IPv4 address → CRA Annex I, Part I(2)(j), attack surfaces and
      external interfaces, cited alone and with a note that it is a general
      requirement rather than a rule about addresses.
    • Every CRA citation carries two notes: the regulation applies from
      11 December 2027 (art. 71(2)), so it is in force and not yet applicable;
      and it binds a manufacturer placing a product on the market (art. 2(1)),
      which a PE header cannot establish about a single file.
    • Nothing is cited that the acts do not contain: a test reads them and fails
      on any reference they lack.
  • publish.yml: tagged releases are built with hatchling and published to PyPI
    through trusted publishing, with no API token in the repository.

Not implemented

  • ELF and Mach-O are recognised by their magic number and declined by name, so
    a Linux binary is answered with "ELF is not supported yet" and not mistaken
    for an unknown format.
  • known_vulnerabilities is mapped to its provisions — CRA Annex I, Part
    I(2)(a) and Part II(1) and (2), NIS2 art. 21(2)(e) — and produced by nothing:
    ExeRadar does not read dependencies yet.
  • No Docker image. docker-build-check.yml builds one from the repository to
    keep the Dockerfile honest, and nothing is published.

Deliberately not reported

  • No finding for a URL served over http://. The obvious candidate was CRA
    Annex I, Part I(2)(e), confidentiality in transit. The only URL in this
    repository's own fixture is http://schemas.microsoft.com/SMI/2016/WindowsSettings,
    an XML namespace out of the PE manifest and not an endpoint the program
    contacts: a finding that fires on every Windows binary with a manifest is not
    a finding.
  • Loopback and 0.0.0.0 are not reported as hardcoded addresses: they are how
    a program binds, not somewhere it calls.

Notes

  • EU acts are fetched from the Publications Office's Cellar service,
    publications.europa.eu/resource/celex/, with the eur-lex.europa.eu page as
    a fallback. That page now answers automated requests with HTTP 202 and an AWS
    WAF challenge. The two renderings hash identically on the provisions cited.
  • asn1crypto decodes the RFC3161 token, in place of signify. signify was
    the obvious choice and depends on oscrypto, unmaintained since March 2022
    and broken against OpenSSL 3.x, which failed on the Linux runners with
    LibraryNotFoundError.
  • Requires Python 3.11 or later; tested on 3.11, 3.12, 3.13 and 3.14.