public void KeyGenerationNET() { 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); Assert.IsTrue(keygen.PublicKey.IsZero); Assert.IsTrue(keygen.SecretKey.IsZero); Assert.AreEqual(12, keygen.EvaluationKeys.Count); for (int i = 0; i < 12; ++i) { Assert.IsTrue(keygen.EvaluationKeys[i].IsZero); } keygen.Generate(); Assert.IsFalse(keygen.PublicKey.IsZero); Assert.IsFalse(keygen.SecretKey.IsZero); Assert.AreEqual(12, keygen.EvaluationKeys.Count); for (int i = 0; i < 12; ++i) { Assert.IsFalse(keygen.EvaluationKeys[i].IsZero); } var publicKey = keygen.PublicKey; var secretKey = keygen.SecretKey; keygen.Generate(); Assert.IsFalse(publicKey.Equals(keygen.PublicKey)); Assert.IsFalse(secretKey.Equals(keygen.SecretKey)); }
public void FVKeyGenerationNoEVKNET() { var parms = new EncryptionParameters { DecompositionBitCount = 0, 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(0); Assert.IsFalse(keygen.PublicKey[0].IsZero); Assert.IsFalse(keygen.PublicKey[1].IsZero); Assert.IsFalse(keygen.SecretKey.IsZero); }
private void Get(long numberOfItems) { var keyGenerator = new KeyGenerator(); var rand = new Random(); while (true) { try { var keyIndex = rand.Next(0, Convert.ToInt32(numberOfItems)); _cache.Get(keyGenerator.Generate(keyIndex)); if (Environment.OSVersion.Platform == PlatformID.Win32NT) { _perfStats.IncrementFetches(); _perfStats.IncrementReqs(); } } catch (Exception exp) { Console.WriteLine(exp); } } }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { LoadData(); return(Page()); } if (AcmeCertificate.KeyId < 0) { var key = _keyGenerator.Generate(AcmeCertificate.Subject, KeyAlgorithm.RS256); if (key == null) { ModelState.AddModelError(string.Empty, "Error creating key"); return(Page()); } AcmeCertificate.KeyId = key.KeyId; } AcmeCertificate.ApiKey1 = ApiKeyGenerator.CreateApiKey(); AcmeCertificate.ApiKey2 = ApiKeyGenerator.CreateApiKey(); _context.AcmeCertificates.Add(AcmeCertificate); await _context.SaveChangesAsync(); StatusMessage = "Certificate created"; return(RedirectToPage("./Index")); }
public async Task <JsonResult> Filter(HomeSearchBindingModel model) { var cacheKey = KeyGenerator.Generate( WebConstants.CacheHomeFilterPrepend, model.SelectedCarType.ToString(), model.SelectedModelType, model.SelectedPriceRange, model.SelectedYear); var cachedModel = await this.cacheService.GetOrDefaultAsync <HomeSearchBindingModel>(cacheKey); if (cachedModel != null) { return(Json(cachedModel)); } var priceRanges = ParameterParser.ParsePriceRange(model.SelectedPriceRange); var filterStrategies = CarFilterStrategyFactory .GetStrategies(model.SelectedYear, priceRanges[0], priceRanges[1], WebConstants.AllFilterTypeModelValue); var mutipleFilterStrategy = CarMultipleFilterStrategyFactory.GetStrategy(new string[] { model.SelectedModelType }); var filteredCars = this.carsService.GetFiltered <BaseCar>(filterStrategies.ToArray()); filteredCars = mutipleFilterStrategy.Filter(filteredCars); var searchModel = await this.homeService.GetSearchModelAsync(filteredCars, model.SelectedCarType); _ = this.cacheService.AddInfinityCacheAsync(searchModel, cacheKey, WebConstants.CacheCarsType); return(Json(searchModel)); }
public override async Task <string> InsertURLAsync(string url) { using (var db = new LiteDB.LiteDatabase(DB_FileName)) { var collection = db.GetCollection <URLObject>(); url = url.ToLower(); var existingResult = collection.FindOne(a => a.URL == url); if (existingResult != null) { return(existingResult.Key); } var urlObject = new URLObject { URL = url, Key = KeyGenerator.Generate() }; collection.Insert(urlObject); return(urlObject.Key); } }
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 FVKeyGenerationNoEVKNET() { var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew()); parms.SetDecompositionBitCount(0); 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(0); Assert.IsFalse(keygen.PublicKey[0].IsZero); Assert.IsFalse(keygen.PublicKey[1].IsZero); Assert.IsFalse(keygen.SecretKey.IsZero); }
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))); }
private void SendData() { var key = _keyGenerator.Generate(); var timer = _metric.StartMeasure(); _metric.AddResult(_adapter.Send(key, _iterator.Current)); _metric.StopMeasure(timer); }
public void Generate_KeyLength_DefinesStringLength() { for (var i = 1; i <= 100; i++) { using var target = new KeyGenerator(i); Assert.Equal(i, target.Generate().Length); } }
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 TransformEncryptedToFromNTTNET() { 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 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 plain = new BigPoly(65, 1); var cipher = new BigPolyArray(2, 65, 1); plain.Set("0"); encryptor.Encrypt(plain, cipher); evaluator.TransformToNTT(cipher); evaluator.TransformFromNTT(cipher); decryptor.Decrypt(cipher, plain); Assert.IsTrue(plain.ToString() == "0"); plain.Set("1"); encryptor.Encrypt(plain, cipher); evaluator.TransformToNTT(cipher); evaluator.TransformFromNTT(cipher); decryptor.Decrypt(cipher, plain); Assert.IsTrue(plain.ToString() == "1"); plain.Set("Fx^10 + Ex^9 + Dx^8 + Cx^7 + Bx^6 + Ax^5 + 1x^4 + 2x^3 + 3x^2 + 4x^1 + 5"); encryptor.Encrypt(plain, cipher); evaluator.TransformToNTT(cipher); evaluator.TransformFromNTT(cipher); decryptor.Decrypt(cipher, plain); Assert.IsTrue(plain.ToString() == "Fx^10 + Ex^9 + Dx^8 + Cx^7 + Bx^6 + Ax^5 + 1x^4 + 2x^3 + 3x^2 + 4x^1 + 5"); }
public void FVEncryptSquareDecryptNET() { 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 BalancedEncoder(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(1)); var product = evaluator.Square(encrypted1); Assert.AreEqual(1UL, encoder.DecodeUInt64(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(encoder.Encode(0)); product = evaluator.Square(encrypted1); Assert.AreEqual(0UL, encoder.DecodeUInt64(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(encoder.Encode(-5)); product = evaluator.Square(encrypted1); Assert.AreEqual(25UL, encoder.DecodeUInt64(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(encoder.Encode(-1)); product = evaluator.Square(encrypted1); Assert.AreEqual(1UL, encoder.DecodeUInt64(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(encoder.Encode(123)); product = evaluator.Square(encrypted1); Assert.AreEqual(15129UL, encoder.DecodeUInt64(decryptor.Decrypt(product))); }
protected override string GenerateKey() { if (string.IsNullOrWhiteSpace(Username)) { throw new EntityKeyGenerationException(GetType(), "Username is empty"); } return(KeyGenerator.Generate(Username)); }
public async Task <IActionResult> OnPostAsync() { // Check basic validation first and bail out early before anything gets updated. if (!ModelState.IsValid) { return(Page()); } if (Uri.CheckHostName(Setup.SiteHostname) != UriHostNameType.Dns) { ModelState.AddModelError("Setup.Domain", "Invalid domain name"); } if (!ModelState.IsValid) { return(Page()); } _httpServerOptions.Update(x => { x.SiteHostname = Setup.SiteHostname; x.HttpsPort = Setup.HttpsPort; }); var acmeAccount = await _dataContext.AcmeAccounts.FirstAsync(x => x.IsAcmeStaging == Setup.UseAcmeStaging); var acmeCert = await _dataContext.AcmeCertificates .Include(x => x.AcmeAccount) .ThenInclude(x => x.Key) .FirstOrDefaultAsync(x => x.Subject == Setup.SiteHostname && x.AcmeAccountId == acmeAccount.AcmeAccountId); if (acmeCert == null) { var certKey = await _dataContext.Keys.FirstOrDefaultAsync(x => x.Name == Setup.SiteHostname); if (certKey == null) { certKey = _keyGenerator.Generate(Setup.SiteHostname, Certes.KeyAlgorithm.RS256, "certera certificate (this site)"); } acmeCert = new Data.Models.AcmeCertificate { ChallengeType = "http-01", DateCreated = DateTime.UtcNow, Name = Setup.SiteHostname, Subject = Setup.SiteHostname, AcmeAccountId = acmeAccount.AcmeAccountId, KeyId = certKey.KeyId }; _dataContext.AcmeCertificates.Add(acmeCert); await _dataContext.SaveChangesAsync(); } return(RedirectToPage("./Certificate")); }
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 override bool OneDataProcess() { var key = _keyGenerator.Generate(); var timer = _metric.StartMeasure(); _metric.AddResult(_adapter.Read(key)); _metric.StopMeasure(timer); return(true); }
static void Main(string[] args) { if (IsValid(args)) { var length = int.Parse(args[0]); var passwordGenerator = new KeyGenerator(length); passwordGenerator.Generate(); TextCopy.Clipboard.SetText(passwordGenerator.Password); } }
protected override string GenerateKey() { if (string.IsNullOrWhiteSpace(Name)) { // TODO: Localize throw new EntityKeyGenerationException(GetType(), "Name is empty"); } return(KeyGenerator.Generate(Name)); }
public void GenerateTest(int length) { //Setup sut = new KeyGenerator(length); //Act sut.Generate(); //Assert Assert.AreEqual(length, sut.Password.Length); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } bool deleteOnError = false; if (AcmeAccount.KeyId < 0) { var stg = AcmeAccount.IsAcmeStaging ? "-staging" : string.Empty; var keyName = $"acme-account{stg}"; var key = _keyGenerator.Generate(keyName, KeyAlgorithm.ES256); if (key == null) { ModelState.AddModelError(string.Empty, "Error creating key"); return(Page()); } deleteOnError = true; AcmeAccount.Key = key; } AcmeAccount.ApplicationUser = await _userManager.GetUserAsync(User); try { _context.AcmeAccounts.Add(AcmeAccount); await _context.SaveChangesAsync(); // Create account with key await _certesAcmeProvider.CreateAccount(AcmeAccount.AcmeContactEmail, AcmeAccount.Key.RawData, AcmeAccount.IsAcmeStaging); } catch (Exception e) { // Delete created key if there's a failure in creating the acme account if (deleteOnError) { _context.Keys.Remove(AcmeAccount.Key); await _context.SaveChangesAsync(); } _logger.LogError(e, "Error creating ACME account"); ModelState.AddModelError(string.Empty, "Error creating ACME account"); return(Page()); } StatusMessage = "Account created"; return(RedirectToPage("./Index")); }
private void AddToCache(long lowerIndex, long upperIndex, int payLoad) { var keyGenerator = new KeyGenerator(); for (long i = lowerIndex; i < upperIndex; i++) { var key = keyGenerator.Generate(i); _cache.Update(key, GetPayload(payLoad)); } }
private SymmetricAlgorithm Algorithm(string salt) { using var key = KeyGenerator.Generate(_key, salt); var algorithm = Aes.Create(); algorithm.Key = key.GetBytes(algorithm.KeySize / 8); algorithm.IV = key.GetBytes(algorithm.BlockSize / 8); return(algorithm); }
public void KeyGenerator_GeneratesOneHundredUniqueKeys_WithValidFormat() { var hexRegex = new Regex(@"^[0-9a-z\-]*$", RegexOptions.Compiled); var set = new HashSet <string>(); for (int i = 0; i < 100; i++) { var key = KeyGenerator.Generate(); Assert.IsTrue(hexRegex.IsMatch(key)); Assert.IsTrue(set.Add(key)); } }
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 void Generate_MultipleCalls_DontReturnSameResult() { using var target = new KeyGenerator(); const int expectedCount = 100; var set = new HashSet <string>(); for (var i = 0; i < expectedCount; i++) { set.Add(target.Generate()); } Assert.Equal(expectedCount, set.Count); }
private async Task <Key> CreateKeyIfNotExists(ApplicationUser user, string keyContents, bool staging) { var stg = staging ? "-staging" : string.Empty; var keyName = $"user-{user.Id}-acme-account{stg}"; var key = await _dataContext.Keys.FirstOrDefaultAsync(x => x.Name == keyName); if (key == null) { var desc = $"Let's Encrypt {(staging ? "Staging " : string.Empty)}Account Key"; key = _keyGenerator.Generate(keyName, KeyAlgorithm.ES256, desc, keyContents); } return(key); }
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))); }
static void Main(string[] args) { while (true) { string key = KeyGenerator.Generate(); Console.WriteLine(key); Console.WriteLine(KeyValidator.IsValid(key)); if (Console.ReadKey().Key == ConsoleKey.Escape) { return; } } }