Make HeContext flexible

Author: fboemer

Benchmarks/RlweBenchmark/RlweBenchmark.swift

@@ -43,7 +43,7 @@ func getRandomPlaintextData<T: ScalarType>(count: Int, in range: Range<T>) -> [T
 
 struct RlweBenchmarkContext<Scheme: HeScheme>: Sendable {
     var encryptionParameters: EncryptionParameters<Scheme.Scalar>
-    var context: Context<Scheme.Scalar>
+    var context: Scheme.Context
 
     let data: [Scheme.Scalar]
     let signedData: [Scheme.SignedScalar]
@@ -69,7 +69,7 @@ struct RlweBenchmarkContext<Scheme: HeScheme>: Sendable {
                                                                  Scheme.Scalar.self),
                                                              errorStdDev: ErrorStdDev.stdDev32,
                                                              securityLevel: SecurityLevel.quantum128)
-        self.context = try Context(encryptionParameters: encryptionParameters)
+        self.context = try Scheme.Context(encryptionParameters: encryptionParameters)
         self.secretKey = try context.generateSecretKey()
         let columnElement = GaloisElement.swappingRows(degree: polyDegree)
         let rowElement = try GaloisElement.rotatingColumns(by: rotateColumnsStep, degree: polyDegree)
@@ -163,7 +163,7 @@ func contextInitBenchmark<Scheme: HeScheme>(_: Scheme.Type, config: EncryptionPa
             let encryptionParameters = try EncryptionParameters<Scheme.Scalar>(config: config)
             benchmark.startMeasurement()
             for _ in benchmark.scaledIterations {
-                try blackHole(_ = Context<Scheme.Scalar>(encryptionParameters: encryptionParameters))
+                try blackHole(_ = Scheme.Context(encryptionParameters: encryptionParameters))
             }
         }
     }

Snippets/HomomorphicEncryption/BasicsSnippet.swift

@@ -24,16 +24,14 @@ import HomomorphicEncryption
 let encryptParams =
     try EncryptionParameters<UInt64>(from: .insecure_n_8_logq_5x18_logt_5)
 // Perform pre-computation for HE computation with these parameters.
-let context = try Context<UInt64>(encryptionParameters: encryptParams)
+let context = try Bfv<UInt64>.Context(encryptionParameters: encryptParams)
 
 // We encode N values using coefficient encoding.
 let values: [UInt64] = [8, 5, 12, 12, 15, 0, 8, 5]
-let plaintext: Bfv<UInt64>.CoeffPlaintext = try context.encode(
-    values: values,
-    format: .coefficient)
+let plaintext = try context.encode(values: values, format: .coefficient)
 
 // We generate a secret key and use it to encrypt the plaintext.
-let secretKey: SecretKey<Bfv<UInt64>> = try context.generateSecretKey()
+let secretKey = try context.generateSecretKey()
 var ciphertext = try plaintext.encrypt(using: secretKey)
 
 // Decrypting the plaintext yields the original values.

Snippets/HomomorphicEncryption/EncryptionParametersSnippet.swift

@@ -85,11 +85,9 @@ func summarize<Scheme: HeScheme>(
     parameters: EncryptionParameters<Scheme.Scalar>, _: Scheme.Type) throws
 {
     let values = (0..<8).map { Scheme.Scalar($0) }
-    let context = try Context<Scheme.Scalar>(encryptionParameters: parameters)
-    let plaintext: Scheme.CoeffPlaintext = try context.encode(
-        values: values,
-        format: .coefficient)
-    let secretKey: SecretKey<Scheme> = try context.generateSecretKey()
+    let context = try Scheme.Context(encryptionParameters: parameters)
+    let plaintext = try context.encode(values: values, format: .coefficient)
+    let secretKey = try context.generateSecretKey()
     let ciphertext = try plaintext.encrypt(using: secretKey)
     let noiseBudget = try ciphertext.noiseBudget(
         using: secretKey,

Snippets/HomomorphicEncryption/EvaluationKeySnippet.swift

@@ -46,17 +46,15 @@ let encryptionParameters =
     try EncryptionParameters<UInt32>(from: .insecure_n_8_logq_5x18_logt_5)
 precondition(encryptionParameters.plaintextModulus == 17)
 // Perform pre-computation for HE computation with these parameters.
-let context = try Context<UInt32>(encryptionParameters: encryptionParameters)
+let context = try Bfv<UInt32>.Context(encryptionParameters: encryptionParameters)
 
 // We encode N values using SIMD encoding.
 // Each value is a Bfv<UInt32>.Scalar, which is UInt32.
 let values = (0..<8).map { Bfv<UInt32>.Scalar($0) }
-let plaintext: Bfv<UInt32>.CoeffPlaintext = try context.encode(
-    values: values,
-    format: .simd)
+let plaintext = try context.encode(values: values, format: .simd)
 
 // We generate a secret key and encrypt the plaintext.
-let secretKey: SecretKey<Bfv<UInt32>> = try context.generateSecretKey()
+let secretKey = try context.generateSecretKey()
 var ciphertext = try plaintext.encrypt(using: secretKey)
 
 // We generate an evaluation key. This is a key used in some HE operations.

Snippets/HomomorphicEncryption/MultiplicationSnippet.swift

@@ -34,19 +34,17 @@ let encryptParams =
     try EncryptionParameters<UInt32>(from: .insecure_n_8_logq_5x18_logt_5)
 precondition(encryptParams.plaintextModulus == 17)
 // Perform pre-computation for HE computation with these parameters.
-let context = try Context<UInt32>(encryptionParameters: encryptParams)
+let context = try Bfv<UInt32>.Context(encryptionParameters: encryptParams)
 
 // We don't need to use all the slots in the encoding.
 // However, performing HE operations on ciphertexts with fewer slots doesn't give
 // any runtime savings.
 let valueCount = encryptParams.polyDegree / 2
 let values = (0..<valueCount).map { UInt32($0) }
-let plaintext: Bfv<UInt32>.CoeffPlaintext = try context.encode(
-    values: values,
-    format: .simd)
+let plaintext = try context.encode(values: values, format: .simd)
 
 // We generate a secret key and encrypt the plaintext.
-let secretKey: SecretKey<Bfv<UInt32>> = try context.generateSecretKey()
+let secretKey = try context.generateSecretKey()
 let ciphertext = try plaintext.encrypt(using: secretKey)
 
 // Multiplication requires the ciphertext and plaintext to be in Evaluation

Snippets/HomomorphicEncryption/NoiseBudgetSnippet.swift

@@ -45,16 +45,14 @@ func checkDecryptsDecodes<Scheme: HeScheme>(
 let encryptionParameters =
     try EncryptionParameters<UInt32>(from: .insecure_n_8_logq_5x18_logt_5)
 // Perform pre-computation for HE computation with these parameters.
-let context = try Context<UInt32>(encryptionParameters: encryptionParameters)
+let context = try Bfv<UInt32>.Context(encryptionParameters: encryptionParameters)
 
 // We encode N values in coefficient format and SIMD encoding.
 let values = (0..<8).map { UInt32($0) }
-let plaintext: Bfv<UInt32>.CoeffPlaintext = try context.encode(
-    values: values,
-    format: .simd)
+let plaintext = try context.encode(values: values, format: .simd)
 
 // We generate a secret key and encrypt the plaintext.
-let secretKey: SecretKey<Bfv<UInt32>> = try context.generateSecretKey()
+let secretKey = try context.generateSecretKey()
 var ciphertext = try plaintext.encrypt(using: secretKey)
 
 // The noiseBudget of a ciphertext is a measure of how many encrypted operations

Snippets/HomomorphicEncryption/SerializationSnippet.swift

@@ -36,18 +36,15 @@ extension SerializedCiphertext {
 let encryptionParameters =
     try EncryptionParameters<UInt32>(from: .n_4096_logq_27_28_28_logt_5)
 // Perform pre-computation for HE computation with these parameters.
-let context = try Context<UInt32>(encryptionParameters: encryptionParameters)
+let context = try Bfv<UInt32>.Context(encryptionParameters: encryptionParameters)
 
 // We encode some values in coefficient format and coefficient encoding.
 let values = (0..<8).map { UInt32($0) }
-let plaintext: Bfv<UInt32>.CoeffPlaintext = try context.encode(
-    values: values,
-    format: .coefficient)
+let plaintext = try context.encode(values: values, format: .coefficient)
 
 // We generate a secret key and encrypt the plaintext.
-let secretKey: SecretKey<Bfv<UInt32>> = try context.generateSecretKey()
-var ciphertext: Bfv<UInt32>.CanonicalCiphertext = try plaintext
-    .encrypt(using: secretKey)
+let secretKey = try context.generateSecretKey()
+var ciphertext = try plaintext.encrypt(using: secretKey)
 
 // A freshly-encrypted ciphertext has one of its 2 polynomials sampled uniformly
 // randomly from a seeded random number generator (RNG). We compress such

Sources/BenchmarkUtilities/PirBenchmarkUtilities.swift

@@ -83,7 +83,7 @@ extension PrivateInformationRetrieval.Response {
 
 struct ProcessBenchmarkContext<Server: IndexPirServer> {
     let database: [[UInt8]]
-    let context: Context<Server.Scheme.Scalar>
+    let context: Server.Scheme.Context
     let parameter: IndexPirParameter
     init(server _: Server.Type, pirConfig: IndexPirConfig,
          parameterConfig: PirEncryptionParametersConfig) throws
@@ -93,7 +93,7 @@ struct ProcessBenchmarkContext<Server: IndexPirServer> {
         self.database = getDatabaseForTesting(
             numberOfEntries: pirConfig.entryCount,
             entrySizeInBytes: pirConfig.entrySizeInBytes)
-        self.context = try Context(encryptionParameters: encryptParameter)
+        self.context = try Server.Scheme.Context(encryptionParameters: encryptParameter)
         self.parameter = Server.generateParameter(config: pirConfig, with: context)
     }
 }
@@ -171,7 +171,7 @@ struct IndexPirBenchmarkContext<Server: IndexPirServer, Client: IndexPirClient>
     {
         let encryptParameter: EncryptionParameters<Server.Scheme.Scalar> =
             try EncryptionParameters(from: parameterConfig)
-        let context = try Context<Server.Scheme.Scalar>(encryptionParameters: encryptParameter)
+        let context = try Server.Scheme.Context(encryptionParameters: encryptParameter)
         let indexPirParameters = Server.generateParameter(config: pirConfig, with: context)
         let database = getDatabaseForTesting(
             numberOfEntries: pirConfig.entryCount,
@@ -286,7 +286,7 @@ struct KeywordPirBenchmarkContext<IndexServer: IndexPirServer, IndexClient: Inde
     {
         let encryptParameter: EncryptionParameters<Server.Scheme.Scalar> =
             try EncryptionParameters(from: parameterConfig)
-        let context = try Context<Server.Scheme.Scalar>(encryptionParameters: encryptParameter)
+        let context = try Server.Scheme.Context(encryptionParameters: encryptParameter)
         let rows = (0..<databaseCount).map { index in KeywordValuePair(
             keyword: [UInt8](String(index).utf8),
             value: (0..<payloadSize).map { _ in UInt8.random(in: 0..<UInt8.max) })

Sources/BenchmarkUtilities/PnnsBenchmarkUtilities.swift

@@ -188,7 +188,7 @@ extension PrivateNearestNeighborSearch.Response {
 
 struct PnnsProcessBenchmarkContext<Scheme: HeScheme> {
     let database: Database
-    let contexts: [Context<Scheme.Scalar>]
+    let contexts: [Scheme.Context]
     let serverConfig: ServerConfig<Scheme>
 
     init(databaseConfig: DatabaseConfig,
@@ -238,7 +238,7 @@ struct PnnsProcessBenchmarkContext<Scheme: HeScheme> {
 
         self.database = getDatabaseForTesting(config: databaseConfig)
         self.contexts = try serverConfig.encryptionParameters.map { encryptionParameters in
-            try Context(encryptionParameters: encryptionParameters)
+            try Scheme.Context(encryptionParameters: encryptionParameters)
         }
     }
 }
@@ -305,7 +305,7 @@ struct PnnsBenchmarkContext<Scheme: HeScheme> {
 
         let database = getDatabaseForTesting(config: databaseConfig)
         let contexts = try clientConfig.encryptionParameters
-            .map { encryptionParameters in try Context<Scheme.Scalar>(encryptionParameters: encryptionParameters) }
+            .map { encryptionParameters in try Scheme.Context(encryptionParameters: encryptionParameters) }
         self.processedDatabase = try database.process(config: serverConfig, contexts: contexts)
         self.client = try Client(config: clientConfig, contexts: contexts)
         self.server = try Server(database: processedDatabase)

Sources/HomomorphicEncryption/Bfv/Bfv+Decrypt.swift

@@ -26,8 +26,8 @@ extension Bfv {
 
     @inlinable
     // swiftlint:disable:next missing_docs attributes
-    public static func decryptEval(_ ciphertext: EvalCiphertext,
-                                   using secretKey: SecretKey<Bfv<T>>) throws -> CoeffPlaintext
+    public static func decryptEval(_ ciphertext: EvalCiphertext, using secretKey: SecretKey<Self>) throws ->
+        CoeffPlaintext
     {
         let t = ciphertext.context.plaintextModulus
         let dotProduct = try Self.dotProduct(ciphertext: ciphertext, with: secretKey)