libsqlite3-sys 0.39.0

Source: https://github.com/rusqlite/rusqlite
Artifact scanned: libsqlite3-sys-0.39.0.crate (crate · 2.6 MB · SHA-256 b0e7f1cd558a…)
Compared with: libsqlite3-sys-0.38.2.crate (0 signals introduced since)
Files: 16 scanned, 6 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 14 info
Scan time: 14.8 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 13 of 13 warn and critical signals; 13 demoted to info.
Disclude version: 4.3.0
Scanned (UTC): 2026-10-26 07:28

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info encoding-base64 build.rs:277:41

base64-like blob (84 bytes, compression ratio 0.95) (in comment) (raw pass, confidence 0.36)

        // the bundled sqlite on android also uses `SQLITE_TEMP_STORE=3`.
        // https://android.googlesource.com/platform/external/sqlite/+/2c8c9ae3b7e6f340a19a0001c2a889a211c9d8b2/dist/Android.mk
        if super::android_target() {
            cfg.flag("-DSQLITE_TEMP_STORE=3");

info ~~warn~~ → info by review macro-keyword-override sqlite3/sqlite3.c:636:1

`#define double` rebinds the reserved C keyword `double` (token pass, confidence 0.85)
```
#ifdef SQLITE_OMIT_FLOATING_POINT
# define double sqlite3_int64
#endif
```
likely benign LLM, confidence 0.90 Conditional macro that maps the double keyword to sqlite3_int64 when floating point is omitted.
Reasoning
This is the standard SQLite pattern for building without floating point. The rebinding sits under SQLITE_OMIT_FLOATING_POINT and maps double to an integer type, which is a deliberate configuration choice, not an attack.
info ~~warn~~ → info by review identifier-confusable-collision sqlite3/sqlite3.c:11510:21

two identifiers collapse to visual skeleton `p|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
SQLITE_API int sqlite3_snapshot_cmp(
  sqlite3_snapshot *p1,
  sqlite3_snapshot *p2
);
```
dismissed LLM, confidence 0.95 Parameter names p1 and p2 in sqlite3_snapshot_cmp, flagged only because the skeleton collapses digits and letters.
Reasoning
The parameters p1 and p2 are ordinary names that only look alike under the digit-to-letter confusable skeleton. This is a false positive from the token pass's confusable heuristic.
info ~~warn~~ → info by review macro-keyword-override sqlite3/sqlite3.c:15856:1

`#define double` rebinds the reserved C keyword `double` (token pass, confidence 0.85)
```
#ifdef SQLITE_OMIT_FLOATING_POINT
# define double sqlite_int64
# define float sqlite_int64
# define fabs(X) ((X)<0?-(X):(X))
```
likely benign LLM, confidence 0.90 Conditional macro mapping double to sqlite_int64 when floating point is omitted, with companion fabs and float macros.
Reasoning
Same SQLite no-floating-point configuration block, mapping double to sqlite_int64 under SQLITE_OMIT_FLOATING_POINT. It is a legitimate build option.
info ~~warn~~ → info by review macro-keyword-override sqlite3/sqlite3.c:15857:1

`#define float` rebinds the reserved C keyword `float` (token pass, confidence 0.85)
```
# define double sqlite_int64
# define float sqlite_int64
# define fabs(X) ((X)<0?-(X):(X))
# define sqlite3IsOverflow(X) 0
```
likely benign LLM, confidence 0.90 Conditional macro mapping float to sqlite_int64 when floating point is omitted.
Reasoning
The float macro is part of the same SQLITE_OMIT_FLOATING_POINT block, a standard way to build SQLite without floating point support.
info ~~warn~~ → info by review identifier-confusable-collision sqlite3/sqlite3.c:22245:70

two identifiers collapse to visual skeleton `zCo||` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
SQLITE_PRIVATE Expr *sqlite3ColumnExprAuth(Table*,Column*,Parse*);
SQLITE_PRIVATE void sqlite3ColumnSetColl(sqlite3*,Column*,const char*zColl);
SQLITE_PRIVATE const char *sqlite3ColumnColl(Column*);
SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3*,Table*);
```
dismissed LLM, confidence 0.95 Function prototypes whose identifiers collapse to the same visual skeleton under the heuristic.
Reasoning
The flagged names are ordinary prototype identifiers such as zColl and Column that collide only under the confusable skeleton. No malicious content is present.
info ~~warn~~ → info by review embedded-nul-in-string sqlite3/sqlite3.c:32807:35

string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)
```
static const char aHex[]    = "0123456789abcdef";
static const char aPrefix[] = "-x0\000X0";
static const et_info fmtinfo[25] = {
  /*  0 */  {  'd', 10, 1, etDECIMAL,    0,  0,  0 },
```
likely benign LLM, confidence 0.90 Static printf prefix string literal containing an intentional embedded NUL used by the formatter.
Reasoning
aPrefix is a printf prefix table in SQLite's formatter. The embedded NUL is an intentional terminator in the string table, and the flagged bytes are data, not executable payload.
info ~~warn~~ → info by review dynamic-import sqlite3/sqlite3.c:47677:10

`dlopen` called with a non-literal path (ast pass, confidence 0.75)
```
  UNUSED_PARAMETER(NotUsed);
  return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
}
```
likely benign LLM, confidence 0.85 Unix sqlite3OsDlOpen wrapper that loads an extension library from a runtime filename.
Reasoning
This is SQLite's unix extension loader, which calls dlopen on a filename the caller supplies. Loading extensions at a runtime path is a documented, user-invoked feature, and the snippet shows no hidden or encoded behaviour.
info ~~warn~~ → info by review identifier-confusable-collision sqlite3/sqlite3.c:108561:7

two identifiers collapse to visual skeleton `i|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
){
  int i1;
  int i2;
  int iRes;
```
dismissed LLM, confidence 0.95 Local integer variables i1 and i2 in a comparison routine, flagged by the confusable heuristic.
Reasoning
The variables i1 and i2 are ordinary local integers. The confusable collision is a heuristic false positive.
info ~~warn~~ → info by review embedded-nul-in-string sqlite3/sqlite3.c:117963:40

string literal contains an embedded NUL followed by 16 more bytes of source (token pass, confidence 0.85)
```
        if( aff>SQLITE_AFF_BLOB ){
          static const char zAff[] = "B\000C\000D\000E\000F";
          assert( SQLITE_AFF_BLOB=='A' );
          assert( SQLITE_AFF_TEXT=='B' );
```
likely benign LLM, confidence 0.90 Static UTF-16-style affinity string with intentional NUL bytes used in SQLite's affinity code.
Reasoning
zAff is a UTF-16 affinity string literal, where the NUL bytes are intentional encoding padding. The assertions around it confirm the intent is affinity-character handling.
info ~~warn~~ → info by review identifier-confusable-collision sqlite3/sqlite3.c:150291:14

two identifiers collapse to visual skeleton `pK|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    int nKey;         /* Number of sorting key columns, including OP_Sequence */
    KeyInfo *pKI;     /* Original KeyInfo on the sorter table */

    regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
```
dismissed LLM, confidence 0.95 Ordinary sorter variables pKI and related names, flagged by the confusable heuristic.
Reasoning
The names nKey, pKI and pK are ordinary sorter-related identifiers. The collision comes only from the confusable heuristic.
info ~~warn~~ → info by review identifier-confusable-collision sqlite3/sqlite3.c:156824:34

two identifiers collapse to visual skeleton `po` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
*/
static int sameSrcAlias(SrcItem *p0, SrcList *pSrc){
  int i;
  for(i=0; i<pSrc->nSrc; i++){
```
dismissed LLM, confidence 0.95 Parameter p0 and related names in sameSrcAlias, flagged by the confusable heuristic.
Reasoning
p0 and the nearby pointer names are plain parameters and locals in an alias-comparison helper. The collision is a heuristic false positive.
info ~~warn~~ → info by review identifier-confusable-collision sqlite3/sqlite3.c:193067:12

two identifiers collapse to visual skeleton `p||` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
      LogEst rLogEst = sqlite3LogEstFromDouble(rIn);
      int *pI1 = va_arg(ap,int*);
      u64 *pU64 = va_arg(ap,u64*);
      int *pI2 = va_arg(ap,int*);
```
dismissed LLM, confidence 0.95 Pointer locals pI1, pU64 and pI2 fetched via va_arg, flagged by the confusable heuristic.
Reasoning
The variables pI1, pU64 and pI2 are ordinary pointer locals that read va_arg values in a variadic handler. The collision is a heuristic false positive.
info ~~warn~~ → info by review macro-keyword-override sqlite3/sqlite3.h:315:1

`#define double` rebinds the reserved C keyword `double` (token pass, confidence 0.85)
```
#ifdef SQLITE_OMIT_FLOATING_POINT
# define double sqlite3_int64
#endif
```
likely benign LLM, confidence 0.90 Public header conditional that maps double to sqlite3_int64 when floating point is omitted.
Reasoning
This is the same SQLITE_OMIT_FLOATING_POINT conditional in the public header, mapping double to sqlite3_int64 for builds without floating point. It is a documented configuration mechanism.

Reproduce This Scan

Run disclude locally to verify. These commands scan the published file; the "new in this release" marks come from comparing it with the previous release's file, which they don't repeat. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.3.0
curl -fsSL -o libsqlite3-sys-0.39.0.crate 'https://static.crates.io/crates/libsqlite3%2Dsys/libsqlite3%2Dsys-0%2E39%2E0.crate'
printf '%s  %s\n' b0e7f1cd558a82cc3af091ed13f0f03846f89851c60a10713ce5cfd484195494 libsqlite3-sys-0.39.0.crate | shasum -a 256 -c -
mkdir pkg && tar -xzf libsqlite3-sys-0.39.0.crate -C pkg --strip-components 1
disclude scan --untrusted --severity info pkg