iccJpegDump.cpp File Reference

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <vector>
#include <fstream>
#include <arpa/inet.h>

Include dependency graph for iccJpegDump.cpp:

Go to the source code of this file.

Macros
#define	LOG_ERROR(msg)   fprintf(stderr, "[ERROR] %s\n", msg)
#define	safe_exit(reason)   do { LOG_ERROR(reason); exit(EXIT_FAILURE); } while (0)
#define	TRAP()   abort()
	Core and external libraries necessary for the fuzzer functionality.

Typedefs
typedef unsigned char *	jpeg_icc_profilep

Functions
bool	ExtractIccFromJpeg (const char *jpegPath, const char *iccOutPath)
bool	InjectIccIntoJpeg (const char *inputPath, const char *iccPath, const char *outputPath)
int	main (int argc, char *argv[])
void	Usage ()

Macro Definition Documentation

LOG_ERROR

#define LOG_ERROR

(

msg

)

fprintf(stderr, "[ERROR] %s\n", msg)

safe_exit

#define safe_exit

(

reason

)

do { LOG_ERROR(reason); exit(EXIT_FAILURE); } while (0)

TRAP

#define TRAP

(

)

abort()

Core and external libraries necessary for the fuzzer functionality.

This section includes the necessary headers for the Foundation framework, UIKit, Core Graphics, standard input/output, standard library, memory management, mathematical functions, Boolean type, floating-point limits, and string functions. These libraries support image processing, UI interaction, and basic C operations essential for the application.

Typedef Documentation

jpeg_icc_profilep

typedef unsigned char* jpeg_icc_profilep

Function Documentation

ExtractIccFromJpeg()

bool ExtractIccFromJpeg	(	const char *	jpegPath,
		const char *	iccOutPath
	)

                                                                      {
    FILE* fp = fopen(jpegPath, "rb");
    if (!fp) safe_exit("Cannot open input JPEG file.");
 
    std::vector<unsigned char> iccData;
    unsigned char marker[2];
    bool found = false;
 
    // ------------------------------------------------------------
    // Iterate JPEG markers and scan for APPx segments
    // ------------------------------------------------------------
    while (fread(marker, 1, 2, fp) == 2) {
        if (marker[0] != 0xFF) break;
        if (marker[1] == 0xD9) break;  // EOI
 
        unsigned short len = 0;
        if (fread(&len, 2, 1, fp) != 1) break;
        len = ntohs(len);
 
        if (len < 2) break;
        std::vector<unsigned char> segment(len - 2);
        if (fread(segment.data(), 1, segment.size(), fp) != segment.size())
            break;
 
        printf("[INFO] Scanning segment 0x%02X, length: %u bytes\n", marker[1], len);
 
        // --------------------------------------------------------
        // Check for APP2 ICC_PROFILE header (spec-compliant)
        // --------------------------------------------------------
        if (marker[1] == 0xE2 && len > 16) {
            if (memcmp(segment.data(), "ICC_PROFILE\0", 12) == 0) {
                unsigned char* dataStart = segment.data() + 14;
                size_t dataLen = segment.size() - 14;
                iccData.insert(iccData.end(), dataStart, dataStart + dataLen);
                printf("[INFO] Found ICC_PROFILE in APP2 segment.\n");
                found = true;
                break;
            }
        }
 
        // --------------------------------------------------------
        // Fallback: Search all APPx for "acsp" ICC signature
        // --------------------------------------------------------
        if (marker[1] >= 0xE0 && marker[1] <= 0xEF) {
            for (size_t i = 0; i + 4 < segment.size(); ++i) {
                if (memcmp(&segment[i], "acsp", 4) == 0) {
                    iccData.insert(iccData.end(), segment.begin() + i, segment.end());
                    printf("[INFO] Found 'acsp' ICC magic in APP segment 0x%02X at offset %zu.\n", marker[1], i);
                    found = true;
                    goto done;
                }
            }
        }
    }
 
    // ------------------------------------------------------------
    // Raw Fallback: Scan entire file for "acsp"
    // ------------------------------------------------------------
    if (!found) {
        std::ifstream file(jpegPath, std::ios::binary);
        if (!file) {
            LOG_ERROR("Fallback open failed.");
            return false;
        }
 
        std::vector<unsigned char> raw((std::istreambuf_iterator<char>(file)),
                                       std::istreambuf_iterator<char>());
 
        for (size_t i = 0; i + 4 < raw.size(); ++i) {
            if (memcmp(&raw[i], "acsp", 4) == 0) {
                iccData.insert(iccData.end(), raw.begin() + i, raw.end());
                printf("[INFO] Fallback: Found 'acsp' in raw file at offset %zu.\n", i);
                found = true;
                break;
            }
        }
    }
 
done:
    fclose(fp);
 
    if (iccData.empty()) {
        LOG_ERROR("No ICC profile found.");
        return false;
    }
 
    FILE* out = fopen(iccOutPath, "wb");
    if (!out) safe_exit("Failed to open output ICC file.");
    fwrite(iccData.data(), 1, iccData.size(), out);
    fclose(out);
 
    printf("[INFO] ICC profile extracted to: %s\n", iccOutPath);
    return true;
}

Referenced by main().

Here is the caller graph for this function:

InjectIccIntoJpeg()

bool InjectIccIntoJpeg	(	const char *	inputPath,
		const char *	iccPath,
		const char *	outputPath
	)

                                                                                           {
    FILE* in = fopen(inputPath, "rb");
    FILE* out = fopen(outputPath, "wb");
    std::ifstream icc(iccPath, std::ios::binary);
 
    if (!in || !out || !icc.is_open())
        safe_exit("Cannot open input/output/ICC file.");
 
    // ------------------------------------------------------------------------
    // Read ICC profile into memory
    // ------------------------------------------------------------------------
    std::vector<unsigned char> iccData((std::istreambuf_iterator<char>(icc)),
                                        std::istreambuf_iterator<char>());
 
    // ------------------------------------------------------------------------
    // Verify and copy SOI marker (0xFFD8)
    // ------------------------------------------------------------------------
    unsigned char soi[2];
    // Line 294: Original Code
    // fread(soi, 1, 2, in);
 
    // Updated Code
    size_t bytesRead = fread(soi, 1, 2, in);
    if (bytesRead != 2) {
    fprintf(stderr, "Error: Failed to read 2 bytes from the input file.\n");
    fclose(in);
    return false; // or handle the error as required
    }
    if (soi[0] != 0xFF || soi[1] != 0xD8)
        safe_exit("Not a valid JPEG file.");
    fwrite(soi, 1, 2, out);
 
    // ------------------------------------------------------------------------
    // Write APP2 segment with ICC header and payload
    // Format:
    //   - Marker      : 0xFFE2
    //   - Length      : 2-byte big endian (header + payload)
    //   - Signature   : "ICC_PROFILE" + '\0'
    //   - Sequence No : 1 (single-segment)
    //   - Total Segs  : 1
    //   - ICC Data    : full profile binary
    // ------------------------------------------------------------------------
    std::string sig = "ICC_PROFILE";
    unsigned short markerLen = 2 + sig.size() + 1 + 2 + iccData.size(); // length includes itself
    unsigned short markerBE = htons(markerLen);
 
    fputc(0xFF, out); fputc(0xE2, out);                   // APP2
    fwrite(&markerBE, 2, 1, out);                         // segment length
    fwrite(sig.c_str(), 1, sig.size(), out);              // "ICC_PROFILE"
    fputc(0x00, out);                                     // null terminator
    fputc(1, out); fputc(1, out);                         // sequence 1 of 1
    fwrite(iccData.data(), 1, iccData.size(), out);       // profile payload
 
    // ------------------------------------------------------------------------
    // Append remainder of JPEG file unmodified
    // ------------------------------------------------------------------------
    unsigned char buf[4096];
    size_t n;
    while ((n = fread(buf, 1, sizeof(buf), in)) > 0)
        fwrite(buf, 1, n, out);
 
    fclose(in); fclose(out); icc.close();
    return true;
}

Referenced by main().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[]
	)

                                 {
    if (argc < 2) {
        Usage();
        safe_exit("Missing arguments.");
    }
 
    // ------------------------------------------------------------------------
    // Parse Command-Line Arguments
    // ------------------------------------------------------------------------
    const char* inputFile = nullptr;
    const char* extractIccOut = nullptr;
    const char* injectIccFile = nullptr;
    const char* outputJpegFile = nullptr;
 
    inputFile = argv[1];
 
    for (int i = 2; i < argc; ++i) {
        if (strcmp(argv[i], "--write-icc") == 0 && i + 1 < argc) {
            injectIccFile = argv[++i];
        } else if (strcmp(argv[i], "--output") == 0 && i + 1 < argc) {
            outputJpegFile = argv[++i];
        } else {
            extractIccOut = argv[i];
        }
    }
 
    // ------------------------------------------------------------------------
    // ICC Injection Mode: Embed ICC profile into a JPEG
    // ------------------------------------------------------------------------
    if (injectIccFile && outputJpegFile) {
        if (!InjectIccIntoJpeg(inputFile, injectIccFile, outputJpegFile)) {
            safe_exit("Failed to inject ICC profile.");
        }
        printf("[INFO] ICC profile successfully injected into: %s\n", outputJpegFile);
 
    // ------------------------------------------------------------------------
    // ICC Extraction Mode: Extract ICC profile from a JPEG
    // ------------------------------------------------------------------------
    } else if (extractIccOut) {
        if (!ExtractIccFromJpeg(inputFile, extractIccOut)) {
            safe_exit("Failed to extract ICC profile.");
        }
 
    // ------------------------------------------------------------------------
    // Invalid Argument Combinations
    // ------------------------------------------------------------------------
    } else {
        Usage();
        safe_exit("Invalid argument combination.");
    }
 
    return 0;
}

References ExtractIccFromJpeg(), InjectIccIntoJpeg(), and Usage().

Here is the call graph for this function:

Usage()

void Usage

(

)

             {
    printf("Usage:\n");
    printf("  iccJpegDump <input.jpg> [output.icc]\n");
    printf("    - Extract ICC profile from JPEG (APP2 or EXIF-based) if present.\n");
    printf("  iccJpegDump <input.jpg> --write-icc <profile.icc> --output <output.jpg>\n");
    printf("    - Inject ICC profile into JPEG image.\n");
}