EIT-2337 | add encryption module

Author: edutomesco

.vscode/settings.json

@@ -5,5 +5,8 @@
   "editor.codeActionsOnSave": {
     "source.organizeImports": true,
     "source.fixAll.eslint": true
-  }
+  },
+  "cSpell.words": [
+    "ciphertext"
+  ]
 }

src/client.ts

@@ -4,13 +4,16 @@ import { AnchorService } from './anchor/service/anchor.service'
 import { NetworkConfiguration } from './config/entity/configuration.entity'
 import Network from './config/entity/networks.entity'
 import { ConfigService } from './config/service/config.service'
+import { EncryptData } from './encryption/entity/encrypt_data'
+import { EncryptionService } from './encryption/service/encryption.service'
 import { HttpClient } from './infrastructure/http.client'
 import { Proof } from './proof/entity/proof.entity'
 import { ProofService } from './proof/service/proof.service'
 import { RecordReceipt } from './record/entity/record-receipt.entity'
 import { Record } from './record/entity/record.entity'
 import { RecordService } from './record/service/record.service'
 import { DependencyInjection } from './shared/dependency-injection'
+import { TypedArray } from './shared/utils'
 
 /**
  * Entrypoint to the Bloock SDK:
@@ -28,6 +31,8 @@ export class BloockClient {
 
   private httpClient: HttpClient
 
+  private encryptionService: EncryptionService
+
   /**
    * Constructor with API Key that enables accessing to Bloock's functionalities.
    * @param  {string} apiKey Client API Key.
@@ -40,6 +45,7 @@ export class BloockClient {
     this.configService = container.resolve<ConfigService>('ConfigService')
     this.recordService = container.resolve<RecordService>('RecordService')
     this.proofService = container.resolve<ProofService>('ProofService')
+    this.encryptionService = container.resolve<EncryptionService>('EncryptionService')
 
     this.httpClient = container.resolve<HttpClient>('HttpClient')
 
@@ -159,4 +165,16 @@ export class BloockClient {
   public async verifySignatures(records: Record[]): Promise<boolean> {
     return this.proofService.verifySignatures(records)
   }
+
+  public async generateSecretKey(): Promise<string> {
+    return this.encryptionService.generateSecretKey()
+  }
+
+  public async encryptData(data: TypedArray, secret: string): Promise<EncryptData> {
+    return this.encryptionService.encrypt(data, secret)
+  }
+
+  public async decryptData(encrypt_data: EncryptData, secret: string): Promise<TypedArray> {
+    return this.encryptionService.decrypt(encrypt_data, secret)
+  }
 }

src/encryption/entity/encrypt_data.ts

@@ -0,0 +1,30 @@
+
+export class EncryptData {
+    public ciphertext: string;
+    public iv: string;
+    public tag: string;
+    public protect?: string;
+    public encrypted_key?: string;
+    public header?: Headers
+
+    constructor(
+        ciphertext: string,
+        iv: string,
+        tag: string,
+        protect?: string,
+        encrypted_key?: string,
+        header?: Headers
+    ) {
+        this.ciphertext = ciphertext;
+        this.iv = iv;
+        this.tag = tag;
+        this.protect = protect;
+        this.encrypted_key = encrypted_key;
+        this.header = header
+    }
+}
+
+type Headers = {
+  alg?: string
+  [propName: string]: unknown
+}

src/encryption/repository/encryption-impl.repository.ts

@@ -0,0 +1,27 @@
+import { inject, injectable } from "tsyringe"
+import { EncryptionClient } from "../../infrastructure/encryption.client"
+import { TypedArray } from "../../shared/utils"
+import { EncryptData } from "../entity/encrypt_data"
+import { EncryptionRepository } from "./encryption.repository"
+
+@injectable()
+export class EncryptionRepositoryImpl implements EncryptionRepository {
+  constructor(
+    @inject('EncryptionClient') private encryptionClient: EncryptionClient,
+  ) {}
+
+  async encrypt(data: TypedArray, secret: string): Promise<EncryptData> {
+    const ed = await this.encryptionClient.encrypt(data, secret)
+    return new EncryptData(ed.ciphertext, ed.iv, ed.tag, ed.protect, ed.encrypted_key, ed.header)
+  }
+
+  async decrypt(encrypt_data: EncryptData, secret: string): Promise<TypedArray> {
+    const dd = await this.encryptionClient.decrypt(encrypt_data, secret)
+    return dd
+  }
+
+  async generateSecretKey(): Promise<string> {
+    const k = await this.encryptionClient.generateSecretKey()
+    return k
+  }
+}

src/encryption/repository/encryption.repository.ts

@@ -0,0 +1,9 @@
+import { TypedArray } from "../../shared/utils"
+import { EncryptData } from "../entity/encrypt_data"
+
+
+export interface EncryptionRepository {
+  encrypt(data: TypedArray, secret: string): Promise<EncryptData>
+  decrypt(encrypt_data: EncryptData, secret: string): Promise<TypedArray>
+  generateSecretKey(): Promise<string>
+}

src/encryption/service/encryption-impl.service.ts

@@ -0,0 +1,27 @@
+import { inject, injectable } from 'tsyringe';
+import { TypedArray } from "../../shared/utils";
+import { EncryptData } from "../entity/encrypt_data";
+import { EncryptionRepository } from '../repository/encryption.repository';
+import { EncryptionService } from "./encryption.service";
+
+@injectable()
+export class EncryptionServiceImpl implements EncryptionService {
+  constructor(
+    @inject('EncryptionRepository') private encryptionRepository: EncryptionRepository
+  ) {}
+
+  async encrypt(data: TypedArray, secret: string): Promise<EncryptData> {
+    const ed = await this.encryptionRepository.encrypt(data, secret)
+    return ed
+  }
+
+  async decrypt(encrypt_data: EncryptData, secret: string): Promise<TypedArray> {
+    const dd = await this.encryptionRepository.decrypt(encrypt_data, secret)
+    return dd
+  }
+
+  async generateSecretKey(): Promise<string> {
+    const k = await this.encryptionRepository.generateSecretKey()
+    return k
+  }
+}

src/encryption/service/encryption.service.ts

@@ -0,0 +1,8 @@
+import { TypedArray } from "../../shared/utils"
+import { EncryptData } from "../entity/encrypt_data"
+
+export interface EncryptionService {
+  encrypt(data: TypedArray, secret: string): Promise<EncryptData>
+  decrypt(encrypt_data: EncryptData, secret: string): Promise<TypedArray>
+  generateSecretKey(): Promise<string>
+}

src/index.ts

@@ -2,8 +2,9 @@ import 'reflect-metadata'
 import { BloockClient } from './client'
 import { NetworkConfiguration } from './config/entity/configuration.entity'
 import Network from './config/entity/networks.entity'
+import { EncryptData } from './encryption/entity/encrypt_data'
 import { Proof } from './proof/entity/proof.entity'
 import { RecordReceipt } from './record/entity/record-receipt.entity'
 import { Record } from './record/entity/record.entity'
 
-export { BloockClient, Record, RecordReceipt, Proof, Network, NetworkConfiguration }
+export { BloockClient, Record, RecordReceipt, Proof, Network, NetworkConfiguration, EncryptData }

src/infrastructure/encryption/jwe.ts

@@ -1,10 +1,12 @@
 import * as jose from 'jose';
+import { injectable } from 'tsyringe';
 import { ConfigData } from '../../config/repository/config-data';
 import { TypedArray } from "../../shared/utils";
 import { Encryption, EncryptionClient, Headers } from "../encryption.client";
 
-
+@injectable()
 export class JWEClient implements EncryptionClient {
+
   async encrypt(payload: TypedArray, rawSecretKey: string): Promise<Encryption> {
     const configData = new ConfigData()
 

src/shared/dependency-injection.ts

@@ -4,7 +4,10 @@ import { AnchorServiceImpl } from '../anchor/service/anchor-impl.service'
 import { ConfigData } from '../config/repository/config-data'
 import { ConfigRepositoryImpl } from '../config/repository/config-impl.repository'
 import { ConfigServiceImpl } from '../config/service/config-impl.service'
+import { EncryptionRepositoryImpl } from '../encryption/repository/encryption-impl.repository'
+import { EncryptionServiceImpl } from '../encryption/service/encryption-impl.service'
 import { Web3Client } from '../infrastructure/blockchain/web3'
+import { JWEClient } from '../infrastructure/encryption/jwe'
 import { Keccak } from '../infrastructure/hashing/keccak'
 import { HttpData } from '../infrastructure/http/http-data'
 import { HttpClientImpl } from '../infrastructure/http/http-impl'
@@ -60,5 +63,16 @@ export class DependencyInjection {
     container.register('ProofService', {
       useClass: ProofServiceImpl
     })
+
+    // Encryption module
+    container.register('EncryptionRepository', {
+      useClass: EncryptionRepositoryImpl
+    })
+    container.register('EncryptionService', {
+      useClass: EncryptionServiceImpl
+    })
+    container.register('EncryptionClient', {
+      useClass: JWEClient
+    })
   }
 }

test/acceptance.test.ts

@@ -31,7 +31,7 @@ describe('Acceptance Tests', () => {
     jest.setTimeout(120000)
 
     const sdk = getSdk()
-
+    
     const records = [Record.fromString(randHex(64))]
 
     const sendReceipt = await sdk.sendRecords(records)

test/functional.test.ts

@@ -1,5 +1,7 @@
+import fs from 'fs'
 import { BloockClient, Network, Record, RecordReceipt } from '../src'
 import { Anchor } from '../src/anchor/entity/anchor.entity'
+import { PDFDocument } from '../src/record/entity/document/pdf'
 
 function getSdk(): BloockClient {
   const apiKey = process.env['API_KEY'] || ''
@@ -117,4 +119,25 @@ describe('Functional Tests', () => {
     let timestamp = await sdk.validateRoot(root, Network.BLOOCK_CHAIN)
     expect(timestamp).toBeGreaterThan(0)
   })
+
+  test('testEncryptDocument', async () => {
+      jest.setTimeout(120000)
+
+      const sdk = getSdk()
+
+      const bytes = fs.readFileSync('./test/assets/dummy.pdf')
+      let file = new PDFDocument(bytes)
+      await file.ready
+
+      const secretKey = await sdk.generateSecretKey()
+      expect(secretKey).toBeTruthy()
+
+      let encryptedData = await sdk.encryptData(file.getDataBytes(), secretKey)
+      expect(encryptedData).toBeTruthy()
+      expect(encryptedData.ciphertext).toBeTruthy()
+
+      let decryptedData = await sdk.decryptData(encryptedData, secretKey)
+      expect(decryptedData).toBeTruthy()
+      expect(decryptedData).toEqual(file.getDataBytes())
+  })
 })