even better name

Author: seebees

modules/cache-material/src/build_cryptographic_materials_cache_key_helpers.ts

@@ -37,13 +37,13 @@ export function buildCryptographicMaterialsCacheKeyHelpers<S extends SupportedAl
   } = serializeFactory(fromUtf8)
 
   return {
-    buildEncryptionResponseCacheKey,
-    buildDecryptionResponseCacheKey,
+    buildEncryptionMaterialCacheKey,
+    buildDecryptionMaterialCacheKey,
     encryptedDataKeysHash,
     encryptionContextHash
   }
 
-  async function buildEncryptionResponseCacheKey (
+  async function buildEncryptionMaterialCacheKey (
     partition: string,
     { suite, encryptionContext }: EncryptionRequest<S>
   ) {
@@ -59,7 +59,7 @@ export function buildCryptographicMaterialsCacheKeyHelpers<S extends SupportedAl
     return toUtf8(key)
   }
 
-  async function buildDecryptionResponseCacheKey (
+  async function buildDecryptionMaterialCacheKey (
     partition: string,
     { suite, encryptedDataKeys, encryptionContext }: DecryptionRequest<S>
   ) {
@@ -96,11 +96,11 @@ export function buildCryptographicMaterialsCacheKeyHelpers<S extends SupportedAl
 }
 
 export interface CryptographicMaterialsCacheKeyHelpersInterface<S extends SupportedAlgorithmSuites> {
-  buildEncryptionResponseCacheKey(
+  buildEncryptionMaterialCacheKey(
     partition: string,
     { suite, encryptionContext }: EncryptionRequest<S>
   ): Promise<string>
-  buildDecryptionResponseCacheKey(
+  buildDecryptionMaterialCacheKey(
     partition: string,
     { suite, encryptedDataKeys, encryptionContext }: DecryptionRequest<S>
   ): Promise<string>

modules/cache-material/src/caching_cryptographic_materials_decorators.ts

@@ -64,23 +64,23 @@ export function decorateProperties<S extends SupportedAlgorithmSuites> (
 }
 
 export function getEncryptionMaterials<S extends SupportedAlgorithmSuites> (
-  { buildEncryptionResponseCacheKey }: CryptographicMaterialsCacheKeyHelpersInterface<S>
+  { buildEncryptionMaterialCacheKey }: CryptographicMaterialsCacheKeyHelpersInterface<S>
 ): GetEncryptionMaterials<S> {
   return async function getEncryptionMaterials (
     this: CachingMaterialsManager<S>,
     request: EncryptionRequest<S>
   ): Promise<EncryptionMaterial<S>> {
     const { suite, encryptionContext, frameLength, plaintextLength } = request
-    /* Check for early return (Postcondition): If I can not cache the EncryptionResponse, do not even look. */
+    /* Check for early return (Postcondition): If I can not cache the EncryptionMaterial, do not even look. */
     if ((suite && !suite.cacheSafe) || typeof plaintextLength !== 'number' || plaintextLength < 0) {
       return this
         ._backingMaterialsManager
         .getEncryptionMaterials(request)
     }
 
-    const cacheKey = await buildEncryptionResponseCacheKey(this._partition, { suite, encryptionContext })
-    const entry = this._cache.getEncryptionResponse(cacheKey, plaintextLength)
-    /* Check for early return (Postcondition): If I have a valid EncryptionResponse, return it. */
+    const cacheKey = await buildEncryptionMaterialCacheKey(this._partition, { suite, encryptionContext })
+    const entry = this._cache.getEncryptionMaterial(cacheKey, plaintextLength)
+    /* Check for early return (Postcondition): If I have a valid EncryptionMaterial, return it. */
     if (entry && !this._cacheEntryHasExceededLimits(entry)) {
       return cloneResponse(entry.response)
     } else {
@@ -94,7 +94,7 @@ export function getEncryptionMaterials<S extends SupportedAlgorithmSuites> (
        */
       .getEncryptionMaterials({ suite, encryptionContext, frameLength })
 
-    /* Check for early return (Postcondition): If I can not cache the EncryptionResponse, just return it. */
+    /* Check for early return (Postcondition): If I can not cache the EncryptionMaterial, just return it. */
     if (!material.suite.cacheSafe) return material
 
     /* It is possible for an entry to exceed limits immediately.
@@ -109,31 +109,31 @@ export function getEncryptionMaterials<S extends SupportedAlgorithmSuites> (
       bytesEncrypted: plaintextLength
     }
     if (!this._cacheEntryHasExceededLimits(testEntry)) {
-      this._cache.putEncryptionResponse(cacheKey, material, plaintextLength, this._maxAge)
+      this._cache.putEncryptionMaterial(cacheKey, material, plaintextLength, this._maxAge)
     }
 
     return cloneResponse(material)
   }
 }
 
 export function decryptMaterials<S extends SupportedAlgorithmSuites> (
-  { buildDecryptionResponseCacheKey }: CryptographicMaterialsCacheKeyHelpersInterface<S>
+  { buildDecryptionMaterialCacheKey }: CryptographicMaterialsCacheKeyHelpersInterface<S>
 ): GetDecryptMaterials<S> {
   return async function decryptMaterials (
     this: CachingMaterialsManager<S>,
     request: DecryptionRequest<S>
   ): Promise<DecryptionMaterial<S>> {
     const { suite } = request
-    /* Check for early return (Postcondition): If I can not cache the DecryptionResponse, do not even look. */
+    /* Check for early return (Postcondition): If I can not cache the DecryptionMaterial, do not even look. */
     if (!suite.cacheSafe) {
       return this
         ._backingMaterialsManager
         .decryptMaterials(request)
     }
 
-    const cacheKey = await buildDecryptionResponseCacheKey(this._partition, request)
-    const entry = this._cache.getDecryptionResponse(cacheKey)
-    /* Check for early return (Postcondition): If I have a valid DecryptionResponse, return it. */
+    const cacheKey = await buildDecryptionMaterialCacheKey(this._partition, request)
+    const entry = this._cache.getDecryptionMaterial(cacheKey)
+    /* Check for early return (Postcondition): If I have a valid DecryptionMaterial, return it. */
     if (entry && !this._cacheEntryHasExceededLimits(entry)) {
       return cloneResponse(entry.response)
     } else {
@@ -144,7 +144,7 @@ export function decryptMaterials<S extends SupportedAlgorithmSuites> (
       ._backingMaterialsManager
       .decryptMaterials(request)
 
-    this._cache.putDecryptionResponse(cacheKey, material, this._maxAge)
+    this._cache.putDecryptionMaterial(cacheKey, material, this._maxAge)
     return cloneResponse(material)
   }
 }
@@ -166,8 +166,8 @@ export function cacheEntryHasExceededLimits<S extends SupportedAlgorithmSuites>
  * Because when the Encryption SDK is done with material, it will zero it out.
  * Plucking off the material and cloning just that and then returning the rest of the response
  * can just be handled in one place.
- * @param material EncryptionResponse|DecryptionResponse
- * @return EncryptionResponse|DecryptionResponse
+ * @param material EncryptionMaterial|DecryptionMaterial
+ * @return EncryptionMaterial|DecryptionMaterial
  */
 function cloneResponse<S extends SupportedAlgorithmSuites, M extends EncryptionMaterial<S>|DecryptionMaterial<S>> (
   material: M

modules/cache-material/src/cryptographic_materials_cache.ts

@@ -20,19 +20,19 @@ import {
 } from '@aws-crypto/material-management'
 
 export interface CryptographicMaterialsCache<S extends SupportedAlgorithmSuites> {
-  putEncryptionResponse(
+  putEncryptionMaterial(
     key: string,
     response: EncryptionMaterial<S>,
     plaintextLength: number,
     maxAge?: number
   ): void
-  putDecryptionResponse(
+  putDecryptionMaterial(
     key: string,
     response: DecryptionMaterial<S>,
     maxAge?: number
   ): void
-  getEncryptionResponse(key: string, plaintextLength: number): EncryptionResponseEntry<S>|false
-  getDecryptionResponse(key: string): DecryptionResponseEntry<S>|false
+  getEncryptionMaterial(key: string, plaintextLength: number): EncryptionMaterialEntry<S>|false
+  getDecryptionMaterial(key: string): DecryptionMaterialEntry<S>|false
   del(key: string): void
 }
 
@@ -43,10 +43,10 @@ export interface Entry<S extends SupportedAlgorithmSuites> {
   readonly now: number
 }
 
-export interface EncryptionResponseEntry<S extends SupportedAlgorithmSuites> extends Entry<S> {
+export interface EncryptionMaterialEntry<S extends SupportedAlgorithmSuites> extends Entry<S> {
   readonly response: EncryptionMaterial<S>
 }
 
-export interface DecryptionResponseEntry<S extends SupportedAlgorithmSuites> extends Entry<S> {
+export interface DecryptionMaterialEntry<S extends SupportedAlgorithmSuites> extends Entry<S> {
   readonly response: DecryptionMaterial<S>
 }

modules/cache-material/src/get_local_cryptographic_materials_cache.ts

@@ -26,8 +26,8 @@ import {
 import {
   CryptographicMaterialsCache, // eslint-disable-line no-unused-vars
   Entry, // eslint-disable-line no-unused-vars
-  EncryptionResponseEntry, // eslint-disable-line no-unused-vars
-  DecryptionResponseEntry // eslint-disable-line no-unused-vars
+  EncryptionMaterialEntry, // eslint-disable-line no-unused-vars
+  DecryptionMaterialEntry // eslint-disable-line no-unused-vars
 } from './cryptographic_materials_cache'
 
 export function getLocalCryptographicMaterialsCache<S extends SupportedAlgorithmSuites> (
@@ -71,13 +71,13 @@ export function getLocalCryptographicMaterialsCache<S extends SupportedAlgorithm
   })()
 
   return {
-    putEncryptionResponse (
+    putEncryptionMaterial (
       key: string,
       material: EncryptionMaterial<S>,
       plaintextLength: number,
       maxAge?: number
     ) {
-      /* Precondition: putEncryptionResponse plaintextLength can not be negative. */
+      /* Precondition: putEncryptionMaterial plaintextLength can not be negative. */
       needs(plaintextLength >= 0, 'Malformed plaintextLength')
       /* Precondition: Only cache EncryptionMaterial. */
       needs(isEncryptionMaterial(material), 'Malformed response.')
@@ -92,7 +92,7 @@ export function getLocalCryptographicMaterialsCache<S extends SupportedAlgorithm
 
       cache.set(key, entry, maxAge)
     },
-    putDecryptionResponse (
+    putDecryptionMaterial (
       key: string,
       material: DecryptionMaterial<S>,
       maxAge?: number
@@ -110,7 +110,7 @@ export function getLocalCryptographicMaterialsCache<S extends SupportedAlgorithm
 
       cache.set(key, entry, maxAge)
     },
-    getEncryptionResponse (key: string, plaintextLength: number) {
+    getEncryptionMaterial (key: string, plaintextLength: number) {
       /* Precondition: plaintextLength can not be negative. */
       needs(plaintextLength >= 0, 'Malformed plaintextLength')
       const entry = cache.get(key)
@@ -122,16 +122,16 @@ export function getLocalCryptographicMaterialsCache<S extends SupportedAlgorithm
       entry.bytesEncrypted += plaintextLength
       entry.messagesEncrypted += 1
 
-      return <EncryptionResponseEntry<S>>entry
+      return <EncryptionMaterialEntry<S>>entry
     },
-    getDecryptionResponse (key: string) {
+    getDecryptionMaterial (key: string) {
       const entry = cache.get(key)
       /* Check for early return (Postcondition): If this key does not have a DecryptionMaterial, return false. */
       if (!entry) return false
       /* Postcondition: Only return DecryptionMaterial. */
       needs(isDecryptionMaterial(entry.response), 'Malformed response.')
 
-      return <DecryptionResponseEntry<S>>entry
+      return <DecryptionMaterialEntry<S>>entry
     },
     del (key: string) {
       cache.del(key)

modules/cache-material/test/build_cryptographic_materials_cache_key_helpers.test.ts

@@ -31,8 +31,8 @@ const sha512 = async (...data: (Uint8Array|string)[]) => data
 const {
   encryptionContextHash,
   encryptedDataKeysHash,
-  buildEncryptionResponseCacheKey,
-  buildDecryptionResponseCacheKey
+  buildEncryptionMaterialCacheKey,
+  buildDecryptionMaterialCacheKey
 } = buildCryptographicMaterialsCacheKeyHelpers(fromUtf8, toUtf8, sha512)
 
 describe('buildCryptographicMaterialsCacheKeyHelpers::encryptionContextHash', () => {
@@ -54,19 +54,19 @@ describe('buildCryptographicMaterialsCacheKeyHelpers::encryptedDataKeysHash', ()
   }
 })
 
-describe('buildCryptographicMaterialsCacheKeyHelpers::buildEncryptionResponseCacheKey', () => {
+describe('buildCryptographicMaterialsCacheKeyHelpers::buildEncryptionMaterialCacheKey', () => {
   for (const vector of encryptCacheKeyVectors) {
     it(`${vector.id}`, async () => {
-      const test = await buildEncryptionResponseCacheKey(...vector.arguments)
+      const test = await buildEncryptionMaterialCacheKey(...vector.arguments)
       expect(test).to.equal(Buffer.from(vector.id, 'base64').toString())
     })
   }
 })
 
-describe('buildCryptographicMaterialsCacheKeyHelpers::buildEncryptionResponseCacheKey', () => {
+describe('buildCryptographicMaterialsCacheKeyHelpers::buildEncryptionMaterialCacheKey', () => {
   for (const vector of decryptCacheKeyVectors) {
     it(`${vector.id}`, async () => {
-      const test = await buildDecryptionResponseCacheKey(...vector.arguments)
+      const test = await buildDecryptionMaterialCacheKey(...vector.arguments)
       expect(test).to.equal(Buffer.from(vector.id, 'base64').toString())
     })
   }