Skip to content

v3.0.0

Latest

Choose a tag to compare

@github-actions github-actions released this 18 Nov 12:35
· 6 commits to master since this release
8ac70a5

3.0.0 turns ApiScout into one apiscout command, adds new input formats, API hash detection and plugins for current IDA, Ghidra and Binary Ninja, and makes everything much faster.

pip install apiscout, then apiscout dbs download and apiscout scan dump_0x00400000 --db win7_prof-n_sp1_example.json.

New input formats. scan reads Windows minidumps (range by range, at their own addresses) and reads from standard input with -. --import-table uses a parser of our own, so LIEF is no longer a dependency.

DLL placement (ASLR). One API DB per Windows build now fits dumps of every boot. --modules FILE, the module list of a minidump, or DLL images found in a flat dump place the DLLs at their real load addresses.

Confidence and explain. Every hit gets a confidence from 0 to 100 against chance hits. scan drops hits below 20 by default; --min-confidence N sets the cut, --min-confidence 0 keeps every hit. apiscout match A B --explain lists the APIs two vectors share, and those only one has, with their weight in the score.

Dynamic API hashes. --dynamic also finds APIs a program resolves at run time: hashes of export names (ROR13, Metasploit block_api, CRC32, djb2, FNV-1a, sdbm), also with an XOR or ADD key of the sample, plus export names as strings. Without the flag, nothing changes.

DBs. apiscout dbs download fetches the example DBs, checked against dbs/SHA256SUMS. New example DBs: Windows Server 2022 21H2 and Windows 11 Pro 26H2. python -m apiscout.db_builder.DllDownloader builds the DB of a Windows build from Winbindex and Microsoft's symbol server, without a machine of that build.

Plugins. IDA 9 (dockable view, batch mode, ida-plugin.json for hcli), Ghidra 12 with PyGhidra (ghidra_scout.py replaces GhidraScout.java), Binary Ninja 6 (binja_scout, new).

Speed. Scanning a 62 MB dump with two DBs went from 73 s to 2.9 s, and a 65 MB dump with one DB from 2.0 s to 0.22 s. --dynamic with the key search on 65 MB: 5.3 s to 1.2 s. Matching against 20,000 vectors: 2.9 s to 0.08 s. scan with all five example DBs: 1.9 s to 0.8 s. Building a DB of 439 DLLs: 80 s to 0.4 s. Same results as before.

Also: Python 3.10+, packaging with pyproject.toml, ruff and ty, CI on GitHub Actions, releases go to PyPI through trusted publishing. File headers now say BSD-2-Clause, like LICENSE. The full list is in the CHANGELOG.

Moving from 2.x

2.x 3.0.0
scout.py dump db.json apiscout scan dump --db db.json
every hit, chance hits included apiscout scan dump --db db.json --min-confidence 0
scout.py -t / -i / -b / -f --import-table / --ignore-aslr / --base-addr / --filter
scout.py -o out.json apiscout scan --json -o out.json
match.py A -v B, -c FILE apiscout match A B, -c FILE
export.py -p x.png -w x.html apiscout export --png x.png --html x.html
collect.py ROOT -r _dump -u FILE apiscout collect ROOT --require _dump --update FILE
update.py apiscout update
GhidraScout.java ghidra_scout.py (PyGhidra)

Breaking:

  • The JSON changed. scout.py -o wrote a list of rows. apiscout scan --json writes an object with the same rows under apis, next to base_address, api_dbs, apivector, apis_in_vector and, with --collection, collection_matches. Scripts that read the list need ["apis"] now. (There are more fields, like placed_dlls, and dynamic_apis with --dynamic.)
  • Python 2 and IDA before 9.0 are no longer supported. Python 3.10 or newer.
  • scout.py, match.py, export.py, collect.py and update.py are gone, and so are setup.py, requirements.txt and template.config.py.
  • update reads the Malpedia token from ~/.config/apiscout/malpedia-token (or --token-file), not from config.py.
  • collect skips API DBs with ASLR offsets unless you pass --use-aslr-dbs or --ignore-aslr.
  • scan drops hits with a confidence below 20 by default, so it can list fewer APIs than scout.py did. --min-confidence 0 keeps every hit.

In detail

  • (BREAKING) Python 2 and IDA before 9.0 are no longer supported, and the scripts scout.py, match.py, export.py, collect.py and update.py are replaced by the apiscout command. Packaging moved to pyproject.toml (with uv.lock), code is linted and formatted with ruff and type checked with ty, CI runs on GitHub Actions, and pushing a version tag builds and checks the distributions, uploads them to PyPI (trusted publishing, with attestations) and creates the GitHub release, as described in RELEASING.md.
    • Command line: pip install apiscout installs the apiscout command with the sub commands scan, match, export, collect, update and dbs. It prints JSON with --json, takes API DBs from --db, --db-dir or $APISCOUT_DB_DIR, reads and writes standard input and output with -, and its errors say what to do. update reads the Malpedia token from a file instead of config.py. dbs download fetches the example DBs of the repository for the installed version, checked against dbs/SHA256SUMS, into the user data folder, which is searched after ./dbs; --db and --collection also find files there by bare name. (BREAKING) The JSON output changed shape: scout.py -o wrote a list of API rows, apiscout scan --json writes an object with these rows, unchanged, under apis, next to base_address, api_dbs, apivector, apis_in_vector and, with --collection, collection_matches.
    • Minidumps: apiscout scan recognizes a Windows minidump by its MDMP signature and scans its memory ranges (Memory64ListStream and MemoryListStream, adjacent ranges joined) at their own addresses with a small parser of its own (apiscout/Minidump.py, no new dependency, bounded by the size of the file), so offsets are virtual addresses (relative to --base-addr if given, which a file name no longer sets for a minidump). The processor architecture of a 32bit system restricts the search to 32bit pointers, and hits inside the images of the DLLs of the module list that are also in the API DB are left out, as they are the export tables and import address tables of the DLLs and not references of the sample. ApiScout.crawlRegions() scans regions like ida_scout.py does, and the references of a crawl result are now in the same coordinates as its offsets.
    • ASLR at scan time: one API DB per Windows build fits dumps of every boot. apiscout scan --modules FILE (lines of <hex load address> <DLL path>, the format and the matching rules of DatabaseBuilder.py --load_addresses, whose logic apiscout/LoadAddresses.py copies because the builder is standalone), the module list of a minidump, and DLL images found in a flat dump (PE headers at page-aligned offsets, identified by the name in their export directory and verified by the RVAs and ordinals of their exports, as the API DB stores no TimeDateStamp or SizeOfImage; the image at offset 0 is the sample's own and is skipped; a DLL whose load address the DB has from its ASLR offsets is not moved by an image, which may be a copy the sample mapped itself, unless --ignore-aslr) place the DLLs of the API DBs at their real load addresses (ApiScout.loadDbFile(path, place)), the other DLLs keep the addresses of the DB. How many DLLs were placed from which source is reported on standard error and listed in placed_dlls of the JSON output.
    • ASLR in the plugins: the IDA, Ghidra and Binary Ninja plugins place the DLLs of the API DBs at the load addresses of an optional module list file in the format of --modules (a field of the IDA and Binary Ninja form, --modules FILE after the API DBs of ida_scout.py and ghidra_scout.py, a choice of the Ghidra dialog, modules= of scan_and_annotate()) and report how many DLLs were placed. DLL images in the analysed memory place nothing: references into the memory itself are left out, and a private copy of a DLL that a sample maps would move the DLL. The references located in the images of the placed DLLs that are in the memory (their import address tables) are left out, as scan does for a minidump. TrickBot's dump with a DB whose DLLs are all elsewhere: 183 references with a module list instead of 0, those of scan --modules. The plugins call placer_for_modules(), describe_placements(), placed_image_ranges() and split_modules_argument() of apiscout.LoadAddresses.
    • Explaining matches: apiscout match VECTOR OTHER --explain lists the APIs the two vectors share and the APIs only one of them has, heaviest first with their weight in the score, and --explain with --collection (match and scan) does the same for the best match. ApiVector.explainMatch() returns the same as a dictionary whose score is that of matchVectors().
    • Library: fixed a crash when a buffer ends in FF 15/FF 25, import tables (apiscout scan --import-table) are read by the own parser only, which gave the same imports as LIEF on all files tested and is bounded for crafted files, so LIEF is no longer a dependency, import descriptors without import name table, PE mapping of truncated or unusual files, matching of vectors given as lists, NaN when matching empty vectors, and API DBs of the same OS replacing each other. Crawl results are now ordered by offset. Imports by ordinal are resolved for ws2_32.dll, wsock32.dll and oleaut32.dll, compressed ApiVectors are validated, and a 32bit and a 64bit export at the same address are both resolved. Scanning is about 25 times faster: candidate addresses are searched with numpy (62 MB with two API DBs: 2.9 instead of 73 seconds), the results are the same. Searching for the addresses and for the calls and jumps through them was reworked (apiscout/numpy_search.py) and is about 9 times faster again (65 MB with one API DB: 0.22 instead of 2.0 seconds, in up to 4 threads for buffers beyond 1 MB), with the same results.
    • Confidence: every hit of a scan gets a confidence from 0 to 100 against chance hits, bytes that happen to equal an API address. It adds up the evidence of the scan: hits in the import table are certain, otherwise other APIs within 16 bytes (an IAT or other table), calls and jumps through the location, another API DB agreeing and an offset aligned to the pointer size count. apiscout scan --min-confidence N drops hits below N, the JSON records get a confidence field, and ApiScout.getConfidences() and filterByConfidence() are there for plugins. On the Malpedia dumps, 99.9% of the hits of the right API DB score 20 or more, while none of 1,786 chance hits (dumps scanned with DBs of other Windows versions, random buffers) do, among them the isolated NdxTableAddObjectToList of TrickBot. (BREAKING) apiscout scan drops hits below 20 by default, so its listing, its JSON and its ApiVector can hold fewer APIs than scout.py gave for the same dump; --min-confidence 0 keeps all of them as before. The plugins still annotate every hit, and apiscout collect still builds the vectors of a collection from every hit.
    • Dynamic APIs: apiscout scan --dynamic also finds APIs that a program resolves at run time and therefore never stores as pointers, in a section after the listing, in the JSON field dynamic_apis and in the ApiVector (without the flag, output and vector are unchanged). Hashes of the export names of the API DBs (ROR13 as in FLARE's shellcode_hashes, Metasploit's block_api with module name, CRC32, djb2, FNV-1a) are searched in the dump as 32bit constants at any offset, and only reported as groups of at least 3 different constants of one algorithm within 128 bytes of each other (more for dumps so large that chance would form such a group; a hash of an algorithm matches by chance every 130 KB or so, with two API DBs a group of 3 about once in 8 GB of random data), export names as whole NUL terminated ASCII or UTF-16LE strings of at least 6 characters, only in runs of at least 3 different names of one encoding that start at most 64 bytes after the end of the previous one (lists passed to GetProcAddress, import name tables; isolated words like socket or system are dropped). ApiScout.findDynamicApis() does the same for the library, addDynamicApisToResults() adds the findings to the results for the ApiVector, and apiscout.DynamicApis holds the hash functions. 62 MB with two API DBs: 3.4 seconds for scan, 4.7 with --dynamic. Malware often XORs or adds a constant of its own to the hash (Emotet: sdbm, the sixth algorithm, with a key; Dridex: CRC-32 with a key), so --dynamic also finds that key: it is the one that at least 3 to 6 of 32 APIs that loaders almost always resolve (LoadLibraryA, GetProcAddress, VirtualAlloc, ...) agree on when their hashes are combined with every 32bit value of the dump (the number is chosen so that chance forms less than 0.01 keys per dump), and the hashes of all export names with the key are listed with it, e.g. sdbm^0x1e5c48de (XOR) or crc32+0x218fe95b (ADD), when at least 3 are within 4096 bytes of each other; blocks of uniformly distributed bytes (encrypted or compressed) are left out of the key search, so 62 MB of random data with two API DBs take 0.2 seconds more with --dynamic, and 256 MB of random data gave no key, with or without leaving out those blocks. --dynamic is also about 4 times faster than it first was: on 65 MB with the key search it takes 1.2 instead of 5.3 seconds, and the hash index of an API DB is built in 0.1 to 0.2 instead of 0.2 to 0.7 seconds, with the same results.
    • Matching against a collection is 35 times faster (20,000 vectors: 0.08 instead of 2.9 seconds, apiscout match 0.25 instead of 3.2): the vectors are decompressed together and scored with sums over lookup tables, with the same scores to the last bit and the same order, and Pillow is only imported to draw a diagram.
    • The ApiQR export works again, the update works from any directory, and updating a collection no longer writes a second file.
    • Speed: an API DB loads 2.5 times faster (0.1 instead of 0.3 seconds), apiscout scan with the five example DBs takes 0.8 instead of 1.9 seconds, apiscout dbs 0.4 instead of 0.6 and apiscout --version 0.05 instead of 0.2 seconds, as modules like numpy, Pillow and the network modules are only imported by the commands that need them. The results are the same.
    • IDA: ida_scout.py is a plugin now (see the README) with a dockable results view instead of a modal dialog, a batch mode and ida-plugin.json for the plugin manager. APIs are also annotated when their location was defined as something else before, type libraries match the bitness of the database and include ntapi, API locations are typed as function pointers, and the decompiler shows the API names for dumps loaded as binary file.
    • Binary Ninja: a plugin (binja_scout, plugin.json) scans the memory of a view with the chosen API DBs in a background task, lists the references found and annotates all of them or those with a neighbour within a given distance: import address symbols typed as pointers to the prototypes of the platform's type libraries. apiscout.BinaryNinjaTools.scan_and_annotate() does the same headless. Verified with Binary Ninja 6.0.10905 Ultimate on macOS 27.2 (menu, forms, report with address links, undo) and headless on memory dumps of Malpedia loaded as Mapped view with win7_prof-n_sp1_example.json: TrickBot (32bit) 182 of 183 references annotated, 179 with prototype; Cobalt Strike (64bit) 196 of 196 with prototype. Functions the linear sweep finds in tables of pointers and that nothing refers to are removed where a pointer is annotated (without this, 115 of the TrickBot references were skipped), Zw* APIs get the prototype of their Nt* counterpart, segments without data are not scanned, a cancelled scan keeps the results of the last one, and the extension manager, which installs the whole repository and imports its root, loads the plugin through the root __init__.py and installs only numpy.
    • Ghidra: GhidraScout.java is replaced by ghidra_scout.py, a script for PyGhidra (Ghidra 12 started with pyghidraRun) that calls the apiscout library instead of running ApiScout through temporary files, so apiscout is installed into the Python environment of PyGhidra. The script asks once for the folder with the API DBs (headless, its arguments are the API DBs only), scans the program's memory instead of the imported file, keeps all references to an API, annotates them like imports (external references and prototypes) and can be run headless (pyghidraRun -H).
    • License: the file headers named the GPL v3, while LICENSE, the package metadata and PyPI have said BSD 2-Clause since the first release. The headers now refer to LICENSE (SPDX-License-Identifier: BSD-2-Clause).
    • DB Builder: --os_name/--os_version build a DB from a copy of the DLLs on any OS, --load_addresses takes the ASLR offsets from a module list (lines of <hex load address> <DLL path>) instead of loading each DLL; DLLs are matched by folder and file name, or by file name alone where it is unique. The DLL filter covers DLLs of current Windows versions. Building a DB is about 200 times faster (439 DLLs: 0.4 instead of 80 seconds), the DB files are the same.
    • DB from the symbol server: DllDownloader.py (standard library, Python 3.10, next to DatabaseBuilder.py, which it calls) builds the API DB of a Windows build without a machine of that build. Winbindex's index per DLL gives the file, its SHA-256, size, timestamp and SizeOfImage for --windows 11-24H2 --update KB5046617 (or a build such as 26100.2605, BASE; --list shows the Windows versions and updates), the file comes from Microsoft's symbol server. It takes the DLLs of the DLL filter, the 64bit for System32 and the 32bit for SysWOW64, rejects every download that differs from the hash and size of Winbindex, skips verified files of an earlier run, downloads with 4 parallel requests and retries with growing pauses, and reports DLLs that are unknown to Winbindex, have no file for the update or are not on the symbol server, building the DB from the others. A DLL that the update does not list is taken from the latest earlier update that does (a cumulative update only lists what it changes). Build 26300.9974 (KB5132061) takes 4 minutes (439 DLLs, 117,499 APIs); of the 462 DLLs of dbs/win11_pro_26h2_example.json, 436 are in it, all with the same version and the same exports and addresses, the other 21 are the Visual C++ runtimes (not part of Windows), fastprox.dll and wbemprox.dll (in wbem, not in System32 itself), apisetschema.dll and slc.dll (not on the symbol server) and cabinet.dll and the 64bit xmllite.dll (the symbol server's copy is not the file of Winbindex: rejected).
    • Loading an API DB no longer warns about the DLLs of the example DBs that share an address: the DB Builder takes the ASLR offset of every DLL in a process of its own, so up to 23 DLLs got the same load address (3 to 6% of the exports of the Windows 10, Windows 11 and Server 2022 DBs), which is logged at info level with --verbose. The warning stays for every collision that involves a DLL without an ASLR offset in the DB (as with --ignore-aslr or DBs without offsets) or one that a module list of apiscout scan places.
    • apiscout collect parses each API DB once instead of twice in the main process (once to check for ASLR offsets, once to load it), about 0.1 seconds less per DB (five DBs: 2.3 instead of 2.7 seconds for a small folder). The workers still load the DBs they need themselves.
    • apiscout collect rejects --use-aslr-dbs together with --ignore-aslr (exit code 2), where --ignore-aslr used to win without a word.
    • ApiScout.api_maps replaces a map instead of editing it: what is kept between scans (the search for the addresses of the maps, the hashes of --dynamic, and what loadDbFile() collected besides a map, such as the exports that share an address with another bitness) belongs to the map object under a name, so a map that is put under the name of another one is searched with its own addresses and names, and not with those of the map it replaced. Editing a map in place is not seen by this.
    • DB Builder: DatabaseBuilder.py needs Python 3.10 like the rest of the package, it no longer runs on the Python 3.8 of Windows 7. For such a system, build the DB from a copy of its DLLs on another system (--os_name, --os_version, --load_addresses).
    • A module list that is applied to 64bit DLLs below 4 GB warns, in DatabaseBuilder.py --load_addresses and in apiscout scan --modules: with a copy of the DLLs that has no SysWOW64 folder, the list of a 32bit process (whose DLLs are named by their System32 path) was matched to the 64bit DLLs of System32, and every offset of them was wrong without a hint. The 64bit ntdll.dll, kernel32.dll and user32.dll do not count, as Windows 7 loads them below 4 GB.
    • DB Builder: 32bit ARM DLLs (machine types 0x1C0, 0x1C2, 0x1C4) are 32bit in the DB like those of x86, they were labelled 64bit with the other machine types, which made a scan search their addresses as QWORDs. DllBaseChecker can not load 32bit ARM DLLs, so their ASLR offset stays 0 with one warning that counts them, where it failed with a warning per DLL; ARM64 DLLs go to the 64bit DllBaseChecker as before.
    • DatabaseBuilder.py --os_name/--os_version without --outfile checks up front that the first two numbers of the version, which name the output file, contain none of the characters Windows does not allow in a file name (/ \ < > : " | ? * and control characters), on every OS as DBs are shared; the build used to fail when it wrote the file, after reading all DLLs.
    • (BREAKING) DB Builder: it runs as a module from a clone, python -m apiscout.db_builder and python -m apiscout.db_builder.DllDownloader, instead of python DatabaseBuilder.py in apiscout/db_builder with imports through sys.path. The vendored pefile, peutils and ordlookup moved to apiscout/db_builder/_vendor/. Still standard library only and not in the wheel.
    • (BREAKING) The IDA plugin moved to plugins/ida/ (with ida-plugin.json and ida-plugin.png), the Ghidra script to plugins/ghidra/ and the Binary Ninja plugin folder binja_scout to plugins/binja_scout/ (plugin.json and the __init__.py the extension manager imports stay at the root). hcli installs only the folder of ida-plugin.json, so the IDA plugin gets apiscout from PyPI (pythonDependencies: apiscout>=3.0.0), install it with hcli plugin install <clone>/plugins/ida. Run from a clone, the IDA and Ghidra plugins still use the package and the dbs folder of the clone.
  • 2026-11-17: Added a Windows 11 Pro 26H2 (build 26300.9974) 32bit and 64bit import DB (dbs/win11_pro_26h2_example.json, 462 DLLs, 140,065 APIs), built with DatabaseBuilder.py --paths C:\Windows\System32 C:\Windows\SysWOW64 --filter on an installed system (not a fresh installation). All DLLs are Microsoft-signed system DLLs from System32 and SysWOW64; the 7 DLLs the crawl also found in the DriverStore folder (copies shipped with driver packages) were removed afterwards. Like the other DBs of recent Windows versions, it carries the ASLR offsets of the boot it was built in and serves as example and for tests, not for dumps of other systems.
  • 2026-11-16: Added a Windows Server 2022 (21H2, build 20348) 64bit import DB (dbs/win2022_server_21h2_example.json, 343 DLLs, built with DatabaseBuilder.py --filter on a fresh installation). Like the Windows 10 DB, it carries the ASLR offsets of the boot it was built in and serves as example and for tests, not for dumps of other systems.
  • 2026-11-16: Follow-ups for the Windows 10 DB: collect.py now skips API DBs with ASLR offsets unless --use_aslr_dbs or --ignore_aslr is given (FingerprintCrawler got an ignore_aslr_offsets parameter) and loading a DB warns about many colliding addresses. ApiVector now matches DLL names case-insensitively (e.g. IPHLPAPI.DLL). Fixed ws2_32.dll being truncated in the JSON output of scout.py, missed references of 64bit jmp [rip+x] thunks, the base address of PE32+ headers and 64bit imports by ordinal. Tests now run with unittest instead of nose.
  • 2026-11-01: Added Windows 10 Pro 1803 (build 17134.1) 64bit import DB, including the ASLR offsets of the boot it was built in (as all 64bit system DLLs share the file ImageBase 0x180000000). These offsets are only valid for memory dumps from that very boot; for other dumps, use import table parsing (scout.py -t) or rebuild the DB on the system the dump was taken from. scout.py --ignore_aslr (ApiScout.ignoreAslrOffsets(True)) is only meaningful for systems without ASLR and not usable for this DB's 64bit DLLs, as they then overlap at 0x180000000. Also note that the offsets of several rarely loaded DLLs in this DB (mostly 32bit ones, e.g. iphlpapi.dll, wininet.dll) put them at overlapping addresses, so APIs of these DLLs may be resolved incorrectly. Also fixed two DB Builder bugs: version 0.0.0.0 was written for all DLLs, and ordinal-only exports were truncated for DLLs mapping many ordinals to one address (e.g. mfc42.dll lost ~90% of its exports).

What's Changed

Changes

  • Fix getAllMemoryFromIda to return all sections instead of just one by @nazywam in #3
  • Added compression for ApiVector by @steffenenders in #4
  • Added matching for ApiVectors by @steffenenders in #5
  • Added visual export (html, png) for ApiVector-instances by @steffenenders in #6
  • sort winapi vector by rank to improve avg. size by @steffenenders in #9
  • Small structure change by @jdval in #11
  • avoid logging.basicConfig when other loggers exist by @jdval in #12
  • adding function type information during naming of imports by @FlxP0c in #13
  • fix some typo by @garanews in #15
  • Fix wrong zero-padding when compressing some ApiVectors by @rikyoz in #16
  • made db_builder python 3.7 compatible by @elanfer in #17
  • ported to IDA 7.4 by @jenfrie in #18
  • Fix requirements.txt by @catsuryuu in #19
  • Fix bug for Python 2 AttributeError: 'tuple' object has no attribute … by @trietptm in #20
  • Bug Fix in dll export without func name by @Dump-GUY in #24
  • Python3 startswith method must work with bytes no string by @Dump-GUY in #26
  • python3 errors by @Dump-GUY in #25
  • Bug not processing uppercase extension (.DLL,.DRV...) by @Dump-GUY in #27
  • Allow Python3 installation to grab the latest lief version by @cccs-rs in #33
  • Add Ghidra plugin. by @mari-mari in #35
  • Ask a user for the scout.py script path instead of its parent directory by @mari-mari in #36
  • Add output support for the call/jmp referencing addresses in JSON_FILE mode by @renzhexigua in #37
  • fix bug which let ida_scout.py crash because of "set is not hashable" error by @7a6570 in #39
  • Windows 10 DB follow-ups: ASLR handling, case-insensitive ApiVector DLL names, 64-bit fixes by @r0ny123 in #40
  • Fix bugs across library, IDA and Ghidra plugins, extend DB Builder, modernize tooling by @r0ny123 in #41
  • Add the apiscout command line tool, rework the README by @r0ny123 in #42
  • Scan about 25 times faster by searching candidate addresses with numpy by @r0ny123 in #43
  • Add apiscout dbs download for the example API DBs by @r0ny123 in #44
  • Add a Windows 11 Pro 26H2 example API DB by @r0ny123 in #45
  • Replace GhidraScout.java with a PyGhidra script by @r0ny123 in #46
  • Add a Binary Ninja plugin by @r0ny123 in #47
  • Make the file headers match the BSD 2-Clause LICENSE by @r0ny123 in #48
  • Shorten the README by @r0ny123 in #49
  • apiscout scan: read Windows minidumps by @r0ny123 in #50
  • apiscout scan: place the DLLs of an API DB where the dump has them by @r0ny123 in #51
  • Score hits with a confidence against chance hits by @r0ny123 in #52
  • Explain why two ApiVectors match by @r0ny123 in #53
  • scan --dynamic: APIs resolved at run time, by name hashes and name strings by @r0ny123 in #54
  • DBs from the symbol server, keyed API hashes, and a lot faster everywhere by @r0ny123 in #56
  • Follow-ups to the review in #55 by @r0ny123 in #57
  • IDA, Ghidra and Binary Ninja plugins: place the DLLs of an API DB by a module list by @r0ny123 in #58
  • scan: drop hits with a confidence below 20 by default by @r0ny123 in #59
  • Repo layout: DB builder as a module, plugins/ for IDA and Ghidra by @r0ny123 in #60
  • ci: adopt the shared release process for v3.0.0 by @danielplohmann in #61

New Contributors

Full Changelog: https://github.com/danielplohmann/apiscout/commits/v3.0.0