rivide 1.1.2

Official Rust idiomatic and zero-allocation bindings for the Rivide Post-Quantum Cryptography (NIST FIPS 203 ML-KEM & NIST FIPS 204 ML-DSA) C99 Library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

/*
 * SPDX-License-Identifier: MIT
 *
 * Rivide Post-Quantum Cryptography Library
 * Copyright (C) 2026 Moh. Ananda Firmansyah Putra
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 */

/**
 * @file kem_encode.c
 * @brief ML-KEM ByteEncode/ByteDecode and message encoding/decoding implementation.
 *
 * Implements ByteEncode_12 and ByteDecode_12 serialization routines for 12-bit
 * polynomial coefficients as well as 32-byte message encoding specified in FIPS 203.
 */

#include "rivide/internal/kem_encode.h"

#include "rivide/internal/kem_compress.h"

/**
 * @brief Serialize a polynomial (12 bits per coefficient) to 384 bytes (ByteEncode_12).
 *
 * @param[out] buf Output byte buffer (384 bytes).
 * @param[in]  p   Polynomial structure to encode.
 */
void poly_tobytes(uint8_t *buf, const poly_t *p) {
    unsigned int i;
    for (i = 0; i < KEM_N / 2; i++) {
        uint16_t t0 = (uint16_t)((uint16_t)p->coeffs[2 * i] & 0x0FFF);
        uint16_t t1 = (uint16_t)((uint16_t)p->coeffs[2 * i + 1] & 0x0FFF);
        buf[3 * i] = (uint8_t)(t0 & 0xFF);
        buf[3 * i + 1] = (uint8_t)((t0 >> 8) | ((t1 & 0x0F) << 4));
        buf[3 * i + 2] = (uint8_t)(t1 >> 4);
    }
}

/**
 * @brief Deserialize a polynomial from 384 bytes (ByteDecode_12).
 *
 * @param[out] p   Output polynomial structure.
 * @param[in]  buf Input byte buffer (384 bytes).
 */
void poly_frombytes(poly_t *p, const uint8_t *buf) {
    unsigned int i;
    for (i = 0; i < KEM_N / 2; i++) {
        p->coeffs[2 * i] =
            (int16_t)(((uint16_t)buf[3 * i] | ((uint16_t)buf[3 * i + 1] << 8)) & 0x0FFF);
        p->coeffs[2 * i + 1] =
            (int16_t)((((uint16_t)buf[3 * i + 1] >> 4) | ((uint16_t)buf[3 * i + 2] << 4)) & 0x0FFF);
    }
}

/**
 * @brief Encode a 32-byte message into a polynomial (ByteDecode_1).
 *
 * @param[out] p   Output polynomial structure.
 * @param[in]  msg Input 32-byte message buffer.
 */
void poly_frommsg(poly_t *p, const uint8_t msg[32]) {
    unsigned int i, j;
    for (i = 0; i < 32; i++) {
        for (j = 0; j < 8; j++) {
            p->coeffs[8 * i + j] = decompress_coeff((uint16_t)((msg[i] >> j) & 1), 1);
        }
    }
}

/**
 * @brief Decode a polynomial into a 32-byte message (ByteEncode_1).
 *
 * @param[out] msg Output 32-byte message buffer.
 * @param[in]  p   Input polynomial structure.
 */
void poly_tomsg(uint8_t msg[32], const poly_t *p) {
    unsigned int i, j;
    for (i = 0; i < 32; i++) {
        msg[i] = 0;
        for (j = 0; j < 8; j++) {
            uint16_t t = compress_coeff(p->coeffs[8 * i + j], 1);
            msg[i] |= (uint8_t)(t << j);
        }
    }
}

/**
 * @brief Serialize a vector of polynomials into byte array (k * 384 bytes).
 *
 * @param[out] buf Output byte buffer.
 * @param[in]  v   Input polynomial vector.
 * @param[in]  k   Module rank.
 */
void polyvec_tobytes(uint8_t *buf, const polyvec_t *v, int k) {
    int i;
    for (i = 0; i < k; i++) {
        poly_tobytes(buf + 384 * i, &v->vec[i]);
    }
}

/**
 * @brief Deserialize a vector of polynomials from byte array (k * 384 bytes).
 *
 * @param[out] v   Output polynomial vector structure.
 * @param[in]  buf Input byte buffer.
 * @param[in]  k   Module rank.
 */
void polyvec_frombytes(polyvec_t *v, const uint8_t *buf, int k) {
    int i;
    for (i = 0; i < k; i++) {
        poly_frombytes(&v->vec[i], buf + 384 * i);
    }
}

/**
 * @brief Deserialize a vector of polynomials with FIPS 203 Section 7.2 Type Check.
 *
 * @param[out] v   Output polynomial vector structure.
 * @param[in]  buf Input byte buffer.
 * @param[in]  k   Module rank.
 * @return 0 on success, or -1 if any coefficient >= 3329.
 */
int polyvec_frombytes_check(polyvec_t *v, const uint8_t *buf, int k) {
    int i, j;
    polyvec_frombytes(v, buf, k);
    for (i = 0; i < k; i++) {
        for (j = 0; j < KEM_N; j++) {
            if ((uint16_t)v->vec[i].coeffs[j] >= KEM_Q) {
                return -1;
            }
        }
    }
    return 0;
}