sleelavirin_scan.c
antivirus/src/sleelavirin_scan.c · 158 line(s) · c
#include "sleelavirin_scan.h"
#include "sleelavirin_native.h"
#include <stdlib.h>
#include <string.h>
typedef struct {
sleelavirin_known_file_t item;
uint64_t key;
uint8_t used;
} sleelavirin_slot_t;
struct sleelavirin_hashmap {
size_t capacity;
size_t count;
sleelavirin_slot_t *slots;
};
int sleelavirin_fingerprint_buffer(const uint8_t *data, size_t length,
sleelavirin_file_fingerprint_t *out)
{
uint64_t hist[64];
uint64_t total = 0, mean;
size_t i;
if (!out) return -1;
if (!data && length) return -1;
memset(out, 0, sizeof(*out));
if (sleelavirin_sha256_buffer(data, length, out->sha256) != 0) return -1;
out->file_size = (uint64_t)length;
/* Byte-value histogram folded into 64 equal-width bands (each band covers
* 4 adjacent byte values). A feature bit is set when its band's frequency
* is at or above the mean band frequency; the mask marks non-empty bands. */
memset(hist, 0, sizeof(hist));
for (i = 0; i < length; ++i) {
hist[data[i] >> 2]++; /* 256 values / 4 = 64 bands */
++total;
}
if (total == 0) return 0; /* empty file: all-zero fp/mask is valid */
mean = total / 64u;
if (mean == 0) mean = 1u;
for (i = 0; i < 64; ++i) {
if (hist[i] > 0) out->feature_mask |= (UINT64_C(1) << i);
if (hist[i] >= mean) out->feature_fp |= (UINT64_C(1) << i);
}
return 0;
}
static uint64_t hash64(const uint8_t digest[32])
{
uint64_t h = UINT64_C(1469598103934665603);
size_t i;
for (i = 0; i < 32; ++i) {
h ^= digest[i];
h *= UINT64_C(1099511628211);
}
return h;
}
static int digest_equal(const uint8_t a[32], const uint8_t b[32])
{
return memcmp(a, b, 32) == 0;
}
static uint32_t popcount64(uint64_t v)
{
uint32_t n = 0;
while (v != 0) { v &= v - 1; ++n; }
return n;
}
static size_t next_pow2(size_t value)
{
size_t n = 1;
while (n < value && n <= ((size_t)-1) / 2) n <<= 1;
return n;
}
sleelavirin_hashmap_t *sleelavirin_hashmap_create(size_t capacity)
{
sleelavirin_hashmap_t *map;
size_t actual = next_pow2(capacity < 8 ? 8 : capacity);
if (actual < capacity) return NULL;
map = (sleelavirin_hashmap_t *)calloc(1, sizeof(*map));
if (!map) return NULL;
map->slots = (sleelavirin_slot_t *)calloc(actual, sizeof(*map->slots));
if (!map->slots) { free(map); return NULL; }
map->capacity = actual;
return map;
}
void sleelavirin_hashmap_destroy(sleelavirin_hashmap_t *map)
{
if (!map) return;
free(map->slots);
free(map);
}
int sleelavirin_hashmap_add(sleelavirin_hashmap_t *map,
const sleelavirin_known_file_t *known)
{
size_t index, probes = 0;
uint64_t key;
if (!map || !known || map->count * 10 >= map->capacity * 7) return -1;
key = hash64(known->fingerprint.sha256);
index = (size_t)(key & (map->capacity - 1));
while (probes++ < map->capacity) {
sleelavirin_slot_t *slot = &map->slots[index];
if (!slot->used) {
slot->item = *known; slot->key = key; slot->used = 1; ++map->count;
return 0;
}
if (slot->key == key &&
digest_equal(slot->item.fingerprint.sha256, known->fingerprint.sha256))
return 1;
index = (index + 1) & (map->capacity - 1);
}
return -1;
}
int sleelavirin_hashmap_scan(const sleelavirin_hashmap_t *map,
const sleelavirin_file_fingerprint_t *file,
uint32_t max_feature_distance,
sleelavirin_match_t *out)
{
size_t index, probes = 0;
uint64_t key;
if (!map || !file || !out) return -1;
memset(out, 0, sizeof(*out));
out->kind = SLEELAVIRIN_UNKNOWN;
key = hash64(file->sha256);
index = (size_t)(key & (map->capacity - 1));
while (probes++ < map->capacity) {
const sleelavirin_slot_t *slot = &map->slots[index];
if (!slot->used) break;
if (slot->key == key &&
digest_equal(slot->item.fingerprint.sha256, file->sha256)) {
out->kind = SLEELAVIRIN_EXACT_MATCH;
out->confidence = 100;
out->known = &slot->item;
return 0;
}
index = (index + 1) & (map->capacity - 1);
}
if (file->feature_mask != 0) {
size_t i;
for (i = 0; i < map->capacity; ++i) {
const sleelavirin_slot_t *slot = &map->slots[i];
uint64_t mask;
uint32_t distance, confidence;
if (!slot->used) continue;
mask = file->feature_mask & slot->item.fingerprint.feature_mask;
if (mask == 0) continue;
distance = popcount64((file->feature_fp ^ slot->item.fingerprint.feature_fp) & mask);
if (distance <= max_feature_distance) {
confidence = (uint32_t)(((uint64_t)(64u - distance) * 100u) / 64u);
out->kind = SLEELAVIRIN_SEMI_MATCH;
out->confidence = (uint8_t)(confidence > 99u ? 99u : confidence);
out->distance_bits = distance;
out->known = &slot->item;
return 0;
}
}
}
/* No known match is not proof that a file is clean. */
out->kind = SLEELAVIRIN_UNKNOWN;
out->confidence = 0;
return 0;
}