audits.toml (65261B)
1 2 # cargo-vet audits file 3 4 [criteria.build-execution-reviewed] 5 description = "The package's build-time process execution, generated inputs, environment handling, filesystem writes, and output paths were reviewed for hermetic, bounded operation." 6 implies = "safe-to-deploy" 7 8 [criteria.crypto-reviewed] 9 description = "The package's cryptographic algorithms, key material handling, randomness, constant-time expectations, and protocol composition were reviewed for the Radroots use case." 10 implies = "safe-to-deploy" 11 12 [criteria.network-parser-reviewed] 13 description = "The package's untrusted network parsing, canonicalization, size limits, recursion limits, and malformed-input behavior were reviewed for fail-closed operation." 14 implies = "safe-to-deploy" 15 16 [criteria.secret-handling-reviewed] 17 description = "The package's secret lifecycle, redaction, zeroization, persistence, keyring boundary, and error behavior were reviewed for the Radroots use case." 18 implies = "safe-to-deploy" 19 20 [[audits.anyhow]] 21 who = "Codex (automated single-owner source review)" 22 criteria = [ 23 "crypto-reviewed", 24 "network-parser-reviewed", 25 "secret-handling-reviewed", 26 ] 27 delta = "1.0.102 -> 1.0.104" 28 notes = "Reviewed the complete published 1.0.102 -> 1.0.104 production and manifest delta, the downcast entry points and pointer wrappers, and the new context-chain mutation/drop regression. Context and nested-error pointer selection now takes raw field addresses without first creating a shared reference to the payload; TypeId admission and owning Error lifetime remain unchanged. This incorporates the RUSTSEC-2026-0190 fix. There is no new cryptographic algorithm, network decoder, formatting, logging or persistence behavior. The selected native public normal/build graphs are byte-identical and exclude this WASI generator dependency. The automated delta review inherits the existing 1.0.102 baseline exemption; it is not an independent full-crate audit, general redaction guarantee, Miri proof or WASI/browser runtime qualification." 29 30 [[audits.async-utility]] 31 who = "Codex (automated single-owner source review)" 32 criteria = "network-parser-reviewed" 33 delta = "0.3.2 -> 0.3.2@git:b323ae0c1c1424b78bf8bb8832b95e86771f1dee" 34 notes = "Reviewed the complete registry-to-Git Rust delta and manifest change. Native task handles delegate polling, completion and abort to Tokio; ordinary drop detaches while AbortOnDrop requests cancellation. Native timeout/runtime modules are unchanged and parse no network bytes. The WASM implementation uses local spawning, an Abortable future, oneshot output and an acquire/release completion guard; its source review does not qualify a browser runtime. Added tests cover cancellation before polling, repeated abort, retained completed output, detached ownership and non-Unpin/non-Send values. This automated delta review inherits the existing registry 0.3.2 exemption and makes no independent audit or universal task-termination claim." 35 36 [[audits.async-wsocket]] 37 who = "Codex (automated single-owner source review)" 38 criteria = "network-parser-reviewed" 39 version = "0.17.0" 40 notes = "Reviewed the complete native production modules, message/socket conversions, manifest and selected SDK WebSocket SPI, plus browser actor/stream ownership. Native errors and sink/stream polling delegate to Tokio/Tungstenite; no new unsafe Send wrapper is introduced. The Radroots adapter supplies its own DNS/address/TLS policy, exact wire-identifier admission, configured connection deadline, fixed frame bounds and metered ingress, so default proxy/SOCKS dialing is not admitted. Both native loopback suites exercise the actual composition. The new browser actor uses unbounded channels; it is not admitted as the bounded Radroots browser implementation. This focused automated native-use review does not qualify those browser queues or unrestricted default dialing." 41 42 [[audits.autocfg]] 43 who = "Codex (automated single-owner RDP050 crypto dependency review)" 44 criteria = "crypto-reviewed" 45 version = "1.5.1" 46 notes = "Reviewed the existing source-review record, dependency-free manifest and num-traits build.rs call site. The build-only probe compiles a fixed total_cmp expression with the governed compiler; no runtime algorithm, randomness or key material is introduced. This same-version criterion extension inherits the recorded probing review and existing baseline exemption. It does not authorize attacker-supplied compiler snippets. This is automated single-owner source review, not an independent full-crate audit." 47 48 [[audits.autocfg]] 49 who = "Codex (automated single-owner source review)" 50 criteria = "network-parser-reviewed" 51 version = "1.5.1" 52 notes = "Reviewed the complete production sources and the published 1.5.0 -> 1.5.1 delta. This build-only helper accepts trusted build-script snippets and compiler/wrapper/flag inputs, invokes Command without a shell, checks the output directory, writes compiler IR there and removes only its generated probe path. Version/IO/process failures remain errors; it has no runtime network parser. The release changes the wrapper test harness, not production probing. Current Rust 1.99 compilation executes the selected build dependency. This automated review assumes governed compiler/build inputs and is not an independent audit or permission to compile untrusted network text." 53 54 [[audits.base16ct]] 55 who = "Codex (automated single-owner RDP050 crypto dependency review)" 56 criteria = "crypto-reviewed" 57 version = "1.0.0" 58 notes = "Reviewed the no_std feature boundary, decoded-length and decode_inner implementations. Decoding requires even input length and a sufficiently large destination, accumulates invalid-nibble errors and returns a bounded slice. Identity uses its own exact-size public hexadecimal admission and calls k256 with bytes, not this package's text API. No key generation or entropy source is selected by that call. Constant-time descriptions remain best effort, with public input length observable. This is automated single-owner source review, not an independent full-crate audit." 59 60 [[audits.bech32]] 61 who = "Codex (automated single-owner source review)" 62 criteria = "network-parser-reviewed" 63 version = "0.12.0" 64 notes = "Reviewed the manifest, top-level decode entry, HRP admission, character/separator checking and checksum-to-byte-iterator path. HRPs have a fixed 83-byte buffer; invalid characters, mixed case, missing separators, insufficient checksum and code-length violations return errors before collecting decoded bytes. Allocating decoding is proportional to admitted input, so callers still need input bounds. The private native Nostr path receives bounded frames and requires canonical hexadecimal EVENT/OK identities before SDK parsing; it does not accept Bech32 aliases as wire identity. This focused automated native-use review does not qualify Bitcoin witness policies, checksum selection by arbitrary callers or unbounded NIP-19 data." 65 66 [[audits.bitcoin-consensus-encoding]] 67 who = "Codex (automated single-owner source review)" 68 criteria = "network-parser-reviewed" 69 version = "1.3.0" 70 notes = "Reviewed the manifest and feature boundaries, slice decoder drivers, fixed ArrayDecoder and byte/array encoders, and complete compact-size byte admission and minimal-encoding checks. The selected native dependency has no alloc/std/serde features; bitcoin_hashes uses fixed-size array codec traits, not a Bitcoin peer or transaction parser. Fixed buffers advance by the available remaining bytes and reject incomplete completion; exact slice decoding rejects trailing input. Arbitrary user-supplied decoders must make progress, and optional allocating collection/IO drivers are outside this admitted use. This focused automated native-use review does not qualify those optional APIs or provide a general resource bound for caller-defined codecs." 71 72 [[audits.bitcoin-internals]] 73 who = "Codex (automated single-owner source review)" 74 criteria = "network-parser-reviewed" 75 version = "0.6.0" 76 notes = "Reviewed all production modules and the build script/manifest: fixed-array/slice transformations, the Copy-only ArrayVec safety boundary, bounded serde insertion, error/storage macros and integer casts. ArrayVec tracks initialized elements within static capacity; safe insertion refuses excess capacity and its raw slice view covers only initialized elements. Slice chunking checks nonzero constant chunk sizes. Some caller APIs can panic on invalid ranges/capacity, and allocating errors can retain raw input. Native hash callers use fixed block/array sizes and public adapter errors normalize upstream causes. The build script runs the governed rustc directly and writes only OUT_DIR/rust_version.rs. This automated source review is not a general unsafe-code proof or redaction guarantee for arbitrary callers." 77 78 [[audits.bitcoin-internals]] 79 who = "Codex (automated single-owner source review)" 80 criteria = "network-parser-reviewed" 81 delta = "0.6.0 -> 0.7.0" 82 notes = "Reviewed the complete production delta and manifest: shared array/slice safety code and build script remain unchanged, input-error formatting escapes debug characters, an integer widening cast is added, and U256 uses two fixed u128 words. U256 hex/byte serde requires exactly 32 bytes; decimal parsing returns overflow/invalid-input errors, formatting uses fixed buffers, and arithmetic/division retain documented panic conditions. Test-only serde dependencies move out of the production feature surface. Current native dependencies select no optional serde/alloc features on either internals version and do not expose U256 arithmetic as Radroots agreement values. This automated delta inherits the reviewed 0.6 source and does not qualify arbitrary arithmetic operands or monetary semantics." 83 84 [[audits.bitcoin_hashes]] 85 who = "Codex (automated single-owner source review)" 86 criteria = "network-parser-reviewed" 87 version = "1.2.0" 88 notes = "Reviewed the selected feature manifest, fixed-hash construction/serde/hex macros, SHA256 buffering and finalization, normal software and CPU-dispatched block-processing paths, and native call sites. Fixed hash byte decoding requires exact array length; string decoding uses the reviewed fixed-size hex decoder. SHA256 buffers at most one 64-byte block and dispatches intrinsic implementations only after CPU feature detection; their four 16-byte block loads are reached with complete blocks. Native adapter ingress is bounded before hashing and its interoperation tests compare event identities across the independent codecs on macOS and Linux. This focused automated native-use review does not independently certify the cryptographic algorithm, every hash family, batch hashing API, unlimited incremental input, or another platform." 89 90 [[audits.bitflags]] 91 who = "Codex (automated single-owner source review)" 92 criteria = "network-parser-reviewed" 93 version = "1.3.2" 94 notes = "Reviewed the manifest and complete production macro expansion and attribute filtering. Generated values contain a caller-selected integer; checked from_bits rejects unknown bits, truncate masks them, and remove uses bit-clear while toggle uses XOR. The unsafe constructor preserves bits and requires the caller's documented validity invariant. There is no byte decoder, allocation, filesystem or process access. This same-version package was already locked with a safe-to-deploy exemption; its newly inherited network criterion is evaluated for the current native composition, where the optional embedded logging edge is not selected. This is automated source review, not application authorization or optional-feature execution evidence." 95 96 [[audits.byteorder]] 97 who = "Codex (automated single-owner source review)" 98 criteria = "network-parser-reviewed" 99 version = "1.5.0" 100 notes = "Reviewed feature boundaries, fixed integer reads/writes, variable-byte-length admission and slice conversion macros used by the hash32 edge. The selected no_std feature set excludes I/O extension helpers. Primitive reads use exact bounded slices and native endian conversions; invalid caller buffer lengths panic, rather than supplying partial values. This edge is compiled through heapless, while the admitted faster-hex std/alloc runtime uses its allocating implementation and no hash32 parser. This focused automated native-use review qualifies no arbitrary-length reader, dynamic allocation policy or invalid-call panic freedom." 101 102 [[audits.chacha20]] 103 who = "Codex (automated single-owner source review)" 104 criteria = "network-parser-reviewed" 105 version = "0.10.2" 106 notes = "Reviewed manifest and feature selection, fixed-size state/seed and RNG entry points and CPU-dispatch boundaries. This optional rand software-generator dependency is absent from both selected native graphs: the SDK selects SysRng, not StdRng/ThreadRng or this package's cipher/RNG APIs. The package owns no network parser; its internal cipher constructors require trusted fixed key/nonce sizes. This automated review admits the inactive dependency in the current macOS/Linux composition only, and does not independently certify a new stream-cipher algorithm, optional RNG state serialization, architecture backend or secret lifecycle." 107 108 [[audits.cmov]] 109 who = "Codex (automated single-owner RDP050 crypto dependency review)" 110 criteria = "crypto-reviewed" 111 version = "0.5.4" 112 notes = "Reviewed backend selection and the aarch64 CSEL, x86 CMOV and portable mask-selection implementations. Native inline assembly uses register operands with nomem/nostack; the portable backend explicitly documents compiler-dependent branch limitations. This supports fixed-width selection in the selected public-key parser. It is not proof of compiler output, a universal side-channel guarantee, or qualification of secret operations on every architecture. This is automated single-owner source review, not an independent full-crate audit." 113 114 [[audits.const-oid]] 115 who = "Codex (automated single-owner RDP050 crypto dependency review)" 116 criteria = "crypto-reviewed" 117 version = "0.10.2" 118 notes = "Reviewed the no_std/deny-unsafe boundary and bounded ObjectIdentifier construction, fallible byte admission and default 39-byte storage. Its new inherited criterion belongs to the SEC1/DER type graph; identity supplies a fixed 33-byte compressed point and never parses an OID or private-key document. No randomness or secret owner is introduced. General ASN.1/BER admission is outside this public-key use review. This is automated single-owner source review, not an independent full-crate audit." 119 120 [[audits.cpubits]] 121 who = "Codex (automated single-owner RDP050 crypto dependency review)" 122 criteria = "crypto-reviewed" 123 version = "0.1.1" 124 notes = "Reviewed the macro selector and target overrides. It chooses fixed 32/64-bit arithmetic backends at compile time, including the explicit wasm32 promotion to 64-bit arithmetic; no runtime feature input, entropy or key material is involved. Governed builds do not supply a cpubits override. Native and wasm32 identity checks exercise the selected configurations. This does not qualify unsupported 16-bit or arbitrary overridden configurations. This is automated single-owner source review, not an independent full-crate audit." 125 126 [[audits.cpufeatures]] 127 who = "Codex (automated single-owner source review)" 128 criteria = "network-parser-reviewed" 129 delta = "0.2.17 -> 0.3.0" 130 notes = "Reviewed the complete production release delta and manifest: trusted CPU detection tokens gain initialization helpers; Apple sysctl reads retain fixed-size outputs and null write arguments; x86 adds CPUID leaf 7 subleaf 1 feature bits; LoongArch feature detection combines CPUCFG and OS capability bits. No network text, collection lengths, parser or writable system setting is introduced. The 0.3 dependency belongs to an optional software RNG edge absent from the current native feature graphs. This automated delta review inherits the existing 0.2.17 exemption and does not qualify cryptographic algorithms or execute the changed optional architecture paths." 131 132 [[audits.crypto-bigint]] 133 who = "Codex (automated single-owner RDP050 crypto dependency review)" 134 criteria = "crypto-reviewed" 135 version = "0.7.6" 136 notes = "Reviewed the selected fixed-width comparison, limb subtraction/word primitives, fixed safegcd inversion and its constant-time versus explicitly variable-time entry points, plus the 0.7.6 correction scope. Comparison scans the public limb count; subtraction delegates to ctutils borrow primitives; fixed inversion runs a precision-derived iteration count and returns invertibility through CtOption. The release removes the affected 0.5.5/0.7.5 selections identified by RUSTSEC-2026-0387. Identity admits public points only; retained X448 remains behind its existing adapter and independent RFC7748 vectors. This focused use review is not a complete review of the 0.5-to-0.7 rewrite, arbitrary dynamic integers, all arithmetic methods or generated-code timing proof. This is automated single-owner source review, not an independent full-crate audit." 137 138 [[audits.crypto-common]] 139 who = "Codex (automated single-owner RDP050 crypto dependency review)" 140 criteria = "crypto-reviewed" 141 version = "0.2.2" 142 notes = "Reviewed the no_std/forbid-unsafe boundary, fixed-size key/IV traits and Generate implementations. Generation requires a caller-supplied TryCryptoRng, propagates failure and only enables ambient SysRng behind getrandom. Identity's arithmetic-only parser invokes neither generation nor key/IV initialization and adds no entropy source. This same-version inherited criterion does not certify arbitrary caller-provided RNGs or optional encryption implementations. This is automated single-owner source review, not an independent full-crate audit." 143 144 [[audits.ctutils]] 145 who = "Codex (automated single-owner RDP050 crypto dependency review)" 146 criteria = "crypto-reviewed" 147 version = "0.4.5" 148 notes = "Reviewed the complete 0.4.4 -> 0.4.5 Rust/manifest delta. Comparison helpers preserve bitwise predicates, borrow subtraction uses a full-width black_box barrier, and leading/trailing-zero operations use advertised native instructions or a fixed-stage fallback. Architecture workarounds are explicitly gated; addition and subtraction return Choice carry/borrow predicates. Boundary and differential regressions are present upstream. The selected identity path processes public values; no compiler-output constant-time proof or unexecuted architecture/runtime claim is made. This is automated single-owner source review, not an independent full-crate audit." 149 150 [[audits.defmt]] 151 who = "Codex (automated single-owner source review)" 152 criteria = "network-parser-reviewed" 153 version = "0.3.101" 154 notes = "Reviewed the complete production source and manifest. This compatibility package reexports defmt 1.x macros, traits and encoding helpers and forwards its feature flags; it has no independent build script, runtime parser or network owner. Both selected native public graphs exclude it. This automated review admits that inactive reexport package for the current composition and does not qualify embedded logging, arbitrary global logger implementations or another platform." 155 156 [[audits.defmt]] 157 who = "Codex (automated single-owner source review)" 158 criteria = "network-parser-reviewed" 159 version = "1.2.0" 160 notes = "Reviewed manifest/module boundaries, the complete build script, logger safety contract and raw-frame/rzcobs encoder ownership. The script reads the packaged linker template and writes only its generated linker script under Cargo OUT_DIR; the encoder consumes caller slices with fixed run/zero counters, not a network decoding API. Global logger thread/interrupt safety remains the implementing host's obligation. This package and build script are absent from both selected native public graphs. This focused automated review admits the inactive dependency for that composition, not embedded runtime qualification, every formatter implementation or a global logger safety proof." 161 162 [[audits.defmt-macros]] 163 who = "Codex (automated single-owner source review)" 164 criteria = "network-parser-reviewed" 165 version = "1.2.0" 166 notes = "Reviewed manifest/build entry, macro dispatch and format-string argument parsing, log expansion/code generation, symbol construction and compile-time environment filtering. The build script emits only DEFMT_LOG rerun tracking; macros accept Rust token streams and literal format strings and generate typed Rust/linker metadata. The selected native graphs exclude this package. Format argument indices and generated code are trusted compiler inputs, not admitted network text; optional logger/panic attributes still require their host safety contracts. This focused automated inactive-use review does not certify all macro expansions or bounded parsing of arbitrary untrusted Rust/format strings." 167 168 [[audits.defmt-parser]] 169 who = "Codex (automated single-owner source review)" 170 criteria = "network-parser-reviewed" 171 version = "1.1.0" 172 notes = "Reviewed all production parsing modules: format fragments, type names, display hints, array/range integers, brace admission and argument consistency. Parsing follows UTF-8 character boundaries and reports malformed types/ranges/braces. Argument indices control vector resizing and index-plus-one arithmetic, so this parser is unsuitable for untrusted network input without separate input/index bounds. The only relevant dependency route is optional compile-time defmt macros with trusted literals, and both selected native graphs exclude it. This automated inactive-use review supplies no runtime parser/resource qualification or permission to route network strings through this API." 173 174 [[audits.der]] 175 who = "Codex (automated single-owner RDP050 crypto dependency review)" 176 criteria = "crypto-reviewed" 177 version = "0.8.2" 178 notes = "Reviewed the feature boundary, Reader completion and SliceReader construction, nested limits, checked cursor advancement and failed-state handling. These bounds reject incomplete/trailing input rather than returning partial documents. Identity passes SEC1 point bytes and invokes no DER/private-key decoder; this same-version dependency criterion is scoped to that inactive decoding surface in the identity composition. It does not qualify arbitrary recursive documents, BER mode, encrypted keys or all workspace consumers. This is automated single-owner source review, not an independent full-crate audit." 179 180 [[audits.ed448-goldilocks]] 181 who = "Codex (automated single-owner RDP050 crypto dependency review)" 182 criteria = "safe-to-deploy" 183 version = "0.14.0-pre.15" 184 notes = "Reviewed the complete pre.13 -> pre.15 Rust/manifest delta and the selected Montgomery ladder entry. The compatibility update explicitly preserves Ed448 little-endian field encoding and adapts batch normalization to in-place zero-skipping inversion. Montgomery multiplication retains its fixed 448-step conditional-swap ladder. Radroots selects X448 through the existing adapter; the independent RFC7748 section 5.2 vectors and retained Simplex cases pass. Unused Decaf encoding, Edwards signing and Montgomery-to-Edwards conversion are not qualified by this focused update review; the latter remains an upstream todo outside the admitted path. This is automated single-owner source review, not an independent full-crate audit." 185 186 [[audits.elliptic-curve]] 187 who = "Codex (automated single-owner RDP050 crypto dependency review)" 188 criteria = "crypto-reviewed" 189 version = "0.14.1" 190 notes = "Reviewed the complete rc.35 -> 0.14.1 delta, checked public-key SEC1 admission and curve byte-order helpers. PublicKey construction decodes the point and rejects the identity; the selected compressed representation has a fixed size. The stable API uses explicit curve endianness rather than the former encoding trait, and distinguishes variable-time arithmetic entry points. Identity enables arithmetic/SEC1 only and invokes no secret generation, signing or PKCS8 decoder. This is a focused selected-use review, not blanket certification of every optional algorithm or secret lifecycle. This is automated single-owner source review, not an independent full-crate audit." 191 192 [[audits.faster-hex]] 193 who = "Codex (automated single-owner source review)" 194 criteria = "network-parser-reviewed" 195 version = "0.10.1" 196 notes = "Reviewed all production encoder, decoder, dispatch, error, serde and build-probe source and the actual Nostr fixed-array call sites. CPU dispatch checks x86 processor/OS state or aarch64 NEON support; vector reads and writes require complete source and destination chunks, with scalar tails. Encoding returns only its initialized ASCII prefix. Checked decoding rejects odd/nonhex input but permits a longer even source than the destination: it is not an exact-identifier validator. The bounded native adapter therefore checks canonical exact-length EVENT and OK identifiers before upstream normalization; real socket regressions retain the previously observed failures. Allocating helpers assume caller-sized inputs, and the admitted messages retain the adapter's frame/ingress limits. This automated native-use review does not claim general constant-time behavior, unrestricted allocation safety, optional embedded logging or browser qualification." 197 198 [[audits.ff]] 199 who = "Codex (automated single-owner RDP050 crypto dependency review)" 200 criteria = "crypto-reviewed" 201 version = "0.14.0" 202 notes = "Reviewed the no_std/forbid-unsafe feature boundary and field trait definitions, random generation/error propagation, CtOption inversion/square-root contracts and constant-time versus variable-time method distinctions. Concrete curve implementations own arithmetic; identity's checked parser selects the reviewed k256 field implementation and calls no random sampler. This same-version dependency review does not certify arbitrary third-party Field implementations, derive-generated fields or every exponentiation caller. This is automated single-owner source review, not an independent full-crate audit." 203 204 [[audits.getrandom]] 205 who = "Codex (automated single-owner source review)" 206 criteria = "network-parser-reviewed" 207 version = "0.4.2" 208 notes = "Reviewed feature/backend selection, the public fill/u32/u64 and SysRng interfaces, initialization helpers and the native macOS and Linux implementations, including the Linux file fallback. macOS uses at most 256-byte getentropy chunks; Linux handles partial reads and EINTR, rejects zero/invalid progress and selects the fixed OS source rather than network-supplied paths. Initialized slice conversion follows successful complete fill. Native SDK callers request fixed-size values for ping/jitter and protocol contexts, and no packet selects a backend or buffer length. System entropy can block or fail, and the upstream UnwrapErr adapter can panic on that failure. This focused automated native-use review does not claim nonblocking entropy, panic freedom, cryptographic implementation audit or qualification of alternate Windows/UEFI/WASI/browser backends." 209 210 [[audits.group]] 211 who = "Codex (automated single-owner RDP050 crypto dependency review)" 212 criteria = "crypto-reviewed" 213 version = "0.14.0" 214 notes = "Reviewed the no_std feature boundary, group/curve/scalar traits, random-generation propagation and fixed input/output length requirement for batch normalization. The package supplies interfaces, with arithmetic delegated to concrete curve implementations. Identity's public-point parser neither samples a random group element nor invokes its scalar-multiplication/wNAF helpers. This same-version inherited criterion is limited to that composition; it does not qualify arbitrary group implementations or secret scalar algorithms. This is automated single-owner source review, not an independent full-crate audit." 215 216 [[audits.hash2curve]] 217 who = "Codex (automated single-owner RDP050 crypto dependency review)" 218 criteria = "safe-to-deploy" 219 version = "0.14.0" 220 notes = "Reviewed the no_std/forbid-unsafe manifest and public module boundary plus hash_to_field's fixed-size output, compile-time u16 expansion bound and error propagation. The stable release aligns its elliptic-curve dependency with the retained X448 arithmetic graph. The Radroots X448 adapter invokes Montgomery key agreement, not hash-to-curve, OPRF or domain expansion APIs. This focused inactive-use review does not certify those optional protocol constructions or change their domain-separation contract. This is automated single-owner source review, not an independent full-crate audit." 221 222 [[audits.hash32]] 223 who = "Codex (automated single-owner source review)" 224 criteria = "network-parser-reviewed" 225 version = "0.3.1" 226 notes = "Reviewed all three production modules and the manifest: trait forwarding, stateless hasher construction, FNV wrapping accumulation and the Murmur3 block/tail implementation. This is a non-cryptographic hash dependency, not an event-identity or signature algorithm. The only selected reverse edge is heapless through faster-hex; the native faster-hex std/alloc implementation invokes neither those collections nor either hasher. Murmur3's potentially uninitialized buffer references are outside the admitted native call path and require separate review/proving inputs before any use. This automated use-scoped review does not certify that unsafe implementation, adversarial collision resistance or an embedded runtime." 227 228 [[audits.heapless]] 229 who = "Codex (automated single-owner source review)" 230 criteria = "network-parser-reviewed" 231 version = "0.8.0" 232 notes = "Reviewed module/feature and build-probe boundaries plus fixed-capacity Vec/String insertion, initialization and UTF-8 conversion paths referenced by faster-hex's non-alloc alternative. Checked push/extend refuse excess capacity and strings preserve UTF-8 after safe insertion; unsafe constructors retain caller initialization/encoding requirements. The build script compiles a fixed trusted probe under OUT_DIR with governed compiler/wrapper arguments and owns no runtime network parser. The only selected reverse edge is faster-hex, whose actual std/alloc implementation uses alloc Vec/String instead; optional embedded logging and non-alloc containers are not invoked by this native composition. This focused automated review does not qualify every pool/queue/map API or the hash32 Murmur3 implementation." 233 234 [[audits.hex-conservative]] 235 who = "Codex (automated single-owner source review)" 236 criteria = "network-parser-reviewed" 237 version = "1.3.0" 238 notes = "Reviewed manifest/feature boundaries, fixed/variable decoding entries, complete hex iterators and their initialized-output handling, Char representation/table conversion and the bounded buffer encoder. Fixed-array decoding checks exactly N*2 bytes before writing; invalid/odd/nonhex input returns typed errors, and decoded Vec length is published only after initialization succeeds. Unchecked ASCII conversions originate from the closed ASCII Char variants. Allocating helpers scale with caller input, so they are not standalone network size limits. The native graph supplies bounded frames and fixed-size public hash values. This focused automated source review does not qualify unbounded formatting/collection by arbitrary callers or every optional feature." 239 240 [[audits.hybrid-array]] 241 who = "Codex (automated single-owner RDP050 crypto dependency review)" 242 criteria = "crypto-reviewed" 243 version = "0.4.15" 244 notes = "Reviewed the complete 0.4.12 -> 0.4.15 production/manifest delta and fixed-size array feature boundary. The delta adds supported type-level sizes, including retained SNTRUP buffers, without changing arithmetic, allocation or reference-conversion bodies. Arrays remain statically sized and the existing zeroize forwarding is preserved. The newly inherited crypto criterion covers these fixed buffers in the identity composition, not every unsafe reference conversion, optional serialization implementation or arbitrary array-size implementation. This is automated single-owner source review, not an independent full-crate audit." 245 246 [[audits.k256]] 247 who = "Codex (automated single-owner RDP050 crypto dependency review)" 248 criteria = "crypto-reviewed" 249 version = "0.14.0" 250 notes = "Reviewed the arithmetic-only manifest selection, checked SEC1/public-key route, affine decompression and the selected field parsing, normalization, fixed square-root addition chain and 5x52 multiplication/reduction. Decoding rejects noncanonical field elements, verifies the square root, chooses the encoded parity and rejects the identity through PublicKey. Identity supplies only 32 public x-coordinate bytes with a fixed even compressed prefix; no private scalar, signer, ECDSA, Schnorr, entropy acquisition or PKCS8 API is introduced. Native/no_std/wasm checks and independent valid/invalid field-boundary vectors pass. This focused review does not certify all of k256 0.14, secret scalar multiplication or every architecture backend. This is automated single-owner source review, not an independent full-crate audit." 251 252 [[audits.libm]] 253 who = "Codex (automated single-owner RDP050 crypto dependency review)" 254 criteria = "crypto-reviewed" 255 version = "0.2.16" 256 notes = "Reviewed the no_std feature/module boundary and num-traits' optional libm edge. This already selected same-version floating-point helper is absent from the identity normal/build graph; the admitted crypto path uses fixed-width integer/field operations and calls no floating-point approximation. It owns neither keys nor entropy in that composition. This criterion extension is limited to that inactive edge, and does not assert constant-time floating-point math or review every libm algorithm. This is automated single-owner source review, not an independent full-crate audit." 257 258 [[audits.lru]] 259 who = "Codex (automated single-owner source review)" 260 criteria = "network-parser-reviewed" 261 delta = "0.16.4 -> 0.18.5" 262 notes = "Reviewed the complete published release delta: the returned mutable reference now borrows the cache, pop detaches before a potentially panicking key destructor, allocation replaces unchecked NonNull construction, and sparse/find-and-promote/retain preserve list ownership. Reviewed the borrowed return and added retention, promotion and destructor regressions. Native SDK callers retain bounded capacities and immutable EventId keys. This delta inherits the existing 0.16.4 exemption; it is not an independent full-crate audit or a general unsafe-code proof." 263 264 [[audits.negentropy]] 265 who = "Codex (automated single-owner source review)" 266 criteria = "network-parser-reviewed" 267 delta = "0.5.0 -> 0.5.2" 268 notes = "Reviewed only the published 0.5.0 -> 0.5.2 delta: count admission before allocation, equivalent accumulator carry and duplicate ordering, private helper visibility and const additions. Protocol 0x61 and MIT licensing remain. Existing upstream regression tests execute separately. This automated single-owner delta review inherits the existing 0.5.0 baseline exemption; it does not claim independent/full-crate audit, complete parser canonicality or release qualification." 269 270 [[audits.nostr]] 271 who = "Codex (automated single-owner source review)" 272 criteria = "network-parser-reviewed" 273 version = "0.45.5" 274 notes = "Reviewed the native protocol path: relay-message sequence visitor and serializers, event intermediate decoding, exact-width kind, tag/vector admission, event ID computation, key/signature decoding and verification, JSON helpers, feature manifest and the paired registry-to-Git source changes. Original bounded wire fields must pass the Radroots canonical-length guard before the upstream fixed-array hex decoder can normalize them; real malformed-ID/ACK controls prove that composition. Tags remain raw nonempty string lists, not domain-policy or typed-NIP validation. Complete event verification is required through private client admission even when the SDK ID cache hits. Optional encrypted/remote-signer NIPs are disabled in the selected native graph. This focused automated native-use review does not qualify every NIP helper, unrestricted parser inputs, cryptographic algorithms independently or another platform." 275 276 [[audits.nostr]] 277 who = "Codex (automated single-owner source review)" 278 criteria = "network-parser-reviewed" 279 delta = "0.45.5 -> 0.45.5@git:de3031aa99986eb29b3f34580355f9a099e4c927" 280 notes = "Reviewed the complete registry-to-Git Rust delta: stronger CryptoRng key-generation bounds and fixed-array conversions, key/tag conversion helpers, optional NIP47 BIP321 request/response codecs, removed infallible NIP66 accessors and relay-URL length admission. The native composition does not enable NIP47 or treat typed helper conversion as domain validation. The admitted bounded JSON/identity path retains the original-wire guard and per-event verification. This automated delta review does not qualify optional payment behavior, a browser runtime or unrestricted helper inputs." 281 282 [[audits.nostr-database]] 283 who = "Codex (automated single-owner source review)" 284 criteria = "network-parser-reviewed" 285 version = "0.45.2" 286 notes = "Reviewed all three production modules and the complete original manifest. The unsafe-forbidden crate now contains typed database traits, statuses, owned Arc conversions, errors and a query-to-negentropy default transformation; it owns no wire decoder, storage backend, socket, process or implicit filesystem access. Save assumes an already verified Event and default negentropy collection inherits the supplied backend query's bounds. The native SDK selects its separate 35,000-entry EventId-only LRU tracker; Radroots does not admit this trait as its durable product store. This automated source review is not qualification of arbitrary backend implementations or an unbounded query." 287 288 [[audits.nostr-database]] 289 who = "Codex (automated single-owner source review)" 290 criteria = "network-parser-reviewed" 291 delta = "0.45.2 -> 0.45.2@git:de3031aa99986eb29b3f34580355f9a099e4c927" 292 notes = "Verified that every Rust source and the original package manifest are byte-identical to registry 0.45.2. The Git workspace resolves the reviewed exact private Nostr family and opaquerr dependency under the immutable source policy. No additional database implementation or parser is introduced by this Git delta." 293 294 [[audits.nostr-gossip]] 295 who = "Codex (automated single-owner source review)" 296 criteria = "network-parser-reviewed" 297 version = "0.45.1" 298 notes = "Reviewed all production modules and the manifest. This unsafe-forbidden crate contains backend traits, typed selection limits/statuses, deterministic ordering, URL category selection, bit flags and typed errors; it opens no network connection and owns no byte decoder or storage backend. A backend must enforce its own query and collection bounds. The native adapter leaves SDK gossip unconfigured and admits destinations only through its explicit hardened connector. The flag remove operation toggles bits and is not an idempotent clear; that optional API is not used by this composition. This automated native-use review does not qualify optional gossip discovery, arbitrary backend behavior or another platform." 299 300 [[audits.nostr-gossip]] 301 who = "Codex (automated single-owner source review)" 302 criteria = "network-parser-reviewed" 303 delta = "0.45.1 -> 0.45.1@git:de3031aa99986eb29b3f34580355f9a099e4c927" 304 notes = "Reviewed the complete registry-to-Git Rust delta: default without_tls becomes false and its two documentation defaults follow that stricter choice. No parser, backend or connection authority is added. Radroots still uses no configured upstream gossip backend." 305 306 [[audits.nostr-sdk]] 307 who = "Codex (automated single-owner source review)" 308 criteria = "network-parser-reviewed" 309 version = "0.45.4" 310 notes = "Reviewed the selected native client/pool/relay ownership, WebSocket SPI, notification and subscription paths, relay-message admission, exact ACK/authentication flow, configured limits, tracker and verification-cache behavior. Radroots supplies one hardened connector, a finite configured relay inventory, bounded ingress and operation budgets, no gossip backend and no implicit authenticator. An ID-only verification cache cannot authenticate a later changed signature, so private per-event admission verifies the complete event; a real loopback regression failed before this correction. Ordinary notification streams lose receiver gaps and are not admitted: this baseline is paired with the exact Git gap/reconnect delta and with_gaps consumers. This focused automated native-use review does not qualify optional discovery/sync/local-relay APIs, upstream diagnostic redaction, an unbounded browser implementation or another platform." 311 312 [[audits.nostr-sdk]] 313 who = "Codex (automated single-owner source review)" 314 criteria = "network-parser-reviewed" 315 delta = "0.45.4 -> 0.45.4@git:de3031aa99986eb29b3f34580355f9a099e4c927" 316 notes = "Reviewed the affected native connection driver and ownership, notification stream, persistent subscription/queued-REQ and admission changes against the registry source. Connection attempts retain identity and completion notification; stale generations cannot take current frames, queued request counters decrement on drop, and explicit disconnect revokes reconnect authority. The added with_gaps stream preserves each receiver's repeated loss and continuation instead of silently filtering it. Real Radroots socket controls cover repeated local gaps, single REQ after reconnect, configured deadlines, wire identity, explicit AUTH and retained receive limits; native source publication requires their executed results. This focused automated delta review is not an independent full-SDK audit or qualification of unused optional APIs, browser actors or diagnostic redaction." 317 318 [[audits.num-traits]] 319 who = "Codex (automated single-owner RDP050 crypto dependency review)" 320 criteria = "crypto-reviewed" 321 version = "0.2.19" 322 notes = "Reviewed the no_std trait/export boundary, optional std/libm selection and complete build.rs probe. The fixed-width crypto-bigint edge uses integer numeric traits with default features disabled; float helpers and arbitrary-radix text admission are not called by identity. Trait implementations delegate arithmetic to the concrete integer types and provide no entropy source or key storage. This same-version inherited criterion covers the selected integer composition, not arbitrary numeric casts, floating-point semantics or untrusted radix parsing. This is automated single-owner source review, not an independent full-crate audit." 323 324 [[audits.opaquerr]] 325 who = "Codex (automated single-owner source review)" 326 criteria = "network-parser-reviewed" 327 version = "0.2.0" 328 notes = "Reviewed both complete production modules and the manifest. The no_std error container and declarative macros construct typed kinds and optional boxed sources; they do not decode network input, invoke processes, access files or use unsafe code. Allocating construction caches the source Display text and Debug exposes the source, so this dependency supplies neither redaction nor an independent allocation limit. The native adapter maps upstream causes into its existing typed public errors, with ingress bounded before parsing. This is automated source review for that use, not a secret-handling or unrestricted-error-formatting claim." 329 330 [[audits.pkcs8]] 331 who = "Codex (automated single-owner RDP050 crypto dependency review)" 332 criteria = "crypto-reviewed" 333 version = "0.11.0" 334 notes = "Reviewed the no_std/forbid-unsafe feature boundary and optional encryption, randomness and legacy DES gates. The identity arithmetic-only dependency graph excludes PKCS8; its API admits fixed SEC1 public points and no private-key document. This same-version inherited criterion covers that inactive edge only. It does not authorize legacy encryption, review arbitrary PKCS8 parsing, or qualify separately selected X448/other consumers' secret-document handling. This is automated single-owner source review, not an independent full-crate audit." 335 336 [[audits.primefield]] 337 who = "Codex (automated single-owner RDP050 crypto dependency review)" 338 criteria = "crypto-reviewed" 339 version = "0.14.0" 340 notes = "Reviewed the no_std/forbid-unsafe exports, fixed-size Montgomery field admission and explicit endian conversion traits. Canonical bytes are copied into a fixed integer representation according to trusted field parameters; concrete arithmetic delegates to the selected crypto-bigint implementation. K256 identity decompression uses its own concrete base-field implementation and introduces no generic-field random generation. This selected-use review does not certify arbitrary field parameters, every Montgomery operation or a new secret-key protocol. This is automated single-owner source review, not an independent full-crate audit." 341 342 [[audits.primeorder]] 343 who = "Codex (automated single-owner RDP050 crypto dependency review)" 344 criteria = "crypto-reviewed" 345 version = "0.14.0" 346 notes = "Reviewed the generic curve-parameter boundary and affine-point implementation, including checked coordinate construction, curve-equation verification, identity state and conditional selection. K256 uses its own affine/field implementation for identity decompression; its new generic arithmetic support is not a new Radroots secret-key or signer boundary. Optional precomputed tables, arbitrary curves and variable-time multiplication are outside this focused public-parser use review. This is automated single-owner source review, not an independent full-crate audit." 347 348 [[audits.r-efi]] 349 who = "Codex (automated single-owner source review)" 350 criteria = "network-parser-reviewed" 351 version = "6.0.0" 352 notes = "Reviewed target/package boundaries, no_std module ownership, RNG protocol ABI and the getrandom UEFI caller. This reference crate supplies constants, ABI structures and unsafe firmware function pointers, not a network decoder or default startup routine. getrandom admits it only for target_os=uefi with the explicit efi_rng backend; its native caller is inactive in both selected macOS/Linux public graphs. This focused automated review admits that inactive target dependency and does not certify all firmware ABIs, a firmware provider, entropy quality or a UEFI artifact." 353 354 [[audits.rand]] 355 who = "Codex (automated single-owner source review)" 356 criteria = "network-parser-reviewed" 357 version = "0.10.1" 358 notes = "Reviewed the feature manifest, RNG extension interface and integer uniform sampling used by the selected SDK. Its actual features select std/alloc/sys_rng and the getrandom SysRng reexport; software StdRng/ThreadRng and their optional ChaCha generator are not selected. The SDK uses fixed ping bytes and a constant nonempty bounded reconnect-jitter range, with no network-controlled sampling range or collection allocation. Infallible wrappers can panic on OS entropy failure and invalid caller ranges; this review does not claim those are impossible. This focused automated native-use review is not a full distribution/cryptographic algorithm audit or another platform's runtime qualification." 359 360 [[audits.rand_core]] 361 who = "Codex (automated single-owner RDP050 crypto dependency review)" 362 criteria = "crypto-reviewed" 363 version = "0.10.1" 364 notes = "Reviewed the dependency-free no_std RNG/try-RNG trait boundary, fallible-to-infallible adapters and CryptoRng marker composition. It implements no ambient entropy acquisition for the selected identity parser, which calls no generation method. Error propagation remains explicit for fallible sources. This same-version inherited criterion does not certify a caller-supplied generator, permit predictable seeds for production secrets, or qualify optional RNG algorithms elsewhere. This is automated single-owner source review, not an independent full-crate audit." 365 366 [[audits.rand_core]] 367 who = "Codex (automated single-owner source review)" 368 criteria = "network-parser-reviewed" 369 version = "0.10.1" 370 notes = "Reviewed the TryRng/Rng and crypto-marker trait interfaces, dereference forwarding, complete UnwrapErr adapter and integer/byte conversion helpers used by SysRng. These interfaces own no network decoder or variable-length packet queue; they forward bounded caller buffers and propagate fallible completion. The explicit UnwrapErr conversion panics on provider errors, and a crypto marker alone proves no algorithm properties. The selected native SDK supplies fixed-size arrays and trusted sampling bounds. This focused automated source review does not qualify optional block/seed generators, arbitrary provider implementations or secret generation policy." 371 372 [[audits.sec1]] 373 who = "Codex (automated single-owner RDP050 crypto dependency review)" 374 criteria = "crypto-reviewed" 375 version = "0.8.1" 376 notes = "Reviewed fixed-size point representation and from_bytes admission: a valid tag determines one exact length before copying into the statically sized buffer. The identity path always supplies 33 bytes with compressed-even tag; the concrete curve then checks field membership and curve validity. DER/private-key and optional serde paths are not called by identity. This same-version selected-use review does not treat SEC1 syntax alone as curve validation or certify unrelated key-document APIs. This is automated single-owner source review, not an independent full-crate audit." 377 378 [[audits.secp256k1]] 379 who = "Codex (automated single-owner source review)" 380 criteria = "network-parser-reviewed" 381 delta = "0.29.1 -> 0.30.0" 382 notes = "Reviewed the complete published Rust release delta and manifest. Fixed-array key/signature constructors reject incorrect slice lengths before FFI; recovery IDs become a closed checked enum. Schnorr signing and verification now pass an explicit message slice length through the existing C backend, and the admitted Nostr path supplies a fixed 32-byte event digest. Secret Debug output remains hidden or an explicit feature-gated fingerprint, and removed no-context parsing paths no longer panic unconditionally. The resolved secp256k1-sys 0.10.1 source is unchanged. This automated delta review inherits the existing 0.29.1 network-parser exemption and does not claim a fresh C/cryptographic algorithm audit, arbitrary-message signing policy, or another platform's runtime qualification." 383 384 [[audits.spki]] 385 who = "Codex (automated single-owner RDP050 crypto dependency review)" 386 criteria = "crypto-reviewed" 387 version = "0.8.0" 388 notes = "Reviewed the no_std/forbid-unsafe feature boundary, DER reexports and optional digest/PEM gates. The identity arithmetic-only graph excludes this package and never parses algorithm identifiers or SPKI documents. Its new inherited crypto criterion is limited to that inactive edge; separately selected workspace document consumers remain subject to their existing controls. This review does not certify arbitrary ASN.1 input, fingerprint algorithms or secret handling. This is automated single-owner source review, not an independent full-crate audit." 389 390 [[audits.syn]] 391 who = "Codex (automated single-owner source review)" 392 criteria = "network-parser-reviewed" 393 version = "3.0.2" 394 notes = "Reviewed package/features, parser entry/completion checks and token-buffer construction/cursor ownership, tracing the optional defmt procedural-macro route. It parses compiler-owned token streams and rejects unconsumed tokens; recursive token construction and syntax trees do not supply a network-input allocation/depth limit. Version 3.0.2 is absent from both selected native public graphs, including build dependencies. This focused automated review admits that inactive compile-time dependency for the current composition; it does not audit every Rust grammar/unsafe cursor operation or qualify an untrusted runtime source parser." 395 396 [[audits.tokio-happy-eyeballs]] 397 who = "Codex (automated single-owner source review)" 398 criteria = "network-parser-reviewed" 399 version = "0.1.0" 400 notes = "Reviewed the entire unsafe-free source and manifest, including empty resolution, IPv4/IPv6 partitioning, the 250 ms race, error completion and remaining-address iteration. The helper extracts the prior Async WebSocket dialing algorithm; it owns no protocol decoder, filesystem or credential input. Its caller owns total dialing deadlines and destination admission. The configured Radroots native connector bypasses this default dialer and enforces its own bounded DNS/address/TLS admission and deadline. This automated native-use review does not qualify unrestricted default dialing or another platform." 401 402 [[audits.tokio-stream]] 403 who = "Codex (automated single-owner source review)" 404 criteria = "network-parser-reviewed" 405 version = "0.1.18" 406 notes = "Reviewed the manifest, module/feature boundaries, complete BroadcastStream and bounded/unbounded MPSC wrappers, and actual SDK call sites. The admitted SDK notification path uses BroadcastStream: each poll preserves Lagged(n), retains receiver ownership across future replacement and returns None on closure. It performs no byte decoding and owns no additional input queue. The SDK ordinary stream discards gaps, so the adapter uses only with_gaps; real socket overflow tests verify two receiver-local losses and continued retained delivery. The SDK local-relay feature is disabled. This focused automated native-use review builds on the existing same-version safe-to-deploy exemption; it does not qualify optional filesystem/signal/local-relay APIs, unbounded channels or every stream combinator." 407 408 [[audits.tokio-tungstenite]] 409 who = "Codex (automated single-owner source review)" 410 criteria = "network-parser-reviewed" 411 delta = "0.26.2 -> 0.28.0" 412 notes = "Reviewed the complete published release delta: into-inner/get-ref accessors, boxed TLS error conversion, the matching Tungstenite parent and example error adaptation. The native connector retains its verified TLS roots, original server name, pinned addresses and bounded frame configuration; real socket, exact-byte, cancellation, authentication and deadline controls execute separately. This automated delta review inherits the existing 0.26.2 exemption and does not claim an independent full-crate audit or browser/runtime-platform qualification." 413 414 [[audits.tokio-util]] 415 who = "Codex (automated single-owner source review)" 416 criteria = "network-parser-reviewed" 417 version = "0.7.19" 418 notes = "Reviewed the manifest and complete ReusableBoxFuture, PollSender and PollSemaphore implementations, tracing the actual SDK BroadcastStream dependency. The selected helper owns one pinned Send future; replacement checks size and alignment before reuse, drops the old value in place, and restores ownership through its unwind guard. Sync exposes no shared access to the non-Sync future. PollSender retains typed ownership around its lifetime cast and reserves bounded channel permits; it is not the SDK notification reader. These helpers parse no network bytes. Current native receiver-local repeated-gap and closure tests exercise the admitted future replacement path. This focused automated review builds on the existing same-version safe-to-deploy exemption; it is not a full-crate unsafe-code proof or qualification of optional codecs, filesystem, task trackers or another platform." 419 420 [[audits.tungstenite]] 421 who = "Codex (automated single-owner source review)" 422 criteria = "network-parser-reviewed" 423 delta = "0.26.2 -> 0.28.0" 424 notes = "Reviewed the complete published release delta: boxed errors, HTTP-version admission and duplicate-header handling, frame buffer reservation/read bounds, borrowed UTF-8 hashing, fragment/control/close state transitions and TLS error conversion. The native Radroots connector supplies fixed message/frame limits and metered ingress before this decoder. Real malformed, oversized, continuation, exact-byte and deadline cases execute separately. This automated delta review inherits the existing 0.26.2 exemption; it is not an independent full-crate audit, unbounded-input guarantee or 32-bit/browser qualification." 425 426 [[audits.universal-time]] 427 who = "Codex (automated single-owner source review)" 428 criteria = "network-parser-reviewed" 429 version = "0.3.1" 430 notes = "Reviewed all production source, feature gates and manifest: native std time uses a OnceLock monotonic origin and explicit wall-clock conversion; checked arithmetic returns Option and duration subtraction saturates, while duration operators can panic on overflow/underflow. There is no network parser or variable-sized input allocation. Native SDK connection durations come from validated adapter configuration, and packet timestamps do not supply Instant arithmetic. The no_std/WASM provider is a separately linked Sync static and is not admitted as the Radroots browser clock. This automated native-use source review is not independent audit, arbitrary-duration panic freedom or browser/no_std runtime qualification." 431 432 [[audits.wasip3]] 433 who = "Codex (automated single-owner source review)" 434 criteria = "network-parser-reviewed" 435 version = "0.4.0+wasi-0.3.0-rc-2026-01-06" 436 notes = "Reviewed manifest, generated import/export module boundaries and the complete random-u64 host import selected by getrandom's WASIp3 backend. That backend fills bounded caller buffers with scalar imports and avoids the allocating random-byte-vector import. Generated imports depend on the trusted component host ABI; other host-pointer/vector/HTTP APIs are outside this use. The target_arch=wasm32, target_os=wasi, target_env=p3 dependency is absent from both selected native public graphs and is not the browser wasm32-unknown-unknown route. This automated review admits the inactive target dependency only, not a full generated-bindings audit, WASI host/entropy qualification or browser execution." 437 438 [[audits.windows-sys]] 439 who = "Codex (automated single-owner source review)" 440 criteria = "network-parser-reviewed" 441 version = "0.60.2" 442 notes = "Reviewed package/feature/dependency boundaries, the complete core types and string-literal helpers, and generated socket-FFI declarations. This crate supplies Windows constants, ABI layouts and unsafe foreign-function declarations rather than a Rust-owned network decoder. Literal conversion is used by compile-time string macros; it is not a Radroots network-text API. Actual macOS aarch64 and Linux x86_64 selected public feature graphs exclude this version. This automated review admits that inactive dependency in the current native composition; it does not audit every generated Windows API, grant raw pointer/buffer authority or qualify a Windows binary." 443 444 [[audits.windows-targets]] 445 who = "Codex (automated single-owner source review)" 446 criteria = "network-parser-reviewed" 447 version = "0.53.5" 448 notes = "Reviewed the complete source and target manifest. The no_std link macro emits external declarations and chooses the matching Windows import-library target or raw-dylib helper; it parses no network data and starts no runtime work. The current macOS/Linux public feature graphs exclude this version. This automated source review does not qualify Windows FFI callers, import-library execution or a Windows artifact." 449 450 [[audits.windows_aarch64_gnullvm]] 451 who = "Codex (automated single-owner source review)" 452 criteria = "network-parser-reviewed" 453 version = "0.53.1" 454 notes = "Reviewed the complete Rust source and build script, package metadata and target selection. Both Rust bodies are identical to 0.52.6: an empty no_std library and a build script that emits only a package-local lib search path; there are no dependencies or network parsers. Checksum-verified packaged import archives and their actual member lists were inventoried separately. The selected macOS/Linux public graphs exclude this target. This automated review admits the inactive package for that native composition, not a binary-code audit or Windows linking/runtime qualification." 455 456 [[audits.windows_aarch64_msvc]] 457 who = "Codex (automated single-owner source review)" 458 criteria = "network-parser-reviewed" 459 version = "0.53.1" 460 notes = "Reviewed the complete Rust source and build script, package metadata and target selection. Both Rust bodies are identical to 0.52.6: an empty no_std library and a build script that emits only a package-local lib search path; there are no dependencies or network parsers. Checksum-verified packaged import archives and their actual member lists were inventoried separately. The selected macOS/Linux public graphs exclude this target. This automated review admits the inactive package for that native composition, not a binary-code audit or Windows linking/runtime qualification." 461 462 [[audits.windows_i686_gnu]] 463 who = "Codex (automated single-owner source review)" 464 criteria = "network-parser-reviewed" 465 version = "0.53.1" 466 notes = "Reviewed the complete Rust source and build script, package metadata and target selection. Both Rust bodies are identical to 0.52.6: an empty no_std library and a build script that emits only a package-local lib search path; there are no dependencies or network parsers. Checksum-verified packaged import archives and their actual member lists were inventoried separately. The selected macOS/Linux public graphs exclude this target. This automated review admits the inactive package for that native composition, not a binary-code audit or Windows linking/runtime qualification." 467 468 [[audits.windows_i686_gnullvm]] 469 who = "Codex (automated single-owner source review)" 470 criteria = "network-parser-reviewed" 471 version = "0.53.1" 472 notes = "Reviewed the complete Rust source and build script, package metadata and target selection. Both Rust bodies are identical to 0.52.6: an empty no_std library and a build script that emits only a package-local lib search path; there are no dependencies or network parsers. Checksum-verified packaged import archives and their actual member lists were inventoried separately. The selected macOS/Linux public graphs exclude this target. This automated review admits the inactive package for that native composition, not a binary-code audit or Windows linking/runtime qualification." 473 474 [[audits.windows_i686_msvc]] 475 who = "Codex (automated single-owner source review)" 476 criteria = "network-parser-reviewed" 477 version = "0.53.1" 478 notes = "Reviewed the complete Rust source and build script, package metadata and target selection. Both Rust bodies are identical to 0.52.6: an empty no_std library and a build script that emits only a package-local lib search path; there are no dependencies or network parsers. Checksum-verified packaged import archives and their actual member lists were inventoried separately. The selected macOS/Linux public graphs exclude this target. This automated review admits the inactive package for that native composition, not a binary-code audit or Windows linking/runtime qualification." 479 480 [[audits.windows_x86_64_gnu]] 481 who = "Codex (automated single-owner source review)" 482 criteria = "network-parser-reviewed" 483 version = "0.53.1" 484 notes = "Reviewed the complete Rust source and build script, package metadata and target selection. Both Rust bodies are identical to 0.52.6: an empty no_std library and a build script that emits only a package-local lib search path; there are no dependencies or network parsers. Checksum-verified packaged import archives and their actual member lists were inventoried separately. The selected macOS/Linux public graphs exclude this target. This automated review admits the inactive package for that native composition, not a binary-code audit or Windows linking/runtime qualification." 485 486 [[audits.windows_x86_64_gnullvm]] 487 who = "Codex (automated single-owner source review)" 488 criteria = "network-parser-reviewed" 489 version = "0.53.1" 490 notes = "Reviewed the complete Rust source and build script, package metadata and target selection. Both Rust bodies are identical to 0.52.6: an empty no_std library and a build script that emits only a package-local lib search path; there are no dependencies or network parsers. Checksum-verified packaged import archives and their actual member lists were inventoried separately. The selected macOS/Linux public graphs exclude this target. This automated review admits the inactive package for that native composition, not a binary-code audit or Windows linking/runtime qualification." 491 492 [[audits.windows_x86_64_msvc]] 493 who = "Codex (automated single-owner source review)" 494 criteria = "network-parser-reviewed" 495 version = "0.53.1" 496 notes = "Reviewed the complete Rust source and build script, package metadata and target selection. Both Rust bodies are identical to 0.52.6: an empty no_std library and a build script that emits only a package-local lib search path; there are no dependencies or network parsers. Checksum-verified packaged import archives and their actual member lists were inventoried separately. The selected macOS/Linux public graphs exclude this target. This automated review admits the inactive package for that native composition, not a binary-code audit or Windows linking/runtime qualification." 497 498 [[audits.wnaf]] 499 who = "Codex (automated single-owner RDP050 crypto dependency review)" 500 criteria = "crypto-reviewed" 501 version = "0.14.1" 502 notes = "Reviewed the no_std/forbid-unsafe feature boundary and bounded-window representation constructor. Representation generation has value-dependent control flow and must not be treated as a general constant-time secret-scalar primitive. Identity only invokes checked public-point decompression, which does not use wNAF generation or scalar multiplication. The package's inherited criterion is scoped to that unused arithmetic surface in the identity composition, with no new signer or private scalar API admitted. This is automated single-owner source review, not an independent full-crate audit."