build.gradle

/***
 * CERT Kaiju
 * Copyright 2021 Carnegie Mellon University.
 *
 * NO WARRANTY. THIS CARNEGIE MELLON UNIVERSITY AND SOFTWARE ENGINEERING
 * INSTITUTE MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY
 * MAKES NO WARRANTIES OF ANY KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER
 * INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR PURPOSE OR
 * MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF THE MATERIAL.
 * CARNEGIE MELLON UNIVERSITY DOES NOT MAKE ANY WARRANTY OF ANY KIND WITH RESPECT
 * TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
 *
 * Released under a BSD (SEI)-style license, please see LICENSE.md or contact permission@sei.cmu.edu for full terms.
 *
 * [DISTRIBUTION STATEMENT A] This material has been approved for public release and unlimited distribution.
 * Please see Copyright notice for non-US Government use and distribution.
 *
 * Carnegie Mellon (R) and CERT (R) are registered in the U.S. Patent and Trademark Office by Carnegie Mellon University.
 *
 * This Software includes and/or makes use of the following Third-Party Software subject to its own license:
 * 1. OpenJDK (http://openjdk.java.net/legal/gplv2+ce.html) Copyright 2021 Oracle.
 * 2. Ghidra (https://github.com/NationalSecurityAgency/ghidra/blob/master/LICENSE) Copyright 2021 National Security Administration.
 * 3. GSON (https://github.com/google/gson/blob/master/LICENSE) Copyright 2020 Google.
 * 4. JUnit (https://github.com/junit-team/junit5/blob/main/LICENSE.md) Copyright 2020 JUnit Team.
 * 5. Gradle (https://github.com/gradle/gradle/blob/master/LICENSE) Copyright 2021 Gradle Inc.
 * 6. markdown-gradle-plugin (https://github.com/kordamp/markdown-gradle-plugin/blob/master/LICENSE.txt) Copyright 2020 Andres Almiray.
 * 7. Z3 (https://github.com/Z3Prover/z3/blob/master/LICENSE.txt) Copyright 2021 Microsoft Corporation.
 * 8. jopt-simple (https://github.com/jopt-simple/jopt-simple/blob/master/LICENSE.txt) Copyright 2021 Paul R. Holser, Jr.
 *
 * DM21-0792
 */

// Builds a Ghidra Extension for a given Ghidra installation.
//
// An absolute path to the Ghidra installation directory must be supplied either by setting the 
// GHIDRA_INSTALL_DIR environment variable or Gradle project property:
//
//     > export GHIDRA_INSTALL_DIR=<Absolute path to Ghidra> 
//     > gradle
//
//         or
//
//     > gradle -PGHIDRA_INSTALL_DIR=<Absolute path to Ghidra>
//
// Gradle should be invoked from the directory of the project to build.  Please see the
// application.gradle.version property in <GHIDRA_INSTALL_DIR>/Ghidra/application.properties
// for the correction version of Gradle to use for the Ghidra installation you specify.

//apply plugin: 'java' // adds 'test' task
//apply plugin: MarkdownPlugin // adds a markdownToHtml task, see buildSrc/ directory

plugins {
    id 'java'
    id 'kaiju.gradle.ghidrahtml'
    id "de.undercouch.download" version "5.5.0" // used to download z3 source zip archive
    id "io.github.tomtzook.gradle-cmake" version "1.2.2" // used to build z3 automatically
    id 'com.adarshr.test-logger' version '4.0.0' // used because gradle sucks at showing test output
}

//----------------------START "DO NOT MODIFY" SECTION------------------------------
def ghidraInstallDir

if (System.env.GHIDRA_INSTALL_DIR) {
	ghidraInstallDir = System.env.GHIDRA_INSTALL_DIR
}
else if (project.hasProperty("GHIDRA_INSTALL_DIR")) {
	ghidraInstallDir = project.getProperty("GHIDRA_INSTALL_DIR")
}

if (ghidraInstallDir) {
	apply from: new File(ghidraInstallDir).getCanonicalPath() + "/support/buildExtension.gradle"
}
else {
    throw new GradleException("GHIDRA_INSTALL_DIR is not defined!")
}
//----------------------END "DO NOT MODIFY" SECTION-------------------------------

OperatingSystem os = org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.currentOperatingSystem;

// Technically we probably should not be doing this, but we need to know which platform we're on.
apply from: new File(ghidraInstallDir).getCanonicalPath() + "/GPL/nativePlatforms.gradle"
def ghidraPlatformName = getCurrentPlatformName()

// change this to set the version of Z3 we're using
String z3Version = "4.12.1"

def autocatsDir
if (System.env.KAIJU_AUTOCATS_DIR) {
	autocatsDir = System.env.KAIJU_AUTOCATS_DIR
}
else if (project.hasProperty("KAIJU_AUTOCATS_DIR")) {
	autocatsDir = project.getProperty("KAIJU_AUTOCATS_DIR")
}


// allow installation using:
// > gradle -PGHIDRA_INSTALL_DIR=/path/to/ghidra install
// you can also allow removal of the any previous Kaiju install prior to
// reinstalling by adding -PKAIJU_AUTO_REMOVE

import org.gradle.util.VersionNumber

// Gradle 6.4+ is needed to compile the markdown gradle plugin written in groovy
// Ghidra 10 requires gradle 6.8 or above
if (VersionNumber.parse( gradle.gradleVersion ) <= VersionNumber.parse ("6.8.0")) {
    throw new GradleException("CERT Kaiju requires at least gradle version 6.8.0. Please update gradle and retry.")
}

// Export GHIDRA_10_4 and _11_1 for conditional compilation
def ghidraVersion = project.ext.ghidra_version;
compileJava {
    options.compilerArgs << '-AGHIDRA_10_4=' + (VersionNumber.parse( ghidraVersion ) >= VersionNumber.parse("10.4")) \
                         << '-AGHIDRA_11_1=' + (VersionNumber.parse( ghidraVersion ) >= VersionNumber.parse("11.1"))
}
compileTestJava {
    options.compilerArgs << '-AGHIDRA_10_4=' + (VersionNumber.parse( ghidraVersion ) >= VersionNumber.parse("10.4")) \
                         << '-AGHIDRA_11_1=' + (VersionNumber.parse( ghidraVersion ) >= VersionNumber.parse("11.1"))
}
repositories {
    mavenCentral()
}

dependencies {

    annotationProcessor 'systems.manifold:manifold-preprocessor:2023.1.28'
    testAnnotationProcessor 'systems.manifold:manifold-preprocessor:2023.1.28'
    
    testImplementation(
        'junit:junit:4.12', // needed on classpath to support junit 5 vintage
        'org.junit.jupiter:junit-jupiter-api:5.9.2',
        'org.junit.jupiter:junit-jupiter-engine:5.9.2',
        'org.junit.jupiter:junit-jupiter-migrationsupport:5.9.2'
    )
    testRuntimeOnly(
        'org.junit.jupiter:junit-jupiter-engine:5.9.2',
        'org.junit.vintage:junit-vintage-engine:5.9.2'
    )
}

tasks.withType(JavaCompile) {
    // If you DO NOT define a module-info.java file:
    options.compilerArgs += ['-Xplugin:Manifold']
}

// don't include files not needed for runtime!
buildExtension.exclude 'azure-pipelines.yml'
buildExtension.exclude '*.bak'
buildExtension.exclude 'buildSrc/**'
buildExtension.exclude '3rdparty/**'
buildExtension.exclude '.github/**'
buildExtension.exclude '.vscode/**'


task printGhidraDir {
    println 'Using Ghidra install directory ' + ghidraInstallDir
    println 'Using Java ' + targetCompatibility + ' for Ghidra ' + ghidraVersion
    println 'Using AUTOCATS test directory ' + autocatsDir
}

task copyToLib(type: Copy) {
    outputs.file file("lib/gson-2.8.6.jar")
    if (!file("lib/gson-2.8.6.jar").exists()) {
        configurations {
            gsonDependency
        }

        dependencies {
            gsonDependency group: 'com.google.code.gson', name: 'gson', version: '2.8.6'
        }

        from configurations.gsonDependency
        into "lib"
    }
    outputs.file file("lib/jopt-simple-5.0.4.jar")
    if (!file("lib/jopt-simple-5.0.4.jar").exists()) {
        configurations {
            joptDependency
        }

        dependencies {
            joptDependency group: 'net.sf.jopt-simple', name: 'jopt-simple', version: '5.0.4'
        }

        from configurations.joptDependency
        into "lib"
    }

    // This will copy com.microsoft.z3.jar without knowing the architecture directory
    from fileTree('build/cmake/z3') {
        include '**/com.microsoft.z3.jar'
    }
    into 'lib'
    eachFile {
        it.path = it.name
    }
    includeEmptyDirs = false
}

// BEGIN: if user gives flag, skip building Z3
if (!project.hasProperty('KAIJU_SKIP_Z3_BUILD')) {

// download task uses plugin:
// https://github.com/michel-kraemer/gradle-download-task
task downloadZ3Source(type: Download) {
    src 'https://github.com/Z3Prover/z3/archive/refs/tags/z3-4.12.1.zip'
    dest new File('3rdparty', 'z3-4.12.1.zip')
    overwrite false
}

task downloadAndUnzipZ3Source(dependsOn: downloadZ3Source, type: Copy) {
    from zipTree(downloadZ3Source.dest)
    into '3rdparty'
    filesMatching("**") {
        it.path = it.path.replace("z3-z3-4.12.1", "z3")
    }
    
    includeEmptyDirs = true
    
    doLast {
        // the zip creates these directories even though renamed?
        // so just clear it during this task
        if (file('3rdparty/z3-z3-4.12.1').exists()) {
            def z3Dir2 = new File('3rdparty/z3-z3-4.12.1')
            z3Dir2.deleteDir()
        }
    }
    
    onlyIf {
        !file('3rdparty/z3/CMakeLists.txt').exists()
    }
}

buildExtension.dependsOn(downloadAndUnzipZ3Source)

task cleanZ3Source(type: Delete) {
    doLast {
        def z3Dir = new File('3rdparty/z3')
        z3Dir.deleteDir()
    }
}

tasks.clean.dependsOn(cleanZ3Source)

// BEGIN: cmake z3 build section
// based on: https://github.com/tomtzook/gradle-cmake

cmake {
    targets {
        z3 {
            cmakeLists.set(file('3rdparty/z3/CMakeLists.txt'))
            targetMachines.add(machines.host)
            // we could use ninja instead of make
            // but for cross-compatibility reasons,
            // we're letting the default run
            if (os.isLinux()) {
                try {
                    def result = exec { 
                        ignoreExitValue = true
                        commandLine 'ninja', '--version'
                    }
                    generator.set(generators.ninja)
                } catch (Exception e) {
                    // do nothing, just let the default generator run
                }
            }
            // pass options to cmake
            cmakeArgs.add('-DCMAKE_BUILD_TYPE=Release')
            cmakeArgs.add('-DZ3_BUILD_LIBZ3_SHARED=true')
            cmakeArgs.add('-DZ3_BUILD_JAVA_BINDINGS=true')
            cmakeArgs.add('-DZ3_USE_LIB_GMP=false')
            cmakeArgs.add('-DZ3_LINK_TIME_OPTIMIZATION=true')
            cmakeArgs.add('-DZ3_BUILD_EXECUTABLE=false')
            cmakeArgs.add('-DZ3_BUILD_TEST_EXECUTABLES=false')
            cmakeArgs.add('-DZ3_ENABLE_EXAMPLE_TARGETS=false')
            //cmakeArgs.add('-DZ3_INCLUDE_GIT_HASH=false')
            //cmakeArgs.add('-DZ3_INCLUDE_GIT_DESCRIBE=false')
            // if wanted to pass options directly to make/ninja, would also use:
            // generatorArgs.add()
        }
    }
}

tasks.clean.dependsOn(tasks.cmakeClean)

// This is our task for building z3.  It's only really needed to work around a
// bug in the gradle cmake plugin that always causes linking to occur, which is
// slow because LTO. So we dynamically decide whether to set tasks.cmakeBuild as
// a dependency depending on whether z3 appears to be built.
task buildZ3 {
    if (fileTree("build/cmake/z3").matching {
        include "*-*/libz3.so"
        include "*-*/libz3.dll"
        include "*-*/libz3.dylib"
        include "*-*/libz3java.so"
        include "*-*/libz3java.dll"
        include "*-*/libz3java.dylib"
    }.isEmpty()) {
        dependsOn(tasks.cmakeBuild)
    }
}

tasks.build.dependsOn(tasks.buildZ3)
buildExtension.dependsOn(tasks.buildZ3)
copyToLib.dependsOn(tasks.buildZ3)

project.getTasks().matching(
    (task)-> {
        task.getName().contains("cmakez3") || task.getName().contains("z3_");
    }
).configureEach(
    (task)-> {
        task.dependsOn(downloadAndUnzipZ3Source);
    }
);

task copyZ3(type: Copy) {
    from ("build/cmake/z3") {
        include "*-*/libz3.so"
        include "*-*/libz3.dll"
        include "*-*/libz3.dylib"
        include "*-*/libz3java.so"
        include "*-*/libz3java.dll"
        include "*-*/libz3java.dylib"

    }
    into "os/${ghidraPlatformName}"

    // https://stackoverflow.com/a/45635959
    // Flatten the hierarchy by setting the path
    // of all files to their respective basename
    eachFile {
      path = name
    }

    // Flattening the hierarchy leaves empty directories,
    // do not copy those
    includeEmptyDirs = false

    copyZ3.dependsOn(tasks.buildZ3)
    copyToLib.dependsOn(copyZ3)
}

// END: cmake z3 build section

}

// END

copyDependencies.dependsOn(copyToLib)
buildExtension.dependsOn(copyToLib)
compileJava.dependsOn(copyToLib)
indexHelp.dependsOn(copyToLib)
indexHelp.dependsOn(markdownToGhidraHtml)
buildHelp.dependsOn(markdownToGhidraHtml)
zipSource.dependsOn(markdownToGhidraHtml)
processResources.dependsOn(markdownToGhidraHtml)
markdownToGhidraHtml.sourceDir = file('docs/')
markdownToGhidraHtml.outputDir = file('src/main/help/help/topics/kaiju/')


task uninstallPreviousOOAnalyzerPlugin {

    group = "Installation"
    description = "Removes a previous OOAnalyzerPlugin installation, or notifies user of previous installation"
    
    doLast {
        
        // check if a previous OOAnalyzer installation exists
        if (file(ghidraInstallDir + '/Ghidra/Extensions/' + 'OOAnalyzerPlugin/').exists()) {
        
            // automatically remove past install if user specifies
            if (project.hasProperty('KAIJU_AUTO_REMOVE')) {
                //delete ghidraInstallDir + '/Ghidra/Extensions/' + 'OOAnalyzerPlugin/'
                def ooDir = new File(ghidraInstallDir + '/Ghidra/Extensions/' + 'OOAnalyzerPlugin/')
                ooDir.deleteDir()
                logger.quiet("SUCCESS! Previous standalone OOAnalyzerPlugin installation was removed automatically by gradle.")
            } else {
                throw new GradleException("FATAL ERROR! A previous installation of the standalone OOAnalyzerPlugin was detected. It is recommended that you either manually remove this installation before re-installing Kaiju, or re-run this gradle installation script with the -PKAIJU_AUTO_REMOVE option. Please note that the standalone plugin is now deprecated; we recommend you use the latest version included with Kaiju instead.")
            }
        }
    }
    
    outputs.upToDateWhen { false } // ensures never cached, always runs if user enables
    
    dependsOn buildExtension
}

task uninstallPreviousKaiju {

    group = "Installation"
    description = "Removes a previous Kaiju installation, or notifies user of previous installation"
    
    doLast {
    
        // check first if a previous Kaiju installation exists
        if (file(ghidraInstallDir + '/Ghidra/Extensions/' + 'kaiju/').exists()) {
        
            // automatically remove past install if user specifies
            if (project.hasProperty('KAIJU_AUTO_REMOVE')) {
                //delete ghidraInstallDir + '/Ghidra/Extensions/' + 'kaiju/'
                def kaijuDir = new File(ghidraInstallDir + '/Ghidra/Extensions/' + 'kaiju/')
                kaijuDir.deleteDir()
                logger.quiet("SUCCESS! Previous Kaiju installation was removed automatically by gradle.")
            } else {
                throw new GradleException("FATAL ERROR! A previous installation of Kaiju was detected. It is recommended that you either manually remove this installation before re-installing Kaiju, or re-run this gradle installation script with the -PKAIJU_AUTO_REMOVE option.")
            }
        }
    }
    
    outputs.upToDateWhen { false } // ensures never cached, always runs if user enables
    
    dependsOn uninstallPreviousOOAnalyzerPlugin
}

task copyZip(type: Copy) {

    group = "Installation"
    description = "Copies zip contents into special Extensions directory so user may enable or disable easily with reinstalling from gradle each time."

    from "${buildExtension.destinationDirectory}/${buildExtension.archiveBaseName}.${buildExtension.archiveExtension}"
    into ghidraInstallDir + '/Extensions/Ghidra'
    
    dependsOn uninstallPreviousKaiju
}

task installZip(type: Exec) {
    
    group = "Installation"
    description = "Installs the zip package in installed Ghidra's default extension directory"
    
    workingDir ghidraInstallDir + '/Ghidra/Extensions'
    commandLine 'unzip', '-o', "${buildExtension.destinationDirectory.getAsFile().get().getAbsolutePath()}/${buildExtension.archiveBaseName.get()}.${buildExtension.archiveExtension.get()}"
    
    dependsOn copyZip
    mustRunAfter copyZip
}

task install() {
     dependsOn installZip

     group = "Installation"
     description = "Alternate name for installZip task"
     //title = "Install zip"

     doLast {
        // Empty action list
        logger.quiet("Installed CERT Kaiju from zip!")
     }
}

testlogger {
    showPassedStandardStreams = false
    slowThreshold = 5000
}

test {

    def osDir = file("${ghidraInstallDir}/Ghidra/Extensions/kaiju/os/")

    // Automatically find the os dir names.
    def osDirNames =
        osDir.listFiles()
        .findAll { it.isDirectory() }
        .collect { file(osDir.name + "/" + it.name )}
        .join(':')

    jvmArgs = ['-Djava.awt.headless=true',
                // add-exports needed prior to Ghidra 10.3 to address sun.awt not exported in JDK 17+
                '--add-exports=java.desktop/sun.awt=ALL-UNNAMED',
                // add the kaiju os directories to load z3 library to run tests
                '-Djava.library.path=' + ghidraInstallDir + '/Ghidra/Extensions/kaiju/lib/:' + osDirNames]
    useJUnitPlatform()
    
    maxHeapSize = '2G'
    
    failFast = false
    
    // Use testlogger config/plugin instead.
    // testLogging {
    //     events "passed", "skipped", "failed"
    //     exceptionFormat = 'full'
    //     showStackTraces = true
    // }
    
    beforeSuite { descriptor ->
    // check that user has specified the property AND set it (not empty)
    if (!autocatsDir || autocatsDir == '') {
        throw new GradleException("FATAL ERROR! Kaiju requires specification of the directory where the AUTOCATS tests may be found. Please re-run the tests with the -PKAIJU_AUTOCATS_DIR=<path/to/autocats/dir> command option. Please consult the README.md for more information on AUTOCATS and how to obtain the AUTOCATS tests.")
    }
    
    // check that the specified directory actually exists
    if (!file(autocatsDir).exists()) {
        throw new GradleException("FATAL ERROR! The AUTOCATS path provided to Kaiju does not appear to exist. Please re-check the path then retry the -PKAIJU_AUTOCATS_DIR=<path/to/autocats/dir> command option. You may wish to provide the full absolute path to reduce errors. Please consult the README.md for more information on AUTOCATS and how to obtain the AUTOCATS tests.")
    }
    
    // TODO: how can we check if this path is actually an AUTOCATS path?
    // for now, just passing along the path and hoping for the best!
    }
    
    // only pass on the environment variable if was specified
    // this doesn't matter if it wasn't set, because the beforeSuite will execute
    // and abort if it wasn't set before running tests, and if you're not
    // running tests then it doesn't matter if it was set or not
    if (project.hasProperty('KAIJU_AUTOCATS_DIR')) {
        environment "KAIJU_AUTOCATS_DIR", project.property('KAIJU_AUTOCATS_DIR')
    }
    
    outputs.upToDateWhen { false } // ensures never cached, always runs if user enables
}