FEAT: squash - auth guard

nestjs access controll mock

swagger implementation

middleware changes and lib

permissions file back to maestro

FEAT: sending permissions to duc on startup


FEAT: new permissions.enum format


FEAT: permissions injection (maestro -> duc)


FIX: changing method invocation order


FEAT: refactored permission enum + duc permission injector + grpcHandler


FEAT: auth guards


FEAT: seq ids updated
This commit is contained in:
Arthur Simas
2022-06-27 18:32:08 -03:00
committed by arthur simas
parent 89b571d7f8
commit 1566efc490
23 changed files with 908 additions and 707 deletions
@@ -0,0 +1,28 @@
import { SetMetadata, applyDecorators } from '@nestjs/common';
import { Request } from 'express';
import { Permission } from './permissions.enum';
export const PERMISSIONS_KEY = '__PERMISSIONS__';
export const MUST_BE_AUTHENTICATED_KEY = '__MUST_BE_AUTHENTICATED__';
export const CUSTOM_AUTHENTICATION_FUNCTION_KEY =
'__CUSTOM_AUTHENTICATION_FUNCTION__';
export type AuthenticationFunction = (req: Request, user: any) => boolean;
export function RequirePermissions(...permissions: Permission[]) {
return applyDecorators(
SetMetadata(PERMISSIONS_KEY, permissions),
SetMetadata(MUST_BE_AUTHENTICATED_KEY, true),
);
}
export function AuthenticateCondition(func: AuthenticationFunction) {
return applyDecorators(
SetMetadata(CUSTOM_AUTHENTICATION_FUNCTION_KEY, func),
SetMetadata(MUST_BE_AUTHENTICATED_KEY, true),
);
}
export function Authenticated() {
return SetMetadata(MUST_BE_AUTHENTICATED_KEY, true);
}
+158
View File
@@ -0,0 +1,158 @@
import {
Injectable,
CanActivate,
OnApplicationBootstrap,
ExecutionContext,
Logger,
} from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import assert from 'assert';
import jwt from 'jsonwebtoken';
import { AuthClientService } from '../clients/auth/client.service';
import { Permission } from './permissions.enum';
import {
AuthenticationFunction,
PERMISSIONS_KEY,
CUSTOM_AUTHENTICATION_FUNCTION_KEY,
MUST_BE_AUTHENTICATED_KEY,
} from './authentication.decorator';
import ErrorBuilder from '../utils/ErrorBuilder';
import ErrorCodes from '../utils/errorCodes';
@Injectable()
export class AuthenticationGuard
implements CanActivate, OnApplicationBootstrap
{
private readonly logger = new Logger(AuthenticationGuard.name);
pems: Map<string, string>;
constructor(
private reflector: Reflector,
private authClient: AuthClientService,
) {
this.pems = new Map();
}
async onApplicationBootstrap() {
return this.loadDucJWKS();
}
async loadDucJWKS() {
const { keys } = await this.authClient.getPublicKeys();
keys.forEach((key) => {
this.pems.set(key.kid, key.pem);
});
}
canActivate(ctx: ExecutionContext): boolean {
const requiredPermissions = this.reflector.getAllAndOverride<Permission[]>(
PERMISSIONS_KEY,
[ctx.getHandler(), ctx.getClass()],
);
const customAuthenticationFunction =
this.reflector.getAllAndOverride<AuthenticationFunction>(
CUSTOM_AUTHENTICATION_FUNCTION_KEY,
[ctx.getHandler(), ctx.getClass()],
);
const mustBeAuthenticated = this.reflector.getAllAndOverride<boolean>(
MUST_BE_AUTHENTICATED_KEY,
[ctx.getHandler(), ctx.getClass()],
);
const request = ctx.switchToHttp().getRequest();
const accessToken = this.verifyToken(request);
if (!accessToken) {
// couldn't load valid token
if (!mustBeAuthenticated) {
// no need to be authenticated
return true;
}
throw new ErrorBuilder(ErrorCodes.AUTH.UNAUTHORIZED);
}
if (
typeof customAuthenticationFunction === 'function' &&
!customAuthenticationFunction(request, request.user)
) {
// custom authentication function forbidden this request
throw new ErrorBuilder(ErrorCodes.AUTH.FORBIDDEN);
}
if (
Array.isArray(requiredPermissions) &&
requiredPermissions.length > 0 &&
!this.matchPermissions(requiredPermissions, accessToken.permissions)
) {
// couldn't match permissions
throw new ErrorBuilder(ErrorCodes.AUTH.FORBIDDEN);
}
return true;
}
private verifyToken(request) {
const accessToken = request.get('Authorization');
let accessTokenPayload;
// If the user isn't authenticated, an error will occurr anywhere here.
// Fancy error avoidance isn't performed by purpose, such as avoiding to access null values.
try {
const accessTokenDecoded: any = jwt.decode(accessToken, {
complete: true,
});
/*assert(
accessTokenDecoded.payload.iss === 'duc',
'token should be issued by DUC',
);*/
assert(
accessTokenDecoded.payload.token_use === 'access',
'should be an access token',
);
const { kid } = accessTokenDecoded.header;
const pemValue: string = this.pems.get(kid);
jwt.verify(accessToken, pemValue);
accessTokenPayload = accessTokenDecoded.payload;
} catch (err) {
this.logger.log('Unable to verify duc access token\n' + err.stack);
return false;
}
request.accessTokenPayload = accessTokenPayload;
request.user = {
user_id: accessTokenPayload.user_id,
username: accessTokenPayload.username,
permissions: accessTokenPayload.permissions,
customer_id: accessTokenPayload.customer_id,
customer_name: accessTokenPayload.customer_name,
customer_tier: accessTokenPayload.customer_tier,
};
// TODO: for backwards compatibility. remove in the future
request.body.info = {
user_id: accessTokenPayload.user_id,
customer_id: accessTokenPayload.customer_id,
customer: accessTokenPayload.customer_name,
customer_tier: accessTokenPayload.customer_tier,
};
return accessTokenPayload;
}
private matchPermissions(
requiredPermissions: Permission[],
userPermissions: number[],
) {
return requiredPermissions.some((permission) =>
userPermissions.includes(permission.seqid),
);
}
}
+216
View File
@@ -0,0 +1,216 @@
import assert from 'assert';
export enum PermissionUsages {
PUBLIC = 'public',
INTERNAL = 'internal',
}
export interface Permission {
seqid: number;
claim: string;
usage: PermissionUsages;
}
// like field numbers in gRPC, avoid to change (or reuse previously used) seqids once its
// deployed to DUC
/*export const Permissions: {
[P in keyof any]: { [Q in keyof any]: Permission };
} = {*/
export const Permissions = {
AUTH: {
CREATE: {
seqid: 18,
claim: 'POST /auth',
usage: PermissionUsages.PUBLIC,
},
},
PIPELINE: {
CREATE: {
seqid: 23,
claim: 'POST /pipelines',
usage: PermissionUsages.PUBLIC,
},
GET: {
seqid: 13,
claim: 'GET /pipelines',
usage: PermissionUsages.PUBLIC,
},
UPDATE: {
seqid: 29,
claim: 'PUT /pipelines',
usage: PermissionUsages.PUBLIC,
},
DELETE: {
seqid: 5,
claim: 'DELETE /pipelines',
usage: PermissionUsages.PUBLIC,
},
},
INPUT: {
CREATE: {
seqid: 21,
claim: 'POST /inputs',
usage: PermissionUsages.PUBLIC,
},
GET: {
seqid: 9,
claim: 'GET /inputs',
usage: PermissionUsages.PUBLIC,
},
UPDATE: {
seqid: 27,
claim: 'PUT /inputs',
usage: PermissionUsages.PUBLIC,
},
UPDATE_PARTIAL: {
seqid: 17,
claim: 'PATCH /inputs',
usage: PermissionUsages.PUBLIC,
},
DELETE: {
seqid: 3,
claim: 'DELETE /inputs',
usage: PermissionUsages.PUBLIC,
},
GET_ENTITIES: {
seqid: 10,
claim: 'GET /inputs/available-entities',
usage: PermissionUsages.PUBLIC,
},
},
OUTPUT: {
CREATE: {
seqid: 22,
claim: 'POST /outputs',
usage: PermissionUsages.PUBLIC,
},
GET: {
seqid: 12,
claim: 'GET /outputs',
usage: PermissionUsages.PUBLIC,
},
UPDATE: {
seqid: 28,
claim: 'PUT /outputs',
usage: PermissionUsages.PUBLIC,
},
DELETE: {
seqid: 4,
claim: 'DELETE /outputs',
usage: PermissionUsages.PUBLIC,
},
},
TRANSFORMATIONS: {
CREATE: {
seqid: 24,
claim: 'POST /transformations',
usage: PermissionUsages.PUBLIC,
},
GET: {
seqid: 15,
claim: 'GET /transformations',
usage: PermissionUsages.PUBLIC,
},
UPDATE: {
seqid: 30,
claim: 'PUT /transformations',
usage: PermissionUsages.PUBLIC,
},
DELETE: {
seqid: 6,
claim: 'DELETE /transformations',
usage: PermissionUsages.PUBLIC,
},
},
CATALOG: {
CREATE: {
seqid: 19,
claim: 'POST /catalog',
usage: PermissionUsages.PUBLIC,
},
GET: {
seqid: 7,
claim: 'GET /catalog',
usage: PermissionUsages.PUBLIC,
},
UPDATE: {
seqid: 25,
claim: 'PUT /catalog',
usage: PermissionUsages.PUBLIC,
},
DELETE: {
seqid: 1,
claim: 'DELETE /catalog',
usage: PermissionUsages.PUBLIC,
},
},
CONNECTORS: {
CREATE: {
seqid: 20,
claim: 'POST /connectors',
usage: PermissionUsages.PUBLIC,
},
GET: {
seqid: 8,
claim: 'GET /connectors',
usage: PermissionUsages.PUBLIC,
},
UPDATE: {
seqid: 26,
claim: 'PUT /connectors',
usage: PermissionUsages.PUBLIC,
},
DELETE: {
seqid: 2,
claim: 'DELETE /connectors',
usage: PermissionUsages.PUBLIC,
},
},
SNOWFLAKE: {
OPEN: {
seqid: 14,
claim: 'GET /snowflake',
usage: PermissionUsages.PUBLIC,
},
},
ZENDESK: {
OPEN: {
seqid: 16,
claim: 'GET /zendesk',
usage: PermissionUsages.PUBLIC,
},
},
METABASE: {
OPEN: {
seqid: 11,
claim: 'GET /metabase',
usage: PermissionUsages.PUBLIC,
},
},
};
// traverses the object searching for duplicate seqids or claims (executes at runtime)
const seqids = Object.values(Permissions).flatMap((namespace) =>
Object.values(namespace).map(({ seqid }) => seqid),
);
const claims = Object.values(Permissions).flatMap((namespace) =>
Object.values(namespace).map(({ claim }) => claim),
);
Object.values(Permissions).map((namespace) =>
Object.values(namespace).map(({ seqid, claim }) => {
const seqidsCount = seqids.filter((x) => x === seqid).length;
assert(seqidsCount === 1, `seqid ${seqid} count is not 1`);
const claimsCount = claims.filter((x) => x === claim).length;
assert(claimsCount === 1, `claim '${claim}' count is not 1`);
}),
);
+23
View File
@@ -0,0 +1,23 @@
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import ErrorBuilder from '../utils/ErrorBuilder';
import ErrorCodes from '../utils/errorCodes';
export interface RequestUser {
user_id: string;
username: string;
permissions: string;
customer_id: string;
customer_name: string;
customer_tier: string;
}
export const User = createParamDecorator((data: any, ctx: ExecutionContext) => {
const request = ctx.switchToHttp().getRequest();
if (!request.user && data?.required) {
throw new ErrorBuilder(ErrorCodes.AUTH.UNAUTHORIZED);
}
return request.user;
});