encryption.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// --- Generate key-based pseudo keystream ---
void generate_keystream(uint8_t *keystream, size_t len, const uint8_t *key, size_t keylen) {
    for (size_t i = 0; i < len; i++) {
        keystream[i] = key[i % keylen] ^ (uint8_t)((i * 37) & 0xFF);
    }
}

// --- Generate permutation from key (Fisher–Yates shuffle) ---
void generate_permutation(size_t *perm, size_t len, const uint8_t *key, size_t keylen) {
    for (size_t i = 0; i < len; i++) perm[i] = i;
    for (size_t i = len - 1; i > 0; i--) {
        uint8_t rnd = key[i % keylen] ^ (uint8_t)(i * 31);
        size_t j = rnd % (i + 1);
        size_t tmp = perm[i];
        perm[i] = perm[j];
        perm[j] = tmp;
    }
}

// --- Invert permutation for decryption ---
void invert_permutation(size_t *inv, const size_t *perm, size_t len) {
    for (size_t i = 0; i < len; i++)
        inv[perm[i]] = i;
}

// --- Encryption ---
void hybrid_encrypt(const uint8_t *plaintext, uint8_t *cipher, size_t len, const uint8_t *key, size_t keylen) {
    uint8_t *keystream = malloc(len);
    uint8_t *temp = malloc(len);
    size_t *perm = malloc(len * sizeof(size_t));

    generate_keystream(keystream, len, key, keylen);
    generate_permutation(perm, len, key, keylen);

    // Step 1: XOR + key-based shift
    for (size_t i = 0; i < len; i++) {
        uint8_t x = plaintext[i] ^ keystream[i];
        temp[i] = (x + key[i % keylen]) & 0xFF;
    }

    // Step 2: Transpose using permutation
    for (size_t i = 0; i < len; i++)
        cipher[perm[i]] = temp[i];

    free(keystream);
    free(temp);
    free(perm);
}

// --- Decryption ---
void hybrid_decrypt(const uint8_t *cipher, uint8_t *plaintext, size_t len, const uint8_t *key, size_t keylen) {
    uint8_t *keystream = malloc(len);
    uint8_t *temp = malloc(len);
    size_t *perm = malloc(len * sizeof(size_t));
    size_t *inv = malloc(len * sizeof(size_t));

    generate_keystream(keystream, len, key, keylen);
    generate_permutation(perm, len, key, keylen);
    invert_permutation(inv, perm, len);

    // Step 1: Reverse transpose
    for (size_t i = 0; i < len; i++)
        temp[inv[i]] = cipher[i];

    // Step 2: Reverse shift and XOR
    for (size_t i = 0; i < len; i++) {
        uint8_t x = (temp[i] - key[i % keylen]) & 0xFF;
        plaintext[i] = x ^ keystream[i];
    }

    free(keystream);
    free(temp);
    free(perm);
    free(inv);
}