11801278792

Committed 12 Nov 2024 04:14PM UTC coverage: 89.084% (-0.03%) from 89.109%

Build # 11801278792

Build Type

push

github

Committed by

hectorgomezv

Commit Message

Adjust AwsEncryptionApiService

Run Details

2725 of 3416 branches covered (79.77%)

Branch coverage included in aggregate %.

2 of 16 new or added lines in 1 file covered. (12.5%)

2 existing lines in 2 files now uncovered.

9092 of 9849 relevant lines covered (92.31%)

425.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

20.83

/src/datasources/accounts/encryption/aws-encryption-api.service.ts

import { IConfigurationService } from '@/config/configuration.service.interface';
import { AccountsEncryptionType } from '@/config/entities/schemas/configuration.schema';
import type { IEncryptionApi } from '@/domain/interfaces/encryption-api.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import {
  CreateKeyCommand,
  DecryptCommand,
  EncryptCommand,
  KMSClient,
  ListKeysCommand,
} from '@aws-sdk/client-kms';
import { Inject, Injectable } from '@nestjs/common';

@Injectable()
export class AwsEncryptionApiService implements IEncryptionApi {
  private readonly kmsClient: KMSClient;
  private awsKmsKeyId: string | undefined; // TODO: remove this when not using LocalStack
  private readonly accountsEncryptionType: AccountsEncryptionType;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {
    this.accountsEncryptionType =
      this.configurationService.getOrThrow<AccountsEncryptionType>(
        'accounts.encryption.type',
      );
    this.awsKmsKeyId = this.configurationService.get<string>(
      'accounts.encryption.awsKms.keyId',
    );
    this.kmsClient = new KMSClient({
      // TODO: localstack
      endpoint: 'http://localhost:4566',
      region: 'us-east-1',
      credentials: {
        accessKeyId: 'test',
        secretAccessKey: 'test',
      },
    });
  }
  async initKey(): Promise<void> {
    // TODO: remove this when not using LocalStack
    if (this.awsKmsKeyId) {
      return;
    }
    const keyId = await this.createKey();
    await this.listKeys();
    this.awsKmsKeyId = keyId;
  }

  async encrypt(data: string): Promise<string> {
    await this.initKey();
    const encryptedData = await this.kmsClient.send(
      new EncryptCommand({
        KeyId: this.awsKmsKeyId,
        Plaintext: Buffer.from(data),
      }),
    );
    if (!encryptedData.CiphertextBlob) {
      throw new Error('Failed to encrypt data');
    }
    return Buffer.from(encryptedData.CiphertextBlob).toString('base64');
  }

  async decrypt(data: string): Promise<string> {
    await this.initKey();
    const decryptedData = await this.kmsClient.send(
      new DecryptCommand({ CiphertextBlob: Buffer.from(data, 'base64') }),
    );
    if (!decryptedData.Plaintext) {
      throw new Error('Failed to decrypt data');
    }
    return Buffer.from(decryptedData.Plaintext).toString('utf-8');
  }

  // TODO: remove this when not using LocalStack
  async createKey(): Promise<string> {
    const command = new CreateKeyCommand({
      Description: 'Test key for LocalStack',
      KeyUsage: 'ENCRYPT_DECRYPT',
      XksKeyId: this.awsKmsKeyId,
    });
    const response = await this.kmsClient.send(command);
    this.loggingService.info(`Created Key: ${response.KeyMetadata?.KeyId}`);
    return response.KeyMetadata?.KeyId || '';
  }

  // TODO: remove this when not using LocalStack
  async listKeys(): Promise<void> {
    const command = new ListKeysCommand({});
    const response = await this.kmsClient.send(command);
    console.log('Available Keys:', response.Keys);
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	108✔
2	import { AccountsEncryptionType } from '@/config/entities/schemas/configuration.schema';
3	import type { IEncryptionApi } from '@/domain/interfaces/encryption-api.interface';
4	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	108✔
5	import {	108✔
6	CreateKeyCommand,
7	DecryptCommand,
8	EncryptCommand,
9	KMSClient,
10	ListKeysCommand,
11	} from '@aws-sdk/client-kms';
12	import { Inject, Injectable } from '@nestjs/common';	108✔
13
14	@Injectable()
15	export class AwsEncryptionApiService implements IEncryptionApi {	108✔
16	private readonly kmsClient: KMSClient;
17	private awsKmsKeyId: string \| undefined; // TODO: remove this when not using LocalStack
18	private readonly accountsEncryptionType: AccountsEncryptionType;
19
20	constructor(
21	@Inject(IConfigurationService)
22	private readonly configurationService: IConfigurationService,	4✔
23	@Inject(LoggingService) private readonly loggingService: ILoggingService,	4✔
24	) {
25	this.accountsEncryptionType =	4✔
26	this.configurationService.getOrThrow<AccountsEncryptionType>(
27	'accounts.encryption.type',
28	);
29	this.awsKmsKeyId = this.configurationService.get<string>(	4✔
30	'accounts.encryption.awsKms.keyId',
31	);
32	this.kmsClient = new KMSClient({	4✔
33	// TODO: localstack
34	endpoint: 'http://localhost:4566',
35	region: 'us-east-1',
36	credentials: {
37	accessKeyId: 'test',
38	secretAccessKey: 'test',
39	},
40	});
41	}
42	async initKey(): Promise<void> {
43	// TODO: remove this when not using LocalStack
NEW 44	if (this.awsKmsKeyId) {	×
NEW 45	return;	×
46	}
NEW 47	const keyId = await this.createKey();	×
NEW 48	await this.listKeys();	×
NEW 49	this.awsKmsKeyId = keyId;	×
50	}
51
52	async encrypt(data: string): Promise<string> {
NEW 53	await this.initKey();	×
UNCOV 54	const encryptedData = await this.kmsClient.send(	×
55	new EncryptCommand({
56	KeyId: this.awsKmsKeyId,
57	Plaintext: Buffer.from(data),
58	}),
59	);
NEW 60	if (!encryptedData.CiphertextBlob) {	×
NEW 61	throw new Error('Failed to encrypt data');	×
62	}
NEW 63	return Buffer.from(encryptedData.CiphertextBlob).toString('base64');	×
64	}
65
66	async decrypt(data: string): Promise<string> {
NEW 67	await this.initKey();	×
NEW 68	const decryptedData = await this.kmsClient.send(	×
69	new DecryptCommand({ CiphertextBlob: Buffer.from(data, 'base64') }),
70	);
NEW 71	if (!decryptedData.Plaintext) {	×
NEW 72	throw new Error('Failed to decrypt data');	×
73	}
NEW 74	return Buffer.from(decryptedData.Plaintext).toString('utf-8');	×
75	}
76
77	// TODO: remove this when not using LocalStack
78	async createKey(): Promise<string> {
79	const command = new CreateKeyCommand({	×
80	Description: 'Test key for LocalStack',
81	KeyUsage: 'ENCRYPT_DECRYPT',
82	XksKeyId: this.awsKmsKeyId,
83	});
84	const response = await this.kmsClient.send(command);	×
85	this.loggingService.info(`Created Key: ${response.KeyMetadata?.KeyId}`);	×
86	return response.KeyMetadata?.KeyId \|\| '';	×
87	}
88
89	// TODO: remove this when not using LocalStack
90	async listKeys(): Promise<void> {
91	const command = new ListKeysCommand({});	×
92	const response = await this.kmsClient.send(command);	×
93	console.log('Available Keys:', response.Keys);	×
94	}
95	}

safe-global / safe-client-gateway / 11801278792

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous