crypto-inventory 0.3.0 and the control-plane planner after the second run on a tree that is not ours (libsignal): BoringSSL, Noise hfs, libcrux Kyber, the libsignal Java/Node API; self-signed trust anchors are blocked, test code is LOW with its own scope

This commit is contained in:
Aere Network committed 2026-10-18 07:52:31 +03:00
1 parent 42b049ef04
commit e453c0c42d
35 files changed
+675 -51

No files matched your search

@@ -0,0 +1,27 @@
// Fixtura: API-ul Java/Android al libsignal (org.signal.libsignal), 2026-10-18. Fisierul nu se compileaza; e doar text pentru scaner.
// Ancora e importul org.signal.libsignal.*; fara el, numele scurte (ECKeyPair, HKDF, Aes256GcmSiv) nu inseamna libsignal.
package fixturi;
import org.signal.libsignal.protocol.IdentityKeyPair;
import org.signal.libsignal.protocol.ecc.ECKeyPair;
import org.signal.libsignal.protocol.kem.KEMKeyPair;
import org.signal.libsignal.protocol.kem.KEMKeyType;
import org.signal.libsignal.protocol.kdf.HKDF;
import org.signal.libsignal.protocol.state.PreKeyBundle;
import org.signal.libsignal.crypto.Aes256GcmSiv;
import org.signal.libsignal.crypto.Aes256GcmEncryption;
import org.signal.libsignal.crypto.Aes256Ctr32;
public class Libsignal {
public void exemple(byte[] key, byte[] nonce, byte[] ikm, KEMKeyType tipDinParametru) throws Exception {
ECKeyPair ec = ECKeyPair.generate(); // EXPECT: X25519 | quantum-vulnerable
IdentityKeyPair id = IdentityKeyPair.generate(); // EXPECT: X25519 | quantum-vulnerable
KEMKeyPair kem = KEMKeyPair.generate(KEMKeyType.KYBER_1024); // EXPECT: Kyber-1024 | quantum-safe
KEMKeyPair kem2 = KEMKeyPair.generate(tipDinParametru); // EXPECT: libsignal KEM key pair | unknown
byte[] okm = HKDF.deriveSecrets(ikm, "info".getBytes(), 32); // EXPECT: HKDF | quantum-safe
Aes256GcmSiv siv = new Aes256GcmSiv(key); // EXPECT: AES-256-GCM-SIV | quantum-safe
Aes256GcmEncryption gcm = new Aes256GcmEncryption(key, nonce, new byte[0]); // EXPECT: AES-256-GCM | quantum-safe
Aes256Ctr32 ctr = new Aes256Ctr32(key, nonce, 0); // EXPECT: AES-256-CTR | quantum-safe
PreKeyBundle bundle = new PreKeyBundle(1, 1, 2, ec.getPublicKey(), 3, ec.getPublicKey(), new byte[64], id.getPublicKey()); // EXPECT: libsignal session setup (X3DH/PQXDH) | unknown
}
}
@@ -0,0 +1,12 @@
// Fixtura: un fisier care importa libsignal fara niciun apel recunoscut: importul e dovada slaba (unknown), o singura data.
// Si un fisier FARA importul libsignal nu primeste nimic pentru aceleasi nume scurte (vezi negative/FaraLibsignal.java).
package fixturi;
import org.signal.libsignal.protocol.SessionCipher; // EXPECT: libsignal (org.signal.libsignal) | unknown
import org.signal.libsignal.protocol.SignalProtocolAddress;
public class LibsignalImport {
public Object cifru(Object store, SignalProtocolAddress adresa) {
return new SessionCipher(store, adresa);
}
}
@@ -0,0 +1,6 @@
// Fixtura: importul pachetului fara niciun apel recunoscut e dovada slaba (unknown), o singura data pe fisier.
import { SessionCipher, ProtocolAddress } from '@signalapp/libsignal-client'; // EXPECT: @signalapp/libsignal-client | unknown
export function adresa(nume: string) {
return { cipher: SessionCipher, address: ProtocolAddress.new(nume, 1) };
}
@@ -0,0 +1,14 @@
// Fixtura: un client al bibliotecii Signal pentru Node (@signalapp/libsignal-client), 2026-10-18. Ancora e importul pachetului.
import * as SignalClient from '@signalapp/libsignal-client';
import { PrivateKey, KEMKeyPair, hkdf, Aes256GcmSiv } from '@signalapp/libsignal-client';
export function chei(ikm: Buffer, key: Buffer) {
const priv = PrivateKey.generate(); // EXPECT: X25519 | quantum-vulnerable
const id = SignalClient.IdentityKeyPair.generate(); // EXPECT: X25519 | quantum-vulnerable
const kem = KEMKeyPair.generate(); // EXPECT: Kyber-1024 | quantum-safe
const okm = hkdf(32, ikm, Buffer.from('info'), null); // EXPECT: HKDF | quantum-safe
const okm2 = SignalClient.hkdf(32, ikm, Buffer.from('info'), null); // EXPECT: HKDF | quantum-safe
const siv = Aes256GcmSiv.new(key); // EXPECT: AES-256-GCM-SIV | quantum-safe
const bundle = SignalClient.PreKeyBundle.new(1, 1, 2, priv.getPublicKey(), 3, priv.getPublicKey(), Buffer.alloc(64), id.publicKey); // EXPECT: libsignal session setup (X3DH/PQXDH) | unknown
return { priv, id, kem, okm, okm2, siv, bundle };
}
@@ -0,0 +1,15 @@
// Fixtura negativa: aceleasi nume scurte ca in API-ul libsignal (ECKeyPair.generate, HKDF.deriveSecrets, new Aes256GcmSiv), dar FARA
// importul org.signal.libsignal: nu sunt libsignal, deci nu produc nicio gasire. Fisierul nu se compileaza; e doar text pentru scaner.
package fixturi;
import com.exemplu.chei.ECKeyPair;
import com.exemplu.kdf.HKDF;
import com.exemplu.cifru.Aes256GcmSiv;
public class FaraLibsignal {
public Object exemple(byte[] key, byte[] ikm) {
ECKeyPair ec = ECKeyPair.generate();
byte[] okm = HKDF.deriveSecrets(ikm, "info".getBytes(), 32);
return new Aes256GcmSiv(key);
}
}
@@ -0,0 +1,10 @@
// Fixtura negativa: aceleasi nume scurte ca in API-ul @signalapp/libsignal-client (PrivateKey.generate, KEMKeyPair.generate, hkdf,
// Aes256GcmSiv.new), dar importate din alta parte: nu sunt libsignal, deci nu produc nicio gasire.
import { PrivateKey, KEMKeyPair, hkdf, Aes256GcmSiv } from '../chei-proprii';
export function chei(ikm: Buffer, key: Buffer) {
const priv = PrivateKey.generate();
const kem = KEMKeyPair.generate();
const okm = hkdf(32, ikm, Buffer.from('info'), null);
return { priv, kem, okm, siv: Aes256GcmSiv.new(key) };
}
@@ -0,0 +1,30 @@
// Fixtura: ce a scapat inventarului pe libsignal (2026-10-18): BoringSSL prin `boring` / `boring-signal` (stiva TLS a lui libsignal,
// acelasi API ca openssl), HmacReset din hmac 0.13, tipul de mod adus prin `use cbc::Decryptor`, functia libera x25519(), modulele
// kyber ale lui libcrux (Kyber pre-standard) si tiparul Noise hibrid hfs (X25519 + Kyber1024 in aceeasi strangere de mana).
use boring_signal::ssl::{SslConnector, SslMethod, SslVersion};
use boring::rsa::Rsa;
use boring::hash::MessageDigest;
use hmac::{HmacReset, Mac};
use sha2::Sha256;
use aes::Aes256;
use cbc::Decryptor;
use cbc::cipher::KeyIvInit;
use x25519_dalek as x25519;
use libcrux_ml_kem::kyber1024;
use libcrux_ml_kem::mlkem768;
use snow::Builder;
pub const NOISE_HFS: &str = "Noise_NKhfs_25519+Kyber1024_ChaChaPoly_SHA256"; // EXPECT: X25519+Kyber1024 (Noise hfs) | quantum-safe ; ChaCha20-Poly1305 | quantum-safe ; SHA-256 | quantum-safe
pub fn exemple(key: &[u8; 32], iv: &[u8; 16], secret: [u8; 32], randomness: [u8; 64]) {
let mut ssl = SslConnector::builder(SslMethod::tls()).unwrap(); // EXPECT: boring-signal SslConnector | unknown
ssl.set_min_proto_version(Some(SslVersion::TLS1_3)).unwrap(); // EXPECT: TLSv1.3 | unknown
let rsa = Rsa::generate(2048).unwrap(); // EXPECT: RSA-2048 | quantum-vulnerable
let md = MessageDigest::sha256(); // EXPECT: SHA-256 | quantum-safe
let mac = HmacReset::<Sha256>::new_from_slice(key).unwrap(); // EXPECT: HMAC-SHA-256 | quantum-safe
let dec = Decryptor::<Aes256>::new(key.into(), iv.into()); // EXPECT: AES-256-CBC | quantum-safe
let pk = x25519::x25519(secret, x25519::X25519_BASEPOINT_BYTES); // EXPECT: X25519 | quantum-vulnerable
let kp = kyber1024::generate_key_pair(randomness); // EXPECT: Kyber-1024 | quantum-safe
let kp2 = mlkem768::generate_key_pair(randomness); // EXPECT: ML-KEM-768 | quantum-safe
let _ = (ssl, rsa, md, mac, dec, pk, kp, kp2, Builder::new(NOISE_HFS.parse().unwrap()));
}