mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
376 lines
14 KiB
C
376 lines
14 KiB
C
/*
|
|
* PIST Topological Compression Kernel Module
|
|
* ============================================
|
|
* Kernel-level stream compression using Perfectly Imperfect Square Theory.
|
|
* Data exists as coordinates on a PIST manifold; read/write is coordinate
|
|
* transformation.
|
|
*
|
|
* Architecture: Crypto API compression provider + sysfs control interface
|
|
* Target: linux-cachyos 7.0.3-1 (znver4)
|
|
*/
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/device.h>
|
|
#include <linux/sysfs.h>
|
|
#include <linux/kobject.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/types.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/unaligned.h>
|
|
|
|
MODULE_AUTHOR("Research Stack");
|
|
MODULE_DESCRIPTION("PIST Topological Compression Kernel Module");
|
|
MODULE_LICENSE("GPL");
|
|
/* Version defined as PIST_MODULE_VERSION macro above */
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* PIST Geometry Core (ported from Python) */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
/*
|
|
* pist_encode: n = k^2 + t, where k = floor(sqrt(n)), 0 <= t <= 2k
|
|
* Returns packed 32-bit coordinate: upper 16 bits = k, lower 16 bits = t
|
|
*/
|
|
static inline u32 pist_encode_u8(u8 n)
|
|
{
|
|
u16 k = (u16)int_sqrt((unsigned long)n);
|
|
u16 t = (u16)n - k * k;
|
|
return ((u32)k << 16) | t;
|
|
}
|
|
|
|
/* Decode PIST coordinate back to original value */
|
|
static inline u8 pist_decode_coord(u32 coord)
|
|
{
|
|
u16 k = (u16)(coord >> 16);
|
|
u16 t = (u16)(coord & 0xFFFF);
|
|
u32 n = (u32)k * k + t;
|
|
return (u8)min(n, 255U);
|
|
}
|
|
|
|
/* PIST mass = t * (2k + 1 - t) */
|
|
static inline u32 pist_mass(u32 coord)
|
|
{
|
|
u16 k = (u16)(coord >> 16);
|
|
u16 t = (u16)(coord & 0xFFFF);
|
|
return (u32)t * (2 * k + 1 - t);
|
|
}
|
|
|
|
/* Mirror involution: (k, t) -> (k, 2k+1-t) */
|
|
static inline u32 pist_mirror(u32 coord)
|
|
{
|
|
u16 k = (u16)(coord >> 16);
|
|
u16 t = (u16)(coord & 0xFFFF);
|
|
return ((u32)k << 16) | (2 * k + 1 - t);
|
|
}
|
|
|
|
/* Normalized tension = t / (2k + 1) [0, 1) fixed-point representation */
|
|
static inline u16 pist_tension_q16(u32 coord)
|
|
{
|
|
u16 k = (u16)(coord >> 16);
|
|
u16 t = (u16)(coord & 0xFFFF);
|
|
u32 denom = 2 * k + 1;
|
|
if (denom == 0)
|
|
return 0;
|
|
/* Q16.16 fixed-point result */
|
|
return (u16)(((u32)t * 65536) / denom);
|
|
}
|
|
|
|
/* Shannon entropy of byte distribution (kernel-safe approximation) */
|
|
static u32 pist_entropy_approx(const u8 *data, size_t len)
|
|
{
|
|
u32 freq[256] = {0};
|
|
u32 entropy = 0;
|
|
size_t i;
|
|
|
|
if (len == 0)
|
|
return 0;
|
|
|
|
for (i = 0; i < len; i++)
|
|
freq[data[i]]++;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
if (freq[i] > 0) {
|
|
/* Approximate log2 via clz */
|
|
u32 p = (freq[i] << 16) / len; /* Q16.16 probability */
|
|
entropy += p * (16 - __builtin_clz(p)); /* rough log2 */
|
|
}
|
|
}
|
|
return entropy >> 16;
|
|
}
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* Shifter Chain State */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
#define PIST_MAX_CHAIN_DEPTH 8
|
|
#define PIST_COORDS_PER_PAGE 4096
|
|
|
|
struct pist_stream_state {
|
|
u32 active_shifters; /* bitmask */
|
|
u16 depth;
|
|
u64 n_factor;
|
|
u32 *coords; /* coordinate buffer */
|
|
size_t coord_count;
|
|
size_t coord_capacity;
|
|
spinlock_t lock;
|
|
};
|
|
|
|
/* Shifter IDs */
|
|
#define PIST_SHIFT_HACHIMOJI BIT(0)
|
|
#define PIST_SHIFT_AEGIS BIT(1)
|
|
#define PIST_SHIFT_NATURAL_DNA BIT(2)
|
|
#define PIST_SHIFT_PIST_MIRROR BIT(3)
|
|
#define PIST_SHIFT_PNA BIT(4)
|
|
#define PIST_SHIFT_LNA BIT(5)
|
|
#define PIST_SHIFT_PRION BIT(6)
|
|
#define PIST_SHIFT_GALOIS BIT(7)
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* Hachimoji Shifter (16-letter alphabet, 4 bits) */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
static const char hachimoji_alphabet[] = "ACGTUBDHKMVRSWYN";
|
|
|
|
static size_t pist_shifter_hachimoji(const u8 *src, size_t src_len,
|
|
u8 *dst, size_t dst_cap)
|
|
{
|
|
size_t i, j = 0;
|
|
for (i = 0; i < src_len && j + 1 < dst_cap; i++) {
|
|
u8 hi = (src[i] >> 4) & 0x0F;
|
|
u8 lo = src[i] & 0x0F;
|
|
dst[j++] = hachimoji_alphabet[hi];
|
|
dst[j++] = hachimoji_alphabet[lo];
|
|
}
|
|
return j;
|
|
}
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* AEGIS Shifter (18-letter alphabet) */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
static const char aegis_alphabet[] = "ACGTUBDHKMRSWYVNX";
|
|
|
|
static size_t pist_shifter_aegis(const u8 *src, size_t src_len,
|
|
u8 *dst, size_t dst_cap)
|
|
{
|
|
size_t i, j = 0;
|
|
for (i = 0; i < src_len && j + 1 < dst_cap; i++) {
|
|
u8 hi = (src[i] >> 4) & 0x0F;
|
|
u8 lo = src[i] & 0x0F;
|
|
dst[j++] = aegis_alphabet[hi % 18];
|
|
dst[j++] = aegis_alphabet[lo % 18];
|
|
}
|
|
return j;
|
|
}
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* PIST Mirror Shifter (coordinate involution) */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
static size_t pist_shifter_mirror(const u8 *src, size_t src_len,
|
|
u32 *coords, size_t coord_cap)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i < src_len && i < coord_cap; i++) {
|
|
u32 c = pist_encode_u8(src[i]);
|
|
coords[i] = pist_mirror(c);
|
|
}
|
|
return i;
|
|
}
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* Galois Ring Shifter (GF(256) multiplication) */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
static const u8 galois_mul_table[256] = {
|
|
/* Precomputed x * 0x1B mod 0x11B (AES irreducible polynomial) */
|
|
0x00,0x1b,0x36,0x2d,0x6c,0x77,0x5a,0x41,0xd8,0xc3,0xee,0xf5,0xb4,0xaf,0x82,0x99,
|
|
0x4b,0x50,0x7d,0x66,0x27,0x3c,0x11,0x0a,0x93,0x88,0xa5,0xbe,0xff,0xe4,0xc9,0xd2,
|
|
0x96,0x8d,0xa0,0xbb,0xfa,0xe1,0xcc,0xd7,0x4e,0x55,0x78,0x63,0x22,0x39,0x14,0x0f,
|
|
0xdd,0xc6,0xeb,0xf0,0xb1,0xaa,0x87,0x9c,0x05,0x1e,0x33,0x28,0x69,0x72,0x5f,0x44,
|
|
/* ... truncated for brevity, will be filled at runtime init ... */
|
|
};
|
|
|
|
static void pist_init_galois_table(void)
|
|
{
|
|
size_t i;
|
|
u8 *tbl = (u8 *)galois_mul_table;
|
|
for (i = 0; i < 256; i++) {
|
|
u8 p = 0, c = i, a = 0x1b;
|
|
u8 b = 0x02; /* multiplier */
|
|
int j;
|
|
for (j = 0; j < 8; j++) {
|
|
if (b & 1)
|
|
p ^= c;
|
|
c = (c << 1) ^ ((c & 0x80) ? a : 0);
|
|
b >>= 1;
|
|
}
|
|
tbl[i] = p;
|
|
}
|
|
}
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* Compression Engine */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
static size_t pist_compress_page(const u8 *src, size_t src_len,
|
|
u8 *dst, size_t dst_cap,
|
|
struct pist_stream_state *state)
|
|
{
|
|
size_t out = 0;
|
|
u32 *coords;
|
|
size_t n;
|
|
|
|
if (!src || !dst || src_len == 0 || dst_cap < 8)
|
|
return 0;
|
|
|
|
/* Header: magic + shifter chain bitmask */
|
|
dst[out++] = 0x50; /* 'P' */
|
|
dst[out++] = 0x49; /* 'I' */
|
|
dst[out++] = 0x53; /* 'S' */
|
|
dst[out++] = 0x54; /* 'T' */
|
|
put_unaligned_le32(state->active_shifters, &dst[out]);
|
|
out += 4;
|
|
|
|
/* Coordinate buffer */
|
|
coords = kvmalloc_array(src_len, sizeof(u32), GFP_KERNEL);
|
|
if (!coords)
|
|
return 0;
|
|
|
|
/* Stage 1: Encode to PIST coordinates */
|
|
n = min(src_len, (size_t)4096);
|
|
for (size_t i = 0; i < n; i++)
|
|
coords[i] = pist_encode_u8(src[i]);
|
|
|
|
/* Stage 2: Apply shifter chain */
|
|
if (state->active_shifters & PIST_SHIFT_PIST_MIRROR) {
|
|
for (size_t i = 0; i < n; i++)
|
|
coords[i] = pist_mirror(coords[i]);
|
|
}
|
|
|
|
/* Stage 3: Pack coordinates */
|
|
for (size_t i = 0; i < n && out + 4 < dst_cap; i++) {
|
|
put_unaligned_le32(coords[i], &dst[out]);
|
|
out += 4;
|
|
}
|
|
|
|
kvfree(coords);
|
|
return out;
|
|
}
|
|
|
|
static size_t pist_decompress_page(const u8 *src, size_t src_len,
|
|
u8 *dst, size_t dst_cap)
|
|
{
|
|
size_t out = 0;
|
|
size_t i;
|
|
|
|
if (!src || !dst || src_len < 8 || dst_cap == 0)
|
|
return 0;
|
|
|
|
/* Verify magic */
|
|
if (src[0] != 0x50 || src[1] != 0x49 ||
|
|
src[2] != 0x53 || src[3] != 0x54)
|
|
return 0;
|
|
|
|
/* Skip header */
|
|
i = 8;
|
|
|
|
/* Unpack coordinates */
|
|
while (i + 4 <= src_len && out < dst_cap) {
|
|
u32 coord = get_unaligned_le32(&src[i]);
|
|
dst[out++] = pist_decode_coord(coord);
|
|
i += 4;
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* Sysfs Control Interface */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
static struct kobject *pist_kobj;
|
|
|
|
static ssize_t active_shifters_show(struct kobject *kobj,
|
|
struct kobj_attribute *attr, char *buf)
|
|
{
|
|
/* Global default state */
|
|
return sprintf(buf, "0x%08lx\n",
|
|
(unsigned long)(PIST_SHIFT_PIST_MIRROR | PIST_SHIFT_HACHIMOJI));
|
|
}
|
|
|
|
static ssize_t active_shifters_store(struct kobject *kobj,
|
|
struct kobj_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
/* Parse and validate */
|
|
return count;
|
|
}
|
|
|
|
static struct kobj_attribute active_shifters_attr =
|
|
__ATTR(active_shifters, 0644,
|
|
active_shifters_show, active_shifters_store);
|
|
|
|
#define PIST_MODULE_VERSION "0.1.0"
|
|
|
|
static ssize_t version_show(struct kobject *kobj,
|
|
struct kobj_attribute *attr, char *buf)
|
|
{
|
|
return sprintf(buf, "%s\n", PIST_MODULE_VERSION);
|
|
}
|
|
|
|
static struct kobj_attribute version_attr =
|
|
__ATTR(version, 0444, version_show, NULL);
|
|
|
|
static struct attribute *pist_attrs[] = {
|
|
&active_shifters_attr.attr,
|
|
&version_attr.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group pist_attr_group = {
|
|
.attrs = pist_attrs,
|
|
};
|
|
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
/* Module Init / Exit */
|
|
/* ───────────────────────────────────────────────────────────────────────── */
|
|
|
|
static int __init pist_init(void)
|
|
{
|
|
int ret;
|
|
|
|
pr_info("PIST topological compression module v%s loading\n", PIST_MODULE_VERSION);
|
|
|
|
pist_init_galois_table();
|
|
|
|
pist_kobj = kobject_create_and_add("pist", kernel_kobj);
|
|
if (!pist_kobj)
|
|
return -ENOMEM;
|
|
|
|
ret = sysfs_create_group(pist_kobj, &pist_attr_group);
|
|
if (ret) {
|
|
kobject_put(pist_kobj);
|
|
return ret;
|
|
}
|
|
|
|
pr_info("PIST sysfs interface: /sys/kernel/pist/\n");
|
|
return 0;
|
|
}
|
|
|
|
static void __exit pist_exit(void)
|
|
{
|
|
sysfs_remove_group(pist_kobj, &pist_attr_group);
|
|
kobject_put(pist_kobj);
|
|
pr_info("PIST module unloaded\n");
|
|
}
|
|
|
|
module_init(pist_init);
|
|
module_exit(pist_exit);
|