1049 lines
31 KiB
Rust
1049 lines
31 KiB
Rust
use std::ops::{Add, BitXor, Div, Mul, Sub};
|
|
|
|
use anyhow::{anyhow, Ok, Result};
|
|
use base64::prelude::*;
|
|
use serde_json::Value;
|
|
|
|
use crate::utils::poly::polynomial_2_block;
|
|
|
|
use super::{math::xor_bytes, poly::gfmul};
|
|
|
|
#[derive(Debug)]
|
|
pub struct Polynomial {
|
|
polynomial: Vec<FieldElement>,
|
|
}
|
|
|
|
impl Polynomial {
|
|
pub const fn new(polynomial: Vec<FieldElement>) -> Self {
|
|
Self { polynomial }
|
|
}
|
|
|
|
pub fn from_c_array(array: &Value) -> Self {
|
|
let mut polynomial: Vec<FieldElement> = vec![];
|
|
let c_array: Vec<String> = array
|
|
.as_array()
|
|
.expect("Input is not an array")
|
|
.iter()
|
|
.map(|x| {
|
|
x.as_str()
|
|
.expect("Array element is not a string")
|
|
.to_string()
|
|
})
|
|
.collect();
|
|
|
|
eprintln!("{:?}", c_array);
|
|
|
|
for coefficient in c_array {
|
|
polynomial.push(FieldElement::new(
|
|
BASE64_STANDARD
|
|
.decode(coefficient)
|
|
.expect("Error on poly decode:"),
|
|
));
|
|
}
|
|
Self { polynomial }
|
|
}
|
|
|
|
pub fn to_c_array(self) -> Vec<String> {
|
|
let mut output: Vec<String> = vec![];
|
|
for coeff in self.polynomial {
|
|
output.push(BASE64_STANDARD.encode(coeff));
|
|
}
|
|
|
|
output
|
|
}
|
|
|
|
pub fn pow(&self, mut exponent: u128) -> Polynomial {
|
|
if exponent == 0 {
|
|
return Polynomial::new(vec![FieldElement::new(
|
|
polynomial_2_block(vec![0], "gcm").unwrap(),
|
|
)]);
|
|
}
|
|
|
|
let base = self.clone();
|
|
let mut result = base.clone();
|
|
exponent -= 1;
|
|
while exponent > 0 {
|
|
result = result * base.clone();
|
|
exponent -= 1;
|
|
}
|
|
|
|
result
|
|
}
|
|
|
|
pub fn pow_mod(mut self, mut exponent: u128, modulus: Polynomial) -> Polynomial {
|
|
let mut result: Polynomial = Polynomial::new(vec![FieldElement::new(
|
|
polynomial_2_block(vec![0], "gcm").unwrap(),
|
|
)]);
|
|
|
|
if exponent == 1 {
|
|
return self;
|
|
}
|
|
|
|
if exponent == 0 {
|
|
Polynomial::new(vec![FieldElement::new(
|
|
polynomial_2_block(vec![1], "gcm").unwrap(),
|
|
)])
|
|
.div(&modulus)
|
|
.1;
|
|
}
|
|
|
|
//eprintln!("Initial result: {:?}", result);
|
|
while exponent > 0 {
|
|
//eprintln!("Current exponent: {:02X}", exponent);
|
|
if exponent & 1 == 1 {
|
|
let temp = &self * &result;
|
|
//eprintln!("After multiplication: {:?}", temp);
|
|
result = temp.div(&modulus).1;
|
|
//eprintln!("After mod: {:?}", result);
|
|
}
|
|
let temp_square = &self * &self;
|
|
//eprintln!("After squaring: {:?}", temp_square);
|
|
self = temp_square.div(&modulus).1;
|
|
//eprintln!("After mod: {:?}", self);
|
|
exponent >>= 1;
|
|
}
|
|
result
|
|
}
|
|
|
|
// Returns (quotient, remainder)
|
|
pub fn div(self, rhs: &Self) -> (Self, Self) {
|
|
// Div by zero check ommitted since data is guaranteed to be non 0
|
|
|
|
eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len());
|
|
|
|
if self.polynomial.len() < rhs.polynomial.len() {
|
|
return (Polynomial::new(vec![FieldElement::new(vec![0; 16])]), self);
|
|
}
|
|
|
|
let mut remainder = self.clone();
|
|
let divisor = rhs;
|
|
let dividend_deg = remainder.polynomial.len() - 1;
|
|
let divisor_deg = divisor.polynomial.len() - 1;
|
|
|
|
if dividend_deg < divisor_deg {
|
|
return (
|
|
Polynomial::new(vec![FieldElement::new(
|
|
polynomial_2_block(vec![0; 16], "gcm").unwrap(),
|
|
)]),
|
|
remainder,
|
|
);
|
|
}
|
|
|
|
let mut quotient_coeffs =
|
|
vec![
|
|
FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap());
|
|
dividend_deg - divisor_deg + 1
|
|
];
|
|
|
|
while remainder.polynomial.len() >= divisor.polynomial.len() {
|
|
let deg_diff = remainder.polynomial.len() - divisor.polynomial.len();
|
|
|
|
let leading_dividend = remainder.polynomial.last().unwrap();
|
|
let leading_divisor = divisor.polynomial.last().unwrap();
|
|
let quot_coeff = leading_dividend / leading_divisor;
|
|
|
|
quotient_coeffs[deg_diff] = quot_coeff.clone();
|
|
|
|
let mut subtrahend =
|
|
vec![FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); deg_diff];
|
|
subtrahend.extend(
|
|
divisor
|
|
.polynomial
|
|
.iter()
|
|
.map(|x| x.clone() * quot_coeff.clone()),
|
|
);
|
|
let subtrahend_poly = Polynomial::new(subtrahend);
|
|
|
|
remainder = remainder + subtrahend_poly;
|
|
|
|
while !remainder.polynomial.is_empty()
|
|
&& remainder
|
|
.polynomial
|
|
.last()
|
|
.unwrap()
|
|
.as_ref()
|
|
.iter()
|
|
.all(|&x| x == 0)
|
|
{
|
|
remainder.polynomial.pop();
|
|
}
|
|
}
|
|
|
|
if remainder.is_empty() {
|
|
remainder = Polynomial::new(vec![FieldElement::new(vec![0; 16])]);
|
|
}
|
|
(Polynomial::new(quotient_coeffs), remainder)
|
|
}
|
|
|
|
fn is_zero(&self) -> bool {
|
|
for field_element in &self.polynomial {
|
|
if !field_element.is_zero() {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
}
|
|
|
|
impl Clone for Polynomial {
|
|
fn clone(&self) -> Self {
|
|
Polynomial {
|
|
polynomial: self.polynomial.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Mul for Polynomial {
|
|
type Output = Self;
|
|
fn mul(self, rhs: Self) -> Self::Output {
|
|
if self.is_zero() || rhs.is_zero() {
|
|
return Polynomial::new(vec![FieldElement::new(vec![0; 16])]);
|
|
}
|
|
let mut polynomial: Vec<FieldElement> =
|
|
vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1];
|
|
for i in 0..self.polynomial.len() {
|
|
for j in 0..rhs.polynomial.len() {
|
|
polynomial[i + j] = &polynomial[i + j]
|
|
+ &(self.polynomial.get(i).unwrap() * rhs.polynomial.get(j).unwrap());
|
|
}
|
|
}
|
|
Polynomial::new(polynomial)
|
|
}
|
|
}
|
|
|
|
impl Mul for &Polynomial {
|
|
type Output = Polynomial;
|
|
fn mul(self, rhs: Self) -> Self::Output {
|
|
if self.is_zero() || rhs.is_zero() {
|
|
return Polynomial::new(vec![FieldElement::new(vec![0])]);
|
|
}
|
|
let mut polynomial: Vec<FieldElement> =
|
|
vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1];
|
|
for i in 0..self.polynomial.len() {
|
|
for j in 0..rhs.polynomial.len() {
|
|
polynomial[i + j] = &polynomial[i + j]
|
|
+ &(self.polynomial.get(i).unwrap() * rhs.polynomial.get(j).unwrap());
|
|
}
|
|
}
|
|
Polynomial::new(polynomial)
|
|
}
|
|
}
|
|
|
|
impl Add for Polynomial {
|
|
type Output = Self;
|
|
fn add(self, rhs: Self) -> Self::Output {
|
|
let mut polynomial: Vec<FieldElement>;
|
|
|
|
if self.polynomial.len() > rhs.polynomial.len() {
|
|
polynomial = self.polynomial.clone();
|
|
for i in 0..rhs.polynomial.len() {
|
|
polynomial[i] = polynomial[i].clone() + rhs.polynomial[i].clone();
|
|
}
|
|
} else {
|
|
polynomial = rhs.polynomial.clone();
|
|
for i in 0..self.polynomial.len() {
|
|
polynomial[i] = polynomial[i].clone() + self.polynomial[i].clone();
|
|
}
|
|
}
|
|
|
|
for i in (0..polynomial.len() - 1).rev() {
|
|
if polynomial[i].is_zero() {
|
|
polynomial.pop();
|
|
}
|
|
}
|
|
|
|
Polynomial::new(polynomial)
|
|
}
|
|
}
|
|
|
|
// Helper implementation for subtraction
|
|
impl Sub for &FieldElement {
|
|
type Output = FieldElement;
|
|
|
|
fn sub(self, rhs: Self) -> FieldElement {
|
|
// In a field of characteristic 2, addition and subtraction are the same operation (XOR)
|
|
self + rhs
|
|
}
|
|
}
|
|
|
|
// Helper trait for checking emptiness
|
|
trait IsEmpty {
|
|
fn is_empty(&self) -> bool;
|
|
}
|
|
|
|
impl IsEmpty for Polynomial {
|
|
fn is_empty(&self) -> bool {
|
|
self.polynomial.is_empty()
|
|
}
|
|
}
|
|
impl AsRef<[FieldElement]> for Polynomial {
|
|
fn as_ref(&self) -> &[FieldElement] {
|
|
&self.polynomial
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct FieldElement {
|
|
field_element: Vec<u8>,
|
|
}
|
|
|
|
impl FieldElement {
|
|
pub const IRREDUCIBLE_POLYNOMIAL: [u8; 17] = [
|
|
87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 01,
|
|
];
|
|
|
|
pub const fn new(field_element: Vec<u8>) -> Self {
|
|
Self { field_element }
|
|
}
|
|
|
|
pub fn mul(&self, poly_a: Vec<u8>, poly_b: Vec<u8>) -> Result<Vec<u8>> {
|
|
gfmul(&poly_a, &poly_b, "gcm")
|
|
}
|
|
|
|
pub fn to_b64(&self) -> String {
|
|
BASE64_STANDARD.encode(&self.field_element)
|
|
}
|
|
|
|
pub fn pow(&self, mut exponent: u128) -> FieldElement {
|
|
if exponent == 0 {
|
|
// Return polynomial with coefficient 1
|
|
return FieldElement::new(vec![1]);
|
|
}
|
|
|
|
let base = self.clone();
|
|
let mut result = base.clone();
|
|
exponent -= 1; // Subtract 1 because we already set result to base
|
|
|
|
while exponent > 0 {
|
|
result = result * base.clone();
|
|
exponent -= 1;
|
|
}
|
|
|
|
result
|
|
}
|
|
|
|
pub fn inv(mut self) -> Self {
|
|
let mut inverser: u128 = 0xfffffffffffffffffffffffffffffffe;
|
|
let mut inverse: Vec<u8> = polynomial_2_block(vec![0], "gcm").unwrap();
|
|
//eprintln!("Inverse start {:02X?}", inverse);
|
|
|
|
while inverser > 0 {
|
|
//eprintln!("{:02X}", inverser);
|
|
if inverser & 1 == 1 {
|
|
inverse = gfmul(&self.field_element, &inverse, "gcm").unwrap();
|
|
}
|
|
inverser >>= 1;
|
|
self.field_element = gfmul(&self.field_element, &self.field_element, "gcm")
|
|
.expect("Error in sqrmul sqr");
|
|
}
|
|
//eprintln!("Inverse rhs {:?}", inverse);
|
|
FieldElement::new(inverse)
|
|
}
|
|
|
|
fn is_zero(&self) -> bool {
|
|
self.field_element.iter().all(|&x| x == 0x00)
|
|
}
|
|
}
|
|
|
|
impl Mul for FieldElement {
|
|
type Output = Self;
|
|
|
|
fn mul(self, rhs: Self) -> Self::Output {
|
|
FieldElement::new(
|
|
gfmul(&self.field_element, &rhs.field_element, "gcm")
|
|
.expect("Error during multiplication"),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Mul for &FieldElement {
|
|
type Output = FieldElement;
|
|
|
|
fn mul(self, rhs: &FieldElement) -> FieldElement {
|
|
FieldElement::new(
|
|
gfmul(&self.field_element, &rhs.field_element, "gcm")
|
|
.expect("Error during multiplication"),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Add for FieldElement {
|
|
type Output = Self;
|
|
fn add(self, rhs: Self) -> Self::Output {
|
|
FieldElement::new(
|
|
xor_bytes(&self.field_element, rhs.field_element).expect("Error in poly add"),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Add for &FieldElement {
|
|
type Output = FieldElement;
|
|
fn add(self, rhs: Self) -> Self::Output {
|
|
FieldElement::new(
|
|
xor_bytes(&self.field_element, rhs.field_element.clone()).expect("Error in poly add"),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl AsRef<[u8]> for FieldElement {
|
|
fn as_ref(&self) -> &[u8] {
|
|
&self.field_element.as_ref()
|
|
}
|
|
}
|
|
|
|
impl Clone for FieldElement {
|
|
fn clone(&self) -> Self {
|
|
FieldElement {
|
|
field_element: self.field_element.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl BitXor for FieldElement {
|
|
type Output = Self;
|
|
fn bitxor(self, rhs: Self) -> Self::Output {
|
|
let result: Vec<u8> = self
|
|
.field_element
|
|
.iter()
|
|
.zip(rhs.field_element.iter())
|
|
.map(|(&x1, &x2)| x1 ^ x2)
|
|
.collect();
|
|
FieldElement::new(result)
|
|
}
|
|
}
|
|
|
|
impl Div for FieldElement {
|
|
type Output = Self;
|
|
fn div(self, rhs: Self) -> Self::Output {
|
|
eprintln!("RHS in div{:02X?}", &rhs);
|
|
|
|
let inverse = rhs.inv();
|
|
eprintln!("Inverse in div{:02X?}", inverse);
|
|
self.clone() * inverse
|
|
}
|
|
}
|
|
|
|
impl Div for &FieldElement {
|
|
type Output = FieldElement;
|
|
|
|
fn div(self, rhs: Self) -> Self::Output {
|
|
// First clone and invert the divisor (rhs)
|
|
let rhs_inv = rhs.clone().inv();
|
|
// Multiply original number by the inverse
|
|
self.clone() * rhs_inv
|
|
}
|
|
}
|
|
|
|
/*
|
|
impl Rem for FieldElement {
|
|
type Output = Self;
|
|
fn rem(self, rhs: Self) -> Self::Output {
|
|
let result: FieldElement = self.field_element;
|
|
|
|
while self.field_element[15] != 0x00 {
|
|
self.field_element
|
|
}
|
|
todo!();
|
|
}
|
|
}
|
|
*/
|
|
/*
|
|
impl BitXor for FieldElement {
|
|
fn bitxor(self, rhs: Self) -> Self::Output {
|
|
FieldElement
|
|
}
|
|
}
|
|
*/
|
|
|
|
/*
|
|
impl From<Vec<u8>> for FieldElement {
|
|
fn from(item: Vec<u8>) -> Self {
|
|
FieldElement { bytes: item }
|
|
}
|
|
}
|
|
*/
|
|
|
|
#[derive(Debug)]
|
|
pub struct ByteArray(pub Vec<u8>);
|
|
|
|
impl ByteArray {
|
|
pub fn left_shift(&mut self, semantic: &str) -> Result<u8> {
|
|
match semantic {
|
|
"xex" => {
|
|
let mut carry = 0u8;
|
|
for byte in self.0.iter_mut() {
|
|
let new_carry = *byte >> 7;
|
|
*byte = (*byte << 1) | carry;
|
|
carry = new_carry;
|
|
}
|
|
Ok(carry)
|
|
}
|
|
"gcm" => {
|
|
let mut carry = 0u8;
|
|
for byte in self.0.iter_mut() {
|
|
let new_carry = *byte & 1;
|
|
*byte = (*byte >> 1) | (carry << 7);
|
|
carry = new_carry;
|
|
}
|
|
Ok(carry)
|
|
}
|
|
_ => Err(anyhow!("Failure in lsh. No compatible action found")),
|
|
}
|
|
}
|
|
|
|
pub fn left_shift_reduce(&mut self, semantic: &str) {
|
|
match semantic {
|
|
"xex" => {
|
|
let alpha_poly: Vec<u8> = base64::prelude::BASE64_STANDARD
|
|
.decode("AgAAAAAAAAAAAAAAAAAAAA==")
|
|
.expect("Decode failed");
|
|
self.0 = gfmul(&self.0, &alpha_poly, "xex").unwrap();
|
|
}
|
|
"gcm" => {
|
|
let alpha_poly: Vec<u8> = base64::prelude::BASE64_STANDARD
|
|
.decode("AgAAAAAAAAAAAAAAAAAAAA==")
|
|
.expect("Decode failed");
|
|
self.0 = gfmul(&self.0, &alpha_poly, "gcm").unwrap();
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
pub fn right_shift(&mut self, semantic: &str) -> Result<u8> {
|
|
match semantic {
|
|
"xex" => {
|
|
let mut carry = 0u8;
|
|
for byte in self.0.iter_mut().rev() {
|
|
let new_carry = *byte & 1;
|
|
*byte = (*byte >> 1) | (carry << 7);
|
|
carry = new_carry;
|
|
}
|
|
Ok(carry)
|
|
}
|
|
"gcm" => {
|
|
let mut carry = 0u8;
|
|
for byte in self.0.iter_mut().rev() {
|
|
let new_carry = *byte & 1;
|
|
*byte = (*byte << 1) | carry;
|
|
carry = new_carry;
|
|
}
|
|
Ok(carry)
|
|
}
|
|
_ => Err(anyhow!("Failure in rsh. No valid semantic found")),
|
|
}
|
|
}
|
|
|
|
pub fn xor_byte_arrays(&mut self, vec2: &ByteArray) {
|
|
self.0
|
|
.iter_mut()
|
|
.zip(vec2.0.iter())
|
|
.for_each(|(x1, x2)| *x1 ^= *x2);
|
|
}
|
|
|
|
pub fn LSB_is_one(&self) -> bool {
|
|
(self.0.first().unwrap() & 1) == 1
|
|
}
|
|
|
|
pub fn msb_is_one(&self) -> bool {
|
|
(self.0.last().unwrap() & 1) == 1
|
|
}
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
for i in self.0.iter() {
|
|
if *i != 0 {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
|
|
pub fn reverse_bits_in_bytevec(&mut self) {
|
|
self.0 = self.0.iter_mut().map(|byte| byte.reverse_bits()).collect();
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use serde_json::json;
|
|
|
|
#[test]
|
|
fn test_byte_array_shift1() {
|
|
let mut byte_array: ByteArray = ByteArray(vec![0x00, 0x01]);
|
|
let shifted_array: ByteArray = ByteArray(vec![0x00, 0x02]);
|
|
byte_array.left_shift("xex").unwrap();
|
|
|
|
assert_eq!(byte_array.0, shifted_array.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_byte_array_shift2() {
|
|
let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]);
|
|
let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x01]);
|
|
byte_array.left_shift("xex").unwrap();
|
|
|
|
assert_eq!(
|
|
byte_array.0, shifted_array.0,
|
|
"Failure: Shifted array was: {:?}",
|
|
byte_array.0
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_byte_array_shift1_gcm() {
|
|
let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]);
|
|
let shifted_array: ByteArray = ByteArray(vec![0x7F, 0x80]);
|
|
byte_array.left_shift("gcm").unwrap();
|
|
|
|
assert_eq!(
|
|
byte_array.0, shifted_array.0,
|
|
"Failure: Shifted array was: {:02X?}",
|
|
byte_array.0
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_byte_array_shift1_right_gcm() {
|
|
let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]);
|
|
let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x00]);
|
|
byte_array.right_shift("gcm").unwrap();
|
|
|
|
assert_eq!(
|
|
byte_array.0, shifted_array.0,
|
|
"Failure: Shifted array was: {:02X?}",
|
|
byte_array.0
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_byte_array_shift_right() {
|
|
let mut byte_array: ByteArray = ByteArray(vec![0x02]);
|
|
let shifted_array: ByteArray = ByteArray(vec![0x01]);
|
|
byte_array.right_shift("xex").unwrap();
|
|
|
|
assert_eq!(
|
|
byte_array.0, shifted_array.0,
|
|
"Failure: Shifted array was: {:?}",
|
|
byte_array.0
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_lsb_one() {
|
|
let byte_array: ByteArray = ByteArray(vec![0x00, 0xFF]);
|
|
assert!(!byte_array.LSB_is_one());
|
|
|
|
let byte_array2: ByteArray = ByteArray(vec![0x02, 0xFF]);
|
|
assert!(!byte_array2.LSB_is_one());
|
|
|
|
let byte_array3: ByteArray = ByteArray(vec![0xFF, 0x00]);
|
|
assert!(byte_array3.LSB_is_one());
|
|
}
|
|
|
|
#[test]
|
|
fn test_byte_xor() {
|
|
let mut byte_array: ByteArray = ByteArray(vec![0x25, 0x25]);
|
|
let byte_array2: ByteArray = ByteArray(vec![0x55, 0x55]);
|
|
|
|
byte_array.xor_byte_arrays(&byte_array2);
|
|
|
|
assert_eq!(byte_array.0, vec![0x70, 0x70]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_byte_xor2() {
|
|
let mut byte_array: ByteArray = ByteArray(vec![0x00, 0x00]);
|
|
let byte_array2: ByteArray = ByteArray(vec![0x55, 0x55]);
|
|
|
|
byte_array.xor_byte_arrays(&byte_array2);
|
|
|
|
assert_eq!(byte_array.0, vec![0x55, 0x55]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_add_01() {
|
|
let element1: FieldElement =
|
|
FieldElement::new(BASE64_STANDARD.decode("NeverGonnaGiveYouUpAAA==").unwrap());
|
|
let element2: FieldElement =
|
|
FieldElement::new(BASE64_STANDARD.decode("KryptoanalyseAAAAAAAAA==").unwrap());
|
|
let sum = element2 + element1;
|
|
|
|
assert_eq!(BASE64_STANDARD.encode(sum), "H1d3GuyA9/0OxeYouUpAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_add_02() {
|
|
let element1: FieldElement =
|
|
FieldElement::new(BASE64_STANDARD.decode("NeverGonnaLetYouDownAA==").unwrap());
|
|
let element2: FieldElement =
|
|
FieldElement::new(BASE64_STANDARD.decode("DHBWMannheimAAAAAAAAAA==").unwrap());
|
|
let sum = element2 + element1;
|
|
|
|
assert_eq!(BASE64_STANDARD.encode(sum), "OZuIncPAGEp4tYouDownAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_add_03() {
|
|
let json1 = json!([
|
|
"NeverGonnaGiveYouUpAAA==",
|
|
"NeverGonnaLetYouDownAA==",
|
|
"NeverGonnaRunAroundAAA==",
|
|
"AndDesertYouAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["KryptoanalyseAAAAAAAAA==", "DHBWMannheimAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let sum = element2 + element1;
|
|
|
|
assert_eq!(
|
|
sum.to_c_array(),
|
|
vec![
|
|
"H1d3GuyA9/0OxeYouUpAAA==",
|
|
"OZuIncPAGEp4tYouDownAA==",
|
|
"NeverGonnaRunAroundAAA==",
|
|
"AndDesertYouAAAAAAAAAA=="
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_add_multiple_zeros() {
|
|
let json1 = json!([
|
|
"AAAAAAAAAAAAAAAAAAAAAA==",
|
|
"AAAAAAAAAAAAAAAAAAAAAA==",
|
|
"AAAAAAAAAAAAAAAAAAAAAA==",
|
|
"AAAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["AAAAAAAAAAAAAAAAAAAAAA==", "AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let sum = element2 + element1;
|
|
|
|
assert_eq!(sum.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA==",]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_add_same_element() {
|
|
let json1 = json!(["NeverGonnaGiveYouUpAAA=="]);
|
|
let json2 = json!(["NeverGonnaGiveYouUpAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let sum = element2 + element1;
|
|
|
|
assert_eq!(sum.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA==",]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_add_zero() {
|
|
let json1 = json!([
|
|
"NeverGonnaGiveYouUpAAA==",
|
|
"NeverGonnaLetYouDownAA==",
|
|
"NeverGonnaRunAroundAAA==",
|
|
"AndDesertYouAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let sum = element2 + element1;
|
|
|
|
assert_eq!(
|
|
sum.to_c_array(),
|
|
vec![
|
|
"NeverGonnaGiveYouUpAAA==",
|
|
"NeverGonnaLetYouDownAA==",
|
|
"NeverGonnaRunAroundAAA==",
|
|
"AndDesertYouAAAAAAAAAA=="
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_add_zero_to_zero() {
|
|
let json1 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let json2 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let sum = element2 + element1;
|
|
|
|
assert_eq!(sum.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_add_short_to_long() {
|
|
let json1 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let json2 = json!([
|
|
"NeverGonnaGiveYouUpAAA==",
|
|
"NeverGonnaLetYouDownAA==",
|
|
"NeverGonnaRunAroundAAA==",
|
|
"AndDesertYouAAAAAAAAAA=="
|
|
]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let sum = element2 + element1;
|
|
|
|
assert_eq!(
|
|
sum.to_c_array(),
|
|
vec![
|
|
"NeverGonnaGiveYouUpAAA==",
|
|
"NeverGonnaLetYouDownAA==",
|
|
"NeverGonnaRunAroundAAA==",
|
|
"AndDesertYouAAAAAAAAAA=="
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_mul_01() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
//eprintln!("{:?}", element1);
|
|
|
|
let result = element1 * element2;
|
|
|
|
assert_eq!(
|
|
result.to_c_array(),
|
|
vec![
|
|
"MoAAAAAAAAAAAAAAAAAAAA==",
|
|
"sUgAAAAAAAAAAAAAAAAAAA==",
|
|
"MbQAAAAAAAAAAAAAAAAAAA==",
|
|
"AAhAAAAAAAAAAAAAAAAAAA=="
|
|
]
|
|
);
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_poly_mul_with_zero() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
//eprintln!("{:?}", element1);
|
|
|
|
let result = element1 * element2;
|
|
|
|
assert_eq!(result.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_poly_pow_01() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
|
|
let result = element1.pow(3);
|
|
|
|
assert_eq!(
|
|
result.to_c_array(),
|
|
vec![
|
|
"AkkAAAAAAAAAAAAAAAAAAA==",
|
|
"DDAAAAAAAAAAAAAAAAAAAA==",
|
|
"LQIIAAAAAAAAAAAAAAAAAA==",
|
|
"8AAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACgCQAAAAAAAAAAAAAAAAA==",
|
|
"AAAMAAAAAAAAAAAAAAAAAA==",
|
|
"AAAAAgAAAAAAAAAAAAAAAA=="
|
|
]
|
|
);
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_poly_pow_with_zero() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
|
|
let result = element1.pow(0);
|
|
|
|
assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_pow_mod_01() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
|
|
let result = element1.pow(3);
|
|
|
|
assert_eq!(
|
|
result.to_c_array(),
|
|
vec![
|
|
"AkkAAAAAAAAAAAAAAAAAAA==",
|
|
"DDAAAAAAAAAAAAAAAAAAAA==",
|
|
"LQIIAAAAAAAAAAAAAAAAAA==",
|
|
"8AAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACgCQAAAAAAAAAAAAAAAAA==",
|
|
"AAAMAAAAAAAAAAAAAAAAAA==",
|
|
"AAAAAgAAAAAAAAAAAAAAAA=="
|
|
]
|
|
);
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_pow_mod_with_zero() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
|
|
let result = element1.pow(0);
|
|
|
|
assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_pow_mod_10mill() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["KryptoanalyseAAAAAAAAA==", "DHBWMannheimAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let modulus: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let result = element1.pow_mod(10000000, modulus);
|
|
|
|
assert!(!result.is_zero())
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_poly_div_01() {
|
|
let element1 =
|
|
FieldElement::new(BASE64_STANDARD.decode("JAAAAAAAAAAAAAAAAAAAAA==").unwrap());
|
|
|
|
let element2 =
|
|
FieldElement::new(BASE64_STANDARD.decode("wAAAAAAAAAAAAAAAAAAAAA==").unwrap());
|
|
|
|
let result = element1 / element2;
|
|
|
|
assert_eq!(BASE64_STANDARD.encode(result), "OAAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_poly_div_01() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
//eprintln!("{:?}", element1);
|
|
|
|
println!("Beginning the new division");
|
|
let (result, remainder) = element1.div(&element2);
|
|
|
|
assert_eq!(
|
|
result.to_c_array(),
|
|
vec!["nAIAgCAIAgCAIAgCAIAgCg==", "m85znOc5znOc5znOc5znOQ=="]
|
|
);
|
|
assert_eq!(remainder.to_c_array(), vec!["lQNA0DQNA0DQNA0DQNA0Dg=="]);
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_poly_div_larger_div() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let element2: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
//eprintln!("{:?}", element1);
|
|
|
|
println!("Beginning the new division");
|
|
let (result, remainder) = element2.div(&element1);
|
|
|
|
assert_eq!(result.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
assert_eq!(
|
|
remainder.to_c_array(),
|
|
vec!["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]
|
|
);
|
|
//assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_poly_powmod_01() {
|
|
let json1 = json!([
|
|
"JAAAAAAAAAAAAAAAAAAAAA==",
|
|
"wAAAAAAAAAAAAAAAAAAAAA==",
|
|
"ACAAAAAAAAAAAAAAAAAAAA=="
|
|
]);
|
|
let json2 = json!(["KryptoanalyseAAAAAAAAA==", "DHBWMannheimAAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let modulus: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let result = element1.pow_mod(1000, modulus);
|
|
|
|
eprintln!("Result is: {:02X?}", result);
|
|
assert_eq!(result.to_c_array(), vec!["oNXl5P8xq2WpUTP92u25zg=="]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_poly_powmod_k1() {
|
|
let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==",]);
|
|
let json2 = json!(["KryptoanalyseAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let modulus: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let result = element1.pow_mod(1, modulus);
|
|
|
|
eprintln!("Result is: {:02X?}", result);
|
|
assert_eq!(result.to_c_array(), vec!["JAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_field_poly_powmod_k0() {
|
|
let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==",]);
|
|
let json2 = json!(["KryptoanalyseAAAAAAAAA=="]);
|
|
let element1: Polynomial = Polynomial::from_c_array(&json1);
|
|
let modulus: Polynomial = Polynomial::from_c_array(&json2);
|
|
|
|
let result = element1.pow_mod(0, modulus);
|
|
|
|
eprintln!("Result is: {:02X?}", result);
|
|
assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]);
|
|
}
|
|
}
|