crypto-inventory 0.3.0: Rust detector (use-resolved names, static calls, generics, ring constants, Noise patterns), Cargo.toml manifests, BLAKE3; 44/44, negative control 21/21

This commit is contained in:
Aere Network committed 2026-10-18 05:35:11 +03:00
1 parent 86779c8334
commit f2f6217b4c
16 files changed
+942 -21

No files matched your search

+24
View File
@@ -16,6 +16,30 @@ const SUITA = join(AICI, 'proba.mjs');
const B = 'negativ: fisierul binar e sarit si numarat';
const MUTATII = [
{
nume: 'comentariile bloc Rust nu se mai imbrica (lexerul)',
fisier: 'lib/lexer.mjs',
ancora: "if (text[j] === '/' && text[j + 1] === '*') { ad++; j += 2; continue; }",
cu: "if (false) { ad++; j += 2; continue; }",
tinta: 'negativ: comentariile, sirurile brute, literalele char si lifetime-urile Rust nu produc gasiri',
martor: B,
},
{
nume: 'SigningKey clasificat dupa nume, nu dupa crate-ul din use (Rust)',
fisier: 'lib/detect-rust.mjs',
ancora: "if (u) return CRATE[u.crate] ? { crate: u.crate, cale: u.cale } : null;",
cu: "if (u) return { crate: 'ed25519_dalek', cale: ['ed25519_dalek', tip] };",
tinta: 'rust: acelasi nume de tip e clasificat dupa crate-ul din use (SigningKey)',
martor: B,
},
{
nume: 'Cargo.toml scos din manifeste',
fisier: 'lib/manifeste.mjs',
ancora: '|go\\.mod|Cargo\\.toml)$/;',
cu: '|go\\.mod)$/;',
tinta: 'pozitiv: manifestele dau biblioteci declarate, nu gasiri',
martor: B,
},
{
nume: 'secp256k1 clasificat quantum-safe',
fisier: 'lib/catalog.mjs',
+10 -2
View File
@@ -27,6 +27,7 @@ const fis = ls.status === 0 ? ls.stdout.toString().split('\n').filter(Boolean) :
if (!fis.length) { console.log(`SARIT: revizia ${REV} nu e in istoricul acestui depozit; NEMASURAT aici`); process.exit(2); }
const vechi = mkdtempSync(join(tmpdir(), 'ci-v010-'));
let dif = 0, comparate = 0;
let versiuneNoua = '?';
try {
for (const f of fis) {
const b = git('show', `${REV}:${f}`);
@@ -37,12 +38,19 @@ try {
}
const imp = (r, m) => import(pathToFileURL(join(r, 'lib', m)).href);
const [SV, SN, LV, LN, PN] = await Promise.all([imp(vechi, 'scan.mjs'), imp(RAD, 'scan.mjs'), imp(vechi, 'lexer.mjs'), imp(RAD, 'lexer.mjs'), imp(RAD, 'pem.mjs')]);
versiuneNoua = SN.VERSIUNE;
if (SV.VERSIUNE !== '0.1.0') { console.log(`NEMASURAT: revizia ${REV} are versiunea ${SV.VERSIUNE}, nu 0.1.0`); process.exit(2); }
// 1. arbori reali
const norm = (g) => JSON.stringify({ ...g, reason: String(g.reason).replace(/, which (cannot be resolved statically|this tool does not resolve statically).*$/, ', which [motiv]') });
for (const d of DOSARE) {
const a = SV.scaneaza(d), b = SN.scaneaza(d);
// 0.3.0 (2026-10-18): Rust si Cargo.toml nu existau in 0.1.0, deci gasirile lor nu intra in echivalenta; se numara si se spun
const rustN = b.findings.filter((g) => g.language === 'rust').length;
const cargoN = b.libraries.filter((x) => x.ecosystem === 'cargo').length;
b.findings = b.findings.filter((g) => g.language !== 'rust');
b.libraries = b.libraries.filter((x) => x.ecosystem !== 'cargo');
if (rustN || cargoN) console.log(` (in afara echivalentei: ${rustN} gasiri Rust, ${cargoN} biblioteci Cargo; 0.1.0 nu le stia)`);
const ka = a.findings.map(norm), kb = b.findings.map(norm);
const sa = new Set(ka), sb = new Set(kb);
const doarV = ka.filter((x) => !sb.has(x)), doarN = kb.filter((x) => !sa.has(x));
@@ -50,7 +58,7 @@ try {
comparate += ka.length;
if (!ok) dif++;
console.log(`${ok ? 'IDENTIC ' : 'DIFERIT '} ${d}: ${a.stats.filesSeen} fisiere, gasiri ${ka.length}/${kb.length}, biblioteci ${a.libraries.length}/${b.libraries.length}`);
for (const x of [...doarV.slice(0, 3).map((x) => 'numai 0.1.0: ' + x), ...doarN.slice(0, 3).map((x) => 'numai 0.2.0: ' + x)]) console.log(' ' + x.slice(0, 260));
for (const x of [...doarV.slice(0, 3).map((x) => 'numai 0.1.0: ' + x), ...doarN.slice(0, 3).map((x) => `numai ${SN.VERSIUNE}: ` + x)]) console.log(' ' + x.slice(0, 260));
}
// 2. texte generate: lexerul pe patru limbaje si cautarea PEM (fata de regexul din 0.1.0)
@@ -83,5 +91,5 @@ try {
}
console.log(`texte generate: ${ITER} runde (lexer x4 + PEM), diferente ${JSON.stringify(cat)}`);
} finally { rmSync(vechi, { recursive: true, force: true }); }
console.log(`\n${dif ? 'DIFERIT' : 'IDENTIC'}: ${dif} diferente in ${comparate} comparatii (0.1.0 din ${REV} fata de 0.2.0)`);
console.log(`\n${dif ? 'DIFERIT' : 'IDENTIC'}: ${dif} diferente in ${comparate} comparatii (0.1.0 din ${REV} fata de ${versiuneNoua})`);
process.exitCode = dif ? 1 : comparate ? 0 : 2;
@@ -0,0 +1,21 @@
[package]
name = "fixtura"
version = "0.1.0"
edition = "2021"
[dependencies]
sha2 = "0.10"
ed25519-dalek = { version = "2", features = ["rand_core"] }
rustls = { version = "0.23", default-features = false, features = ["ring"] }
tokio = { version = "1", features = ["full"] }
aes-gcm = { workspace = true }
pq = { package = "pqcrypto-mlkem", version = "0.1" }
serde = "1"
[dependencies.ml-dsa]
version = "0.1.1"
default-features = false
[dev-dependencies]
hex-literal = "0.4"
argon2 = "0.5"
@@ -0,0 +1,23 @@
// Fixtura negativa Rust: nicio folosire reala. Comentarii (si imbricate), siruri obisnuite, brute si de octeti, literale char
// (inclusiv '"' si '\''), durate de viata si etichete: niciuna nu are voie sa produca o gasire sau sa deschida un sir.
use std::fmt;
/* use sha2::Sha256;
/* let h = Sha256::new(); */
let d = Sha1::digest(b"x");
*/
/// Aes256Gcm::new_from_slice(key) intr-un comentariu de documentatie nu e o folosire.
pub fn nimic<'a>(x: &'a str, y: &'a str) -> &'a str {
let ghilimea = '"';
let apostrof = '\'';
let brut = r#"Sha256::new() si "Hmac::<Sha256>::new_from_slice""#;
let octeti = b"RsaPrivateKey::new(&mut rng, 1024)";
let text = "use ed25519_dalek::SigningKey; SigningKey::generate(rng)";
'exterior: loop {
if ghilimea == apostrof { break 'exterior; }
break;
}
let _ = (brut, octeti, text, fmt::Error);
if x.len() > y.len() { x } else { y }
}
@@ -0,0 +1,6 @@
// Fixtura: Rust, fara niciun `use` care sa spuna din ce crate vine SigningKey. Numele e purtat de ed25519-dalek, ml-dsa, slh-dsa,
// p256, k256 si rsa, cu intelesuri diferite; unealta nu ghiceste, raporteaza unknown cu motivul scris.
pub fn cheie(b: &[u8; 32]) -> Vec<u8> {
let k = SigningKey::from_bytes(b); // EXPECT: SigningKey (crate not resolved) | unknown
k.to_bytes().to_vec()
}
@@ -0,0 +1,53 @@
// Fixtura: Rust. Numele din scop vin din `use`, si acelasi nume inseamna alt algoritm dupa crate (SigningKey e Ed25519 in
// ed25519-dalek, ML-DSA in ml-dsa, ECDSA in p256). Un import fara niciun apel recunoscut ramane dovada slaba (unknown).
use sha2::{Digest, Sha256, Sha512};
use sha1::Sha1;
use hmac::{Hmac, Mac};
use hkdf::Hkdf;
use argon2::{Algorithm, Argon2, Params, Version};
use chacha20poly1305::{aead::KeyInit, XChaCha20Poly1305};
use aes_gcm::Aes256Gcm;
use x25519_dalek::{PublicKey, StaticSecret};
use ed25519_dalek::SigningKey;
use ml_dsa::{KeyGen, MlDsa65};
use slh_dsa::{Sha2_128s, SigningKey as SlhSigningKey};
use ml_kem::{KemCore, MlKem768};
use rsa::RsaPrivateKey;
use p256::ecdsa::SigningKey as P256SigningKey;
use libsignal_protocol::kem;
use ring::aead;
use jsonwebtoken::Algorithm as JwtAlg;
use openssl::hash::MessageDigest;
use rustls::crypto::ring as rustls_ring;
use snow::Builder;
use blake2::Blake2b512; // EXPECT: blake2 | unknown
use zeroize::Zeroizing;
type HmacSha256 = Hmac<Sha256>; // EXPECT: HMAC-SHA-256 | quantum-safe
pub fn exemple(data: &[u8], key: &[u8; 32], rng: &mut impl rand_core::CryptoRngCore) {
let h = Sha256::new(); // EXPECT: SHA-256 | quantum-safe
let d = Sha1::digest(data); // EXPECT: SHA-1 | weak-now
let m = Hmac::<Sha512>::new_from_slice(key).unwrap(); // EXPECT: HMAC-SHA-512 | quantum-safe
let hk = Hkdf::<Sha256>::new(None, key); // EXPECT: HKDF | quantum-safe
let argon = Argon2::new(Algorithm::Argon2id, Version::V0x13, Params::default()); // EXPECT: Argon2id | quantum-safe
let aead1 = XChaCha20Poly1305::new_from_slice(key).unwrap(); // EXPECT: XChaCha20-Poly1305 | quantum-safe
let aead2 = Aes256Gcm::new_from_slice(key).unwrap(); // EXPECT: AES-256-GCM | quantum-safe
let bloc = ecb::Encryptor::<aes::Aes128>::new(key[..16].into()); // EXPECT: AES-128-ECB | weak-now
let secret = StaticSecret::random_from_rng(rng); // EXPECT: X25519 | quantum-vulnerable
let pk = PublicKey::from(&secret); // EXPECT: X25519 | quantum-vulnerable
let ed = SigningKey::generate(rng); // EXPECT: Ed25519 | quantum-vulnerable
let kp = MlDsa65::key_gen(rng); // EXPECT: ML-DSA-65 | quantum-safe
let slh = SlhSigningKey::<Sha2_128s>::new(rng); // EXPECT: SLH-DSA-SHA2-128s | quantum-safe
let (dk, ek) = MlKem768::generate(rng); // EXPECT: ML-KEM-768 | quantum-safe
let r = RsaPrivateKey::new(rng, 2048).unwrap(); // EXPECT: RSA-2048 | quantum-vulnerable
let p = P256SigningKey::random(rng); // EXPECT: ECDSA-secp256r1 | quantum-vulnerable
let kt = kem::KeyType::Kyber1024; // EXPECT: Kyber-1024 | quantum-safe
let sealing = aead::UnboundKey::new(&aead::AES_256_GCM, key).unwrap(); // EXPECT: AES-256-GCM | quantum-safe
let alg = JwtAlg::RS256; // EXPECT: JWS RS256 | quantum-vulnerable
let md = MessageDigest::md5(); // EXPECT: MD5 | weak-now
let provider = rustls_ring::default_provider(); // EXPECT: X25519 | quantum-vulnerable
let noise = Builder::new("Noise_XX_25519_ChaChaPoly_SHA256".parse().unwrap()); // EXPECT: X25519 | quantum-vulnerable ; ChaCha20-Poly1305 | quantum-safe ; SHA-256 | quantum-safe
let _ = (h, d, m, hk, argon, aead1, aead2, bloc, pk, ed, kp, slh, dk, ek, r, p, kt, sealing, alg, md, provider, noise, Zeroizing::new(0u8));
let _t: Option<HmacSha256> = None;
}
+56 -5
View File
@@ -14,11 +14,12 @@ const AICI = dirname(fileURLToPath(import.meta.url));
const FIX = join(AICI, 'fixturi');
const CALE_MODUL = process.env.CRYPTO_INVENTORY_MODULE ? resolve(process.env.CRYPTO_INVENTORY_MODULE) : join(AICI, '..', 'inventar.mjs');
const inv = await import(pathToFileURL(CALE_MODUL).href);
const lx = await import(pathToFileURL(join(dirname(CALE_MODUL), 'lib', 'lexer.mjs')).href);
const CA_JSON = process.argv.includes('--json');
// numarul total de marcaje EXPECT scrise de mana in fixturi; o schimbare aici se face constient
const MARCAJE_ASTEPTATE = 96;
const FISIERE_CU_MARCAJE = ['js/node-crypto.mjs', 'js/webcrypto.js', 'js/biblioteci.ts', 'js/tls.cjs', 'python/crypto_py.py', 'java/Crypto.java', 'go/crypto.go', 'negative/variabile.js'];
const MARCAJE_ASTEPTATE = 123;
const FISIERE_CU_MARCAJE = ['js/node-crypto.mjs', 'js/webcrypto.js', 'js/biblioteci.ts', 'js/tls.cjs', 'python/crypto_py.py', 'java/Crypto.java', 'go/crypto.go', 'rust/cripto.rs', 'rust/ambiguu.rs', 'negative/variabile.js'];
const probe = [];
const proba = (nume, fn) => probe.push({ nume, fn });
@@ -89,11 +90,12 @@ proba('pozitiv: manifestele dau biblioteci declarate, nu gasiri', () => {
const libs = rez.libraries.map((b) => `${b.file}:${b.line} ${b.name}`).sort();
const ast = ['go.mod:6 github.com/cloudflare/circl', 'go.mod:7 golang.org/x/crypto', 'package.json:10 @noble/post-quantum',
'package.json:5 ethers', 'package.json:7 jsonwebtoken', 'pom.xml:5 org.bouncycastle:bcprov-jdk18on',
'requirements.txt:2 cryptography', 'requirements.txt:3 pyjwt'].sort();
'requirements.txt:2 cryptography', 'requirements.txt:3 pyjwt', 'Cargo.toml:7 sha2', 'Cargo.toml:8 ed25519-dalek', 'Cargo.toml:9 rustls',
'Cargo.toml:11 aes-gcm', 'Cargo.toml:12 pqcrypto-mlkem', 'Cargo.toml:15 ml-dsa', 'Cargo.toml:21 argon2'].sort();
asigura(JSON.stringify(libs) === JSON.stringify(ast), `biblioteci: ${libs.join(' | ')}`);
const bom = inv.buildCbom(rez, { deterministic: true });
const c = bom.components.filter((x) => x.type === 'library');
asigura(c.length === 8 && c.every((x) => x.properties.some((p) => p.name.endsWith('declared-only') && p.value === 'true')), 'componentele library nu poarta declared-only');
asigura(c.length === 15 && c.every((x) => x.properties.some((p) => p.name.endsWith('declared-only') && p.value === 'true')), 'componentele library nu poarta declared-only');
});
proba('pozitiv: material PEM (certificat si cheie publica)', () => {
@@ -192,9 +194,58 @@ proba('negativ: comentariile si sirurile Java si Go nu produc gasiri', () => {
asigura(g.length === 0, `au produs: ${g.map((x) => `${x.file}:${x.line} ${x.name}`).join(', ')}`);
});
proba('negativ: comentariile, sirurile brute, literalele char si lifetime-urile Rust nu produc gasiri', () => {
const rez = scan(FIX);
asigura(gasiriDin(rez, 'rust/cripto.rs').some((x) => x.name === 'MD5'), 'controlul pozitiv: MD5 din fixtura Rust lipseste');
const g = gasiriDin(rez, 'negative/comentarii.rs');
asigura(g.length === 0, `au produs: ${g.map((x) => `${x.line} ${x.name}`).join(', ')}`);
});
proba('rust: lexerul: lifetime-urile si literalele char nu deschid siruri, comentariile bloc se imbrica, sirurile brute se inchid la diezi', () => {
const t1 = "fn f<'a>(x: &'a str) { let c = '\"'; let s = \"Sha256::new()\"; Sha1::digest(x) }";
const c1 = lx.curata(t1, 'rust');
asigura(lx.inSir(c1.siruri, t1.indexOf('Sha256')) && !lx.inSir(c1.siruri, t1.indexOf('Sha1')), `t1: siruri ${JSON.stringify(c1.siruri)}`);
const t2 = '/* a /* b */ Sha256::new() */ Md5::new()';
const c2 = lx.curata(t2, 'rust');
asigura(!c2.code.includes('Sha256') && c2.code.includes('Md5') && c2.code.length === t2.length, `t2: ${JSON.stringify(c2.code)}`);
const t3 = 'let s = r#"a"b"#; let o = b"x\\"y"; Sha1::digest(d)';
const c3 = lx.curata(t3, 'rust');
asigura(c3.siruri.length === 2 && !lx.inSir(c3.siruri, t3.indexOf('Sha1')), `t3: ${JSON.stringify(c3.siruri)}`);
const t4 = "let a = '\\''; let e = '\\u{1F600}'; 'outer: loop { break 'outer; } Md5::new()";
const c4 = lx.curata(t4, 'rust');
asigura(c4.siruri.length === 2 && !lx.inSir(c4.siruri, t4.indexOf('Md5')), `t4: ${JSON.stringify(c4.siruri)}`);
});
proba('rust: acelasi nume de tip e clasificat dupa crate-ul din use (SigningKey)', () => {
const g = gasiriDin(scan(FIX), 'rust/cripto.rs');
const nume = (api) => g.filter((x) => x.api === api).map((x) => x.name);
asigura(JSON.stringify(nume('SigningKey::generate')) === '["Ed25519"]', `ed25519_dalek: ${nume('SigningKey::generate')}`);
asigura(JSON.stringify(nume('P256SigningKey::random')) === '["ECDSA-secp256r1"]', `p256 prin alias: ${nume('P256SigningKey::random')}`);
asigura(JSON.stringify(nume('SlhSigningKey::new')) === '["SLH-DSA-SHA2-128s"]', `slh_dsa prin alias + generic: ${nume('SlhSigningKey::new')}`);
const a = gasiriDin(scan(FIX), 'rust/ambiguu.rs');
asigura(a.length === 1 && a[0].classification === 'unknown' && /ed25519-dalek/.test(a[0].reason) && /ml-dsa/.test(a[0].reason), `fara use: ${JSON.stringify(a.map((x) => [x.name, x.classification]))}`);
});
proba('rust: importul fara apel e dovada slaba (unknown), importul cu apel in acelasi fisier nu se raporteaza', () => {
const g = gasiriDin(scan(FIX), 'rust/cripto.rs');
const imp = g.filter((x) => x.evidenceKind === 'import');
asigura(imp.length === 1 && imp[0].name === 'blake2' && imp[0].classification === 'unknown', `importuri: ${JSON.stringify(imp.map((x) => [x.name, x.classification]))}`);
asigura(!g.some((x) => x.api === 'use sha2' || x.api === 'use ed25519_dalek'), 'sha2 / ed25519_dalek au apeluri, importul lor nu trebuie raportat');
});
proba('rust: Cargo.toml: forma tabel, workspace = true fara versiune, redenumire prin package, purl pkg:cargo', () => {
const libs = scan(join(FIX, 'manifeste')).libraries.filter((b) => b.ecosystem === 'cargo');
const l = (n) => libs.find((b) => b.name === n);
asigura(l('ml-dsa') && l('ml-dsa').version === '0.1.1' && l('ml-dsa').line === 15, `tabel: ${JSON.stringify(l('ml-dsa'))}`);
asigura(l('aes-gcm') && l('aes-gcm').version === undefined && l('aes-gcm').purl === 'pkg:cargo/aes-gcm', `workspace: ${JSON.stringify(l('aes-gcm'))}`);
asigura(l('pqcrypto-mlkem') && l('pqcrypto-mlkem').version === '0.1' && !l('pq'), `package =: ${JSON.stringify(l('pqcrypto-mlkem'))}`);
asigura(l('sha2') && l('sha2').purl === 'pkg:cargo/[email protected]' && l('argon2') && l('argon2').line === 21, `purl / dev-dependencies: ${JSON.stringify([l('sha2'), l('argon2')])}`);
asigura(!l('tokio') && !l('serde') && !l('hex-literal'), 'crate-urile fara criptografie nu sunt biblioteci declarate');
});
proba('negativ: fisier fara criptografie da zero gasiri, si a fost citit', () => {
const rez = scan(join(FIX, 'negative'));
asigura(rez.stats.filesSeen === 7 && rez.stats.codeFilesTotal === 7, `vazute ${rez.stats.filesSeen}, analizate ${rez.stats.codeFilesTotal}`);
asigura(rez.stats.filesSeen === 8 && rez.stats.codeFilesTotal === 8, `vazute ${rez.stats.filesSeen}, analizate ${rez.stats.codeFilesTotal}`);
const g = gasiriDin(rez, 'fara-cripto.js');
asigura(g.length === 0, `fara-cripto.js a produs ${g.length}`);
});