1
const crypto = require('crypto')
2

3
// 해시 함수 사용 예제
4
const hash = crypto.createHash('sha256')
5
hash.update('password123')
6
const hashedPassword = hash.digest('hex')
7

8
console.log(hashedPassword) // 해시된 비밀번호 출력

1
const crypto = require('crypto')
2

3
// 비밀번호 해싱 예제
4
const salt = crypto.randomBytes(16).toString('hex')
5
const hash = crypto.pbkdf2Sync('password123', salt, 1000, 64, 'sha512').toString('hex')
6

7
// 비밀번호 'password123'에 솔트를 추가하고 해시 값을 생성
8
// 이를 통해 사전 공격에 대한 방어력을 높일 수 있다
9
console.log(`Salt: ${salt}`)
10
console.log(`Hash: ${hash}`)

1
const crypto = require('crypto')
2

3
// 비밀번호와 솔트를 사용한 해싱 예제
4
const password = 'password123'
5
const salt = crypto.randomBytes(16).toString('hex') // 임의의 솔트 생성
6
const hash = crypto.pbkdf2Sync(password, salt, 1000, 64, 'sha512').toString('hex')
7

8
console.log(`Salt: ${salt}`)
9
console.log(`Hash: ${hash}`)

1
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
2
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.
3
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

1
import { Injectable } from '@nestjs/common'
2
import { PassportStrategy } from '@nestjs/passport'
3
import { Strategy } from 'passport-local'
4
import { AuthService } from './auth.service'
5

6
@Injectable()
7
export class LocalStrategy extends PassportStrategy(Strategy) {
8
  constructor(private authService: AuthService) {
9
    super()
10
  }
11

12
  async validate(username: string, password: string) {
13
    const user = await this.authService.validateUser(username, password)
14
    if (!user) {
15
      throw new UnauthorizedException()
16
    }
17
    return user
18
  }
19
}

1
@Controller('auth')
2
export class AuthController {
3
  @UseGuards(AuthGuard('local'))
4
  @Post('login')
5
  async login(@Request() req) {
6
    return req.user
7
  }
8
}

1
import {
2
  BadRequestException,
3
  CanActivate,
4
  ExecutionContext,
5
  ForbiddenException,
6
  Injectable,
7
  UnauthorizedException,
8
} from '@nestjs/common'
9

10
import { RolesEnum } from 'src/users/const/roles.const'
11
import { PostsService } from '../posts.service'
12
import { Request } from 'express'
13
import { UsersModel } from 'src/users/entity/users.entity'
14

15
@Injectable()
16
export class IsPostMineOrAdminGuard implements CanActivate {
17
  constructor(private readonly postService: PostsService) {}
18

19
  async canActivate(context: ExecutionContext): Promise<boolean> {
20
    const req = context.switchToHttp().getRequest() as Request & {
21
      user: UsersModel
22
    }
23

24
    const { user } = req
25

26
    if (!user) {
27
      throw new UnauthorizedException('사용자 정보를 가져올 수 없습니다.')
28
    }
29

30
    // Admin일 경우 그냥 패스
31
    if (user.role === RolesEnum.ADMIN) return true
32

33
    const postId = req.params.postId
34

35
    if (!postId) {
36
      throw new BadRequestException('Post ID가 파라미터로 제공 돼야합니다.')
37
    }
38

39
    const isOk = await this.postService.isPostMine(user.id, parseInt(postId))
40

41
    if (!isOk) throw new ForbiddenException('권한이 없습니다.')
42

43
    return true
44
  }
45
}

1
// posts.service.ts 생략
2
// **** 내 포스트인지 아닌지 확인
3
async isPostMine(userId: number, postId: number) {
4
  return this.postsRepository.exist({
5
    where: {
6
      id: postId,
7
      author: { id: userId },
8
    },
9
    relations: { author: true },
10
  })
11
}

1
// **** (5) PATCH /posts/:id : id에 해당하는 post를 부분 변경
2
@Patch(':postId')
3
@UseGuards(IsPostMineOrAdminGuard)
4
patchPost(
5
  @Param('postId', ParseIntPipe) id: number, //
6
  @Body() body: UpdatePostDto,
7
) {
8
  return this.postsService.updatePost(id, body)
9
}

1
import { CanActivate, ExecutionContext, ForbiddenException, Injectable, UnauthorizedException } from '@nestjs/common'
2
import { Request } from 'express'
3
import { UsersModel } from 'src/users/entity/users.entity'
4
import { RolesEnum } from 'src/users/const/roles.const'
5
import { CommentsService } from '../comments.service'
6

7
@Injectable()
8
export class IsCommentMineOrAdminGuard implements CanActivate {
9
  constructor(private readonly commentService: CommentsService) {}
10

11
  async canActivate(context: ExecutionContext): Promise<boolean> {
12
    const req = context.switchToHttp().getRequest() as Request & {
13
      user: UsersModel
14
    }
15

16
    const { user } = req
17

18
    if (!user) {
19
      throw new UnauthorizedException('사용자 정보를 가져올 수 없습니다.')
20
    }
21

22
    if (user.role === RolesEnum.ADMIN) {
23
      return true
24
    }
25

26
    const commentId = req.params.commentId
27

28
    const isOk = await this.commentService.isCommentMine(user.id, parseInt(commentId))
29

30
    if (!isOk) {
31
      throw new ForbiddenException('권한이 없습니다.')
32
    }
33

34
    return true
35
  }
36
}

1
// **** 내가 작성한 댓글인지 확인
2
async isCommentMine(userId: number, commentId: number) {
3
  return this.commentsRepository.exist({
4
    where: {
5
      id: commentId,
6
      author: { id: userId },
7
    },
8
    relations: { author: true },
9
  })
10
}

1
// **** (4) 댓글 수정
2
@Patch(':commentId')
3
@UseGuards(IsCommentMineOrAdminGuard)
4
async patchComment() {} // 생략
5

6
// **** (5) 댓글 삭제
7
@Delete(':commentId')
8
@UseGuards(IsCommentMineOrAdminGuard)
9
async deleteComment() {} // 생략