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

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/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 (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 (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 (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/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 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:

<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:

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:

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:

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/master/pom.xml)
Utils POM	Utility libraries (lz4, commons-codec, caffeine)	[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/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/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/master/iped-viewers/pom.xml)
ThirdParty.txt	Complete license inventory for all shipped libraries	[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 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 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/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 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/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 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/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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}