crypto-inventory 0.4.0: Swift and Kotlin detectors (CryptoKit, CommonCrypto, Security.framework, Android Keystore, Tink, OkHttp, the libsignal Swift and Android APIs), Apple and Android manifests; remediation recipes for Apache and HAProxy measured on real servers, HAProxy precondition fixed

This commit is contained in:
Aere Network committed 2026-10-18 08:53:13 +03:00
1 parent e453c0c42d
commit b6ed4d2b71
37 files changed
+1623 -82

No files matched your search

@@ -0,0 +1,102 @@
// Fixtura: JCA/JSSE din Kotlin (fara `new`, cu `val`), verificatorul PKIX al lui rustls-platform-verifier asa cum sta in clona libsignal
// (java/android/src/main/java/org/rustls/platformverifier/CertificateVerifier.kt, randurile in dreptul formelor), Android Keystore
// (developer.android.com/reference/android/security/keystore/KeyGenParameterSpec.Builder), Tink (developers.google.com/tink, sabloanele
// de chei) si OkHttp (square.github.io/okhttp/features/https: ConnectionSpec, TlsVersion, CipherSuite, CertificatePinner). Nu se compileaza.
package fixturi
import java.security.KeyPairGenerator
import java.security.KeyStore
import java.security.MessageDigest
import java.security.cert.CertPathValidator
import java.security.cert.CertificateFactory
import java.security.spec.ECGenParameterSpec
import javax.crypto.Cipher
import javax.crypto.KeyGenerator
import javax.crypto.Mac
import javax.net.ssl.SSLContext
import javax.net.ssl.TrustManagerFactory
import javax.net.ssl.X509TrustManager
import android.security.keystore.KeyGenParameterSpec
import android.security.keystore.KeyProperties
import com.google.crypto.tink.KeyTemplates
import com.google.crypto.tink.KeysetHandle
import com.google.crypto.tink.aead.AeadConfig
import okhttp3.CertificatePinner
import okhttp3.CipherSuite
import okhttp3.ConnectionSpec
import okhttp3.OkHttpClient
import okhttp3.TlsVersion
import org.bouncycastle.crypto.engines.RC4Engine // EXPECT: RC4 | weak-now
class Android {
private val DIGEST = "SHA-256"
fun jca(algDinParametru: String, keystore: KeyStore) {
val alias = "root_${keystore.size()}" // CertificateVerifier.kt:149: un sablon ${ } inaintea apelurilor (lexerul trebuie sa il inchida)
val kpg = KeyPairGenerator.getInstance("RSA") // EXPECT: RSA-3072 | quantum-vulnerable
kpg.initialize(3072)
val ec = KeyPairGenerator.getInstance("EC") // EXPECT: EC-secp256r1 | quantum-vulnerable
ec.initialize(ECGenParameterSpec("secp256r1"))
val c1 = Cipher.getInstance("AES/GCM/NoPadding") // EXPECT: AES-GCM | quantum-safe
val mac = Mac.getInstance("HmacSHA256") // EXPECT: HMAC-SHA-256 | quantum-safe
val md = MessageDigest.getInstance(DIGEST) // EXPECT: SHA-256 | quantum-safe
val md2 = MessageDigest.getInstance(algDinParametru) // EXPECT: MessageDigest.getInstance | unknown
val tls = SSLContext.getInstance("TLSv1.2") // EXPECT: TLSv1.2 | quantum-vulnerable
println(listOf(alias, c1, mac, md, md2, tls))
}
// rustls-platform-verifier, CertificateVerifier.kt: lantul de incredere TLS al clientului (verificare de certificate, nu schimb de cheie)
fun pkix(keystore: KeyStore?, principal: ByteArray) {
val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()) // :101; EXPECT: X.509 chain validation (PKIX) | quantum-vulnerable
factory.init(keystore)
for (manager in factory.trustManagers) {
if (manager is X509TrustManager) { // :113; EXPECT: X.509 chain validation (PKIX) | quantum-vulnerable
manager.checkServerTrusted(arrayOf(), "RSA") // :291; EXPECT: X.509 chain validation (PKIX) | quantum-vulnerable
}
}
val certFactory: CertificateFactory = CertificateFactory.getInstance("X.509") // :198: parsare de certificate, nu verificare: nimic
val systemKeystore = KeyStore.getInstance("AndroidCAStore") // :209; EXPECT: X.509 chain validation (PKIX) | quantum-vulnerable
val validator = CertPathValidator.getInstance("PKIX") // :367; EXPECT: X.509 chain validation (PKIX) | quantum-vulnerable
val digest = MessageDigest.getInstance("MD5").digest(principal) // :435: aliasul de sistem al unei radacini, nu securitate; unealta nu judeca intentia; EXPECT: MD5 | weak-now
println(listOf(certFactory, systemKeystore, validator, digest))
}
fun keystore() {
val kpg = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore") // curba din Builder-ul de mai jos; EXPECT: EC-secp256r1 | quantum-vulnerable
kpg.initialize(
KeyGenParameterSpec.Builder("alias", KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY)
.setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
.setDigests(KeyProperties.DIGEST_SHA256)
.build()
)
val rsa = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_RSA, "AndroidKeyStore") // marimea din variabila spec; EXPECT: RSA-2048 | quantum-vulnerable
val spec = KeyGenParameterSpec.Builder("rsa", KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
.setKeySize(2048)
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_OAEP)
.build()
rsa.initialize(spec)
val kg = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore") // EXPECT: AES-256-GCM | quantum-safe
kg.init(KeyGenParameterSpec.Builder("aes", KeyProperties.PURPOSE_ENCRYPT).setBlockModes(KeyProperties.BLOCK_MODE_GCM).setKeySize(256).build())
val singur = KeyGenParameterSpec.Builder("hmac", KeyProperties.PURPOSE_SIGN).setKeySize(521).build() // fara generator in fisier: din marime; EXPECT: EC-secp521r1 | quantum-vulnerable
println(singur)
}
fun tink() {
AeadConfig.register() // dovada slaba, suprimata de sabloanele de mai jos: nimic
val aead = KeysetHandle.generateNew(KeyTemplates.get("AES256_GCM")) // EXPECT: AES-256-GCM | quantum-safe
val sig = KeysetHandle.generateNew(KeyTemplates.get("ECDSA_P256")) // EXPECT: ECDSA-secp256r1 | quantum-vulnerable
val hybrid = KeysetHandle.generateNew(KeyTemplates.get("DHKEM_X25519_HKDF_SHA256_HKDF_SHA256_AES_256_GCM")) // HPKE; EXPECT: X25519 | quantum-vulnerable
val mac = KeysetHandle.generateNew(KeyTemplates.get("HMAC_SHA256_256BITTAG")) // EXPECT: HMAC-SHA-256 | quantum-safe
val rsa = KeysetHandle.generateNew(KeyTemplates.get("RSA_SSA_PSS_3072_SHA256_F4")) // EXPECT: RSA-3072 | quantum-vulnerable
println(listOf(aead, sig, hybrid, mac, rsa))
}
fun okhttp(): OkHttpClient {
val spec = ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS) // EXPECT: TLS (negotiated, OkHttp MODERN_TLS) | unknown
.tlsVersions(TlsVersion.TLS_1_2, TlsVersion.TLS_1_3) // EXPECT: TLSv1.2 | quantum-vulnerable ; TLSv1.3 | unknown
.cipherSuites(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, CipherSuite.TLS_AES_256_GCM_SHA384) // EXPECT: TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 | quantum-vulnerable ; AES-256-GCM | quantum-safe
.build()
val pinner = CertificatePinner.Builder().add("example.com", "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=").build() // EXPECT: certificate pinning (SPKI) | quantum-vulnerable
return OkHttpClient.Builder().connectionSpecs(listOf(spec)).certificatePinner(pinner).build()
}
}
@@ -0,0 +1,40 @@
// Fixtura: API-ul libsignal din Kotlin (org.signal.libsignal), 2026-10-18. Formele vin din clona signalapp/libsignal 1738ead8
// (fisier:rand in dreptul lor); unde Kotlin-ul clonei are numai DEFINITIA, forma de apel e semnatura ei plus apelul Java corespunzator
// din aceeasi clona (scris in dreptul randului). Fisierul nu se compileaza; e doar text pentru scaner. Ancora e importul
// org.signal.libsignal.* (sau pachetul); fara ea, aceleasi nume nu inseamna libsignal (vezi negative/FaraLibsignal.kt).
package fixturi
import org.signal.libsignal.protocol.IdentityKeyPair
import org.signal.libsignal.protocol.ecc.ECKeyPair
import org.signal.libsignal.protocol.ecc.ECPrivateKey
import org.signal.libsignal.protocol.kem.KEMKeyPair
import org.signal.libsignal.protocol.kem.KEMKeyType
import org.signal.libsignal.protocol.kem.KEMPublicKey
import org.signal.libsignal.protocol.kdf.HKDF
import org.signal.libsignal.protocol.state.PreKeyBundle
import org.signal.libsignal.metadata.SealedSessionCipher
import org.signal.libsignal.crypto.Aes256GcmSiv
import org.signal.libsignal.internal.Native
class Libsignal {
fun exemple(key: ByteArray, ikm: ByteArray, info: ByteArray, bytes: ByteArray, tip: KEMKeyType, store: Any, aci: Any, e164: String) {
var privateKey = ECPrivateKey.generate() // java/shared/.../protocol/ecc/ECKeyPair.kt:15; EXPECT: X25519 | quantum-vulnerable
val pair = ECKeyPair(privateKey.getPublicKey(), privateKey) // ECKeyPair.kt:16: constructor din parti, NU o generare: nimic
val pair2 = ECKeyPair.generate() // semnatura ECKeyPair.kt:14 + apelul Java `ECKeyPair.generate()` (x66 in clona); EXPECT: X25519 | quantum-vulnerable
val id = IdentityKeyPair.generate() // apelul Java `IdentityKeyPair.generate()` (x9 in clona); EXPECT: X25519 | quantum-vulnerable
val kem = KEMKeyPair.generate(KEMKeyType.KYBER_1024) // semnatura KEMKeyPair.kt:18 + apelul Java (x5); EXPECT: Kyber-1024 | quantum-safe
val kem2 = KEMKeyPair.generate(tip) // tipul nu e pe rand: nu se ghiceste; EXPECT: libsignal KEM key pair | unknown
val kemDinPunte = KEMKeyPair(Native.KyberKeyPair_Generate()) // KEMKeyPair.kt:20; EXPECT: Kyber-1024 | quantum-safe
val remote = KEMPublicKey(bytes) // java/client/src/test/.../net/AuthKeysServiceTest.kt:66; EXPECT: Kyber-1024 | quantum-safe
val okm = HKDF.deriveSecrets(ikm, info, 32) // semnatura HKDF.kt:10 + apelul Java (x7); EXPECT: HKDF | quantum-safe
val okm2 = Native.HKDF_DeriveSecrets(32, ikm, info, null) // HKDF.kt:15; EXPECT: HKDF | quantum-safe
val siv = Aes256GcmSiv(key) // Java `new Aes256GcmSiv(key)` (x3), in Kotlin fara new; EXPECT: AES-256-GCM-SIV | quantum-safe
val bundle = PreKeyBundle(1, 1, 2, pair.publicKey, 3, pair.publicKey, ByteArray(64), id.publicKey, 4, kem.publicKey, ByteArray(64)) // constructorul PreKeyBundle.kt:26; EXPECT: libsignal session setup (X3DH/PQXDH) | unknown
val sealed = SealedSessionCipher(store, aci, e164, 1) // Java `new SealedSessionCipher(store, aci, e164, deviceId)`; plicul e X25519 + HKDF; EXPECT: X25519 | quantum-vulnerable
val deserializat = ECPrivateKey(bytes) // UnauthBackupsServiceTest.kt:61: deserializare, nu generare: nimic
val semnatura = Native.ECPrivateKey_Sign(1L, info) // ECPrivateKey.kt:30 (calculateSignature): XEdDSA pe cheia Curve25519; EXPECT: XEdDSA (Curve25519) | quantum-vulnerable
val acord = Native.ECPrivateKey_Agree(1L, 2L) // ECPrivateKey.kt:35 (calculateAgreement); EXPECT: X25519 | quantum-vulnerable
val deschis = Native.ECPrivateKey_HpkeOpen(1L, bytes, info, info) // ECPrivateKey.kt:55 (open, HPKE RFC 9180 cu DHKEM X25519); EXPECT: X25519 | quantum-vulnerable
println(listOf(pair, pair2, kem2, kemDinPunte, remote, okm, okm2, siv, bundle, sealed, deserializat, semnatura, acord, deschis))
}
}