JEB

https://www.pnfsoftware.com/jeb/manual/
Admin
JEB is a reverse-engineering platform for disassembly, decompilation, debugging, and analysis of...
Tokens:46,654
Snippets:512
Trust Score:9.9
Update:7 months ago
Show doc for...
Tokens:
Raw
### Implement a basic JEB plugin entry point

Source: https://www.pnfsoftware.com/jeb/manual/dev/1-getting-started-with-parsers

Demonstrates the implementation of the IPlugin interface, which serves as the entry point for custom JEB plugins. The class must provide plugin information including name, description, author, and version.

```java
package com.jeb.sample;

import com.pnfsoftware.jeb.core.IPlugin;
import com.pnfsoftware.jeb.core.PluginInformation;
import com.pnfsoftware.jeb.core.Version;

public class SamplePlugin implements IPlugin {
    @Override
    public IPluginInformation getPluginInformation() {
        return new PluginInformation("Sample", "Description", "PNF Software", Version.create(1, 0));
    }
}
```

--------------------------------

### Install WebKitGTK for JEB Browser Support

Source: https://www.pnfsoftware.com/jeb/manual/faq

Instructions for identifying and installing the required WebKit2GTK package to enable browser-based pop-up overlays in the JEB GUI.

```bash
# find what version is available on your distro
apt-cache search libwebkit2gtk
# install the package (e.g. here, version 4.0.37)
sudo apt install libwebkit2gtk-4.0.37
```

--------------------------------

### JEB Network Proxy Configuration Examples

Source: https://www.pnfsoftware.com/jeb/manual/faq

These examples illustrate various formats for configuring network proxy settings within JEB configuration files. They cover HTTP and SOCKS proxies, with and without authentication, and include an option for whitelisting specific hosts.

```properties
.NetworkProxy = http|10.0.0.123|8080
```

```properties
.NetworkProxy = http|10.0.0.123|8080||
```

```properties
.NetworkProxy = http|10.0.0.123|8080|||
```

```properties
.NetworkProxy = http|10.0.0.123|8080|||*.pnfsoftware.com
```

```properties
.NetworkProxy = socks|proxy0.intranet.com|8088|user|pass|*.pnfsoftware.com
```

--------------------------------

### Native Debugger Command Example (GDB/LLDB)

Source: https://www.pnfsoftware.com/jeb/manual/android-debugging

Demonstrates issuing an 'info' command to the native debugger (gdbserver) when debugging a native process. This command retrieves basic target information, such as the architecture, process ID, and the debugger server being used.

```text
Process> info
Debuggee is running on ARM64 (LITTLE_ENDIAN)
Target process id: 19218
Target is being debugged by lldb-server
```

--------------------------------

### JEB Global Logging Example (Java)

Source: https://www.pnfsoftware.com/jeb/manual/dev/3-documents-delegation

This Java snippet demonstrates how to obtain and use JEB's global logging facility within a plugin. It shows the standard way to get an `ILogger` instance associated with a class using `GlobalLog.getLogger()`. This logger can then be used to send messages (e.g., `logger.catching(e)`) to the JEB Logger panel, aiding in debugging and code investigation. This is a common utility provided by the JEB framework.

```java
import com.pnfsoftware.jeb.util.logging.GlobalLog;
import com.pnfsoftware.jeb.util.logging.ILogger;

public class Xxx {
    private static final ILogger logger = GlobalLog.getLogger(Xxx.class);
    ...


```

--------------------------------

### Start JEB for Remote Debugging

Source: https://www.pnfsoftware.com/jeb/manual/dev/5-development-tips

Command-line instructions to launch JEB in a state that waits for a remote debugger connection on port 8001. Separate commands are provided for Windows/Linux and macOS.

```bash
# Windows/Linux
java -Xdebug -Xrunjdwp:transport=dt_socket,address=8001,server=y,suspend=y -jar bin/app/jeb.jar.jar
```

```bash
# macOS
java -XstartOnFirstThread -Xdebug -Xrunjdwp:transport=dt_socket,address=8001,server=y,suspend=y -jar bin/app/jeb.jar
```

--------------------------------

### Customize JEB Keyboard Shortcuts (Configuration)

Source: https://www.pnfsoftware.com/jeb/manual/settings

This configuration file allows users to customize keyboard shortcuts for JEB commands. Users should copy the template file and uncomment lines to define their preferred key bindings. It provides examples for remapping actions like 'jump'.

```cfg
#------------------------------------------------------------------------------
# JEB Custom Keyboard Shortcuts
#------------------------------------------------------------------------------

# 1) Rename or copy this file to jeb-shortcuts.cfg
# 2) Uncomment and add your own keyboard shortcuts for the actions for which you'd like to override the default shortcuts

# Example: by default, Jump is mapped to the 'G' key; the following line (minus the # character) can be used to remap the action to CTRL+J:
#jump=Ctrl+J

# *** CUSTOMIZABLE HANDLERS ***

#runScript=
#runLastScript=
#share=
...
```

--------------------------------

### Redirect JEB Controller Logs to File (Windows)

Source: https://www.pnfsoftware.com/jeb/manual/faq

This command demonstrates how to start a JEB Controller on Windows and redirect all INFO-level log output to rotating files. It specifies the log file name, minimum log level, maximum number of files, and maximum file size.

```batch
jeb_wincon.bat -c --controller --logfiles=controller.log,INFO,5,2
```

--------------------------------

### JavaScript Syntax Highlighting Example

Source: https://www.pnfsoftware.com/jeb/manual/dev/7-unit-interactivity

This JavaScript code snippet demonstrates a basic function structure, which serves as a foundation for implementing syntax highlighting. It's used to illustrate how keywords like 'function' can be identified and styled within the JEB editor.

```javascript
function a() {
  alert("a called");
}

```

--------------------------------

### Implement Unit Formatter for Text Document

Source: https://www.pnfsoftware.com/jeb/manual/dev/2-creating-simple-parser

Demonstrates overriding the getFormatter method to provide a custom IUnitFormatter. This example uses UnitFormatterAdapter with an AbstractUnitRepresentation to display raw JavaScript code using AsciiDocument.

```java
@Override
public IUnitFormatter getFormatter() {
    return new UnitFormatterAdapter(new AbstractUnitRepresentation("javascript raw code", true) {
        @Override
        public IGenericDocument getDocument() {
            return new AsciiDocument(getInput());
        }
    });
}
```

--------------------------------

### JNI Auto-Binding Example 1

Source: https://www.pnfsoftware.com/jeb/manual/android-debugging

Demonstrates the auto-binding process for a simple Java method signature to its corresponding JNI function name. Shows both the short form (class and method name) and the long form (including parameter types).

```text
void f(int x) in class com.xyz.A
=> short form: Java_com_xyz_A_f
=> long form: Java_com_xyz_A_f__I
```

--------------------------------

### JNI Auto-Binding Example 2 (Unicode and Array)

Source: https://www.pnfsoftware.com/jeb/manual/android-debugging

Provides an example of JNI auto-binding for a Java method with a Unicode class name and an array parameter. It illustrates how special characters and array types are mangled according to JNI specifications.

```text
void g(long array[], String s) in class com.\x4f60\x597d
=> short form: Java_com__04f60_0597d_g
=> long form: Java_com__04f60_0597d_g___3JLjava_lang_String_2
```

--------------------------------

### Check License Information via Command-Line (Windows)

Source: https://www.pnfsoftware.com/jeb/manual/faq

This command executes the JEB client on Windows with specific switches to display license information. It requires the JEB executable to be in the system's PATH or to be run from its installation directory.

```batch
jeb_wincon.bat -c --license

```

--------------------------------

### Identify Resource Parsing Errors

Source: https://www.pnfsoftware.com/jeb/manual/android

Example of aapt2 failing to parse an APK due to resource ID conflicts caused by non-standard arsc formatting.

```bash
aapt2 dump Facebook_v153.0.0.54.88.apk
```

--------------------------------

### C Implementation of a Java Native Method (JNI)

Source: https://www.pnfsoftware.com/jeb/manual/android-debugging

Example of the C/C++ implementation for a Java native method, following the JNI naming convention. The function name is derived from the Java class and method name, prefixed with 'Java_'. It takes JNIEnv and jobject as arguments.

```c
jstring Java_com_xyz_appcheck_AppCheck_getPlatform(JNIEnv* env, jobject thiz) {
    ...
}
```

--------------------------------

### Analyze Obfuscated Android Manifest

Source: https://www.pnfsoftware.com/jeb/manual/android

Example of an obfuscated AndroidManifest.xml where resource names have been stripped, followed by the use of aapt to inspect the underlying resource IDs.

```xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" :="1.1" android:versionCode="2" platformBuildVersionName="6.0-5078647" platformBuildVersionCode="23" package="com.virginoff.player">
    <uses-sdk :="7" :="23"/>
    <uses-permission :="android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission :="android.permission.SEND_SMS"/>
    <uses-permission :="android.permission.INTERNET"/>
    <uses-permission :="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission :="android.permission.WAKE_LOCK"/>
    <application :="@style/Theme.NoTitleBar.Fullscreen" :="Anal Sex Video" :="@drawable/ic_launcher" :=".Application" :="false">
        <activity :=".activity.WrapperActivity" :="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <activity :="o.ϟ" :="0" :="a0"/>
        <activity :="o.ȭ" :="0" :="a0"/>
        <service :="o.Ƃ"/>
    </application>
</manifest>
```

```bash
aapt dump xmltree 1.apk AndroidManifest.xml
```

--------------------------------

### Check for JEB Updates via Command Line

Source: https://www.pnfsoftware.com/jeb/manual/faq

This command allows users to check for available JEB software updates from the command line. After the update is downloaded, JEB should be executed normally to complete the installation.

```shell
$ <jeb_startup_script> -c --check-update
```

--------------------------------

### Java Native Method Declaration

Source: https://www.pnfsoftware.com/jeb/manual/android-debugging

Example of a Java class declaring a native method. The 'native' keyword indicates that the implementation of this method is provided in native code (e.g., C/C++). The System.loadLibrary call ensures the native library containing the implementation is loaded.

```java
package com.xyz.appcheck;

class AppCheck {
    static {
        System.loadLibrary("somelib");
    }
    ...
    String foo() {
        ...
        return getPlatform();
    }

    public native String getPlatform();
}
...
```

--------------------------------

### Define JavaScript Header for Detection

Source: https://www.pnfsoftware.com/jeb/manual/dev/2-creating-simple-parser

This Java code defines a byte array representing the header signature for JavaScript files. It's used within the `canIdentify` method to check if the input artifact starts with the expected '#Javascript' tag, enabling JEB to recognize and process JS files.

```java
private final static byte[] JS_HEADER = "#Javascript".getBytes();

@Override
public boolean canIdentify(IInput input, IUnitCreator parent) {
    return checkBytes(input, 0, JS_HEADER);
}
```

--------------------------------

### Mark Unit as Processed (Java)

Source: https://www.pnfsoftware.com/jeb/manual/dev/7-unit-interactivity

This Java code snippet provides a method to set a flag indicating that a unit has already been processed. This prevents redundant processing, which is crucial when manually triggering the process() method, as shown in the 'Force Notification Processing on Unit Creation' example.

```Java
setProcessed(true);
```

--------------------------------

### Create a Sample Unit using AbstractBinaryUnit

Source: https://www.pnfsoftware.com/jeb/manual/dev/2-creating-simple-parser

Shows how to create a custom unit by extending the AbstractBinaryUnit class. This is suitable for binary files and allows for specific initialization parameters, including null for the first argument.

```java
public class SampleUnit extends AbstractBinaryUnit {
    public SampleUnit(String name, IInput input, IUnitProcessor unitProcessor, IUnitCreator parent, IPropertyDefinitionManager pdm) {
        super(null, input, "js", name, unitProcessor, parent, pdm);
    }
}
```

--------------------------------

### Create a Sample Unit using AbstractUnit

Source: https://www.pnfsoftware.com/jeb/manual/dev/2-creating-simple-parser

Demonstrates how to create a custom unit by extending the AbstractUnit class. This unit overrides the process method to indicate completion and success. It requires standard unit dependencies in its constructor.

```java
public class SampleUnit extends AbstractUnit {
    public SampleUnit(String name, IInput input, IUnitProcessor unitProcessor, IUnitCreator parent, IPropertyDefinitionManager pdm) {
        super("js", name, unitProcessor, parent, pdm);
    }

    @Override
    public boolean process() {
        // indicates that the processing is already done: process won't be called again in future
        setProcessed(true);
        // default is false. True indicates that processing is successful.
        return true;
    }
}
```

--------------------------------

### Prepare Method for SampleUnit

Source: https://www.pnfsoftware.com/jeb/manual/dev/2-creating-simple-parser

Illustrates the caller method responsible for preparing and returning an instance of the SampleUnit. This method takes unit creation parameters and instantiates the custom unit.

```java
@Override
public IUnit prepare(String name, IInput input, IUnitProcessor unitProcessor, IUnitCreator parent) {
    return new SampleUnit(name, input, unitProcessor, parent, pdm);
}
```

--------------------------------

### Configure JEB UI Scaling for Linux

Source: https://www.pnfsoftware.com/jeb/manual/faq

Demonstrates how to adjust the high-DPI scaling factor for the JEB GUI on Linux by modifying the startup script with Java system properties.

```bash
"$JAVA" $JVMOPT -Dswt.autoScale=200 -jar "$BASEDIR/bin/app/jebc.jar" "$@"
```

--------------------------------

### Execute JEB Python Script from Command Line (Windows)

Source: https://www.pnfsoftware.com/jeb/manual/faq

This command shows how to run a JEB Python script from the command line on Windows. It requires a Pro or CE license and is used here to execute a sample 'Hello World' script located in the 'scripts/samples/' directory.

```shell
$ jeb_wincon.bat -c --script=scripts/samples/SampleScript.py
```

--------------------------------

### Implement IEnginesPlugin for JEB

Source: https://www.pnfsoftware.com/jeb/manual/dev/writing-engines-plugins

A skeleton implementation of the IEnginesPlugin interface. It demonstrates how to provide plugin metadata, define execution options, and handle the execution logic within the JEB environment.

```java
public class SampleEnginesPlugin implements IEnginesPlugin {
    private static final ILogger logger = GlobalLog.getLogger(SampleEnginesPlugin.class);

    @Override
    public IPluginInformation getPluginInformation() {
        return new PluginInformation("Sample Plugin", "A sample JEB plugin", "PNF Software", Version.create(1, 0));
    }

    @Override
    public List<? extends IOptionDefinition> getExecutionOptionDefinitions() {
        return null;
    }

    @Override
    public void execute(IEnginesContext context) {
        execute(context, null);
    }

    @Override
    public void execute(IEnginesContext engctx, Map<String, String> executionOptions) {
        logger.info("Executing sample plugin");
    }

    @Override
    public void dispose() {
    }
}
```

--------------------------------

### Sample JavaScript Code

Source: https://www.pnfsoftware.com/jeb/manual/dev/2-creating-simple-parser

This is a sample JavaScript code snippet that defines two simple functions, 'a' and 'b'. This code serves as the input for the parser being developed in the tutorial, demonstrating the structure that the parser aims to analyze and split.

```javascript
function a() {
  alert("a called");
}

function b() {
  var b = "b called";
  alert(b);
}
```

--------------------------------

### Implement a basic JEB client script

Source: https://www.pnfsoftware.com/jeb/manual/dev/writing-client-scripts

This snippet demonstrates the minimum requirements for a JEB script by implementing the IScript interface. The run method receives an IClientContext object, which provides access to environment details like the software version, arguments, and base directory.

```python
from com.pnfsoftware.jeb.client.api import IScript

class JEBSampleScript(IScript):
  def run(self, ctx):
    print('Hello, JEB version %s' % ctx.getSoftwareVersion())
    print('- Arguments: %s' % ctx.getArguments())
    print('- Base directory: %s' % ctx.getBaseDirectory())
```

--------------------------------

### Initialize and Use JEB Loggers

Source: https://www.pnfsoftware.com/jeb/manual/dev/5-development-tips

Demonstrates how to create a class-specific logger using GlobalLog and how to output formatted messages. It follows standard Java logging practices for the JEB API.

```java
private static final ILogger logger = GlobalLog.getLogger(MyClass.class);
logger.info("Hello %s", "World");
```

--------------------------------

### JEB Command-Line Client Skeleton (Java)

Source: https://www.pnfsoftware.com/jeb/manual/dev/writing-front-ends

A Java template for creating a command-line JEB client. It demonstrates initializing JEB, creating an engines context, processing files, and interacting with project units. Requires JEB Pro version 5.37+ and the JEB_HOME environment variable to be set.

```java
import java.io.File;

import com.pnfsoftware.jeb.core.JebCoreService;
import com.pnfsoftware.jeb.core.units.IUnit;
import com.pnfsoftware.jeb.util.base.Env;
import com.pnfsoftware.jeb.util.io.IO;
import com.pnfsoftware.jeb.util.logging.GlobalLog;
import com.pnfsoftware.jeb.util.logging.ILogger;

/**
 * Skeleton file for a custom JEB client. Requires JEB Pro version 5.37 or above.
 * <p>
 * This client assumes that an installation of JEB, with a valid license key, is pointed to by a
 * {@code JEB_HOME} environment variable.
 *
 */
public class JebCustomClientSample {
    static final ILogger logger = GlobalLog.getLogger(JebCustomClientSample.class);
    static {
        GlobalLog.addDestinationStream(System.out);
    }

    // provide a folder with files as the command-line argument
    public static void main(String[] args) throws Exception {
        if(args.length == 0) {
            throw new RuntimeException("Provide a directory for scanning as the first command-line argument");
        }

        var jebHome = Env.get("JEB_HOME");
        if(jebHome == null) {
            throw new RuntimeException("Set the JEB_HOME environment variable to point to your JEB folder");
        }

        // instantiate the JEB core service
        var jeb = JebCoreService.getInstance(new File(jebHome));

        // create an engines context (a container of JEB projects)
        var engctx = jeb.createEnginesContext();

        // scan some files
        var files = IO.listFiles(args[0]);
        int i = 0;
        for(var file: files) {
            i++;
            logger.info("Processing file %d/%d : %s ...", i, files.size(), file.getName());

            // create or load a project (artifact container)
            var prj = engctx.createProject("ProjectTest" + i);

            // process the artifact, get units
            var art = prj.processArtifact(file);

            // proceed with the units
            var units = art.getUnits();

            // work with the units
            for(IUnit unit: units) {
                logger.info("Unit: %s", unit);
                //
                // ... do some work
                //
            }

            engctx.unloadProject(prj.getKey());
        }

        // close our engines context
        jeb.closeEnginesContext(engctx);

        // close JEB
        jeb.close();
    }
}

```

--------------------------------

### Build and Package JEB Plugin with Apache Ant

Source: https://www.pnfsoftware.com/jeb/manual/dev/6-releasing-plugin

An XML-based Ant build script designed to automate the compilation and packaging of JEB plugins. It validates the environment, compiles Java source files against the JEB core library, and creates a JAR file with the necessary manifest attributes.

```xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<!-- Sample Ant build file used to build and package a JEB plugin.
- Requirements: set up the JEB_HOME environment variable to point to your
JEB installation folder.
- Customize the outfile, entryclass, extcp_build, and extcp_manifest properties. -->

<project basedir="." default="build" name="jebplugin">

    <fail message="Set the plugin version number: ant -Dversion=x.y.z">
      <condition>
        <not>
          <isset property="version"/>
        </not>
      </condition>
    </fail>

    <echo message="Plugin version: ${version}"/>

    <property environment="env"/>
    <echo message="JEB_HOME: ${env.JEB_HOME}"/>

    <property name="jebjar" value="${env.JEB_HOME}/bin/cl/jeb.jar"/>
    <echo message="JEB Core expected at location: ${jebjar}"/>

    <fail message="Please set JEB_HOME environment variable to point to your JEB installation folder">
      <condition>
        <not>
          <available file="${jebjar}"/>
        </not>
      </condition>
    </fail>

    <property name="debuglevel" value="source,lines,vars"/>
    <property name="target" value="1.7"/>
    <property name="source" value="1.7"/>

    <!-- Mandatory properties -->
    <property name="outfile" value="CUSTOMIZE"/>
    <property name="entryclass" value="CUSTOMIZE"/>
    <!-- External libraries, for build process (semi-colon separated) -->
    <property name="extcp_build" value=""/>
    <!-- External libraries, for Manifest (space separated) -->
    <property name="extcp_manifest" value=""/>

    <target name="build" depends="clean,compile,package"/>
    <target name="audit" depends="clean,compile-audit"/>

    <target name="clean">
        <delete dir="bin"/>
        <mkdir dir="bin"/>
    </target>

    <target name="compile">
        <delete dir="bin"/>
        <mkdir dir="bin"/>
        <javac debug="true" debuglevel="${debuglevel}" destdir="bin"
               includeantruntime="false" source="${source}" target="${target}" encoding="UTF-8">
            <src path="src/main/java"/>
            <classpath>
                <pathelement location="${jebjar}"/>
                <pathelement path="${extcp_build}"/>
            </classpath>
        </javac>
    </target>

    <target name="package">
        <delete file="${outfile}"/>
        <jar destfile="${outfile}">
            <manifest>
                <attribute name="Class-Path" value="${extcp_manifest}"/>
                <attribute name="JebPlugin-entryclass" value="${entryclass}"/>
                <attribute name="JebPlugin-version" value="${version}"/>
            </manifest>
            <fileset dir="bin"/>
            <!-- copy resources -->
            <fileset dir="src/main/java" excludes="**/*.java"/>
            <fileset dir="." includes="README.md"/>
        </jar>
    </target>

</project>
```

--------------------------------

### Execute JEB GUI Client via Command Line

Source: https://www.pnfsoftware.com/jeb/manual/faq

Directly execute the JEB GUI client JAR file using the Java runtime. This is useful for debugging or bypassing standard launcher scripts.

```bash
java -jar bin/app/jebc.jar
```

--------------------------------

### Create a Static Table Document in JEB

Source: https://www.pnfsoftware.com/jeb/manual/dev/4-tables-trees

Demonstrates how to instantiate a StaticTableDocument with defined headers and rows. This approach is suitable for displaying small, simple datasets within a JEB plugin.

```java
private ITableDocument getStatisticsTable() {
    List<TableRow> rows = new ArrayList<>();
    rows.add(new TableRow(new Cell("Length"), new Cell(Integer.toString(root.getLength()))));
    rows.add(new TableRow(new Cell("Type"), new Cell(Integer.toString(root.getType()))));
    return new StaticTableDocument(Arrays.asList("Property", "Value"), rows);
}
```

--------------------------------

### Enable External Plugins (MIPS64)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

A boolean setting to enable external plugins like custom IR/AST optimizers. If disabled, user-made Java/Python plugins will not be instantiated. Defaults to true.

```text
EnableExternalPlugins = false
```

--------------------------------

### Configure Decryptor Support (MIPS64)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Enables support for generic, emulator-backed decryption, which aids optimizers in complex code cleaning. Options are Disabled (0) and Enabled (1). Defaults to Enabled.

```text
DecryptorSupport = 0
```

--------------------------------

### Delegate Unit Processing for FunctionNodes in JEB

Source: https://www.pnfsoftware.com/jeb/manual/dev/3-documents-delegation

This snippet demonstrates how to iterate through AST nodes, identify function definitions, and delegate the processing of those functions to the JEB Unit Processor. It creates new child units for each identified function, allowing for modular parsing of complex file formats.

```java
// save functions
List<AstNode> statements = root.getStatements();
for(AstNode statement: statements) {
        if(statement.getType() == Token.FUNCTION) {
            FunctionNode function = (FunctionNode)statement;
            functions.add(function);
            IUnit jsUnit = getUnitProcessor().process(function.getName(), new BytesInput(function.toSource().getBytes()), this);
            if(jsUnit != null) {
                addChildUnit(jsUnit);
            }
        }
}
```

--------------------------------

### Execute JEB Python Script from Command Line (Linux)

Source: https://www.pnfsoftware.com/jeb/manual/faq

This command demonstrates how to execute a JEB Python script from the command line on Linux systems. It requires a Pro or CE license and allows passing script arguments. The script path and any arguments are specified after the '--' separator.

```shell
$ jeb_linux.sh -c --script=SCRIPT_PATH -- SCRIPT_ARG1 SCRIPT_ARG2 ...
```

--------------------------------

### Select Structurer Version (MIPS)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Specifies the version of the structurer to use. Version 0 uses default structuring algorithms. Accepts integers from 0 to 3, with a default of 3.

```text
StructurerUseVersion = 1
```

--------------------------------

### Ant Build File for JEB Plugin Packaging

Source: https://www.pnfsoftware.com/jeb/manual/dev/6-releasing-plugin

This Ant build script (`build.xml`) is used to compile and package a JEB plugin into a JAR file. It defines properties for JEB JAR path, output file, entry class, and external libraries. The script includes targets for compiling the Java source code and packaging the compiled classes and resources into a JAR with a manifest file.

```xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<project basedir="." default="build" name="jebplugin">
    <property name="jebjar" value="${env.JEB_HOME}/bin/cl/jeb.jar"/>
    <property name="jebpath" value="/home/clucas/jeb-2.0.6.201508260620/bin/cl/jeb.jar"/>
    <property name="outfile" value="out/JebJavascriptPlugin.jar"/>
    <property name="entryclass" value="com.jeb.sample.JavascriptPlugin"/>

    <property name="extcp_build" value="lib/js.jar"/>
    <property name="extcp_manifest" value="lib/js.jar"/>

    <target name="build" depends="compile,package"/>

    <target name="compile">
        <delete dir="bin"/>
        <mkdir dir="bin"/>
        <javac debug="true" debuglevel="source,lines,vars"
               destdir="bin" includeantruntime="false" source="1.7" target="1.7">
            <src path="src"/>
            <classpath>
                <pathelement location="${jebpath}"/>
                <pathelement path="${extcp_build}"/>
            </classpath>
        </javac>
    </target>

    <target name="package">
        <delete file="${outfile}"/>
        <jar destfile="${outfile}">
            <manifest>
                <attribute name="Class-Path" value="${extcp_manifest}"/>
                <attribute name="JebPlugin-entryclass" value="${entryclass}"/>
            </manifest>
            <fileset dir="bin"/>
            <fileset dir="." includes="README.md"/>
        </jar>
    </target>

</project>

```

--------------------------------

### Add Document Presentations for Each Function (Java)

Source: https://www.pnfsoftware.com/jeb/manual/dev/3-documents-delegation

This Java code snippet modifies the `getFormatter()` method in a JEB plugin unit. It utilizes `UnitFormatterAdapter` to create multiple document presentations. For each extracted `FunctionNode`, it adds a new presentation with the function's name as the tab title. The content of each tab is the source code of the respective function, presented as an `AsciiDocument` using `BytesInput`. This requires the `functions` list to be populated by the `process()` method.

```java
@Override
public IUnitFormatter getFormatter() {
    UnitFormatterAdapter adapter = new UnitFormatterAdapter(new AbstractUnitRepresentation("javascript raw code", true) {
        @Override
        public IGenericDocument getDocument() {
                return new AsciiDocument(getInput());
        }
    });
    if(functions != null) {
        for(final FunctionNode function: functions) {
            adapter.addDocumentPresentation(new AbstractUnitRepresentation(function.getName()) {
                @Override
                public IGenericDocument getDocument() {
                    return new AsciiDocument(new BytesInput(function.toSource().getBytes()));
                }
            });
        }
    }
    return adapter;
}

```

--------------------------------

### Upgrade GTK Libraries on Ubuntu 16.04

Source: https://www.pnfsoftware.com/jeb/manual/faq

Provides commands to upgrade GTK libraries via PPA repositories to meet the minimum requirements for modern JEB UI frameworks.

```bash
sudo add-apt-repository ppa:gnome3-team/gnome3-staging
sudo add-apt-repository ppa:gnome3-team/gnome3
sudo apt update
sudo apt upgrade
```

--------------------------------

### MIPS Analysis and Signature Loading

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Configure signature package loading and analysis styles for MIPS code.

```APIDOC
## MIPS Analysis and Signature Loading

### Description
Settings related to how signature packages are loaded and how different analysis styles are applied to MIPS code.

### Parameters
#### Query Parameters
- **.parsers.native.disas.mips.SignaturePackagesLoading** (Selection) - Optional - Select how signature packages are loaded. Options: `Disabled(0)`, `Manual(1)`, `Automatic(2)`. Default: `2`.
- **.parsers.native.disas.mips.SwitchAnalysisStyle** (Selection) - Optional - Search for possible switch statements at assembly level. Options: `Automatic(-1)`, `Disabled(0)`, `Safe heuristics only(1)`, `Aggressive heuristics(2)`. Default: `-1`.
- **.parsers.native.disas.mips.TailCallAnalysisStyle** (Selection) - Optional - Search for possible tail calls optimized as branches, and build proper routines. Options: `Automatic(-1)`, `Disabled(0)`, `Safe heuristics only(1)`, `Aggressive heuristics(2)`. Default: `-1`.
- **.parsers.native.disas.mips.UseTypeLibraries** (Boolean) - Optional - Use native type libraries (e.g. win32, libc, etc.). Default: `true`.
```

--------------------------------

### Redirect Logging to File

Source: https://www.pnfsoftware.com/jeb/manual/dev/5-development-tips

Configures the GlobalLog factory to output logs to a specific file in the system temporary directory. This is useful for persistent log collection during plugin development.

```java
String foldername = System.getProperty("java.io.tmpdir");
File folder = foldername != null ? new File(foldername): TestData.getTestDataRoot();
File file = new File(folder, "jeb-test-output.log");
GlobalLog.addDestinationStream(new PrintStream(file));
```

--------------------------------

### Accessing Dex Units and Method Signatures

Source: https://www.pnfsoftware.com/jeb/manual/dev/android-scripting

This script demonstrates how to locate the primary IDexUnit within a JEB project and iterate through all methods to print their signatures. It requires a loaded project and is intended for execution within the JEB environment.

```Python
from com.pnfsoftware.jeb.client.api import IScript
from com.pnfsoftware.jeb.core.units.code.android import IDexUnit, IApkUnit

class SomeScript(IScript):
  def run(self, ctx):
    prj = ctx.getMainProject()  # current project; None if no project is opened
    dex = prj.findUnit(IDexUnit)  # find the first dex unit
    for m in dex.getMethods():
      print m.getSignature()  # print method reference descriptor
```

--------------------------------

### MIPS64 Advanced Analysis and Display

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Configure advanced analysis options and display settings for MIPS64 architecture.

```APIDOC
## MIPS64 Advanced Analysis and Display

### Description
Configuration options for advanced analysis passes and display settings specific to the MIPS64 architecture.

### Parameters
#### Query Parameters
- **.parsers.native.disas.mips64.AdvancedAnalysis** (Selection) - Optional - The advanced analysis is an optional pass that comes after the initial (standard) analysis. Options: `Disabled(0)`, `Only For Small Binaries(1)`, `Always(2)`. Default: `0`.
- **.parsers.native.disas.mips64.AnalysisStyle** (Selection) - Optional - N/A. Options: `Conservative(0)`, `Automatic(1)`, `Aggressive(2)`, `Lazy(3)`, `Lazy no data(4)`. Default: `1`.
- **.parsers.native.disas.mips64.ApplyAndroidNativePrototypes** (Boolean) - Optional - Generate and apply prototypes for native methods which are the implementations of Java Native abstract methods. Default: `true`.
- **.parsers.native.disas.mips64.BlockXrefsCount** (Integer) - Optional - Maximum number of cross-references displayed at any address. Default: `50`.
- **.parsers.native.disas.mips64.CharBreak64BitAddresses** (String) - Optional - If not empty, the address column will display 64-bit addresses as two 8-hexdigit parts, separated by the provided character string. Default: `"`.
- **.parsers.native.disas.mips64.CompilerIdentification** (Selection) - Optional - N/A. Options: `Automatic(0)`, `Unknown compiler(1)`, `Generic Linux compiler(2)`, `Android ART(3)`, `Android NDK(4)`, `Generic Windows compiler(5)`, `Microsoft Visual C++(6)`. Default: `0`.
- **.parsers.native.disas.mips64.CreatePackagesFromRoutineNames** (Boolean) - Optional - Automatically create packages from native method names; for example 'std::foo::bar' method will be moved to package 'std::foo' and renamed 'bar'. Default: `true`.
```

--------------------------------

### Resolve Resource IDs via Framework Dump

Source: https://www.pnfsoftware.com/jeb/manual/android

Using aapt to dump framework resources to map obfuscated IDs back to their original attribute names.

```bash
aapt dump --values resources ~/.jeb-android-frameworks/1.apk
```

--------------------------------

### Manage Disabled External Plugins (MIPS64)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Specifies a comma-separated list of decompiler plugins to be disabled. By default, all plugins are enabled. This setting is a string.

```text
ListOfDisabledExternalPlugins = "pluginA,pluginB"
```

--------------------------------

### Enable Unsafe Optimizers (MIPS64)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

A boolean setting to allow unsafe optimizers to run. These optimizers may make assumptions about program state and modify it. Defaults to true.

```text
EnableUnsafeOptimizers = false
```

--------------------------------

### Register Native Methods using JNI

Source: https://www.pnfsoftware.com/jeb/manual/android-debugging

Demonstrates how to manually bind native C/C++ functions to Java methods using the RegisterNatives JNI function. This approach bypasses standard naming conventions and is typically invoked during the JNI_OnLoad lifecycle event.

```C++
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
    JNIEnv* env = NULL;
    if(vm->GetEnv(&env, JNI_VERSION_1_4) != JNI_OK) {
        return -1;
    }
    if(registerNatives(env) != JNI_TRUE) {
        return -1;
    }
    return JNI_VERSION_1_4;
}

int registerNatives(JNIEnv* env) {
    if(!registerNativeMethods(env, classPathName, methods, sizeof(methods) / sizeof(methods[0]))) {
        return JNI_FALSE;
    }
    return JNI_TRUE;
}

int registerNativeMethods(JNIEnv* env, const char* className, JNINativeMethod* gMethods, int numMethods) {
    jclass clazz = env->FindClass(className);
    if(clazz == NULL) {
        return JNI_FALSE;
    }
    if(env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
        return JNI_FALSE;
    }
    return JNI_TRUE;
}

static const char *classPathName = "a/b/c/Foo";
static JNINativeMethod methods[] = {
        {"methodX", "()V", (void*)routineX},
};

// bound to Java method: a.b.c.Foo.methodX()V
static jint JNICALL routineX(JNIEnv* env, jobject thiz, jint a, jint b, jint c) {
    //...
}
```

--------------------------------

### Manage Disabled External Plugins (MIPS)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Specifies a comma-separated list of decompiler plugins to be disabled. By default, all plugins are enabled. This setting is a string.

```text
ListOfDisabledExternalPlugins = "plugin1,plugin2"
```

--------------------------------

### Enable Deobfuscators (MIPS64)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

A boolean setting to allow deobfuscators to run. Deobfuscators simplify code intentionally complicated by obfuscation tools. Defaults to true.

```text
EnableDeobfuscators = false
```

--------------------------------

### Force Notification Processing on Unit Creation (Java)

Source: https://www.pnfsoftware.com/jeb/manual/dev/7-unit-interactivity

This Java code snippet shows how to ensure that notifications are processed immediately when a unit is created, rather than waiting for the process() method to be called later. This is useful for displaying all notifications as soon as a file is opened in JEB.

```Java
public IUnit prepare(String name, IInput input, IUnitProcessor unitProcessor, IUnitCreator parent) {
    IUnit sampleUnit = new SampleUnit(name, input, unitProcessor, parent, pdm);
    sampleUnit.process(); // forces children calculation
    return sampleUnit;
}
```

--------------------------------

### Manage Breakpoints in JEB VM

Source: https://www.pnfsoftware.com/jeb/manual/android-debugging

Commands to list, add, and clear breakpoints on bytecode or fields. The 'b' command displays or adds breakpoints, while 'bc' removes specific or all breakpoints.

```JEB CLI
VM> b
VM> b Lcom/xyz/appcheck/AppCheck;->runTest(Lcom/xyz/appcheck/TestId;)Z+21Ah
VM> bc 5
VM> bc
```

--------------------------------

### Provide Default Constructor for JEB Plugin

Source: https://www.pnfsoftware.com/jeb/manual/dev/2-creating-simple-parser

This Java code snippet provides the required public no-argument constructor for a JEB plugin class. JEB requires this constructor to instantiate plugin classes, and it's essential for avoiding errors like 'Unit plugin class ... must have a public no-argument constructor'.

```java
public SamplePlugin() {
    super("Javascript", 0);
}
```

--------------------------------

### Configure Java Security Manager for JEB (JDK 17+)

Source: https://www.pnfsoftware.com/jeb/manual/faq

This configuration is used to address warnings related to the deprecated Java SecurityManager when using JEB with JDK 17 or later. It involves adding a specific option to the jvmopt.txt file.

```text
-Djava.security.manager=allow
```

--------------------------------

### Interact with JEB via Python Interpreter

Source: https://www.pnfsoftware.com/jeb/manual/dev/introducing-jeb-extensions

Demonstrates how to use the interactive Python terminal within the JEB GUI to access the IClientContext, retrieve project information, and query DEX units.

```python
py> jeb.getSoftwareVersion()
5.19.0.202410222128
py> prj = jeb.getMainProject()
py> dex = prj.findUnit(IDexUnit)
py> print dex
Unit:name={af559961_classes4.dex},type={dex}
py> print dex.getMethods()
[Method:#0,name=<init>,address=Landroid/animation/AnimatorListenerAdapter;-><init>()V, ...]
```

--------------------------------

### Create a Static Tree Document in JEB

Source: https://www.pnfsoftware.com/jeb/manual/dev/4-tables-trees

Shows how to construct a hierarchical view using StaticTreeDocument and recursive Node objects. This is useful for displaying nested data structures like function parameters.

```java
private ITreeDocument getFunctionsTree() {
    List<Node> treeRoot = new ArrayList<>();
    try {
        if(functions != null) {
            for(FunctionNode function: functions) {
                treeRoot.add(buildFunctionNode(function));
            }
        }
    }
    catch(Exception e) {
        logger.catching(e);
    }
    return new StaticTreeDocument(treeRoot);
}

private Node buildFunctionNode(FunctionNode function) {
    Node functionNode = new Node(function.getName());
    if(function.getParamCount() > 0) {
        for(AstNode var: function.getParams()) {
            functionNode.addChild(new Node(((Name)var).getIdentifier()));
        }
    }
    return functionNode;
}
```

--------------------------------

### Parse and Extract JavaScript Functions (Java)

Source: https://www.pnfsoftware.com/jeb/manual/dev/3-documents-delegation

This Java code snippet implements the `process()` method for a JEB plugin unit. It parses a JavaScript input stream using Mozilla Rhino's IRFactory to create an Abstract Syntax Tree (AST). It then iterates through the AST's statements to identify and save FunctionNode objects into a list. Dependencies include Mozilla Rhino's JAR and JEB's core libraries. Input is an `InputStream` from `getInput()`, and output is a list of `FunctionNode` objects.

```java
private static final ILogger logger = GlobalLog.getLogger(SampleUnit.class);

private AstRoot root = null;
private List<FunctionNode> functions = new ArrayList<FunctionNode>();

@Override
public boolean process() {
    // parse the javascript
    IRFactory factory = new IRFactory();
    try {
        BufferedReader reader = new BufferedReader(new InputStreamReader(getInput().getStream()));
        reader.readLine(); // ignore first line with #Javascript
        root = factory.parse(reader, null, 0);
    }
    catch(IOException e) {
        logger.catching(e);
        return false;
    }

    // save functions
    List<AstNode> statements = root.getStatements();
    for(AstNode statement: statements) {
        if(statement.getType() == Token.FUNCTION) {
            functions.add((FunctionNode)statement);
        }
    }

    // done
    setProcessed(true);
    return true;
}

```

--------------------------------

### Control Spacing of Compounds (MIPS)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

A boolean setting to determine whether blank lines should be inserted between compounds. Defaults to true.

```text
SpaceOutCompounds = false
```

--------------------------------

### MIPS64 Calling Convention

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Set the default calling convention for MIPS64 analysis.

```APIDOC
## MIPS64 Calling Convention

### Description
Specifies the default calling convention to be used for MIPS64 analysis. Leaving it unknown allows for automatic detection.

### Parameters
#### Query Parameters
- **.parsers.native.disas.mips64.CallingConvention** (Selection) - Optional - Default calling convention to use. Options: `__unknown(0)`, `__cdecl(1)`, `__stdcall(2)`, `__fastcall(3)`, `__thiscall(4)`, `__vectorcall(5)`, `__a32(6)`, `aapcs64(7)`, `__o32(8)`, `__n32(9)`, `__n64(10)`, `__sysv_abi(11)`, `__a32_hf(12)`. Default: `0`.
```

--------------------------------

### MIPS Segment Header Formatting

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Configure how segment headers are displayed, including indentation, separators, and separator length.

```APIDOC
## MIPS Segment Header Configuration

### Description
Configuration options for formatting segment headers in the MIPS disassembler.

### Parameters
#### Query Parameters
- **.parsers.native.disas.mips.SegmentHeadersIndentABL** (Boolean) - Optional - Indent Segment Header using (address / byte / label) length. Default: `false`.
- **.parsers.native.disas.mips.SegmentHeadersSeparator** (String) - Optional - Segment Header character separator. Default: `.`.
- **.parsers.native.disas.mips.SegmentHeadersSeparatorLength** (Integer) - Optional - Number of characters used to build the line in Segment Header. Default: `80`.
- **.parsers.native.disas.mips.SegmentHeadersSeparatorLengthABL** (Boolean) - Optional - Use prefix (address / byte / label) length for the Segment Header separator. Default: `true`.
```

--------------------------------

### Configure Memory Resolution Policy (MIPS64)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Sets the policy for how the memory resolver handles memory dereferences. This is an integer value, with a default of 3.

```text
MemoryResolutionPolicy = 2
```

--------------------------------

### Prepare String Renaming Action in JEB Plugin

Source: https://www.pnfsoftware.com/jeb/manual/dev/8-more-interactivity

This Java code snippet shows the `prepareExecution` method for a JEB plugin's rename action. It checks if the action is RENAME, retrieves a StringLiteral at the current address, and sets its current name in `ActionRenameData` to prefill the rename dialog. It returns true to continue execution if successful, false otherwise.

```java
public boolean prepareExecution(ActionContext actionContext, IActionData actionData) {
    if(actionContext.getActionId() == Actions.RENAME) {
        StringLiteral string = getElementAt(actionContext.getAddress(), strings);
        if(string != null) {
            ((ActionRenameData)actionData).setCurrentName(string.getValue());
            return true;
        }
    }
    return false;
}
```

--------------------------------

### Configure JEB Emulator with Java Security Manager (JDK 18-23)

Source: https://www.pnfsoftware.com/jeb/manual/faq

This configuration enhances the JEB Dex decompiler's emulator functionality for JDK versions 18 through 23. It requires adding two options to the jvmopt.txt file.

```text
-Djava.security.manager=allow --add-opens java.base/java.lang=ALL-UNNAMED
```

--------------------------------

### Add Notification for 'alert' in JavaScript Plugin (Java)

Source: https://www.pnfsoftware.com/jeb/manual/dev/7-unit-interactivity

This Java code snippet, intended for a JavaScript plugin's process() method, demonstrates how to traverse the Abstract Syntax Tree (AST) of a JavaScript file. It identifies calls to the 'alert' function and adds a notification to highlight these potentially harmful calls.

```Java
root.visit(new NodeVisitor() {
    @Override
    public boolean visit(AstNode node) {
        switch(node.getType()) {
        case Token.EXPR_VOID:
        case Token.EXPR_RESULT:
            break;
        case Token.CALL:
            visitTarget(((FunctionCall)node).getTarget());
            break;
        default:
            break;
        }
    return true;
    }

    private void visitTarget(AstNode target) {
        if(target.getType() == Token.NAME) {
            if(((Name)target).getIdentifier().equals("alert")) {
                // Add notification
                addNotification(new UnitNotification(NotificationType.POTENTIALLY_HARMFUL,
                        String.format("alert is detected at position %d", target.getAbsolutePosition())));
            }
        }
    }
});
```

--------------------------------

### MIPS Display Options

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

Control the display of addresses, bytes, routine headers, segment headers, and spacing between blocks.

```APIDOC
## MIPS Display Options

### Description
Options to control the visibility and formatting of various elements during MIPS disassembly.

### Parameters
#### Query Parameters
- **.parsers.native.disas.mips.ShowAddresses** (Boolean) - Optional - Display addresses of items. Default: `true`.
- **.parsers.native.disas.mips.ShowBytesCount** (Integer) - Optional - Maximum count of instruction bytes to be displayed before the instruction. Default: `0`.
- **.parsers.native.disas.mips.ShowRoutineHeaders** (Boolean) - Optional - Display the routine headers and footers. Default: `true`.
- **.parsers.native.disas.mips.ShowSegmentHeaders** (Boolean) - Optional - Display the segment or section headers. Default: `true`.
- **.parsers.native.disas.mips.ShowSpaceBetweenBlocks** (Boolean) - Optional - Insert blank lines between basic blocks. Default: `false`.
```

--------------------------------

### Accessing APK Units and Debuggable Status

Source: https://www.pnfsoftware.com/jeb/manual/dev/android-scripting

This script retrieves the IApkUnit from the current project to determine if the application is marked as debuggable. It utilizes the JEB client API to interact with the loaded APK structure.

```Python
from com.pnfsoftware.jeb.client.api import IScript
from com.pnfsoftware.jeb.core.units.code.android import IApkUnit

class SomeScript(IScript):
  def run(self, ctx):
    prj = ctx.getMainProject()  # current project; None if no project is opened
    apk = prj.findUnits(IApkUnit)  # find the first apk unit
    print(apk.isDebuggable())
```

--------------------------------

### Enable Well-Known Literals (MIPS)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

A boolean setting to generate constants using well-known literals instead of raw immediate values whenever possible. Defaults to true.

```text
UseWellKnownLiterals = false
```

--------------------------------

### Enable Friendly Variable Names (MIPS)

Source: https://www.pnfsoftware.com/jeb/manual/engines-configuration

A boolean setting to enable the generation of more descriptive variable names, potentially using types or dictionaries. Defaults to true.

```text
UseFriendlyVariableNames = false
```
Tokens:
Raw