Documentation

Source

encryption-parameter-qualifiers.ts

  1. import { Instance } from './seal'
  2. import { SecurityLevel } from './security-level'
  4. export type EncryptionParameterQualifiersDependencies = {
  5.   (): EncryptionParameterQualifiersConstructorOptions
  6. }
  8. export type EncryptionParameterQualifiersConstructorOptions = {
  9.   (): EncryptionParameterQualifiers
  10. }
  12. export type EncryptionParameterQualifiers = {
  13.   readonly instance: Instance
  14.   readonly unsafeInject: (instance: Instance) => void
  15.   readonly delete: () => void
  16.   readonly parametersSet: () => boolean
  17.   readonly usingFFT: boolean
  18.   readonly usingNTT: boolean
  19.   readonly usingBatching: boolean
  20.   readonly usingFastPlainLift: boolean
  21.   readonly usingDescendingModulusChain: boolean
  22.   readonly securityLevel: SecurityLevel
  23. }
  25. const EncryptionParameterQualifiersConstructor =
  26.   (): EncryptionParameterQualifiersDependencies =>
  27.   (): EncryptionParameterQualifiersConstructorOptions =>
  28.   (): EncryptionParameterQualifiers => {
  29.     let _instance: Instance
  30.     /**
  31.      * @implements EncryptionParameterQualifiers
  32.      */
  34.     /**
  35.      * @interface EncryptionParameterQualifiers
  36.      */
  37.     return {
  38.       /**
  39.        * Get the underlying WASM instance
  40.        *
  41.        * @private
  42.        * @readonly
  43.        * @name EncryptionParameterQualifiers#instance
  44.        * @type {Instance}
  45.        */
  46.       get instance() {
  47.         return _instance
  48.       },
  50.       /**
  51.        * Inject this object with a raw WASM instance. No type checking is performed.
  52.        *
  53.        * @private
  54.        * @function
  55.        * @name EncryptionParameterQualifiers#unsafeInject
  56.        * @param {Instance} instance WASM instance
  57.        */
  58.       unsafeInject(instance: Instance) {
  59.         if (_instance) {
  60.           _instance.delete()
  61.           _instance = undefined
  62.         }
  63.         _instance = instance
  64.       },
  66.       /**
  67.        * Delete the underlying WASM instance.
  68.        *
  69.        * Should be called before dereferencing this object to prevent the
  70.        * WASM heap from growing indefinitely.
  71.        * @function
  72.        * @name EncryptionParameterQualifiers#delete
  73.        */
  74.       delete() {
  75.         if (_instance) {
  76.           _instance.delete()
  77.           _instance = undefined
  78.         }
  79.       },
  81.       /**
  82.        * If the encryption parameters are set in a way that is considered valid by
  83.        * Microsoft SEAL, the variable parameters_set is set to true.
  84.        *
  85.        * @function
  86.        * @name EncryptionParameterQualifiers#parametersSet
  87.        * @type {boolean}
  88.        */
  89.       parametersSet() {
  90.         return _instance.parametersSet()
  91.       },
  93.       /**
  94.        * Tells whether FFT can be used for polynomial multiplication. If the
  95.        * polynomial modulus is of the form X^N+1, where N is a power of two, then
  96.        * FFT can be used for fast multiplication of polynomials modulo the polynomial
  97.        * modulus. In this case the variable using_fft will be set to true. However,
  98.        * currently Microsoft SEAL requires this to be the case for the parameters
  99.        * to be valid. Therefore, parameters_set can only be true if using_fft is
  100.        * true.
  101.        *
  102.        * @readonly
  103.        * @name EncryptionParameterQualifiers#usingFFT
  104.        * @type {boolean}
  105.        */
  106.       get usingFFT() {
  107.         return _instance.usingFFT
  108.       },
  110.       /**
  111.        * Tells whether NTT can be used for polynomial multiplication. If the primes
  112.        * in the coefficient modulus are congruent to 1 modulo 2N, where X^N+1 is the
  113.        * polynomial modulus and N is a power of two, then the number-theoretic
  114.        * transform (NTT) can be used for fast multiplications of polynomials modulo
  115.        * the polynomial modulus and coefficient modulus. In this case the variable
  116.        * using_ntt will be set to true. However, currently Microsoft SEAL requires
  117.        * this to be the case for the parameters to be valid. Therefore, parameters_set
  118.        * can only be true if using_ntt is true.
  119.        *
  120.        * @readonly
  121.        * @name EncryptionParameterQualifiers#usingNTT
  122.        * @type {boolean}
  123.        */
  124.       get usingNTT() {
  125.         return _instance.usingNTT
  126.       },
  128.       /**
  129.        * Tells whether batching is supported by the encryption parameters. If the
  130.        * plaintext modulus is congruent to 1 modulo 2N, where X^N+1 is the polynomial
  131.        * modulus and N is a power of two, then it is possible to use the BatchEncoder
  132.        * class to view plaintext elements as 2-by-(N/2) matrices of integers modulo
  133.        * the plaintext modulus. This is called batching, and allows the user to
  134.        * operate on the matrix elements (slots) in a SIMD fashion, and rotate the
  135.        * matrix rows and columns. When the computation is easily vectorizable, using
  136.        * batching can yield a huge performance boost. If the encryption parameters
  137.        * support batching, the variable using_batching is set to true.
  138.        *
  139.        * @readonly
  140.        * @name EncryptionParameterQualifiers#usingBatching
  141.        * @type {boolean}
  142.        */
  143.       get usingBatching() {
  144.         return _instance.usingBatching
  145.       },
  147.       /**
  148.        * Tells whether fast plain lift is supported by the encryption parameters.
  149.        * A certain performance optimization in multiplication of a ciphertext by
  150.        * a plaintext (Evaluator::multiply_plain) and in transforming a plaintext
  151.        * element to NTT domain (Evaluator::transform_to_ntt) can be used when the
  152.        * plaintext modulus is smaller than each prime in the coefficient modulus.
  153.        * In this case the variable using_fast_plain_lift is set to true.
  154.        *
  155.        * @readonly
  156.        * @name EncryptionParameterQualifiers#usingFastPlainLift
  157.        * @type {boolean}
  158.        */
  159.       get usingFastPlainLift() {
  160.         return _instance.usingFastPlainLift
  161.       },
  163.       /**
  164.        * Tells whether the coefficient modulus consists of a set of primes that
  165.        * are in decreasing order. If this is true, certain modular reductions in
  166.        * base conversion can be omitted, improving performance.
  167.        *
  168.        * @readonly
  169.        * @name EncryptionParameterQualifiers#usingDescendingModulusChain
  170.        * @type {boolean}
  171.        */
  172.       get usingDescendingModulusChain() {
  173.         return _instance.usingDescendingModulusChain
  174.       },
  176.       /**
  177.        * Tells whether the encryption parameters are secure based on the standard
  178.        * parameters from HomomorphicEncryption.org security standard.
  179.        *
  180.        * @readonly
  181.        * @name EncryptionParameterQualifiers#securityLevel
  182.        * @type {(SecurityLevel.none|SecurityLevel.tc128|SecurityLevel.tc192|SecurityLevel.tc256)}
  183.        */
  184.       get securityLevel() {
  185.         return _instance.securityLevel
  186.       }
  187.     }
  188.   }
  190. export const EncryptionParameterQualifiersInit =
  191.   (): EncryptionParameterQualifiersDependencies => {
  192.     return EncryptionParameterQualifiersConstructor()
  193.   }