poly.c

#include "ntt.h"
#include "params.h"
#include "poly.h"
#include "reduce.h"
#include <stdint.h>
#include <string.h>

static uint16_t compress_scalar(int16_t x, unsigned int bits) {
    const uint32_t m = 1u << bits;
    uint32_t t = (uint32_t)PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_freeze(x);

    return (uint16_t)((((uint64_t)t * m + (RUDRAKSH_Q / 2)) / RUDRAKSH_Q) & (m - 1u));
}

static int16_t decompress_scalar(uint16_t x, unsigned int bits) {
    const uint32_t m = 1u << bits;

    return (int16_t)(((uint64_t)x * RUDRAKSH_Q + (m / 2u)) / m);
}

static void pack_bits(uint8_t *r, size_t outlen, const uint16_t *a, unsigned int bits) {
    size_t bitpos = 0;
    unsigned int i;

    memset(r, 0, outlen);
    for (i = 0; i < RUDRAKSH_N; i++) {
        unsigned int j;
        uint16_t v = (uint16_t)(a[i] & ((1u << bits) - 1u));

        for (j = 0; j < bits; j++) {
            r[bitpos >> 3] |= (uint8_t)(((v >> j) & 1u) << (bitpos & 7u));
            bitpos++;
        }
    }
}

static void unpack_bits(uint16_t *r, const uint8_t *a, unsigned int bits) {
    size_t bitpos = 0;
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        unsigned int j;
        uint16_t v = 0;

        for (j = 0; j < bits; j++) {
            v |= (uint16_t)(((a[bitpos >> 3] >> (bitpos & 7u)) & 1u) << j);
            bitpos++;
        }
        r[i] = v;
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_reduce(poly *r) {
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        r->coeffs[i] = PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_freeze(r->coeffs[i]);
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_add(poly *r, const poly *a, const poly *b) {
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        r->coeffs[i] = PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_reduce32((int32_t)a->coeffs[i] + b->coeffs[i]);
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_sub(poly *r, const poly *a, const poly *b) {
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        r->coeffs[i] = PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_reduce32((int32_t)a->coeffs[i] - b->coeffs[i]);
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_ntt(poly *r) {
    PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_ntt(r->coeffs);
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_invntt(poly *r) {
    PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_invntt(r->coeffs);
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_pointwise(poly *r, const poly *a, const poly *b) {
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        r->coeffs[i] = PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_reduce32((int32_t)a->coeffs[i] * b->coeffs[i]);
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_tobytes(uint8_t r[RUDRAKSH_POLYBYTES], const poly *a) {
    uint16_t t[RUDRAKSH_N];
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        t[i] = (uint16_t)PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_freeze(a->coeffs[i]);
    }
    pack_bits(r, RUDRAKSH_POLYBYTES, t, 13);
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_frombytes(poly *r, const uint8_t a[RUDRAKSH_POLYBYTES]) {
    uint16_t t[RUDRAKSH_N];
    unsigned int i;

    unpack_bits(t, a, 13);
    for (i = 0; i < RUDRAKSH_N; i++) {
        r->coeffs[i] = PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_reduce32(t[i]);
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_compress_u(uint8_t r[RUDRAKSH_POLYCOMPRESSEDBYTES], const poly *a) {
    uint16_t t[RUDRAKSH_N];
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        t[i] = compress_scalar(a->coeffs[i], 10);
    }
    pack_bits(r, RUDRAKSH_POLYCOMPRESSEDBYTES, t, 10);
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_decompress_u(poly *r, const uint8_t a[RUDRAKSH_POLYCOMPRESSEDBYTES]) {
    uint16_t t[RUDRAKSH_N];
    unsigned int i;

    unpack_bits(t, a, 10);
    for (i = 0; i < RUDRAKSH_N; i++) {
        r->coeffs[i] = decompress_scalar(t[i], 10);
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_compress_v(uint8_t r[RUDRAKSH_POLYVCOMPRESSEDBYTES], const poly *a) {
    uint16_t t[RUDRAKSH_N];
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        t[i] = compress_scalar(a->coeffs[i], 5);
    }
    pack_bits(r, RUDRAKSH_POLYVCOMPRESSEDBYTES, t, 5);
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_decompress_v(poly *r, const uint8_t a[RUDRAKSH_POLYVCOMPRESSEDBYTES]) {
    uint16_t t[RUDRAKSH_N];
    unsigned int i;

    unpack_bits(t, a, 5);
    for (i = 0; i < RUDRAKSH_N; i++) {
        r->coeffs[i] = decompress_scalar(t[i], 5);
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_frommsg(poly *r, const uint8_t msg[RUDRAKSH_MSGBYTES]) {
    unsigned int i;

    for (i = 0; i < RUDRAKSH_N; i++) {
        unsigned int bitpos = i * RUDRAKSH_B;
        uint16_t v = (uint16_t)((msg[bitpos >> 3] >> (bitpos & 7u)) & 0x03u);

        r->coeffs[i] = decompress_scalar(v, RUDRAKSH_B);
    }
}

void PQCLEAN_RUDRAKSHKEMPOLY64_CLEAN_poly_tomsg(uint8_t msg[RUDRAKSH_MSGBYTES], const poly *a) {
    unsigned int i;

    memset(msg, 0, RUDRAKSH_MSGBYTES);
    for (i = 0; i < RUDRAKSH_N; i++) {
        unsigned int bitpos = i * RUDRAKSH_B;
        uint16_t v = (uint16_t)(compress_scalar(a->coeffs[i], RUDRAKSH_B) & 0x03u);

        msg[bitpos >> 3] |= (uint8_t)(v << (bitpos & 7u));
    }
}