public void EncryptExponentiateDecryptNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 4);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var Encoder = new BinaryEncoder(parms.PlainModulus);
var encryptor = new Encryptor(parms, keygen.PublicKey);
var evaluator = new Evaluator(parms, keygen.EvaluationKeys);
var keygenEvals = keygen.EvaluationKeys;
var evaluatorEvals = keygen.EvaluationKeys;
for (int i = 0; i < keygen.EvaluationKeys.Count; ++i)
{
Assert.AreEqual(keygenEvals[i], evaluatorEvals[i]);
}
var decryptor = new Decryptor(parms, keygen.SecretKey);
var encrypted = encryptor.Encrypt(Encoder.Encode(5));
var power = evaluator.Exponentiate(encrypted, 1);
Assert.AreEqual(5, Encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(Encoder.Encode(5));
power = evaluator.Exponentiate(encrypted, 0);
Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(Encoder.Encode(5));
power = evaluator.Exponentiate(encrypted, 0);
Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(Encoder.Encode(7));
power = evaluator.Exponentiate(encrypted, 2);
Assert.AreEqual(49, Encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(Encoder.Encode(-7));
power = evaluator.Exponentiate(encrypted, 3);
Assert.AreEqual(-343, Encoder.DecodeInt32(decryptor.Decrypt(power)));
}
public void EncryptAddDecryptNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 6);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var Encoder = new BinaryEncoder(parms.PlainModulus);
var encryptor = new Encryptor(parms, keygen.PublicKey);
var evaluator = new Evaluator(parms, keygen.EvaluationKeys);
var decryptor = new Decryptor(parms, keygen.SecretKey);
var encrypted1 = encryptor.Encrypt(Encoder.Encode(0x12345678));
var encrypted2 = encryptor.Encrypt(Encoder.Encode(0x54321));
var sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(0));
encrypted2 = encryptor.Encrypt(Encoder.Encode(0));
sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(0UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(0));
encrypted2 = encryptor.Encrypt(Encoder.Encode(5));
sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(5UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(5));
encrypted2 = encryptor.Encrypt(Encoder.Encode(-3));
sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(2, Encoder.DecodeInt32(decryptor.Decrypt(sum)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(-7));
encrypted2 = encryptor.Encrypt(Encoder.Encode(2));
sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(-5, Encoder.DecodeInt32(decryptor.Decrypt(sum)));
}
public void FVEncryptAddsNoiseNET()
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(4);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("FFFFFFFFC001");
parms.SetCoeffModulus(coeffModulus);
var plainModulus = new BigUInt(7);
plainModulus.Set(1 << 6);
parms.SetPlainModulus(plainModulus);
var polyModulus = new BigPoly(65, 1);
polyModulus[0].Set(1);
polyModulus[64].Set(1);
parms.SetPolyModulus(polyModulus);
parms.Validate();
var Encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew());
var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew());
keygen.Generate();
var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew());
// however, this line is fine
Assert.AreEqual(encryptor.PublicKey[0], keygen.PublicKey[0]);
Assert.AreEqual(encryptor.PublicKey[1], keygen.PublicKey[1]);
var encrypted1 = encryptor.Encrypt(Encoder.Encode(0x12345678));
var encrypted2 = encryptor.Encrypt(Encoder.Encode(0x12345678));
// this is what we want to check
Assert.AreNotEqual(encrypted1[0], encrypted2[0]);
Assert.AreNotEqual(encrypted1[1], encrypted2[1]);
var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew());
Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted1)));
Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted2)));
}
public static bool Encode(BinaryEncoder encoder, byte[] value)
{
try
{
encoder.Encode((uint)value.Length);
encoder.Encode(value);
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public void FVEncryptExponentiateDecryptNET()
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(4);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("FFFFFFFFC001");
parms.SetCoeffModulus(coeffModulus);
var plainModulus = new BigUInt(7);
plainModulus.Set(1 << 6);
parms.SetPlainModulus(plainModulus);
var polyModulus = new BigPoly(65, 1);
polyModulus[0].Set(1);
polyModulus[64].Set(1);
parms.SetPolyModulus(polyModulus);
parms.Validate();
var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew());
keygen.Generate(1);
var encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew());
var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew());
var evaluator = new Evaluator(parms, keygen.EvaluationKeys, MemoryPoolHandle.AcquireNew());
var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew());
var encrypted = encryptor.Encrypt(encoder.Encode(5));
var power = evaluator.Exponentiate(encrypted, 1);
Assert.AreEqual(5, encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(encoder.Encode(7));
power = evaluator.Exponentiate(encrypted, 2);
Assert.AreEqual(49, encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(encoder.Encode(-7));
power = evaluator.Exponentiate(encrypted, 3);
Assert.AreEqual(-343, encoder.DecodeInt32(decryptor.Decrypt(power)));
}
//public static bool EncodeUTF8String(BinaryEncoder encoder, string value)
//{
// try
// {
// byte[] encoded_str = System.Text.Encoding.UTF8.GetBytes(value);
// encoder.Encode((uint)encoded_str.Length);
// encoder.Encode(encoded_str);
// }
// catch (System.Exception)
// {
// return false;
// }
// return true;
//}
public static bool EncodeUnicodeString(BinaryEncoder encoder, string value)
{
try
{
encoder.Encode((ushort)value.Length);
byte[] encoded_str = System.Text.Encoding.Unicode.GetBytes(value);
encoder.Encode(encoded_str);
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public void TestEncoderDecoder()
{
Value value = new Value(new SubValue(new SubSubValue("")), Value.bytes);
Value decoded = new Value();
this.Measure(() => {
byte[] buffer = new byte[8 * 1024];
int length = BinaryEncoder.Encode(value, buffer, 0);
Logger.Log($"Encoded message size: {length}");
decoded = BinaryDecoder.Decode <Value>(buffer, 0, length);
}, "Encoder and Decoder");
Assert.AreEqual(value.intVal, decoded.intVal);
Assert.AreEqual(value.shortVal, decoded.shortVal);
Assert.AreEqual(value.longVal, decoded.longVal);
Assert.AreEqual(value.uintVal, decoded.uintVal);
Assert.AreEqual(value.ushortVal, decoded.ushortVal);
Assert.AreEqual(value.ulongVal, decoded.ulongVal);
Assert.AreEqual(value.stringVal, decoded.stringVal);
Assert.AreEqual(value.bytesVal, decoded.bytesVal);
Assert.AreEqual(value.subValue, decoded.subValue);
Assert.AreEqual(value.subValue?.subSubValue.empty, decoded.subValue?.subSubValue.empty);
}
public void FVEncryptAddsNoiseNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 6);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var Encoder = new BinaryEncoder(parms.PlainModulus);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var encryptor = new Encryptor(parms, keygen.PublicKey);
// however, this line is fine
Assert.AreEqual(encryptor.PublicKey[0], keygen.PublicKey[0]);
Assert.AreEqual(encryptor.PublicKey[1], keygen.PublicKey[1]);
var encrypted1 = encryptor.Encrypt(Encoder.Encode(0x12345678));
var encrypted2 = encryptor.Encrypt(Encoder.Encode(0x12345678));
// this is what we want to check
Assert.AreNotEqual(encrypted1[0], encrypted2[0]);
Assert.AreNotEqual(encrypted1[1], encrypted2[1]);
var decryptor = new Decryptor(parms, keygen.SecretKey);
Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted1)));
Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted2)));
}
public void TestEncoder()
{
Value value = new Value(new SubValue(new SubSubValue("")), Value.bytes);
this.Measure(() => {
byte[] buffer = new byte[8 * 1024];
BinaryEncoder.Encode(value, buffer, 0);
}, "Encoder");
}
public void FVEncryptDecryptNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 6);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var Encoder = new BinaryEncoder(parms.PlainModulus);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var encryptor = new Encryptor(parms, keygen.PublicKey);
Assert.AreEqual(encryptor.PublicKey[0], keygen.PublicKey[0]);
Assert.AreEqual(encryptor.PublicKey[1], keygen.PublicKey[1]);
var decryptor = new Decryptor(parms, keygen.SecretKey);
Assert.AreEqual(decryptor.SecretKey, keygen.SecretKey);
var encrypted = encryptor.Encrypt(Encoder.Encode(0x12345678));
Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(0));
Assert.AreEqual(0U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(1));
Assert.AreEqual(1U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(2));
Assert.AreEqual(2U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFDUL));
Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFEUL));
Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFFUL));
Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted)));
}
public void Write <TMessage>(TMessage message) where TMessage : ITypedMessage
{
lock (this.lockToken) {
var startIndex = this.currentBufferLength;
this.currentBufferLength += CoderHelper.WriteInt(message.type, this.currentBuffer, this.currentBufferLength);
this.currentBufferLength += BinaryEncoder.Encode(message, this.currentBuffer, this.currentBufferLength);
this.currentBufferLength += CoderHelper.AddChecksum(this.currentBuffer, startIndex, this.currentBufferLength);
this.currentBufferLength += CoderHelper.InsertDelimiter(this.currentBuffer, this.currentBufferLength);
}
}
public void TestDecoder()
{
Value value = new Value(new SubValue(new SubSubValue("")), Value.bytes);
byte[] buffer = new byte[8 * 1024];
int length = BinaryEncoder.Encode(value, buffer, 0);
this.Measure(() => {
_ = BinaryDecoder.Decode <Value>(buffer, 0, length);
}, "Decoder");
}
public Task <long> WriteBlockAsync(IAvroWriterBlock <T> block)
{
if (block == null)
{
throw new ArgumentNullException("block");
}
var taskSource = new TaskCompletionSource <long>();
block.Flush();
long result = 0;
lock (this.locker)
{
if (!this.isHeaderWritten)
{
// This is never used.
result = this.WriteHeader();
}
if (block.ObjectCount != 0)
{
// Replace this with a MemoryStream, as we will be limited to the size of an Azure Blob Block
using (var stream = new MemoryStream())
{
using (var encoder = new BinaryEncoder(stream, true))
{
encoder.Encode(block.ObjectCount);
encoder.Encode(block.Content);
encoder.EncodeFixed(this.header.SyncMarker);
stream.Seek(0, SeekOrigin.Begin);
this.WriteStreamToBlobAsync(stream);
}
}
}
}
taskSource.SetResult(result);
return(taskSource.Task);
}
public static bool Encode(BinaryEncoder encoder, string value)
{
try
{
ushort size = (ushort)value.Length;
encoder.Encode(size);
byte[] bytes = new byte[value.Length];
for (int i = 0; i < value.Length; ++i)
{
bytes[i] = (byte)value[i];
}
encoder.Encode(bytes);
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public void TestMessageSize()
{
LoginRequest request = new LoginRequest {
accessToken = "asdfasdfasdf",
username = "******"
};
byte[] buffer = new byte[8 * 1024];
int size = BinaryEncoder.Encode(request, buffer, 0);
Logger.Log($"LoginRequest Message size: {size}");
}
public static bool Encode(BinaryEncoder encoder, FixedPoint value)
{
try
{
encoder.Encode(value.RawValue);
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public static bool Encode(BinaryEncoder encoder, double value)
{
try
{
encoder.Encode(value);
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public void EncryptNegateDecryptNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 6);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var Encoder = new BinaryEncoder(parms.PlainModulus);
var encryptor = new Encryptor(parms, keygen.PublicKey);
var evaluator = new Evaluator(parms, keygen.EvaluationKeys);
var decryptor = new Decryptor(parms, keygen.SecretKey);
var encrypted = encryptor.Encrypt(Encoder.Encode(0x12345678));
var negated = evaluator.Negate(encrypted);
Assert.AreEqual(-0x12345678, Encoder.DecodeInt32(decryptor.Decrypt(negated)));
encrypted = encryptor.Encrypt(Encoder.Encode(0));
negated = evaluator.Negate(encrypted);
Assert.AreEqual(0, Encoder.DecodeInt32(decryptor.Decrypt(negated)));
encrypted = encryptor.Encrypt(Encoder.Encode(1));
negated = evaluator.Negate(encrypted);
Assert.AreEqual(-1, Encoder.DecodeInt32(decryptor.Decrypt(negated)));
encrypted = encryptor.Encrypt(Encoder.Encode(-1));
negated = evaluator.Negate(encrypted);
Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(negated)));
encrypted = encryptor.Encrypt(Encoder.Encode(2));
negated = evaluator.Negate(encrypted);
Assert.AreEqual(-2, Encoder.DecodeInt32(decryptor.Decrypt(negated)));
encrypted = encryptor.Encrypt(Encoder.Encode(-5));
negated = evaluator.Negate(encrypted);
Assert.AreEqual(5, Encoder.DecodeInt32(decryptor.Decrypt(negated)));
}
public void Encode()
{
FormatterContext formatterContext =
new FormatterContext(FormatterContext.DefaultBufferSize);
_encoder.Encode(_data, ref formatterContext);
Assert.IsTrue(formatterContext.DataLength == _data.Length);
byte[] encodedData = formatterContext.GetData();
for (int i = _data.Length - 1; i >= 0; i--)
{
Assert.IsTrue(_data[i] == encodedData[i]);
}
}
public void FVEncryptAddManyDecryptNET()
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(4);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("FFFFFFFFC001");
parms.SetCoeffModulus(coeffModulus);
var plainModulus = new BigUInt(7);
plainModulus.Set(1 << 6);
parms.SetPlainModulus(plainModulus);
var polyModulus = new BigPoly(65, 1);
polyModulus[0].Set(1);
polyModulus[64].Set(1);
parms.SetPolyModulus(polyModulus);
parms.Validate();
var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew());
keygen.Generate();
var encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew());
var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew());
var evaluator = new Evaluator(parms, MemoryPoolHandle.AcquireNew());
var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew());
var encrypted1 = encryptor.Encrypt(encoder.Encode(5));
var encrypted2 = encryptor.Encrypt(encoder.Encode(6));
var encrypted3 = encryptor.Encrypt(encoder.Encode(7));
var encrypteds = new List <BigPolyArray>()
{
encrypted1, encrypted2, encrypted3
};
var product = evaluator.AddMany(encrypteds);
Assert.AreEqual(18, encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(encoder.Encode(-9));
encrypted2 = encryptor.Encrypt(encoder.Encode(-17));
encrypteds = new List <BigPolyArray>()
{
encrypted1, encrypted2
};
product = evaluator.AddMany(encrypteds);
Assert.AreEqual(-26, encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(encoder.Encode(2));
encrypted2 = encryptor.Encrypt(encoder.Encode(-31));
encrypted3 = encryptor.Encrypt(encoder.Encode(7));
encrypteds = new List <BigPolyArray>()
{
encrypted1, encrypted2, encrypted3
};
product = evaluator.AddMany(encrypteds);
Assert.AreEqual(-22, encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(encoder.Encode(1));
encrypted2 = encryptor.Encrypt(encoder.Encode(-1));
encrypted3 = encryptor.Encrypt(encoder.Encode(1));
var encrypted4 = encryptor.Encrypt(encoder.Encode(-1));
encrypteds = new List <BigPolyArray>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.AddMany(encrypteds);
Assert.AreEqual(0, encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(encoder.Encode(98765));
encrypted2 = encryptor.Encrypt(encoder.Encode(0));
encrypted3 = encryptor.Encrypt(encoder.Encode(12345));
encrypted4 = encryptor.Encrypt(encoder.Encode(34567));
encrypteds = new List <BigPolyArray>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.AddMany(encrypteds);
Assert.AreEqual(145677, encoder.DecodeInt32(decryptor.Decrypt(product)));
BalancedFractionalEncoder fracEncoder = new BalancedFractionalEncoder(plainModulus, polyModulus, 10, 15, MemoryPoolHandle.AcquireNew());
encrypted1 = encryptor.Encrypt(fracEncoder.Encode(3.1415));
encrypted2 = encryptor.Encrypt(fracEncoder.Encode(12.345));
encrypted3 = encryptor.Encrypt(fracEncoder.Encode(98.765));
encrypted4 = encryptor.Encrypt(fracEncoder.Encode(1.1111));
encrypteds = new List <BigPolyArray>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.AddMany(encrypteds);
Assert.IsTrue(System.Math.Abs(fracEncoder.Decode(decryptor.Decrypt(product)) - 115.3626) < 0.000001);
}
public void FVEncryptAddDecryptNET()
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(4);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("FFFFFFFFC001");
parms.SetCoeffModulus(coeffModulus);
var plainModulus = new BigUInt(7);
plainModulus.Set(1 << 6);
parms.SetPlainModulus(plainModulus);
var polyModulus = new BigPoly(65, 1);
polyModulus[0].Set(1);
polyModulus[64].Set(1);
parms.SetPolyModulus(polyModulus);
parms.Validate();
var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew());
keygen.Generate();
var encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew());
var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew());
var evaluator = new Evaluator(parms, MemoryPoolHandle.AcquireNew());
var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew());
var encrypted1 = encryptor.Encrypt(encoder.Encode(0x12345678));
var encrypted2 = encryptor.Encrypt(encoder.Encode(0x54321));
var sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(0x12399999UL, encoder.DecodeUInt64(decryptor.Decrypt(sum)));
encrypted1 = encryptor.Encrypt(encoder.Encode(0));
encrypted2 = encryptor.Encrypt(encoder.Encode(0));
sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(0UL, encoder.DecodeUInt64(decryptor.Decrypt(sum)));
encrypted1 = encryptor.Encrypt(encoder.Encode(0));
encrypted2 = encryptor.Encrypt(encoder.Encode(5));
sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(5UL, encoder.DecodeUInt64(decryptor.Decrypt(sum)));
encrypted1 = encryptor.Encrypt(encoder.Encode(5));
encrypted2 = encryptor.Encrypt(encoder.Encode(-3));
sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(2, encoder.DecodeInt32(decryptor.Decrypt(sum)));
encrypted1 = encryptor.Encrypt(encoder.Encode(-7));
encrypted2 = encryptor.Encrypt(encoder.Encode(2));
sum = evaluator.Add(encrypted1, encrypted2);
Assert.AreEqual(-5, encoder.DecodeInt32(decryptor.Decrypt(sum)));
}
public void BinaryEncodeDecodeBigUIntNET()
{
var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF);
var encoder = new BinaryEncoder(modulus);
var value = new BigUInt(64);
value.Set("0");
var poly = encoder.Encode(value);
Assert.AreEqual(0, poly.SignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(value, encoder.DecodeBigUInt(poly));
value.Set("1");
var poly1 = encoder.Encode(value);
Assert.AreEqual(1, poly1.SignificantCoeffCount());
Assert.AreEqual("1", poly1.ToString());
Assert.AreEqual(value, encoder.DecodeBigUInt(poly1));
value.Set("2");
var poly2 = encoder.Encode(value);
Assert.AreEqual(2, poly2.SignificantCoeffCount());
Assert.AreEqual("1x^1", poly2.ToString());
Assert.AreEqual(value, encoder.DecodeBigUInt(poly2));
value.Set("3");
var poly3 = encoder.Encode(value);
Assert.AreEqual(2, poly3.SignificantCoeffCount());
Assert.AreEqual("1x^1 + 1", poly3.ToString());
Assert.AreEqual(value, encoder.DecodeBigUInt(poly3));
value.Set("FFFFFFFFFFFFFFFF");
var poly4 = encoder.Encode(value);
Assert.AreEqual(64, poly4.SignificantCoeffCount());
for (int i = 0; i < 64; ++i)
{
Assert.AreEqual("1", poly4[i].ToString());
}
Assert.AreEqual(value, encoder.DecodeBigUInt(poly4));
value.Set("80F02");
var poly5 = encoder.Encode(value);
Assert.AreEqual(20, poly5.SignificantCoeffCount());
for (int i = 0; i < 20; ++i)
{
if (i == 19 || (i >= 8 && i <= 11) || i == 1)
{
Assert.AreEqual("1", poly5[i].ToString());
}
else
{
Assert.IsTrue(poly5[i] == 0);
}
}
Assert.AreEqual(value, encoder.DecodeBigUInt(poly5));
var poly6 = new Plaintext(3);
poly6[0] = 1;
poly6[1] = 500;
poly6[2] = 1023;
value.Set(1 + 500 * 2 + 1023 * 4);
Assert.AreEqual(value, encoder.DecodeBigUInt(poly6));
modulus.Set(1024);
var encoder2 = new BinaryEncoder(modulus);
var poly7 = new Plaintext(4);
poly7[0] = 1023; // -1 (*1)
poly7[1] = 512; // -512 (*2)
poly7[2] = 511; // 511 (*4)
poly7[3] = 1; // 1 (*8)
value.Set(-1 + -512 * 2 + 511 * 4 + 1 * 8);
Assert.AreEqual(value, encoder2.DecodeBigUInt(poly7));
}
public void EvaluateTestModeNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06,
Mode = EncryptionMode.Test
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 6);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var Encoder = new BinaryEncoder(parms.PlainModulus);
var encryptor = new Encryptor(parms, keygen.PublicKey);
var evaluator = new Evaluator(parms, keygen.EvaluationKeys);
var decryptor = new Decryptor(parms, keygen.SecretKey);
var encrypted = encryptor.Encrypt(Encoder.Encode(0x12345678));
var negated = evaluator.Negate(encrypted);
Assert.AreEqual(-0x12345678, Encoder.DecodeInt32(negated));
Assert.AreEqual(-0x12345678, Encoder.DecodeInt32(decryptor.Decrypt(negated)));
var plain2 = Encoder.Encode(0x54321);
var encrypted2 = encryptor.Encrypt(plain2);
var sum = evaluator.Add(encrypted, encrypted2);
Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(sum));
Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum)));
sum = evaluator.AddPlain(encrypted, plain2);
Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(sum));
Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum)));
var diff = evaluator.Sub(encrypted, encrypted2);
Assert.AreEqual(0x122F1357, Encoder.DecodeInt32(diff));
Assert.AreEqual(0x122F1357, Encoder.DecodeInt32(decryptor.Decrypt(diff)));
diff = evaluator.SubPlain(encrypted, plain2);
Assert.AreEqual(0x122F1357, Encoder.DecodeInt32(diff));
Assert.AreEqual(0x122F1357, Encoder.DecodeInt32(decryptor.Decrypt(diff)));
var prod = evaluator.Multiply(encrypted, encrypted2);
Assert.AreEqual(0x5FCBBBB88D78UL, Encoder.DecodeUInt64(prod));
Assert.AreEqual(0x5FCBBBB88D78UL, Encoder.DecodeUInt64(decryptor.Decrypt(prod)));
prod = evaluator.MultiplyPlain(encrypted, plain2);
Assert.AreEqual(0x5FCBBBB88D78UL, Encoder.DecodeUInt64(prod));
Assert.AreEqual(0x5FCBBBB88D78UL, Encoder.DecodeUInt64(decryptor.Decrypt(prod)));
}
public void BinaryEncodeDecodeInt32NET()
{
var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF);
var encoder = new BinaryEncoder(modulus, MemoryPoolHandle.New());
var poly = encoder.Encode(0);
Assert.AreEqual(0, poly.SignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0, encoder.DecodeInt32(poly));
var poly1 = encoder.Encode(1);
Assert.AreEqual(1, poly1.SignificantCoeffCount());
Assert.AreEqual("1", poly1.ToString());
Assert.AreEqual(1, encoder.DecodeInt32(poly1));
var poly2 = encoder.Encode(2);
Assert.AreEqual(2, poly2.SignificantCoeffCount());
Assert.AreEqual("1x^1", poly2.ToString());
Assert.AreEqual(2, encoder.DecodeInt32(poly2));
var poly3 = encoder.Encode(3);
Assert.AreEqual(2, poly3.SignificantCoeffCount());
Assert.AreEqual("1x^1 + 1", poly3.ToString());
Assert.AreEqual(3, encoder.DecodeInt32(poly3));
var poly4 = encoder.Encode(-1);
Assert.AreEqual(1, poly4.SignificantCoeffCount());
Assert.AreEqual("FFFFFFFFFFFFFFE", poly4.ToString());
Assert.AreEqual(-1, encoder.DecodeInt32(poly4));
var poly5 = encoder.Encode(-2);
Assert.AreEqual(2, poly5.SignificantCoeffCount());
Assert.AreEqual("FFFFFFFFFFFFFFEx^1", poly5.ToString());
Assert.AreEqual(-2, encoder.DecodeInt32(poly5));
var poly6 = encoder.Encode(-3);
Assert.AreEqual(2, poly6.SignificantCoeffCount());
Assert.AreEqual("FFFFFFFFFFFFFFEx^1 + FFFFFFFFFFFFFFE", poly6.ToString());
Assert.AreEqual(-3, encoder.DecodeInt32(poly6));
var poly7 = encoder.Encode(0x7FFFFFFF);
Assert.AreEqual(31, poly7.SignificantCoeffCount());
for (int i = 0; i < 31; ++i)
{
Assert.AreEqual("1", poly7[i].ToString());
}
Assert.AreEqual(0x7FFFFFFF, encoder.DecodeInt32(poly7));
var poly8 = encoder.Encode(unchecked ((int)0x80000000));
Assert.AreEqual(32, poly8.SignificantCoeffCount());
Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly8[31]);
for (int i = 0; i < 31; ++i)
{
Assert.IsTrue(poly8[i] == 0);
}
Assert.AreEqual(unchecked ((int)0x80000000), encoder.DecodeInt32(poly8));
var poly9 = encoder.Encode(0x80F02);
Assert.AreEqual(20, poly9.SignificantCoeffCount());
for (int i = 0; i < 20; ++i)
{
if (i == 19 || (i >= 8 && i <= 11) || i == 1)
{
Assert.AreEqual("1", poly9[i].ToString());
}
else
{
Assert.IsTrue(poly9[i] == 0);
}
}
Assert.AreEqual(0x80F02, encoder.DecodeInt32(poly9));
var poly10 = encoder.Encode(-1073);
Assert.AreEqual(11, poly10.SignificantCoeffCount());
Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[10]);
Assert.IsTrue(poly10[9] == 0);
Assert.IsTrue(poly10[8] == 0);
Assert.IsTrue(poly10[7] == 0);
Assert.IsTrue(poly10[6] == 0);
Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[5]);
Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[4]);
Assert.IsTrue(poly10[3] == 0);
Assert.IsTrue(poly10[2] == 0);
Assert.IsTrue(poly10[1] == 0);
Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[0]);
Assert.AreEqual(-1073, encoder.DecodeInt32(poly10));
modulus.Set(0xFFFF);
var encoder2 = new BinaryEncoder(modulus, MemoryPoolHandle.New());
var poly11 = new Plaintext(6);
poly11[0] = 1;
poly11[1] = 0xFFFE; // -1
poly11[2] = 0xFFFD; // -2
poly11[3] = 0x8000; // -32767
poly11[4] = 0x7FFF; // 32767
poly11[5] = 0x7FFE; // 32766
Assert.AreEqual(1 + -1 * 2 + -2 * 4 + -32767 * 8 + 32767 * 16 + 32766 * 32, encoder2.DecodeInt32(poly11));
}
public void EncryptAddManyDecryptNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 4);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var Encoder = new BinaryEncoder(parms.PlainModulus);
var encryptor = new Encryptor(parms, keygen.PublicKey);
var evaluator = new Evaluator(parms, keygen.EvaluationKeys);
var keygenEvals = keygen.EvaluationKeys;
var evaluatorEvals = keygen.EvaluationKeys;
for (int i = 0; i < keygen.EvaluationKeys.Count; ++i)
{
Assert.AreEqual(keygenEvals[i], evaluatorEvals[i]);
}
var decryptor = new Decryptor(parms, keygen.SecretKey);
var encrypted1 = encryptor.Encrypt(Encoder.Encode(5));
var encrypted2 = encryptor.Encrypt(Encoder.Encode(6));
var encrypted3 = encryptor.Encrypt(Encoder.Encode(7));
var encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3
};
var product = evaluator.AddMany(encrypteds);
Assert.AreEqual(18, Encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(-9));
encrypted2 = encryptor.Encrypt(Encoder.Encode(-17));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2
};
product = evaluator.AddMany(encrypteds);
Assert.AreEqual(-26, Encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(2));
encrypted2 = encryptor.Encrypt(Encoder.Encode(-31));
encrypted3 = encryptor.Encrypt(Encoder.Encode(7));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3
};
product = evaluator.AddMany(encrypteds);
Assert.AreEqual(-22, Encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(1));
encrypted2 = encryptor.Encrypt(Encoder.Encode(-1));
encrypted3 = encryptor.Encrypt(Encoder.Encode(1));
var encrypted4 = encryptor.Encrypt(Encoder.Encode(-1));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.AddMany(encrypteds);
Assert.AreEqual(0, Encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(98765));
encrypted2 = encryptor.Encrypt(Encoder.Encode(0));
encrypted3 = encryptor.Encrypt(Encoder.Encode(12345));
encrypted4 = encryptor.Encrypt(Encoder.Encode(34567));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.AddMany(encrypteds);
Assert.AreEqual(145677, Encoder.DecodeInt32(decryptor.Decrypt(product)));
BalancedFractionalEncoder fracEncoder = new BalancedFractionalEncoder(plainModulus, polyModulus, 10, 15);
encrypted1 = encryptor.Encrypt(fracEncoder.Encode(3.1415));
encrypted2 = encryptor.Encrypt(fracEncoder.Encode(12.345));
encrypted3 = encryptor.Encrypt(fracEncoder.Encode(98.765));
encrypted4 = encryptor.Encrypt(fracEncoder.Encode(1.1111));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.AddMany(encrypteds);
Assert.IsTrue(System.Math.Abs(fracEncoder.Decode(decryptor.Decrypt(product)) - 115.3626) < 0.000001);
}
public void BinaryEncodeDecodeUInt64NET()
{
var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF);
var encoder = new BinaryEncoder(modulus, MemoryPoolHandle.New());
var poly = encoder.Encode(0UL);
Assert.AreEqual(0, poly.SignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0UL, encoder.DecodeUInt64(poly));
var poly1 = encoder.Encode(1UL);
Assert.AreEqual(1, poly1.SignificantCoeffCount());
Assert.AreEqual("1", poly1.ToString());
Assert.AreEqual(1UL, encoder.DecodeUInt64(poly1));
var poly2 = encoder.Encode(2UL);
Assert.AreEqual(2, poly2.SignificantCoeffCount());
Assert.AreEqual("1x^1", poly2.ToString());
Assert.AreEqual(2UL, encoder.DecodeUInt64(poly2));
var poly3 = encoder.Encode(3UL);
Assert.AreEqual(2, poly3.SignificantCoeffCount());
Assert.AreEqual("1x^1 + 1", poly3.ToString());
Assert.AreEqual(3UL, encoder.DecodeUInt64(poly3));
var poly4 = encoder.Encode(0xFFFFFFFFFFFFFFFFUL);
Assert.AreEqual(64, poly4.SignificantCoeffCount());
for (int i = 0; i < 64; ++i)
{
Assert.AreEqual("1", poly4[i].ToString());
}
Assert.AreEqual(0xFFFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(poly4));
var poly5 = encoder.Encode(0x80F02UL);
Assert.AreEqual(20, poly5.SignificantCoeffCount());
for (int i = 0; i < 20; ++i)
{
if (i == 19 || (i >= 8 && i <= 11) || i == 1)
{
Assert.AreEqual("1", poly5[i].ToString());
}
else
{
Assert.IsTrue(poly5[i] == 0);
}
}
Assert.AreEqual(0x80F02UL, encoder.DecodeUInt64(poly5));
var poly6 = new Plaintext(3);
poly6[0] = 1;
poly6[1] = 500;
poly6[2] = 1023;
Assert.AreEqual((1UL + 500 * 2 + 1023 * 4), encoder.DecodeUInt64(poly6));
modulus.Set(1024);
var encoder2 = new BinaryEncoder(modulus, MemoryPoolHandle.New());
var poly7 = new Plaintext(4);
poly7[0] = 1023; // -1 (*1)
poly7[1] = 512; // -512 (*2)
poly7[2] = 511; // 511 (*4)
poly7[3] = 1; // 1 (*8)
Assert.AreEqual((ulong)(-1 + -512 * 2 + 511 * 4 + 1 * 8), encoder2.DecodeUInt64(poly7));
}
public void EncryptMultiplyManyDecryptNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 4);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var Encoder = new BinaryEncoder(parms.PlainModulus);
var encryptor = new Encryptor(parms, keygen.PublicKey);
var evaluator = new Evaluator(parms, keygen.EvaluationKeys);
var keygenEvals = keygen.EvaluationKeys;
var evaluatorEvals = keygen.EvaluationKeys;
for (int i = 0; i < keygen.EvaluationKeys.Count; ++i)
{
Assert.AreEqual(keygenEvals[i], evaluatorEvals[i]);
}
var decryptor = new Decryptor(parms, keygen.SecretKey);
var encrypted1 = encryptor.Encrypt(Encoder.Encode(2));
var encrypted2 = encryptor.Encrypt(Encoder.Encode(-3));
var encrypted3 = encryptor.Encrypt(Encoder.Encode(4));
var encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3
};
var product = evaluator.MultiplyMany(encrypteds);
Assert.AreEqual(-24, Encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(-9));
encrypted2 = encryptor.Encrypt(Encoder.Encode(-17));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2
};
product = evaluator.MultiplyMany(encrypteds);
Assert.AreEqual(153, Encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(2));
encrypted2 = encryptor.Encrypt(Encoder.Encode(-31));
encrypted3 = encryptor.Encrypt(Encoder.Encode(7));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3
};
product = evaluator.MultiplyMany(encrypteds);
Assert.AreEqual(-434, Encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(1));
encrypted2 = encryptor.Encrypt(Encoder.Encode(-1));
encrypted3 = encryptor.Encrypt(Encoder.Encode(1));
var encrypted4 = encryptor.Encrypt(Encoder.Encode(-1));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.MultiplyMany(encrypteds);
Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(Encoder.Encode(98765));
encrypted2 = encryptor.Encrypt(Encoder.Encode(0));
encrypted3 = encryptor.Encrypt(Encoder.Encode(12345));
encrypted4 = encryptor.Encrypt(Encoder.Encode(34567));
encrypteds = new List <BigPoly>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.MultiplyMany(encrypteds);
Assert.AreEqual(0, Encoder.DecodeInt32(decryptor.Decrypt(product)));
}
public void BinaryEncodeDecodeInt32NET()
{
var modulus = new BigUInt("FFFFFFFFFFFFFFFF");
var encoder = new BinaryEncoder(modulus);
var poly = encoder.Encode(0);
Assert.AreEqual(0, poly.GetSignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0, encoder.DecodeInt32(poly));
var poly1 = encoder.Encode(1);
Assert.AreEqual(1, poly1.GetSignificantCoeffCount());
Assert.AreEqual(1, poly1.CoeffBitCount);
Assert.AreEqual("1", poly1.ToString());
Assert.AreEqual(1, encoder.DecodeInt32(poly1));
var poly2 = encoder.Encode(2);
Assert.AreEqual(2, poly2.GetSignificantCoeffCount());
Assert.AreEqual(1, poly2.CoeffBitCount);
Assert.AreEqual("1x^1", poly2.ToString());
Assert.AreEqual(2, encoder.DecodeInt32(poly2));
var poly3 = encoder.Encode(3);
Assert.AreEqual(2, poly3.GetSignificantCoeffCount());
Assert.AreEqual(1, poly3.CoeffBitCount);
Assert.AreEqual("1x^1 + 1", poly3.ToString());
Assert.AreEqual(3, encoder.DecodeInt32(poly3));
var poly4 = encoder.Encode(-1);
Assert.AreEqual(1, poly4.GetSignificantCoeffCount());
Assert.AreEqual(64, poly4.CoeffBitCount);
Assert.AreEqual("FFFFFFFFFFFFFFFE", poly4.ToString());
Assert.AreEqual(-1, encoder.DecodeInt32(poly4));
var poly5 = encoder.Encode(-2);
Assert.AreEqual(2, poly5.GetSignificantCoeffCount());
Assert.AreEqual(64, poly5.CoeffBitCount);
Assert.AreEqual("FFFFFFFFFFFFFFFEx^1", poly5.ToString());
Assert.AreEqual(-2, encoder.DecodeInt32(poly5));
var poly6 = encoder.Encode(-3);
Assert.AreEqual(2, poly6.GetSignificantCoeffCount());
Assert.AreEqual(64, poly6.CoeffBitCount);
Assert.AreEqual("FFFFFFFFFFFFFFFEx^1 + FFFFFFFFFFFFFFFE", poly6.ToString());
Assert.AreEqual(-3, encoder.DecodeInt32(poly6));
var poly7 = encoder.Encode(0x7FFFFFFF);
Assert.AreEqual(31, poly7.GetSignificantCoeffCount());
Assert.AreEqual(1, poly7.CoeffBitCount);
for (int i = 0; i < 31; ++i)
{
Assert.AreEqual("1", poly7[i].ToString());
}
Assert.AreEqual(0x7FFFFFFF, encoder.DecodeInt32(poly7));
var poly8 = encoder.Encode(unchecked ((int)0x80000000));
Assert.AreEqual(32, poly8.GetSignificantCoeffCount());
Assert.AreEqual(64, poly8.CoeffBitCount);
Assert.AreEqual("FFFFFFFFFFFFFFFE", poly8[31].ToString());
for (int i = 0; i < 31; ++i)
{
Assert.IsTrue(poly8[i].IsZero);
}
Assert.AreEqual(unchecked ((int)0x80000000), encoder.DecodeInt32(poly8));
var poly9 = encoder.Encode(0x80F02);
Assert.AreEqual(20, poly9.GetSignificantCoeffCount());
Assert.AreEqual(1, poly9.CoeffBitCount);
for (int i = 0; i < 20; ++i)
{
if (i == 19 || (i >= 8 && i <= 11) || i == 1)
{
Assert.AreEqual("1", poly9[i].ToString());
}
else
{
Assert.IsTrue(poly9[i].IsZero);
}
}
Assert.AreEqual(0x80F02, encoder.DecodeInt32(poly9));
var poly10 = encoder.Encode(-1073);
Assert.AreEqual(11, poly10.GetSignificantCoeffCount());
Assert.AreEqual(64, poly10.CoeffBitCount);
Assert.AreEqual("FFFFFFFFFFFFFFFE", poly10[10].ToString());
Assert.IsTrue(poly10[9].IsZero);
Assert.IsTrue(poly10[8].IsZero);
Assert.IsTrue(poly10[7].IsZero);
Assert.IsTrue(poly10[6].IsZero);
Assert.AreEqual("FFFFFFFFFFFFFFFE", poly10[5].ToString());
Assert.AreEqual("FFFFFFFFFFFFFFFE", poly10[4].ToString());
Assert.IsTrue(poly10[3].IsZero);
Assert.IsTrue(poly10[2].IsZero);
Assert.IsTrue(poly10[1].IsZero);
Assert.AreEqual("FFFFFFFFFFFFFFFE", poly10[0].ToString());
Assert.AreEqual(-1073, encoder.DecodeInt32(poly10));
modulus.Set("FFFF");
var encoder2 = new BinaryEncoder(modulus);
var poly11 = new BigPoly(6, 64);
poly11[0].Set(1);
poly11[1].Set("FFFE"); // -1
poly11[2].Set("FFFD"); // -2
poly11[3].Set("8000"); // -32767
poly11[4].Set("7FFF"); // 32767
poly11[5].Set("7FFE"); // 32766
Assert.AreEqual(1 + -1 * 2 + -2 * 4 + -32767 * 8 + 32767 * 16 + 32766 * 32, encoder2.DecodeInt32(poly11));
}
public void BinaryEncodeDecodeUInt64NET()
{
var modulus = new BigUInt("FFFFFFFFFFFFFFFF");
var encoder = new BinaryEncoder(modulus);
var poly = encoder.Encode(0UL);
Assert.AreEqual(0, poly.GetSignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0UL, encoder.DecodeUInt64(poly));
var poly1 = encoder.Encode(1UL);
Assert.AreEqual(1, poly1.GetSignificantCoeffCount());
Assert.AreEqual(1, poly1.CoeffBitCount);
Assert.AreEqual("1", poly1.ToString());
Assert.AreEqual(1UL, encoder.DecodeUInt64(poly1));
var poly2 = encoder.Encode(2UL);
Assert.AreEqual(2, poly2.GetSignificantCoeffCount());
Assert.AreEqual(1, poly2.CoeffBitCount);
Assert.AreEqual("1x^1", poly2.ToString());
Assert.AreEqual(2UL, encoder.DecodeUInt64(poly2));
var poly3 = encoder.Encode(3UL);
Assert.AreEqual(2, poly3.GetSignificantCoeffCount());
Assert.AreEqual(1, poly3.CoeffBitCount);
Assert.AreEqual("1x^1 + 1", poly3.ToString());
Assert.AreEqual(3UL, encoder.DecodeUInt64(poly3));
var poly4 = encoder.Encode(0xFFFFFFFFFFFFFFFFUL);
Assert.AreEqual(64, poly4.GetSignificantCoeffCount());
Assert.AreEqual(1, poly4.CoeffBitCount);
for (int i = 0; i < 64; ++i)
{
Assert.AreEqual("1", poly4[i].ToString());
}
Assert.AreEqual(0xFFFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(poly4));
var poly5 = encoder.Encode(0x80F02UL);
Assert.AreEqual(20, poly5.GetSignificantCoeffCount());
Assert.AreEqual(1, poly5.CoeffBitCount);
for (int i = 0; i < 20; ++i)
{
if (i == 19 || (i >= 8 && i <= 11) || i == 1)
{
Assert.AreEqual("1", poly5[i].ToString());
}
else
{
Assert.IsTrue(poly5[i].IsZero);
}
}
Assert.AreEqual(0x80F02UL, encoder.DecodeUInt64(poly5));
var poly6 = new BigPoly(3, 10);
poly6[0].Set(1);
poly6[1].Set(500);
poly6[2].Set(1023);
Assert.AreEqual((1UL + 500 * 2 + 1023 * 4), encoder.DecodeUInt64(poly6));
modulus.Set(1024);
var encoder2 = new BinaryEncoder(modulus);
var poly7 = new BigPoly(4, 10);
poly7[0].Set(1023); // -1 (*1)
poly7[1].Set(512); // -512 (*2)
poly7[2].Set(511); // 511 (*4)
poly7[3].Set(1); // 1 (*8)
Assert.AreEqual((ulong)(-1 + -512 * 2 + 511 * 4 + 1 * 8), encoder2.DecodeUInt64(poly7));
}
public void FVEncryptDecryptNET()
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(4);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("FFFFFFFFC001");
parms.SetCoeffModulus(coeffModulus);
var plainModulus = new BigUInt(7);
plainModulus.Set(1 << 6);
parms.SetPlainModulus(plainModulus);
var polyModulus = new BigPoly(65, 1);
polyModulus[0].Set(1);
polyModulus[64].Set(1);
parms.SetPolyModulus(polyModulus);
parms.Validate();
var Encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew());
var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew());
keygen.Generate();
var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew());
Assert.AreEqual(encryptor.PublicKey[0], keygen.PublicKey[0]);
Assert.AreEqual(encryptor.PublicKey[1], keygen.PublicKey[1]);
var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew());
Assert.AreEqual(decryptor.SecretKey, keygen.SecretKey);
var encrypted = encryptor.Encrypt(Encoder.Encode(0x12345678));
Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(0));
Assert.AreEqual(0U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(1));
Assert.AreEqual(1U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(2));
Assert.AreEqual(2U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFDUL));
Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFEUL));
Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted)));
encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFFUL));
Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted)));
}
