08-nestjs基础实践，密码加密，序列化拦截器，数据脱敏，

kgm
713 阅读2分钟

服务端和Mysql存储，密码的加解密

安装加密插件:

$ npm i argon2

注册时，实现用户密码加密功能, 编辑src/user/user.service.ts

  import * as argon2 from 'argon2'
  ...
  // 创建数据
  async create(dto: Partial<User>) {
    ...
    // 使用argon2对密码进行加密
    + user.password = await argon2.hash(user.password)
    ...
  }

image.png

登陆时,实现用户密码解密功能,编辑src/auth/auth.service.ts

...
import * as argon2 from 'argon2'

@Injectable()
export class AuthService {
  constructor(
    private userService: UserService,
    private jwt: JwtService,
  ) {}

  // 用户登录
  async singin(username: string, password: string) {
    const res = await this.userService.findAll({ username } as getUserDto)
    const user = res.total > 0 ? res.records[0] : null
    if (!user) throw new ForbiddenException('用户不存在，请先注册')
    const { password: userPassword, ...userInfo } = user
    // 比较用户密码
    + nst isValidPassword = await argon2.verify(userPassword, password)
    + if (!isValidPassword) throw new ForbiddenException('用户名或密码错误')
    // 生成token
    const token = await this.jwt.signAsync({ username, sub: user.id })
    return { token, userInfo }
  }

  // 用户注册
  async signup(username: string, password: string) {
    + nst users = await this.userService.findAll({ username } as getUserDto)
    + const user = users.total > 0 ? users.records[0] : null
    + if (user) throw new ForbiddenException('用户已存在，不能重复注册')
    const saverResult = await this.userService.create({ username, password })
    return saverResult
  }
}

接口传输和接收过程，密码的加解密

上面的加密和解密只解决了密码在数据库的存储安全,但是在用户发出登录和注册请求过程中的密码还是明文的,这一段主要解决这个问题

安装插件:npm i crypto-js @types/crypto-js

封装插件:

import * as CryptoJS from 'crypto-js'

const key = CryptoJS.enc.Utf8.parse('set_by_youself_random_string')

// 加密方法
export function handleEncrypt(word: string) {
  let srcs = CryptoJS.enc.Utf8.parse(word)
  let encrypted = CryptoJS.AES.encrypt(srcs, key, { mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.Pkcs7 })
  return encrypted.toString()
}

// 解密方法
export function handleDecrypt(word: string) {
  let decrypt = CryptoJS.AES.decrypt(word, key, { mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.Pkcs7 })
  let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8)
  return decryptedStr.toString()
}

在客户端登录时先给密码加密,再请求接口

在服务端创建一个管道,对请求接口中的密码进行解密

  1. 创建密码解密管道:src/user/pipes/crypto-pwd.pipe.ts
import { ArgumentMetadata, Injectable, PipeTransform } from '@nestjs/common'
import { handleDecrypt } from '../../utils/crypto.helper'

/** 对密码进行解密 */
@Injectable()
export class CryptoPwdPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    console.log('原始请求参数', value)
    if ('password' in value) {
      value.password = handleDecrypt(value.password)
    }
    console.log('转化之后的请求参数', value)
    return value
  }
}
  1. 在登录控制器中使用管道
  + import { CryptoPwdPipe } from '../user/pipes/crypto-pwd.pipe'
  // 用户登录
  @Post('/signin')
  + async singin(@Body(CryptoPwdPipe) body: SignginUserDto) {

image.png 3. 之后的流程保持不变

拦截器

创建拦截器

$ nest g itc interceptors/serialize --no-spec --flat -d
$ nest g itc interceptors/serialize --no-spec --flat

生成文件src/interceptors/serialize.interceptors.ts

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common'
import { Observable, map } from 'rxjs'
/** 自定义序列化拦截器 */
@Injectable()
export class SerializeInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // 拦截器之前执行
    console.log('在拦截器之前执行', context.switchToHttp().getRequest().user)
    return next.handle().pipe(
      map((data) => {
        console.log('在拦截器之后执行', context.switchToHttp().getRequest().user)
        return data
      }),
    )
  }
}

在控制器中使用

...
@Get(':id')
@UseInterceptors(SerializeInterceptor)
getUserById(@Param('id') id: number) {
  return this.userService.findOne(id)
}
...

序列换拦截器

编辑src/user/user.entity.ts

  ...
  @Column()
  @Exclude() // 添加Exclude属性,此属性不会返回给请求用户
  password: string
  ...

修改user控制器

import { ClassSerializerInterceptor } from '@nestjs/common'
...
@Get(':id')
+ seInterceptors(ClassSerializerInterceptor)
getUserById(@Param('id') id: number) {
  return this.userService.findOne(id)
}
...

请求接口如下 image.png

利用自定义dto序列化拦截器

编辑文件src/interceptors/serialize.interceptors.ts

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common'
import { plainToInstance } from 'class-transformer'
import { Observable, map } from 'rxjs'

export interface ClassConstructor {
  new (...arg: any[]): {}
}
/**
 * 自定义序列化拦截器
 * 用法如下
 * @UseInterceptors(new SerializeInterceptor(dto))
 * @Get('/:id')
 * async findUser(@Param('id') id: string) { }
 * 
 * @param dto 用于定义输出响应的类，如user.dto.ts
 * @returns
 */
@Injectable()
export class SerializeInterceptor implements NestInterceptor {
  constructor(private dto: ClassConstructor) {}
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // 拦截器之前执行 ，console.log('在拦截器之前执行', context.switchToHttp().getRequest().user)
    return next.handle().pipe(
      map((data) => {
        // console.log('在拦截器之后执行')
        return plainToInstance(this.dto, data, {
          // 设置为true, 所有经过该拦截器的数据都需要设置Expose(暴露的意思)或者Exclude(排除的意思)
          excludeExtraneousValues: true,
        })
      }),
    )
  }
}

创建自定义装饰器,简化序列化拦截器的用法,创建文件src\decorators\serialize.decorators.ts

import { UseInterceptors } from '@nestjs/common'
import { ClassConstructor, SerializeInterceptor } from '../interceptors/serialize.interceptor'
/**
 * 包装为装饰器，简化自定义序列化拦截器的使用
 * @param dto 用于定义输出响应的类，如user.dto.ts
 *
 * 用于控制器
 * @Controller('auth')
 * @Serialize(UserDto)
 * export class UsersController {}
 *
 * 用于路由
 * @Serialize(UserDto)
 * @Get('/:id')
 * async findUser(@Param('id') id: string) { }
 *
 * @returns
 */
export function Serialize(dto: ClassConstructor) {
  return UseInterceptors(new SerializeInterceptor(dto))
}

创建UserDto文件src/user/dto/user.dto.ts

import { Expose, Transform } from 'class-transformer'
import { Profile } from 'passport'
import { Logs } from '../../logs/logs.entity'
import { Roles } from '../../roles/roles.entity'

// 用于定义用户的响应字段
export class UserDto {
  @Expose()
  id: number
  @Expose()
  username: string

  @Transform(({ obj }) => obj.logs)
  @Expose()
  logs: Logs[]

  @Transform(({ obj }) => obj.roles)
  @Expose()
  roles: Roles[]

  @Transform(({ obj }) => obj.profile)
  @Expose()
  profile: Profile
}

在控制器的方法中使用

import { Serialize } from '../decorators/serialize.decorators'
import { UserDto } from './dto/user.dto'

@Get(':id')
@Serialize(UserDto)
getUserById(@Param('id') id: number) {
  return this.userService.findOne(id)
}
avatar
文章
阅读
粉丝