Native MD5 Implementation

Implementing cryptographic algorithms at the native C++ layer ensures cross-platform compatibility, allowing both Android and iOS to utilize the same shared library. The implementation follows the specifications outlined in RFC 1321.

Header Definition (hash_engine.hpp)

#ifndef HASH_ENGINE_HPP
#define HASH_ENGINE_HPP

#include <cstdint>

typedef struct {
    uint32_t digest_state[4];
    uint32_t bit_count[2];
    uint8_t  input_buffer[64];
} Md5Context;

#ifdef __cplusplus
extern "C" {
#endif

void initMd5(Md5Context *ctx);
void feedMd5(Md5Context *ctx, uint8_t *data, uint32_t dataLen);
void finalizeMd5(uint8_t result[16], Md5Context *ctx);

#ifdef __cplusplus
}
#endif

#endif

Algorithm Implementation (hash_engine.cpp)

#include "hash_engine.hpp"
#include <cstring>

#define CYCLE_1_1 7
#define CYCLE_1_2 12
#define CYCLE_1_3 17
#define CYCLE_1_4 22
#define CYCLE_2_1 5
#define CYCLE_2_2 9
#define CYCLE_2_3 14
#define CYCLE_2_4 20
#define CYCLE_3_1 4
#define CYCLE_3_2 11
#define CYCLE_3_3 16
#define CYCLE_3_4 23
#define CYCLE_4_1 6
#define CYCLE_4_2 10
#define CYCLE_4_3 15
#define CYCLE_4_4 21

static uint8_t PADDING_BLOCK[64] = {
    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

#define OP_F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define OP_G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define OP_H(x, y, z) ((x) ^ (y) ^ (z))
#define OP_I(x, y, z) ((y) ^ ((x) | (~z)))

#define LEFT_SHIFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

#define ROUND_1(a, b, c, d, x, s, ac) { \
 (a) += OP_F((b), (c), (d)) + (x) + (uint32_t)(ac); \
 (a) = LEFT_SHIFT((a), (s)); \
 (a) += (b); \
}
#define ROUND_2(a, b, c, d, x, s, ac) { \
 (a) += OP_G((b), (c), (d)) + (x) + (uint32_t)(ac); \
 (a) = LEFT_SHIFT((a), (s)); \
 (a) += (b); \
}
#define ROUND_3(a, b, c, d, x, s, ac) { \
 (a) += OP_H((b), (c), (d)) + (x) + (uint32_t)(ac); \
 (a) = LEFT_SHIFT((a), (s)); \
 (a) += (b); \
}
#define ROUND_4(a, b, c, d, x, s, ac) { \
 (a) += OP_I((b), (c), (d)) + (x) + (uint32_t)(ac); \
 (a) = LEFT_SHIFT((a), (s)); \
 (a) += (b); \
}

static void encodeBlock(uint8_t *dest, uint32_t *src, uint32_t len) {
    for (uint32_t i = 0, j = 0; j < len; i++, j += 4) {
        dest[j]   = (uint8_t)(src[i] & 0xff);
        dest[j+1] = (uint8_t)((src[i] >> 8) & 0xff);
        dest[j+2] = (uint8_t)((src[i] >> 16) & 0xff);
        dest[j+3] = (uint8_t)((src[i] >> 24) & 0xff);
    }
}

static void decodeBlock(uint32_t *dest, uint8_t *src, uint32_t len) {
    for (uint32_t i = 0, j = 0; j < len; i++, j += 4) {
        dest[i] = ((uint32_t)src[j]) | (((uint32_t)src[j+1]) << 8) |
                  (((uint32_t)src[j+2]) << 16) | (((uint32_t)src[j+3]) << 24);
    }
}

static void transformState(uint32_t state[4], uint8_t block[64]) {
    uint32_t reg0 = state[0], reg1 = state[1], reg2 = state[2], reg3 = state[3], chunk[16];
    decodeBlock(chunk, block, 64);

    ROUND_1(reg0, reg1, reg2, reg3, chunk[ 0], CYCLE_1_1, 0xd76aa478);
    ROUND_1(reg3, reg0, reg1, reg2, chunk[ 1], CYCLE_1_2, 0xe8c7b756);
    ROUND_1(reg2, reg3, reg0, reg1, chunk[ 2], CYCLE_1_3, 0x242070db);
    ROUND_1(reg1, reg2, reg3, reg0, chunk[ 3], CYCLE_1_4, 0xc1bdceee);
    ROUND_1(reg0, reg1, reg2, reg3, chunk[ 4], CYCLE_1_1, 0xf57c0faf);
    ROUND_1(reg3, reg0, reg1, reg2, chunk[ 5], CYCLE_1_2, 0x4787c62a);
    ROUND_1(reg2, reg3, reg0, reg1, chunk[ 6], CYCLE_1_3, 0xa8304613);
    ROUND_1(reg1, reg2, reg3, reg0, chunk[ 7], CYCLE_1_4, 0xfd469501);
    ROUND_1(reg0, reg1, reg2, reg3, chunk[ 8], CYCLE_1_1, 0x698098d8);
    ROUND_1(reg3, reg0, reg1, reg2, chunk[ 9], CYCLE_1_2, 0x8b44f7af);
    ROUND_1(reg2, reg3, reg0, reg1, chunk[10], CYCLE_1_3, 0xffff5bb1);
    ROUND_1(reg1, reg2, reg3, reg0, chunk[11], CYCLE_1_4, 0x895cd7be);
    ROUND_1(reg0, reg1, reg2, reg3, chunk[12], CYCLE_1_1, 0x6b901122);
    ROUND_1(reg3, reg0, reg1, reg2, chunk[13], CYCLE_1_2, 0xfd987193);
    ROUND_1(reg2, reg3, reg0, reg1, chunk[14], CYCLE_1_3, 0xa679438e);
    ROUND_1(reg1, reg2, reg3, reg0, chunk[15], CYCLE_1_4, 0x49b40821);

    ROUND_2(reg0, reg1, reg2, reg3, chunk[ 1], CYCLE_2_1, 0xf61e2562);
    ROUND_2(reg3, reg0, reg1, reg2, chunk[ 6], CYCLE_2_2, 0xc040b340);
    ROUND_2(reg2, reg3, reg0, reg1, chunk[11], CYCLE_2_3, 0x265e5a51);
    ROUND_2(reg1, reg2, reg3, reg0, chunk[ 0], CYCLE_2_4, 0xe9b6c7aa);
    ROUND_2(reg0, reg1, reg2, reg3, chunk[ 5], CYCLE_2_1, 0xd62f105d);
    ROUND_2(reg3, reg0, reg1, reg2, chunk[10], CYCLE_2_2, 0x2441453);
    ROUND_2(reg2, reg3, reg0, reg1, chunk[15], CYCLE_2_3, 0xd8a1e681);
    ROUND_2(reg1, reg2, reg3, reg0, chunk[ 4], CYCLE_2_4, 0xe7d3fbc8);
    ROUND_2(reg0, reg1, reg2, reg3, chunk[ 9], CYCLE_2_1, 0x21e1cde6);
    ROUND_2(reg3, reg0, reg1, reg2, chunk[14], CYCLE_2_2, 0xc33707d6);
    ROUND_2(reg2, reg3, reg0, reg1, chunk[ 3], CYCLE_2_3, 0xf4d50d87);
    ROUND_2(reg1, reg2, reg3, reg0, chunk[ 8], CYCLE_2_4, 0x455a14ed);
    ROUND_2(reg0, reg1, reg2, reg3, chunk[13], CYCLE_2_1, 0xa9e3e905);
    ROUND_2(reg3, reg0, reg1, reg2, chunk[ 2], CYCLE_2_2, 0xfcefa3f8);
    ROUND_2(reg2, reg3, reg0, reg1, chunk[ 7], CYCLE_2_3, 0x676f02d9);
    ROUND_2(reg1, reg2, reg3, reg0, chunk[12], CYCLE_2_4, 0x8d2a4c8a);

    ROUND_3(reg0, reg1, reg2, reg3, chunk[ 5], CYCLE_3_1, 0xfffa3942);
    ROUND_3(reg3, reg0, reg1, reg2, chunk[ 8], CYCLE_3_2, 0x8771f681);
    ROUND_3(reg2, reg3, reg0, reg1, chunk[11], CYCLE_3_3, 0x6d9d6122);
    ROUND_3(reg1, reg2, reg3, reg0, chunk[14], CYCLE_3_4, 0xfde5380c);
    ROUND_3(reg0, reg1, reg2, reg3, chunk[ 1], CYCLE_3_1, 0xa4beea44);
    ROUND_3(reg3, reg0, reg1, reg2, chunk[ 4], CYCLE_3_2, 0x4bdecfa9);
    ROUND_3(reg2, reg3, reg0, reg1, chunk[ 7], CYCLE_3_3, 0xf6bb4b60);
    ROUND_3(reg1, reg2, reg3, reg0, chunk[10], CYCLE_3_4, 0xbebfbc70);
    ROUND_3(reg0, reg1, reg2, reg3, chunk[13], CYCLE_3_1, 0x289b7ec6);
    ROUND_3(reg3, reg0, reg1, reg2, chunk[ 0], CYCLE_3_2, 0xeaa127fa);
    ROUND_3(reg2, reg3, reg0, reg1, chunk[ 3], CYCLE_3_3, 0xd4ef3085);
    ROUND_3(reg1, reg2, reg3, reg0, chunk[ 6], CYCLE_3_4, 0x4881d05);
    ROUND_3(reg0, reg1, reg2, reg3, chunk[ 9], CYCLE_3_1, 0xd9d4d039);
    ROUND_3(reg3, reg0, reg1, reg2, chunk[12], CYCLE_3_2, 0xe6db99e5);
    ROUND_3(reg2, reg3, reg0, reg1, chunk[15], CYCLE_3_3, 0x1fa27cf8);
    ROUND_3(reg1, reg2, reg3, reg0, chunk[ 2], CYCLE_3_4, 0xc4ac5665);

    ROUND_4(reg0, reg1, reg2, reg3, chunk[ 0], CYCLE_4_1, 0xf4292244);
    ROUND_4(reg3, reg0, reg1, reg2, chunk[ 7], CYCLE_4_2, 0x432aff97);
    ROUND_4(reg2, reg3, reg0, reg1, chunk[14], CYCLE_4_3, 0xab9423a7);
    ROUND_4(reg1, reg2, reg3, reg0, chunk[ 5], CYCLE_4_4, 0xfc93a039);
    ROUND_4(reg0, reg1, reg2, reg3, chunk[12], CYCLE_4_1, 0x655b59c3);
    ROUND_4(reg3, reg0, reg1, reg2, chunk[ 3], CYCLE_4_2, 0x8f0ccc92);
    ROUND_4(reg2, reg3, reg0, reg1, chunk[10], CYCLE_4_3, 0xffeff47d);
    ROUND_4(reg1, reg2, reg3, reg0, chunk[ 1], CYCLE_4_4, 0x85845dd1);
    ROUND_4(reg0, reg1, reg2, reg3, chunk[ 8], CYCLE_4_1, 0x6fa87e4f);
    ROUND_4(reg3, reg0, reg1, reg2, chunk[15], CYCLE_4_2, 0xfe2ce6e0);
    ROUND_4(reg2, reg3, reg0, reg1, chunk[ 6], CYCLE_4_3, 0xa3014314);
    ROUND_4(reg1, reg2, reg3, reg0, chunk[13], CYCLE_4_4, 0x4e0811a1);
    ROUND_4(reg0, reg1, reg2, reg3, chunk[ 4], CYCLE_4_1, 0xf7537e82);
    ROUND_4(reg3, reg0, reg1, reg2, chunk[11], CYCLE_4_2, 0xbd3af235);
    ROUND_4(reg2, reg3, reg0, reg1, chunk[ 2], CYCLE_4_3, 0x2ad7d2bb);
    ROUND_4(reg1, reg2, reg3, reg0, chunk[ 9], CYCLE_4_4, 0xeb86d391);

    state[0] += reg0;
    state[1] += reg1;
    state[2] += reg2;
    state[3] += reg3;
    std::memset(chunk, 0, sizeof(chunk));
}

void initMd5(Md5Context *ctx) {
    ctx->bit_count[0] = ctx->bit_count[1] = 0;
    ctx->digest_state[0] = 0x67452301;
    ctx->digest_state[1] = 0xefcdab89;
    ctx->digest_state[2] = 0x98badcfe;
    ctx->digest_state[3] = 0x10325476;
}

void feedMd5(Md5Context *ctx, uint8_t *data, uint32_t dataLen) {
    uint32_t idx = (uint32_t)((ctx->bit_count[0] >> 3) & 0x3F);
    if ((ctx->bit_count[0] += ((uint32_t)dataLen << 3)) < ((uint32_t)dataLen << 3))
        ctx->bit_count[1]++;
    ctx->bit_count[1] += ((uint32_t)dataLen >> 29);
    uint32_t partLen = 64 - idx;
    uint32_t i;
    if (dataLen >= partLen) {
        std::memcpy(&ctx->input_buffer[idx], data, partLen);
        transformState(ctx->digest_state, ctx->input_buffer);
        for (i = partLen; i + 63 < dataLen; i += 64)
            transformState(ctx->digest_state, &data[i]);
        idx = 0;
    } else {
        i = 0;
    }
    std::memcpy(&ctx->input_buffer[idx], &data[i], dataLen - i);
}

void finalizeMd5(uint8_t result[16], Md5Context *ctx) {
    uint8_t bits[8];
    encodeBlock(bits, ctx->bit_count, 8);
    uint32_t idx = (uint32_t)((ctx->bit_count[0] >> 3) & 0x3f);
    uint32_t padLen = (idx < 56) ? (56 - idx) : (120 - idx);
    feedMd5(ctx, PADDING_BLOCK, padLen);
    feedMd5(ctx, bits, 8);
    encodeBlock(result, ctx->digest_state, 16);
    std::memset(ctx, 0, sizeof(*ctx));
}

JNI Integration

#include <jni.h>
#include <string>
#include "hash_engine.hpp"

#define HASH_SALT "CUSTOM_SALT_KEY"

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_native_Utils_computeHash(JNIEnv *env, jobject thiz, jstring raw_input) {
    const char *inputChars = env->GetStringUTFChars(raw_input, nullptr);

    std::string payload(inputChars);
    payload = HASH_SALT + payload;
    if (payload.length() >= 2) {
        payload.pop_back();
        payload.pop_back();
    }

    Md5Context ctx;
    initMd5(&ctx);
    feedMd5(&ctx, reinterpret_cast<uint8_t*>(&payload[0]), payload.length());

    uint8_t hashBytes[16];
    finalizeMd5(hashBytes, &ctx);
    env->ReleaseStringUTFChars(raw_input, inputChars);

    char hexOutput[33] = {0};
    for (int i = 0; i < 16; i++) {
        sprintf(hexOutput + i * 2, "%02x", hashBytes[i]);
    }

    return env->NewStringUTF(hexOutput);
}