Repository navigation
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 -owrote a list of rows.apiscout scan --jsonwrites an object with the same rows underapis, next tobase_address,api_dbs,apivector,apis_in_vectorand, with--collection,collection_matches. Scripts that read the list need["apis"]now. (There are more fields, likeplaced_dlls, anddynamic_apiswith--dynamic.) - Python 2 and IDA before 9.0 are no longer supported. Python 3.10 or newer.
scout.py,match.py,export.py,collect.pyandupdate.pyare gone, and so aresetup.py,requirements.txtandtemplate.config.py.updatereads the Malpedia token from~/.config/apiscout/malpedia-token(or--token-file), not fromconfig.py.collectskips API DBs with ASLR offsets unless you pass--use-aslr-dbsor--ignore-aslr.scandrops hits with a confidence below 20 by default, so it can list fewer APIs thanscout.pydid.--min-confidence 0keeps 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.pyandupdate.pyare replaced by theapiscoutcommand. Packaging moved topyproject.toml(withuv.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 inRELEASING.md.- Command line:
pip install apiscoutinstalls theapiscoutcommand with the sub commandsscan,match,export,collect,updateanddbs. It prints JSON with--json, takes API DBs from--db,--db-diror$APISCOUT_DB_DIR, reads and writes standard input and output with-, and its errors say what to do.updatereads the Malpedia token from a file instead ofconfig.py.dbs downloadfetches the example DBs of the repository for the installed version, checked againstdbs/SHA256SUMS, into the user data folder, which is searched after./dbs;--dband--collectionalso find files there by bare name. (BREAKING) The JSON output changed shape:scout.py -owrote a list of API rows,apiscout scan --jsonwrites an object with these rows, unchanged, underapis, next tobase_address,api_dbs,apivector,apis_in_vectorand, with--collection,collection_matches. - Minidumps:
apiscout scanrecognizes a Windows minidump by itsMDMPsignature 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-addrif 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 likeida_scout.pydoes, 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 ofDatabaseBuilder.py --load_addresses, whose logicapiscout/LoadAddresses.pycopies 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 inplaced_dllsof 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 FILEafter the API DBs ofida_scout.pyandghidra_scout.py, a choice of the Ghidra dialog,modules=ofscan_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, asscandoes for a minidump. TrickBot's dump with a DB whose DLLs are all elsewhere: 183 references with a module list instead of 0, those ofscan --modules. The plugins callplacer_for_modules(),describe_placements(),placed_image_ranges()andsplit_modules_argument()ofapiscout.LoadAddresses. - Explaining matches:
apiscout match VECTOR OTHER --explainlists the APIs the two vectors share and the APIs only one of them has, heaviest first with their weight in the score, and--explainwith--collection(matchandscan) does the same for the best match.ApiVector.explainMatch()returns the same as a dictionary whose score is that ofmatchVectors(). - 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,NaNwhen 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 forws2_32.dll,wsock32.dllandoleaut32.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 Ndrops hits below N, the JSON records get aconfidencefield, andApiScout.getConfidences()andfilterByConfidence()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 isolatedNdxTableAddObjectToListof TrickBot. (BREAKING)apiscout scandrops hits below 20 by default, so its listing, its JSON and its ApiVector can hold fewer APIs thanscout.pygave for the same dump;--min-confidence 0keeps all of them as before. The plugins still annotate every hit, andapiscout collectstill builds the vectors of a collection from every hit. - Dynamic APIs:
apiscout scan --dynamicalso finds APIs that a program resolves at run time and therefore never stores as pointers, in a section after the listing, in the JSON fielddynamic_apisand 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 likesocketorsystemare dropped).ApiScout.findDynamicApis()does the same for the library,addDynamicApisToResults()adds the findings to the results for the ApiVector, andapiscout.DynamicApisholds the hash functions. 62 MB with two API DBs: 3.4 seconds forscan, 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--dynamicalso 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) orcrc32+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.--dynamicis 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 match0.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 scanwith the five example DBs takes 0.8 instead of 1.9 seconds,apiscout dbs0.4 instead of 0.6 andapiscout --version0.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.pyis a plugin now (see the README) with a dockable results view instead of a modal dialog, a batch mode andida-plugin.jsonfor 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 asMappedview withwin7_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 theirNt*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__.pyand installs only numpy. - Ghidra:
GhidraScout.javais replaced byghidra_scout.py, a script for PyGhidra (Ghidra 12 started withpyghidraRun) 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 toLICENSE(SPDX-License-Identifier: BSD-2-Clause). - DB Builder:
--os_name/--os_versionbuild a DB from a copy of the DLLs on any OS,--load_addressestakes 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 toDatabaseBuilder.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 as26100.2605,BASE;--listshows the Windows versions and updates), the file comes from Microsoft's symbol server. It takes the DLLs of the DLL filter, the 64bit forSystem32and the 32bit forSysWOW64, 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 ofdbs/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.dllandwbemprox.dll(inwbem, not inSystem32itself),apisetschema.dllandslc.dll(not on the symbol server) andcabinet.dlland the 64bitxmllite.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-aslror DBs without offsets) or one that a module list ofapiscout scanplaces. apiscout collectparses 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 collectrejects--use-aslr-dbstogether with--ignore-aslr(exit code 2), where--ignore-aslrused to win without a word.ApiScout.api_mapsreplaces a map instead of editing it: what is kept between scans (the search for the addresses of the maps, the hashes of--dynamic, and whatloadDbFile()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.pyneeds 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_addressesand inapiscout scan --modules: with a copy of the DLLs that has noSysWOW64folder, the list of a 32bit process (whose DLLs are named by theirSystem32path) was matched to the 64bit DLLs ofSystem32, and every offset of them was wrong without a hint. The 64bitntdll.dll,kernel32.dllanduser32.dlldo 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.DllBaseCheckercan 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 64bitDllBaseCheckeras before. DatabaseBuilder.py --os_name/--os_versionwithout--outfilechecks 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_builderandpython -m apiscout.db_builder.DllDownloader, instead ofpython DatabaseBuilder.pyinapiscout/db_builderwith imports throughsys.path. The vendored pefile, peutils and ordlookup moved toapiscout/db_builder/_vendor/. Still standard library only and not in the wheel. - (BREAKING) The IDA plugin moved to
plugins/ida/(withida-plugin.jsonandida-plugin.png), the Ghidra script toplugins/ghidra/and the Binary Ninja plugin folderbinja_scouttoplugins/binja_scout/(plugin.jsonand the__init__.pythe extension manager imports stay at the root). hcli installs only the folder ofida-plugin.json, so the IDA plugin gets apiscout from PyPI (pythonDependencies:apiscout>=3.0.0), install it withhcli plugin install <clone>/plugins/ida. Run from a clone, the IDA and Ghidra plugins still use the package and thedbsfolder of the clone.
- Command line:
- 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 withDatabaseBuilder.py --paths C:\Windows\System32 C:\Windows\SysWOW64 --filteron an installed system (not a fresh installation). All DLLs are Microsoft-signed system DLLs fromSystem32andSysWOW64; the 7 DLLs the crawl also found in theDriverStorefolder (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 withDatabaseBuilder.py --filteron 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.pynow skips API DBs with ASLR offsets unless--use_aslr_dbsor--ignore_aslris given (FingerprintCrawlergot anignore_aslr_offsetsparameter) and loading a DB warns about many colliding addresses. ApiVector now matches DLL names case-insensitively (e.g.IPHLPAPI.DLL). Fixedws2_32.dllbeing truncated in the JSON output ofscout.py, missed references of 64bitjmp [rip+x]thunks, the base address of PE32+ headers and 64bit imports by ordinal. Tests now run withunittestinstead 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
- @nazywam made their first contribution in #3
- @steffenenders made their first contribution in #4
- @jdval made their first contribution in #11
- @FlxP0c made their first contribution in #13
- @garanews made their first contribution in #15
- @rikyoz made their first contribution in #16
- @elanfer made their first contribution in #17
- @jenfrie made their first contribution in #18
- @catsuryuu made their first contribution in #19
- @trietptm made their first contribution in #20
- @Dump-GUY made their first contribution in #24
- @cccs-rs made their first contribution in #33
- @mari-mari made their first contribution in #35
- @renzhexigua made their first contribution in #37
- @7a6570 made their first contribution in #39
- @r0ny123 made their first contribution in #40
- @danielplohmann made their first contribution in #61
Full Changelog: https://github.com/danielplohmann/apiscout/commits/v3.0.0