8627373776

Committed 10 Apr 2024 07:11AM UTC coverage: 93.063% (+0.2%) from 92.862%

Build # 8627373776

Build Type

Pull #1369

github

Committed by

iamacook

Commit Message

Update comment

Pull Request Pull Request #1369: Add `AuthGuard`

Run Details

1943 of 2341 branches covered (83.0%)

Branch coverage included in aggregate %.

19 of 19 new or added lines in 3 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

6724 of 6972 relevant lines covered (96.44%)

357.88 hits per line

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

89.66

/src/domain/auth/auth.repository.ts

import { CacheRouter } from '@/datasources/cache/cache.router';
import { IAuthRepository } from '@/domain/auth/auth.repository.interface';
import { SiweMessage } from '@/domain/auth/entities/siwe-message.entity';
import { IAuthApi } from '@/domain/interfaces/auth-api.interface';
import { Inject, Injectable, UnauthorizedException } from '@nestjs/common';
import { Request } from 'express';
import { IConfigurationService } from '@/config/configuration.service.interface';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import { AuthService } from '@/routes/auth/auth.service';
import { VerifyAuthMessageDto } from '@/routes/auth/entities/verify-auth-message.dto.entity';
import { IJwtService } from '@/datasources/jwt/jwt.service.interface';

@Injectable()
export class AuthRepository implements IAuthRepository {
  private readonly nonceTtlInSeconds: number;

  constructor(
    @Inject(IAuthApi)
    private readonly authApi: IAuthApi,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject(IJwtService)
    private readonly jwtService: IJwtService,
  ) {
    this.nonceTtlInSeconds = this.configurationService.getOrThrow(
      'auth.nonceTtlSeconds',
    );
  }

  /**
   * Generates a unique nonce and stores it in cache for later verification.
   *
   * @returns nonce - unique string to be signed
   */
  async generateNonce(): Promise<{ nonce: string }> {
    const nonce = this.authApi.generateNonce();

    // Store nonce for reference to verify/prevent replay attacks
    const cacheDir = CacheRouter.getAuthNonceCacheDir(nonce);
    await this.cacheService.set(cacheDir, nonce, this.nonceTtlInSeconds);

    return {
      nonce,
    };
  }

  /**
   * Verifies the validity of a signed message and returns an access token:
   *
   * 1. Ensure the message itself has not expired.
   * 2. Ensure the nonce was generated by us/is not a replay attack.
   * 3. Verify the signature of the message.
   * 4. Return an access token if all checks pass.
   *
   * @param args - DTO containing the message and signature to verify.
   *
   * The following adhere to JWT standard {@link https://datatracker.ietf.org/doc/html/rfc7519}
   *
   * @returns accessToken - JWT access token
   * @returns tokenType - token type ('Bearer') to be used in the `Authorization` header
   * @returns notBefore - epoch from when token is valid (if applicable, otherwise null)
   * @returns expiresIn - time in seconds until the token expires (if applicable, otherwise null)
   */
  async verifyMessage(args: VerifyAuthMessageDto): Promise<{
    accessToken: string;
    tokenType: string;
    notBefore: number | null;
    expiresIn: number | null;
  }> {
    const isValid = await this.isValid(args).catch(() => false);

    if (!isValid) {
      throw new UnauthorizedException();
    }

    const dateWhenTokenIsValid = args.message.notBefore
      ? new Date(args.message.notBefore)
      : null;
    const dateWhenTokenExpires = args.message.expirationTime
      ? new Date(args.message.expirationTime)
      : null;

    const secondsUntilTokenIsValid = dateWhenTokenIsValid
      ? this.getSecondsUntil(dateWhenTokenIsValid)
      : null;
    const secondsUntilTokenExpires = dateWhenTokenExpires
      ? this.getSecondsUntil(dateWhenTokenExpires)
      : null;

    const accessToken = this.jwtService.sign(args.message, {
      ...(secondsUntilTokenIsValid !== null && {
        notBefore: secondsUntilTokenIsValid,
      }),
      ...(secondsUntilTokenExpires !== null && {
        expiresIn: secondsUntilTokenExpires,
      }),
    });

    return {
      tokenType: AuthService.AUTH_TOKEN_TOKEN_TYPE,
      accessToken,
      // Differing measurements match JWT standard {@link https://datatracker.ietf.org/doc/html/rfc7519}
      notBefore: dateWhenTokenIsValid?.getTime() ?? null,
      expiresIn: secondsUntilTokenExpires,
    };
  }

  /**
   * Verifies that a message is valid according to its expiration date,
   * signature and nonce.
   *
   * @param args.message - SiWe message in object form
   * @param args.signature - signature from signing the message
   *
   * @returns boolean - whether the message is valid
   */
  private async isValid(args: {
    message: SiweMessage;
    signature: `0x${string}`;
  }): Promise<boolean> {
    const cacheDir = CacheRouter.getAuthNonceCacheDir(args.message.nonce);

    const isExpired =
      !!args.message.expirationTime &&
      new Date(args.message.expirationTime) < new Date();

    try {
      // Verification is not necessary, message has expired
      if (isExpired) {
        return false;
      }

      const [isValidSignature, cachedNonce] = await Promise.all([
        this.authApi.verifyMessage(args),
        this.cacheService.get(cacheDir),
      ]);
      const isValidNonce = cachedNonce === args.message.nonce;

      return isValidSignature && isValidNonce;
    } catch {
      return false;
    } finally {
      await this.cacheService.deleteByKey(cacheDir.key);
    }
  }

  private getSecondsUntil(date: Date): number {
    return Math.floor((date.getTime() - Date.now()) / 1_000);
  }

  /**
   * Extracts the access token from the request.
   *
   * @param request - the express request object
   * @param tokenType - the type of token used in the Authorization header
   * @returns the access token, or null if not found
   */
  getAccessToken(request: Request, tokenType: string): string | null {
    const header = request.headers.authorization;

    if (!header) {
      return null;
    }

    const [type, token] = header.split(' ');

    if (type !== tokenType || !token) {
      return null;
    }

    return token;
  }

  /**
   * Verifies access token and returns the decoded payload.
   *
   * Returns null if token is not yet valid, expired or malformed.
   *
   * @param accessToken - JWT access token
   * @returns the decoded payload, or null if token is invalid.
   */
  verifyAccessToken(accessToken: string): unknown | null {
    try {
      return this.jwtService.verify(accessToken);
    } catch {
      return null;
    }
  }
}

1	import { CacheRouter } from '@/datasources/cache/cache.router';	94✔
2	import { IAuthRepository } from '@/domain/auth/auth.repository.interface';
3	import { SiweMessage } from '@/domain/auth/entities/siwe-message.entity';
4	import { IAuthApi } from '@/domain/interfaces/auth-api.interface';	94✔
5	import { Inject, Injectable, UnauthorizedException } from '@nestjs/common';	94✔
6	import { Request } from 'express';
7	import { IConfigurationService } from '@/config/configuration.service.interface';	94✔
8	import {	94✔
9	CacheService,
10	ICacheService,
11	} from '@/datasources/cache/cache.service.interface';
12	import { AuthService } from '@/routes/auth/auth.service';	94✔
13	import { VerifyAuthMessageDto } from '@/routes/auth/entities/verify-auth-message.dto.entity';
14	import { IJwtService } from '@/datasources/jwt/jwt.service.interface';	94✔
15
16	@Injectable()
17	export class AuthRepository implements IAuthRepository {	94✔
18	private readonly nonceTtlInSeconds: number;
19
20	constructor(
21	@Inject(IAuthApi)
22	private readonly authApi: IAuthApi,	1,214✔
23	@Inject(IConfigurationService)
24	private readonly configurationService: IConfigurationService,	1,214✔
25	@Inject(CacheService) private readonly cacheService: ICacheService,	1,214✔
26	@Inject(IJwtService)
27	private readonly jwtService: IJwtService,	1,214✔
28	) {
29	this.nonceTtlInSeconds = this.configurationService.getOrThrow(	1,214✔
30	'auth.nonceTtlSeconds',
31	);
32	}
33
34	/**
35	* Generates a unique nonce and stores it in cache for later verification.
36	*
37	* @returns nonce - unique string to be signed
38	*/
39	async generateNonce(): Promise<{ nonce: string }> {
40	const nonce = this.authApi.generateNonce();	10✔
41
42	// Store nonce for reference to verify/prevent replay attacks
43	const cacheDir = CacheRouter.getAuthNonceCacheDir(nonce);	10✔
44	await this.cacheService.set(cacheDir, nonce, this.nonceTtlInSeconds);	10✔
45
46	return {	10✔
47	nonce,
48	};
49	}
50
51	/**
52	* Verifies the validity of a signed message and returns an access token:
53	*
54	* 1. Ensure the message itself has not expired.
55	* 2. Ensure the nonce was generated by us/is not a replay attack.
56	* 3. Verify the signature of the message.
57	* 4. Return an access token if all checks pass.
58	*
59	* @param args - DTO containing the message and signature to verify.
60	*
61	* The following adhere to JWT standard {@link https://datatracker.ietf.org/doc/html/rfc7519}
62	*
63	* @returns accessToken - JWT access token
64	* @returns tokenType - token type ('Bearer') to be used in the `Authorization` header
65	* @returns notBefore - epoch from when token is valid (if applicable, otherwise null)
66	* @returns expiresIn - time in seconds until the token expires (if applicable, otherwise null)
67	*/
68	async verifyMessage(args: VerifyAuthMessageDto): Promise<{
69	accessToken: string;
70	tokenType: string;
71	notBefore: number \| null;
72	expiresIn: number \| null;
73	}> {
74	const isValid = await this.isValid(args).catch(() => false);	10✔
75
76	if (!isValid) {	10✔
77	throw new UnauthorizedException();	8✔
78	}
79
80	const dateWhenTokenIsValid = args.message.notBefore	2!
81	? new Date(args.message.notBefore)
82	: null;
83	const dateWhenTokenExpires = args.message.expirationTime	2!
84	? new Date(args.message.expirationTime)
85	: null;
86
87	const secondsUntilTokenIsValid = dateWhenTokenIsValid	2!
88	? this.getSecondsUntil(dateWhenTokenIsValid)
89	: null;
90	const secondsUntilTokenExpires = dateWhenTokenExpires	2!
91	? this.getSecondsUntil(dateWhenTokenExpires)
92	: null;
93
94	const accessToken = this.jwtService.sign(args.message, {	2✔
95	...(secondsUntilTokenIsValid !== null && {	2✔
96	notBefore: secondsUntilTokenIsValid,
97	}),
98	...(secondsUntilTokenExpires !== null && {	2✔
99	expiresIn: secondsUntilTokenExpires,
100	}),
101	});
102
103	return {	2✔
104	tokenType: AuthService.AUTH_TOKEN_TOKEN_TYPE,
105	accessToken,
106	// Differing measurements match JWT standard {@link https://datatracker.ietf.org/doc/html/rfc7519}
107	notBefore: dateWhenTokenIsValid?.getTime() ?? null,	6!
108	expiresIn: secondsUntilTokenExpires,
109	};
110	}
111
112	/**
113	* Verifies that a message is valid according to its expiration date,
114	* signature and nonce.
115	*
116	* @param args.message - SiWe message in object form
117	* @param args.signature - signature from signing the message
118	*
119	* @returns boolean - whether the message is valid
120	*/
121	private async isValid(args: {
122	message: SiweMessage;
123	signature: `0x${string}`;
124	}): Promise<boolean> {
125	const cacheDir = CacheRouter.getAuthNonceCacheDir(args.message.nonce);	10✔
126
127	const isExpired =
128	!!args.message.expirationTime &&	10✔
129	new Date(args.message.expirationTime) < new Date();
130
131	try {	10✔
132	// Verification is not necessary, message has expired
133	if (isExpired) {	10✔
134	return false;	2✔
135	}
136
137	const [isValidSignature, cachedNonce] = await Promise.all([	8✔
138	this.authApi.verifyMessage(args),
139	this.cacheService.get(cacheDir),
140	]);
141	const isValidNonce = cachedNonce === args.message.nonce;	8✔
142
143	return isValidSignature && isValidNonce;	8✔
144	} catch {
UNCOV 145	return false;	×
146	} finally {
147	await this.cacheService.deleteByKey(cacheDir.key);	10✔
148	}
149	}
150
151	private getSecondsUntil(date: Date): number {
152	return Math.floor((date.getTime() - Date.now()) / 1_000);	4✔
153	}
154
155	/**
156	* Extracts the access token from the request.
157	*
158	* @param request - the express request object
159	* @param tokenType - the type of token used in the Authorization header
160	* @returns the access token, or null if not found
161	*/
162	getAccessToken(request: Request, tokenType: string): string \| null {
163	const header = request.headers.authorization;	22✔
164
165	if (!header) {	22✔
166	return null;	2✔
167	}
168
169	const [type, token] = header.split(' ');	20✔
170
171	if (type !== tokenType \|\| !token) {	20!
UNCOV 172	return null;	×
173	}
174
175	return token;	20✔
176	}
177
178	/**
179	* Verifies access token and returns the decoded payload.
180	*
181	* Returns null if token is not yet valid, expired or malformed.
182	*
183	* @param accessToken - JWT access token
184	* @returns the decoded payload, or null if token is invalid.
185	*/
186	verifyAccessToken(accessToken: string): unknown \| null {
187	try {	20✔
188	return this.jwtService.verify(accessToken);	20✔
189	} catch {
190	return null;	6✔
191	}
192	}
193	}

safe-global / safe-client-gateway / 8627373776

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