private static bool EncodeValueString(string s, Encoding?valueEncoding, Span <byte> buffer, out int length) { if (buffer.Length != 0) { buffer[0] = 0; int encodedStringLength = valueEncoding is null || ReferenceEquals(valueEncoding, Encoding.Latin1) ? s.Length : valueEncoding.GetByteCount(s); if (IntegerEncoder.Encode(encodedStringLength, 7, buffer, out int nameLength)) { buffer = buffer.Slice(nameLength); if (buffer.Length >= encodedStringLength) { if (valueEncoding is null) { EncodeValueStringPart(s, buffer); } else { int written = valueEncoding.GetBytes(s, buffer); Debug.Assert(written == encodedStringLength); } length = nameLength + encodedStringLength; return(true); } } } length = 0; return(false); }
public void CreateTest() { IntegerEncoder encoder = new IntegerEncoder(GlobalContext.BFVContext); Assert.IsNotNull(encoder); Assert.AreEqual(65537ul, encoder.PlainModulus.Value); }
public void ExceptionsTest() { EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PlainModulus = new SmallModulus(4ul) }; SEALContext context = SEALContext.Create(parms); SEALContext context_null = null; IntegerEncoder enc = new IntegerEncoder(context); IntegerEncoder copy_null = null; BigUInt bui_null = null; BigUInt bui = new BigUInt(5ul); Plaintext plain = new Plaintext(); Assert.ThrowsException <ArgumentNullException>(() => enc = new IntegerEncoder(context_null)); Assert.ThrowsException <ArgumentNullException>(() => enc = new IntegerEncoder(copy_null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(1ul, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(1L, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(1, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(1u, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(bui_null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(bui, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(bui_null, plain)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeUInt32(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeUInt64(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeInt32(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeInt64(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeBigUInt(null)); }
public void HPack_IntegerEncode_ShortBuffer(int value, int bits, byte[] expectedResult) { Span <byte> actualResult = new byte[expectedResult.Length - 1]; bool success = IntegerEncoder.Encode(value, bits, actualResult, out int bytesWritten); Assert.False(success); }
/* * 0 1 2 3 4 5 6 7 +---+---+---+---+---+---+---+---+ | Required Insert Count (8+) | +---+---------------------------+ | S | Delta Base (7+) | +---+---------------------------+ | Compressed Headers ... +-------------------------------+ * */ private static bool EncodeHeaderBlockPrefix(Span<byte> destination, out int bytesWritten) { int length; bytesWritten = 0; // Required insert count as first int if (!IntegerEncoder.Encode(0, 8, destination, out length)) { return false; } bytesWritten += length; destination = destination.Slice(length); // Delta base if (destination.IsEmpty) { return false; } destination[0] = 0x00; if (!IntegerEncoder.Encode(0, 7, destination, out length)) { return false; } bytesWritten += length; return true; }
public void CreateTest() { EncryptionParameters parms1 = new EncryptionParameters(SchemeType.BFV) { PlainModulus = new SmallModulus(8192) }; SEALContext context1 = SEALContext.Create(parms1); IntegerEncoder encoder = new IntegerEncoder(context1); Assert.IsNotNull(encoder); Assert.AreEqual(8192ul, encoder.PlainModulus.Value); EncryptionParameters parms2 = new EncryptionParameters(SchemeType.BFV) { PlainModulus = new SmallModulus(4096) }; SEALContext context2 = SEALContext.Create(parms2); IntegerEncoder encoder2 = new IntegerEncoder(context2); Assert.IsNotNull(encoder2); Assert.AreEqual(4096ul, encoder2.PlainModulus.Value); IntegerEncoder encoder3 = new IntegerEncoder(encoder); Assert.IsNotNull(encoder3); Assert.AreEqual(8192ul, encoder3.PlainModulus.Value); }
public void DecodeTest() { EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PlainModulus = new SmallModulus(1024) }; SEALContext context = SEALContext.Create(parms); IntegerEncoder encoder = new IntegerEncoder(context); Plaintext plain = new Plaintext("0x^5 + 1x^4 + 1x^3 + 1x^1 + 0"); Assert.AreEqual(6ul, plain.CoeffCount); ulong resultU64 = encoder.DecodeUInt64(plain); Assert.AreEqual(26UL, resultU64); long resultI64 = encoder.DecodeInt64(plain); Assert.AreEqual(26L, resultI64); uint resultU32 = encoder.DecodeUInt32(plain); Assert.AreEqual(26U, resultU32); int resultI32 = encoder.DecodeInt32(plain); Assert.AreEqual(26, resultI32); BigUInt bui = encoder.DecodeBigUInt(plain); Assert.IsNotNull(bui); Assert.AreEqual(0, bui.CompareTo(26ul)); }
public void IntegerEncoderDecoderRoundtrips() { IntegerDecoder decoder = new IntegerDecoder(); Span <byte> integerBytes = stackalloc byte[5]; for (int i = 0; i < 2048; ++i) { for (int prefixLength = 1; prefixLength <= 8; ++prefixLength) { integerBytes.Clear(); Assert.True(IntegerEncoder.Encode(i, prefixLength, integerBytes, out int length)); bool decodeResult = decoder.BeginTryDecode(integerBytes[0], prefixLength, out int intResult); for (int j = 1; j < length; j++) { Assert.False(decodeResult); decodeResult = decoder.TryDecode(integerBytes[j], out intResult); } Assert.True(decodeResult); Assert.Equal(i, intResult); } } }
public void ExceptionsTest() { SEALContext context = GlobalContext.BFVContext; SEALContext context_null = null; IntegerEncoder enc = new IntegerEncoder(context); BigUInt bui_null = null; BigUInt bui = new BigUInt(5ul); Plaintext plain = new Plaintext(); Assert.ThrowsException <ArgumentNullException>(() => enc = new IntegerEncoder(context_null)); Assert.ThrowsException <ArgumentException>(() => enc = new IntegerEncoder(GlobalContext.CKKSContext)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(1ul, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(1L, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(1, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(1u, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(bui_null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(bui, null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(bui_null, plain)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeUInt32(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeUInt64(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeInt32(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeInt64(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.DecodeBigUInt(null)); }
public void DecodeTest() { IntegerEncoder encoder = new IntegerEncoder(GlobalContext.BFVContext); Plaintext plain = new Plaintext("0x^5 + 1x^4 + 1x^3 + 1x^1 + 0"); Assert.AreEqual(6ul, plain.CoeffCount); ulong resultU64 = encoder.DecodeUInt64(plain); Assert.AreEqual(26UL, resultU64); long resultI64 = encoder.DecodeInt64(plain); Assert.AreEqual(26L, resultI64); uint resultU32 = encoder.DecodeUInt32(plain); Assert.AreEqual(26U, resultU32); int resultI32 = encoder.DecodeInt32(plain); Assert.AreEqual(26, resultI32); BigUInt bui = encoder.DecodeBigUInt(plain); Assert.IsNotNull(bui); Assert.AreEqual(0, bui.CompareTo(26ul)); }
public void IntegerEncoderDecoderRoundtrips() { var decoder = new IntegerDecoder(); var range = 1 << 8; foreach (var i in Enumerable.Range(0, range).Concat(Enumerable.Range(int.MaxValue - range + 1, range))) { for (int n = 1; n <= 8; n++) { var integerBytes = new byte[6]; Assert.True(IntegerEncoder.Encode(i, n, integerBytes, out var length)); var decodeResult = decoder.BeginTryDecode(integerBytes[0], n, out var intResult); for (int j = 1; j < length; j++) { Assert.False(decodeResult); decodeResult = decoder.TryDecode(integerBytes[j], out intResult); } Assert.True(decodeResult); Assert.Equal(i, intResult); } } }
static void Main(string[] args) { int votersCount = 10000; ulong keysize = 2048; int[] votes = createSampleVotes(votersCount, 1); #if (TEST) Console.WriteLine("votes=[{0}]", string.Join(", ", votes)); #endif Console.WriteLine("Sum of all votes = {0}", votes.Sum()); SEALContext context = createContext(keysize); IntegerEncoder encoder = new IntegerEncoder(context); KeyGenerator keygen = new KeyGenerator(context); PublicKey publicKey = keygen.PublicKey; SecretKey secretKey = keygen.SecretKey; Encryptor encryptor = new Encryptor(context, publicKey); Evaluator evaluator = new Evaluator(context); Decryptor decryptor = new Decryptor(context, secretKey); Ciphertext encryptedTotal = new Ciphertext(); encryptor.Encrypt(encoder.Encode(0), encryptedTotal); Ciphertext encrypted = new Ciphertext(); Console.WriteLine("-----------------------------------"); Console.WriteLine("Encoding the vote values ... "); Stopwatch sw = new Stopwatch(); sw.Start(); for (int i = 0; i < votes.Length; i++) { Plaintext plain = encoder.Encode(votes[i]); encryptor.Encrypt(plain, encrypted); #if (TEST) Console.WriteLine($"Noise budget in encrypted: {decryptor.InvariantNoiseBudget(encrypted)} bits"); Console.WriteLine($"Encoded {votes[i]} as polynomial {plain.ToString()}"); #endif evaluator.AddInplace(encryptedTotal, encrypted); } sw.Stop(); Console.WriteLine("Elapsed={0}", sw.Elapsed); Console.WriteLine("Done"); Console.WriteLine("-----------------------------------"); Plaintext plainResult = new Plaintext(); decryptor.Decrypt(encryptedTotal, plainResult); Console.Write($"Decrypting the result polynomial {plainResult.ToString()} ... "); Console.WriteLine("Done"); Console.WriteLine("-----------------------------------"); Console.WriteLine($"Decoded result: {encoder.DecodeInt32(plainResult)}"); Console.ReadLine(); }
public void IntegerEncode(int i, int prefixLength, byte[] expectedOctets) { var buffer = new byte[expectedOctets.Length]; Assert.True(IntegerEncoder.Encode(i, prefixLength, buffer, out var octets)); Assert.Equal(expectedOctets.Length, octets); Assert.Equal(expectedOctets, buffer); }
public BfvDecryptor(SEALContext Context, SecretKey PrivateKey) { //Takes in The original seal context as an argument. context = Context; //----------------------------------------------------------------- //Create an instance of Decryptor with the Generated Private Key. decryptor = new Decryptor(context, PrivateKey); encoder = new IntegerEncoder(context); }
public void HPack_IntegerEncode(int value, int bits, byte[] expectedResult) { Span <byte> actualResult = new byte[64]; bool success = IntegerEncoder.Encode(value, bits, actualResult, out int bytesWritten); Assert.True(success); Assert.Equal(expectedResult.Length, bytesWritten); Assert.True(actualResult.Slice(0, bytesWritten).SequenceEqual(expectedResult)); }
/// <summary> /// Encodes just the name part of a Literal Header Field With Static Name Reference. Must call <see cref="EncodeValueString(string, Span{byte}, out int)"/> after to encode the header's value. /// </summary> public static byte[] EncodeLiteralHeaderFieldWithStaticNameReferenceToArray(int index) { Span<byte> temp = stackalloc byte[IntegerEncoder.MaxInt32EncodedLength]; temp[0] = 0b01110000; bool res = IntegerEncoder.Encode(index, 4, temp, out int headerBytesWritten); Debug.Assert(res == true); return temp.Slice(0, headerBytesWritten).ToArray(); }
public static bool EncodeStringLiterals(string[] values, string separator, Span <byte> destination, out int bytesWritten) { bytesWritten = 0; if (values.Length == 0) { return(EncodeStringLiteral("", destination, out bytesWritten)); } else if (values.Length == 1) { return(EncodeStringLiteral(values[0], destination, out bytesWritten)); } if (!destination.IsEmpty) { int valueLength = 0; // Calculate length of all parts and separators. foreach (string part in values) { valueLength = checked ((int)(valueLength + part.Length)); } valueLength = checked ((int)(valueLength + (values.Length - 1) * separator.Length)); if (IntegerEncoder.Encode(valueLength, 7, destination, out int integerLength)) { Debug.Assert(integerLength >= 1); int encodedLength = 0; for (int j = 0; j < values.Length; j++) { if (j != 0 && !EncodeStringLiteralValue(separator, destination.Slice(integerLength), out encodedLength)) { return(false); } integerLength += encodedLength; if (!EncodeStringLiteralValue(values[j], destination.Slice(integerLength), out encodedLength)) { return(false); } integerLength += encodedLength; } bytesWritten = integerLength; return(true); } } return(false); }
public void generateKeys(int x, int y, string publicFile, string secretFile, string encryptedXFile, string encryptedYFile) { //Console.WriteLine("Rider at ({0},{1})",x,y); using EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV); ulong polyModulusDegree = 4096; parms.PolyModulusDegree = polyModulusDegree; parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree); parms.PlainModulus = new Modulus(1024); using SEALContext context = new SEALContext(parms); //Console.WriteLine("Set encryption parameters and print"); //Console.WriteLine(context); //Console.WriteLine("Parameter validation (success): {0}", context.ParameterErrorMessage()); using KeyGenerator keygen = new KeyGenerator(context); using PublicKey riderPub = keygen.PublicKey; using SecretKey riderSec = keygen.SecretKey; using Evaluator evaluator = new Evaluator(context); using IntegerEncoder encoder = new IntegerEncoder(context); using Encryptor riderEncryptor = new Encryptor(context, riderPub); using Decryptor riderDecryptor = new Decryptor(context, riderSec); using Plaintext riderxPlain = encoder.Encode(x); using Plaintext rideryPlain = encoder.Encode(y); using Ciphertext riderxEncrypted = new Ciphertext(); using Ciphertext rideryEncrypted = new Ciphertext(); riderEncryptor.Encrypt(riderxPlain, riderxEncrypted); riderEncryptor.Encrypt(rideryPlain, rideryEncrypted); var fileStream = File.Create(publicFile); riderPub.Save(fileStream); fileStream.Close(); fileStream = File.Create(secretFile); riderSec.Save(fileStream); fileStream.Close(); fileStream = File.Create(encryptedXFile); riderxEncrypted.Save(fileStream); fileStream.Close(); fileStream = File.Create(encryptedYFile); rideryEncrypted.Save(fileStream); fileStream.Close(); }
// TODO these all need to be updated! /* * 0 1 2 3 4 5 6 7 +---+---+---+---+---+---+---+---+ | 1 | S | Index (6+) | +---+---+-----------------------+ */ public static bool EncodeIndexedHeaderField(int index, Span <byte> destination, out int bytesWritten) { if (destination.IsEmpty) { bytesWritten = 0; return(false); } EncodeHeaderBlockPrefix(destination, out bytesWritten); destination = destination.Slice(bytesWritten); return(IntegerEncoder.Encode(index, 6, destination, out bytesWritten)); }
public static bool EncodeStaticIndexedHeaderField(int index, Span <byte> destination, out int bytesWritten) { if (!destination.IsEmpty) { destination[0] = 0b11000000; return(IntegerEncoder.Encode(index, 6, destination, out bytesWritten)); } else { bytesWritten = 0; return(false); } }
/// <summary>Encodes a "Literal Header Field without Indexing".</summary> public static bool EncodeLiteralHeaderFieldWithNameReference(int index, string value, Span <byte> destination, out int bytesWritten) { if (destination.IsEmpty) { bytesWritten = 0; return(false); } EncodeHeaderBlockPrefix(destination, out bytesWritten); destination = destination.Slice(bytesWritten); return(IntegerEncoder.Encode(index, 6, destination, out bytesWritten)); }
public static bool EncodeValueString(ReadOnlySpan <string> values, string?separator, Span <byte> buffer, out int length) { if (values.Length == 1) { return(EncodeValueString(values[0], buffer, out length)); } if (values.Length == 0) { // TODO: this will be called with a string array from HttpHeaderCollection. Can we ever get a 0-length array from that? Assert if not. return(EncodeValueString(string.Empty, buffer, out length)); } if (buffer.Length > 0) { Debug.Assert(separator != null); int valueLength = separator.Length * (values.Length - 1); for (int i = 0; i < values.Length; ++i) { valueLength += values[i].Length; } buffer[0] = 0; if (IntegerEncoder.Encode(valueLength, 7, buffer, out int nameLength)) { buffer = buffer.Slice(nameLength); if (buffer.Length >= valueLength) { string value = values[0]; EncodeValueStringPart(value, buffer); buffer = buffer.Slice(value.Length); for (int i = 1; i < values.Length; ++i) { EncodeValueStringPart(separator, buffer); buffer = buffer.Slice(separator.Length); value = values[i]; EncodeValueStringPart(value, buffer); buffer = buffer.Slice(value.Length); } length = nameLength + valueLength; return(true); } } } length = 0; return(false); }
public void encryptDriverLocation(int x, int y, string publicFile, string encryptedXFile, string encryptedYFile) { //Console.WriteLine("Driver at ({0},{1})",x,y); using EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV); ulong polyModulusDegree = 4096; parms.PolyModulusDegree = polyModulusDegree; parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree); parms.PlainModulus = new Modulus(1024); using SEALContext context = new SEALContext(parms); using KeyGenerator keygen = new KeyGenerator(context); using PublicKey riderPub = new PublicKey(); using Ciphertext xEncrypted = new Ciphertext(); using (var sr = new StreamReader(publicFile)) { riderPub.Load(context, sr.BaseStream); } using Evaluator evaluator = new Evaluator(context); using IntegerEncoder encoder = new IntegerEncoder(context); using Encryptor riderEncryptor = new Encryptor(context, riderPub); using Plaintext driverxPlain = encoder.Encode(x); using Plaintext driveryPlain = encoder.Encode(y); using Ciphertext driverxEncrypted = new Ciphertext(); using Ciphertext driveryEncrypted = new Ciphertext(); riderEncryptor.Encrypt(driverxPlain, driverxEncrypted); riderEncryptor.Encrypt(driveryPlain, driveryEncrypted); var fileStream = File.Create(encryptedXFile); driverxEncrypted.Save(fileStream); fileStream.Close(); fileStream = File.Create(encryptedYFile); driveryEncrypted.Save(fileStream); fileStream.Close(); }
public ulong decryptDistance(string publicFile, string secretFile, string distanceFile) { using EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV); ulong polyModulusDegree = 4096; parms.PolyModulusDegree = polyModulusDegree; parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree); parms.PlainModulus = new Modulus(1024); using SEALContext context = new SEALContext(parms); using KeyGenerator keygen = new KeyGenerator(context); using PublicKey riderPub = new PublicKey(); using (var sr = new StreamReader(publicFile)) { riderPub.Load(context, sr.BaseStream); } using SecretKey riderSec = new SecretKey(); using (var sr = new StreamReader(secretFile)) { riderSec.Load(context, sr.BaseStream); } using Ciphertext X2MinusX1SquaredPlusY2MinusY1Squared = new Ciphertext(); using (var sr = new StreamReader(distanceFile)) { X2MinusX1SquaredPlusY2MinusY1Squared.Load(context, sr.BaseStream); } using Encryptor riderEncryptor = new Encryptor(context, riderPub); using Decryptor riderDecryptor = new Decryptor(context, riderSec); using Plaintext distance = new Plaintext(); riderDecryptor.Decrypt(X2MinusX1SquaredPlusY2MinusY1Squared, distance); using IntegerEncoder encoder = new IntegerEncoder(context); //Console.WriteLine("Decrypted polynomial f(x) = {0}.", distance ); //Console.WriteLine(" distance from rider {0}", encoder.DecodeUInt64(distance)); return(encoder.DecodeUInt64(distance)); }
public EncCal(BigPolyArray publicKey, string polyMod, int coeffDefault, ulong plainMod) { // Create encryption parameters. parms = new EncryptionParameters(); parms.PolyModulus.Set(polyMod); parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[coeffDefault]); parms.PlainModulus.Set(plainMod); //parms.DecompositionBitCount = 12; // Create encoder (for encoding and decoding) encoder = new IntegerEncoder(parms.PlainModulus); //encoder = new FractionalEncoder(parms.PlainModulus, parms.PolyModulus, 64, 32, 3); //Create Encryptor // not mandatory encryptor = new Encryptor(parms, publicKey); //Create Evaluator for arithmatic operations evaluator = new Evaluator(parms); CrtBuilder = new PolyCRTBuilder(parms); }
public void HPack_IntegerRoundTrip(int value, int bits) { var decoder = new IntegerDecoder(); Span <byte> encoded = stackalloc byte[5]; Assert.True(IntegerEncoder.Encode(value, bits, encoded, out int bytesWritten)); bool finished = decoder.StartDecode(encoded[0], bits); int i = 1; for (; !finished && i < encoded.Length; ++i) { finished = decoder.Decode(encoded[i]); } Assert.True(finished); Assert.Equal(bytesWritten, i); Assert.Equal(value, decoder.Value); }
public static bool EncodeLiteralHeaderFieldWithStaticNameReference(int index, string value, Encoding?valueEncoding, Span <byte> destination, out int bytesWritten) { // Requires at least two bytes (one for name reference header, one for value length) if (destination.Length >= 2) { destination[0] = 0b01010000; if (IntegerEncoder.Encode(index, 4, destination, out int headerBytesWritten)) { destination = destination.Slice(headerBytesWritten); if (EncodeValueString(value, valueEncoding, destination, out int valueBytesWritten)) { bytesWritten = headerBytesWritten + valueBytesWritten; return(true); } } } bytesWritten = 0; return(false); }
private static bool EncodeValueString(string s, Span <byte> buffer, out int length) { if (buffer.Length != 0) { buffer[0] = 0; if (IntegerEncoder.Encode(s.Length, 7, buffer, out int nameLength)) { buffer = buffer.Slice(nameLength); if (buffer.Length >= s.Length) { EncodeValueStringPart(s, buffer); length = nameLength + s.Length; return(true); } } } length = 0; return(false); }
private static bool EncodeLiteralHeaderName(string value, Span <byte> destination, out int bytesWritten) { // From https://tools.ietf.org/html/rfc7541#section-5.2 // ------------------------------------------------------ // 0 1 2 3 4 5 6 7 // +---+---+---+---+---+---+---+---+ // | H | String Length (7+) | // +---+---------------------------+ // | String Data (Length octets) | // +-------------------------------+ if (!destination.IsEmpty) { destination[0] = 0; // TODO: Use Huffman encoding if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) { Debug.Assert(integerLength >= 1); destination = destination.Slice(integerLength); if (value.Length <= destination.Length) { for (int i = 0; i < value.Length; i++) { char c = value[i]; destination[i] = (byte)((uint)(c - 'A') <= ('Z' - 'A') ? c | 0x20 : c); } bytesWritten = integerLength + value.Length; return(true); } } } bytesWritten = 0; return(false); }
public EncCal(string polyMod, int coeffDefault, ulong plainMod, int dbc, int noOfEvaluationKeys) { // Create encryption parameters. parms = new EncryptionParameters(); parms.PolyModulus.Set(polyMod); parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[coeffDefault]); parms.PlainModulus.Set(plainMod); // Generate keys. generator = new KeyGenerator(parms); generator.Generate(noOfEvaluationKeys); //Integer // Generator contains the keys publicKey = generator.PublicKey; secretKey = generator.SecretKey; evaluationKeys = generator.EvaluationKeys; // Create encoder (for encoding and decoding) encoder = new IntegerEncoder(parms.PlainModulus); //Integer //Create Encryptor encryptor = new Encryptor(parms, publicKey); //Create Decryptor decryptor = new Decryptor(parms, secretKey); //Create Evaluator for arithmatic operations evaluator = new Evaluator(parms); CrtBuilder = new PolyCRTBuilder(parms); }