# IPED Project Dependencies: A Complete Guide to the Maven Module Architecture

> Explore the IPED project dependencies organized in a Maven module architecture. Understand how parent POM and individual modules manage libraries for logging testing facades compression UI and parsing.

- Repository: [Serviço de Perícias em Informática/IPED](https://github.com/sepinf-inc/IPED)
- Tags: api-reference
- Published: 2026-03-11

---

**The IPED project dependencies are managed through a hierarchical Maven structure where the parent POM defines core logging, testing, and facade libraries, while individual modules like `iped-utils`, `iped-app`, and `iped-parsers` declare specialized dependencies for compression, UI components, and forensic parsing.**

The `sepinf-inc/IPED` repository implements a modular Java architecture for digital forensic analysis, with dependency management centralized in a parent Maven POM that coordinates specialized libraries across functional modules. Understanding the complete dependency landscape requires examining both the global configuration in [[`pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/pom.xml) and the module-specific declarations that enable targeted evidence processing capabilities.

## Core Dependencies in the Parent POM

The parent POM establishes the foundation for all IPED project dependencies through centralized property management and shared library versions. Located at [[`pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/pom.xml) (lines 76-106)](https://github.com/sepinf-inc/IPED/blob/master/pom.xml#L76-L106), this configuration defines four critical dependency categories:

- **Logging**: `log4j-api`, `log4j-core`, `log4j-web`, and `log4j-slf4j-impl` provide structured logging with SLF4J bridging
- **Facade**: `slf4j-api` and `jul-to-slf4j` create a uniform logging API across modules
- **Testing**: `junit` and `hamcrest` supply the unit-test framework
- **Version Management**: Properties like `log4j.version`, `slf4j.version`, `junit.version`, and `hamcrest.version` ensure consistent versioning across the entire project

## Module-Specific Dependency Extensions

While the parent POM provides the baseline, individual modules extend the IPED dependencies with domain-specific libraries required for their specialized functions.

### iped-utils Dependencies

The `iped-utils` module adds low-level utility libraries declared in [[`iped-utils/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-utils/pom.xml) (lines 13-38)](https://github.com/sepinf-inc/IPED/blob/master/iped-utils/pom.xml#L13-L38):

- **`lz4`**: High-performance compression for forensic data processing
- **`commons-codec`**: Encoding utilities for cryptographic operations
- **`caffeine`**: High-performance caching for frequently accessed data

### iped-app Dependencies

The application layer in `iped-app` incorporates user interface and command-line libraries defined in [[`iped-app/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-app/pom.xml) (lines 20-55)](https://github.com/sepinf-inc/IPED/blob/master/iped-app/pom.xml#L20-L55):

- **`jcommander`**: Annotation-based command-line argument parsing
- **`docking-frames-common`**: Advanced Swing UI docking management
- **`kharon`**: Specialized forensic visualization components
- **`jcalendar`**: Date selection widgets for temporal filtering
- **`jfreechartextensions`**: Extended charting capabilities for evidence analytics

### iped-parsers and Forensic Libraries

The `iped-parsers` module implements file format detection and text extraction through a specialized dependency chain including **Apache Tika**, **PDFBox**, **Lucene**, **SleuthKit**, and **LibreOffice** integrations. These dependencies enable deep content inspection across hundreds of file formats critical to forensic investigation.

### Additional Module Dependencies

- **`iped-carvers`**: Depends on `ahocorasick` for efficient pattern matching during artifact carving
- **`iped-geo`**: Incorporates GeoTools and related geolocation libraries for spatial evidence analysis
- **`iped-engine`**: Manages core processing workflows, hash-database interactions, and web API support

## How the Maven Dependency Hierarchy Works

The IPED project dependencies follow a strict three-tier inheritance model:

1. **Parent POM (`iped-parent`)**: Establishes global properties, repositories, and the universal dependency list in [[`pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/pom.xml)

2. **Module Inheritance**: Each submodule references the parent via `<parent>...</parent>` tags, automatically inheriting logging and testing configurations

3. **Selective Extension**: Modules add specific `<dependency>` entries in their local [`pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/pom.xml) files, optionally overriding parent version properties when newer releases are required

Maven resolves the **effective POM** by merging parent definitions with child specifications, ensuring consistent logging and testing stacks while permitting specialized tool integration.

## Practical Usage Examples

### Integrating IPED as a Maven Dependency

Add the core engine to your project by referencing the `iped-engine` artifact:

```xml
<dependency>
    <groupId>iped</groupId>
    <artifactId>iped-engine</artifactId>
    <version>4.4.0-SNAPSHOT</version>
</dependency>

```

This declaration pulls the core processing engine together with the parent-defined logging and test libraries.

### Implementing Logging with SLF4J

The SLF4J facade routes to Log4j2 through the `log4j-slf4j-impl` bridge defined in the parent POM:

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyProcessor {
    private static final Logger log = LoggerFactory.getLogger(MyProcessor.class);

    public void run() {
        log.info("Processing started");
        // Forensic processing logic here
        log.debug("Processing finished");
    }
}

```

### Compressing Data with LZ4

The `iped-utils` module exposes the LZ4 library for fast compression of forensic artifacts:

```java
import net.jpountz.lz4.*;

byte[] original = // raw forensic data
LZ4Factory factory = LZ4Factory.fastestInstance();
LZ4Compressor compressor = factory.fastCompressor();

int maxCompressedLength = compressor.maxCompressedLength(original.length);
byte[] compressed = new byte[maxCompressedLength];
int compressedSize = compressor.compress(original, 0, original.length, compressed, 0);

```

### Parsing Command-Line Arguments with JCommander

The `iped-app` module utilizes JCommander for type-safe CLI parsing:

```java
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;

public class MainArgs {
    @Parameter(names = {"-i", "--input"}, description = "Path to case folder", required = true)
    private String inputPath;

    @Parameter(names = {"-h", "--help"}, help = true)
    private boolean help;
    
    public static void main(String[] args) {
        MainArgs ma = new MainArgs();
        JCommander jc = JCommander.newBuilder()
                                  .addObject(ma)
                                  .build();
        jc.parse(args);
        if (ma.help) {
            jc.usage();
            return;
        }
        // Continue processing...
    }
}

```

## Key Configuration Files

Explore these specific files to understand the complete IPED dependency landscape:

| File | Contents | Location |
|------|----------|----------|
| **Parent POM** | Global properties, repositories, core dependencies, plugin configuration | [[`pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/pom.xml) |
| **Utils POM** | Utility libraries (lz4, commons-codec, caffeine) | [[`iped-utils/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-utils/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/iped-utils/pom.xml) |
| **App POM** | Application dependencies (jcommander, docking-frames, kharon) | [[`iped-app/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-app/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/iped-app/pom.xml) |
| **Parsers POM** | Forensic parsing libraries (Tika, PDFBox, Lucene, SleuthKit) | [[`iped-parsers/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-parsers/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/iped-parsers/pom.xml) |
| **Viewers POM** | Swing-based UI and custom viewer implementations | [[`iped-viewers/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-viewers/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/iped-viewers/pom.xml) |
| **ThirdParty.txt** | Complete license inventory for all shipped libraries | [[`ThirdParty.txt`](https://github.com/sepinf-inc/IPED/blob/main/ThirdParty.txt)](https://github.com/sepinf-inc/IPED/blob/master/ThirdParty.txt) |

## Summary

- **IPED project dependencies** are managed through a hierarchical Maven structure with a parent POM defining shared logging (Log4j2, SLF4J) and testing (JUnit) frameworks at [[`pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/pom.xml) lines 76-106](https://github.com/sepinf-inc/IPED/blob/master/pom.xml#L76-L106)

- The `iped-utils` module extends baseline dependencies with **LZ4 compression**, **Apache Commons Codec**, and **Caffeine caching** for high-performance forensic operations

- `iped-app` adds UI and CLI capabilities through **JCommander**, **Docking Frames**, and visualization libraries declared in [[`iped-app/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-app/pom.xml) lines 20-55](https://github.com/sepinf-inc/IPED/blob/master/iped-app/pom.xml#L20-L55)

- Specialized forensic parsing in `iped-parsers` depends on **Apache Tika**, **PDFBox**, **Lucene**, and **SleuthKit** for comprehensive file format support

- Module inheritance ensures consistent versioning while permitting localized dependency extensions for specific functional requirements

## Frequently Asked Questions

### What logging framework does IPED use?

IPED utilizes **Apache Log4j2** as its primary logging implementation, bridged through **SLF4J** to provide a unified logging facade across all modules. The parent POM defines these dependencies centrally in [[`pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/pom.xml), including `log4j-api`, `log4j-core`, and `log4j-slf4j-impl`, ensuring consistent structured logging throughout the application architecture.

### How do I add IPED as a dependency to my own Maven project?

Reference the `iped-engine` artifact in your project's [`pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/pom.xml) with the appropriate version, typically `4.4.0-SNAPSHOT` for current development builds. This coordinates declared in [[`iped-app/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-app/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/iped-app/pom.xml) automatically transitively includes the logging and utility libraries defined in the parent POM, though you should verify version compatibility with your existing SLF4J and Log4j2 configurations.

### Which compression libraries are available in IPED?

The `iped-utils` module provides **LZ4** compression through the `lz4` dependency declared at [[`iped-utils/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-utils/pom.xml) lines 13-38](https://github.com/sepinf-inc/IPED/blob/master/iped-utils/pom.xml#L13-L38). This high-performance library is accessible to any module depending on `iped-utils`, offering significantly faster compression speeds than traditional algorithms for large forensic evidence files.

### Where are parser-specific dependencies defined?

Forensic parsing dependencies—including **Apache Tika**, **PDFBox**, **Lucene**, and **SleuthKit**—are declared within the `iped-parsers` module hierarchy in [[`iped-parsers/pom.xml`](https://github.com/sepinf-inc/IPED/blob/main/iped-parsers/pom.xml)](https://github.com/sepinf-inc/IPED/blob/master/iped-parsers/pom.xml). This modular approach isolates heavy parsing libraries from the core engine, allowing selective inclusion only when deep file content analysis capabilities are required for digital evidence processing.