move json ersistence into cpg-core

peckto · peckto · commit a5f56cb54350 · 2025-08-07T08:42:05.000+02:00
diff --git a/cpg-core/build.gradle.kts b/cpg-core/build.gradle.kts
@@ -53,6 +53,7 @@ dependencies {
     implementation(libs.jacksonyml)
 
     testImplementation(libs.junit.params)
+    integrationTestImplementation(libs.kotlin.reflect)
 
     testFixturesApi(
         libs.kotlin.test.junit5
diff --git a/cpg-core/src/integrationTest/kotlin/de/fraunhofer/aisec/cpg/IntegrationTest.kt b/cpg-core/src/integrationTest/kotlin/de/fraunhofer/aisec/cpg/IntegrationTest.kt
@@ -23,37 +23,39 @@
  *                    \______/ \__|       \______/
  *
  */
-package de.fraunhofer.aisec.neo4j
+package de.fraunhofer.aisec.cpg
 
-import de.fraunhofer.aisec.cpg.TranslationManager
-import de.fraunhofer.aisec.cpg.TranslationResult
 import de.fraunhofer.aisec.cpg.graph.declarations.FunctionDeclaration
 import de.fraunhofer.aisec.cpg.graph.functions
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.CallExpression
 import de.fraunhofer.aisec.cpg.persistence.createJsonGraph
 import de.fraunhofer.aisec.cpg.persistence.persistJson
-import de.fraunhofer.aisec.cpg_vis_neo4j.Application
 import java.nio.file.Paths
 import kotlin.io.path.createTempFile
-import kotlin.reflect.jvm.javaField
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import org.junit.jupiter.api.Test
-import org.neo4j.ogm.annotation.Relationship
-import picocli.CommandLine
 
-fun createTranslationResult(file: String = "client.cpp"): Pair<Application, TranslationResult> {
+fun createTranslationResult(file: String = "client.cpp"): TranslationResult {
     val topLevel = Paths.get("src").resolve("integrationTest").resolve("resources").toAbsolutePath()
     val path = topLevel.resolve(file).toAbsolutePath()
 
-    val cmd = CommandLine(Application::class.java)
-    cmd.parseArgs(path.toString())
-    val application = cmd.getCommand<Application>()
+    val result =
+        TranslationManager.builder()
+            .config(
+                TranslationConfiguration.builder()
+                    .topLevel(path.toFile())
+                    .optionalLanguage("de.fraunhofer.aisec.cpg.frontends.cxx.CLanguage")
+                    .optionalLanguage("de.fraunhofer.aisec.cpg.frontends.cxx.CPPLanguage")
+                    .sourceLocations(path.toFile())
+                    .defaultPasses()
+                    .build()
+            )
+            .build()
+            .analyze()
+            .get()
 
-    val translationConfiguration = application.setupTranslationConfiguration()
-    val translationResult =
-        TranslationManager.builder().config(translationConfiguration).build().analyze().get()
-    return application to translationResult
+    return result
 }
 
 /**
@@ -64,7 +66,7 @@ class IntegrationTest {
 
     @Test
     fun testBuildJsonGraph() {
-        val (application, translationResult) = createTranslationResult()
+        val translationResult = createTranslationResult()
 
         // 22 inferred functions, 1 inferred method, 2 inferred constructors, 11 regular functions
         assertEquals(36, translationResult.functions.size)
@@ -86,9 +88,7 @@ class IntegrationTest {
 
         val invokesEdge =
             graph.edges.firstOrNull {
-                it.type ==
-                    (CallExpression::invokeEdges.javaField?.getAnnotation(Relationship::class.java))
-                        ?.value &&
+                it.type == "INVOKES" &&
                     it.startNode == connectToCallExpr.id &&
                     it.endNode == connectToFuncDel.id
             }
@@ -97,7 +97,7 @@ class IntegrationTest {
 
     @Test
     fun testExportToJson() {
-        val (application, translationResult) = createTranslationResult()
+        val translationResult = createTranslationResult()
         // 22 inferred functions, 1 inferred method, 2 inferred constructors, 11 regular functions
         assertEquals(36, translationResult.functions.size)
         val path = createTempFile().toFile()
diff --git a/cpg-core/src/integrationTest/resources/client.cpp b/cpg-core/src/integrationTest/resources/client.cpp
@@ -0,0 +1,131 @@
+#include <iostream>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+SSL *ssl;
+std::string bad_ciphers = "MD5";
+
+int callMeBack(int preverify_ok, X509_STORE_CTX *x509_ctx);
+
+int connectTo(std::string ip, int test) {
+  int s = socket(AF_INET, SOCK_STREAM, 0);
+
+  if(!s) {
+    printf("Error creating socket.\n");
+    return -1;
+  }
+
+  std::cerr << "Connecting to " << ip << "..." << std::endl;
+
+  struct sockaddr_in sa;
+  memset(&sa, 0, sizeof(sa));
+  sa.sin_family = AF_INET;
+  sa.sin_addr.s_addr = inet_addr(ip.c_str());
+  sa.sin_port = htons(443);
+  socklen_t socklen = sizeof(sa);
+
+  if(connect(s, (struct sockaddr*)&sa, sizeof(sa))) {
+    std::cerr << "Error connecting to server." << std::endl;
+    return -1;
+  }
+
+  return s;
+}
+
+void failDisableVerification(SSL_CTX* ctx) {
+  SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, callMeBack);
+}
+
+void failSetInsecureCiphers(SSL_CTX* ctx) {
+  char ciphers[] = "ALL:!ADH";
+
+  SSL_CTX_set_cipher_list(ctx, ciphers);
+}
+
+void failSetInsecureCiphersLiteral(SSL_CTX* ctx) {
+  SSL_CTX_set_cipher_list(ctx, "ALL:!ADH");
+}
+
+void failSetInsecureCiphersSTL(SSL_CTX* ctx) {
+  std::string ciphers = "ALL:!ADH";
+
+  SSL_CTX_set_cipher_list(ctx, ciphers.c_str());
+}
+
+void failSetInsecureCiphersGlobal(SSL_CTX* ctx) {
+  SSL_CTX_set_cipher_list(ctx, bad_ciphers.c_str());
+}
+
+void failDisableVerificationLambda(SSL_CTX* ctx) {
+  // lambdas do not work yet
+  /*SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, [](int preverify_ok, X509_STORE_CTX *x509_ctx) {
+    return 1;
+  });*/
+}
+
+SSL_CTX* initTLSContext() {
+  SSL_library_init();
+  SSL_load_error_strings();
+  SSL_CTX* ctx = SSL_CTX_new(TLSv1_2_client_method());
+
+  // set insecure cipher
+  failSetInsecureCiphers(ctx);
+  failSetInsecureCiphersLiteral(ctx);
+  failSetInsecureCiphersSTL(ctx);
+  failSetInsecureCiphersGlobal(ctx);
+
+  // enable verification
+  SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, nullptr);
+
+  // disable verification
+  failDisableVerification(ctx);
+
+  return ctx;
+}
+
+int main(int argc, char** argv) {
+  int s = connectTo("172.217.18.99", 2);
+  if(s < 0) {
+    return -1;
+  }
+
+  SSL_CTX* ctx = initTLSContext();
+
+  ssl = SSL_new(ctx);
+
+  if(!ssl) {
+    std::cerr << "Error creating SSL." << std::endl;
+    return -1;
+  }
+
+  SSL_set_fd(ssl, s);
+
+  int err = SSL_connect(ssl);
+  // this one confuses neo4j ogm
+  if(err <= 0) {
+    int sslerr = ERR_get_error();
+
+    std::cerr << "Error creating SSL connection. Error Code: " << ERR_error_string(sslerr, nullptr) << std::endl;
+    return -1;
+  }
+
+  if(err <= 0) {
+    std::cerr << "Error creating SSL connection. Error Code: " << ERR_error_string(ERR_get_error(), nullptr) << std::endl;
+    return -1;
+  }
+
+  if (SSL_get_verify_result(ssl) == X509_V_OK) {
+    std::cout << "Call to SSL_get_verify_result is ok" << std::endl;
+  }
+
+  std::cout << "SSL communication established using " << SSL_get_cipher(ssl) << std::endl;
+
+  return 0;
+}
+
+int callMeBack(int preverify_ok, X509_STORE_CTX *x509_ctx) {
+  return 1;
+}
diff --git a/cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/persistence/Common.kt b/cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/persistence/Common.kt
@@ -30,7 +30,10 @@ import de.fraunhofer.aisec.cpg.graph.Node
 import de.fraunhofer.aisec.cpg.graph.Persistable
 import de.fraunhofer.aisec.cpg.graph.edges.collections.EdgeCollection
 import de.fraunhofer.aisec.cpg.graph.edges.collections.EdgeList
+import de.fraunhofer.aisec.cpg.helpers.IdentitySet
+import de.fraunhofer.aisec.cpg.helpers.identitySetOf
 import de.fraunhofer.aisec.cpg.helpers.neo4j.NameConverter
+import kotlin.collections.plusAssign
 import kotlin.reflect.KClass
 import kotlin.reflect.KProperty1
 import kotlin.reflect.KTypeProjection
@@ -349,3 +352,74 @@ fun String.toUpperSnakeCase(): String {
     val pattern = "(?<=.)[A-Z]".toRegex()
     return this.replace(pattern, "_$0").uppercase()
 }
+
+internal typealias CpgRelationship = Map<String, Any?>
+
+/**
+ * Returns all [Node] objects that are connected with this node with some kind of relationship
+ * defined in [schemaRelationships].
+ */
+val Persistable.connectedNodes: IdentitySet<Node>
+    get() {
+        val nodes = identitySetOf<Node>()
+
+        for (entry in this::class.schemaRelationships) {
+            val value = entry.value.call(this)
+            if (value is EdgeCollection<*, *>) {
+                nodes += value.toNodeCollection()
+            } else if (value is List<*>) {
+                nodes += value.filterIsInstance<Node>()
+            } else if (value is Node) {
+                nodes += value
+            }
+        }
+
+        return nodes
+    }
+
+fun List<Node>.collectRelationships(): List<CpgRelationship> {
+    val relationships = mutableListOf<CpgRelationship>()
+
+    for (node in this) {
+        for (entry in node::class.schemaRelationships) {
+            val value = entry.value.call(node)
+            if (value is EdgeCollection<*, *>) {
+                relationships +=
+                    value.map { edge ->
+                        mapOf(
+                            "startId" to edge.start.id.toString(),
+                            "endId" to edge.end.id.toString(),
+                            "type" to entry.key,
+                        ) + edge.properties()
+                    }
+            } else if (value is List<*>) {
+                relationships +=
+                    value.filterIsInstance<Node>().map { end ->
+                        mapOf(
+                            "startId" to node.id.toString(),
+                            "endId" to end.id.toString(),
+                            "type" to entry.key,
+                        )
+                    }
+            } else if (value is Node) {
+                relationships +=
+                    mapOf(
+                        "startId" to node.id.toString(),
+                        "endId" to value.id.toString(),
+                        "type" to entry.key,
+                    )
+            }
+        }
+    }
+
+    // Since Neo4J does not support multiple labels on edges, but we do internally, we
+    // duplicate the edge for each label
+    /*edge.labels.map { label ->
+        mapOf(
+            "startId" to edge.start.id.toString(),
+            "endId" to edge.end.id.toString(),
+            "type" to label
+        ) + edge.properties()
+    }*/
+    return relationships
+}
diff --git a/cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/persistence/Json.kt b/cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/persistence/Json.kt
@@ -32,9 +32,14 @@ import de.fraunhofer.aisec.cpg.graph.Persistable
 import de.fraunhofer.aisec.cpg.graph.nodes
 import de.fraunhofer.aisec.cpg.helpers.Benchmark
 import java.io.File
+import org.slf4j.LoggerFactory
 
+internal val log = LoggerFactory.getLogger("Persistence")
+
+/** Serialized cpg [Node] to be exported with jackson */
 data class JsonNode(val id: String, val labels: Set<String>, val properties: Map<String, Any?>)
 
+/** Serialized cpg Relation to be exported with jackson */
 data class JsonEdge(
     val id: Long,
     val type: String,
@@ -43,6 +48,7 @@ data class JsonEdge(
     val properties: Map<String, Any?>,
 )
 
+/** Container to hold serialized Nodes and Edge list of a cpg to be exported with jackson */
 data class JsonGraph(val nodes: List<JsonNode>, val edges: List<JsonEdge>)
 
 /** Serialise the cpg using the OGM as nodes and edge list. */
diff --git a/cpg-neo4j/src/main/kotlin/de/fraunhofer/aisec/cpg/persistence/Neo4J.kt b/cpg-neo4j/src/main/kotlin/de/fraunhofer/aisec/cpg/persistence/Neo4J.kt
