자기계발

ls -al 명령어를 실행후 hint가 존재 하길래 cat hint로 열어보았다 .

"텍스트 파일 편집 중 쉘의 명령을 실행시킬 수 있다는데..." 라고 힌트가 적혀있다

여기서 먼저 텍스트 파일  편집을 하는 법을 알아봐야겠다. 

트레이너에서 배운 cat > 명령어가 잇지만 나는 vi 편집기를 사용하기로 하였다.

level1과 마찬가지로 level3로 넘어가는 권한이 걸린것을 찾아보았다

/usr/bin/editor 에 권한이 존재한다고 나오고있다 

editor라고 하는거보니 굳이 편집기를 내가 사용하지 않아도 자체적으로 editor 에서  실행될수도 잇을거같다.

/usr/bin/editor로 이동을하니 역시나 vi편집기가 실행이된다.

너무나도 간단하다. vi 편집기에서 FTZ 워게임의 다음레벨 비밀번호를 얻기 위한 바이너리인 my - pass를 실행시키니 비밀번호가 나왔다.

ls -al 명령어를 이용하여 숨겨진 파일과 디렉토리를 출력하였다

cat 명령어를 이용하여 hint를 열어봤더니

level 2 권한에 setuid가 걸린 파일을 찾으라고 한다 .

그럼 level2 권한이 걸린 setuid를 찾아야겠다

2>/dev/null은 2번 스크립터(에러스크립트)를 안나오게 해주는 명령어다 

이렇게 level2 권한이 걸린 setuid를 찾으니 /bin/ExcuteMe에 존재한다고한다 

bin/ExecuteMe로 이동한 화면이다 

참고로 여기서 my-pass는 ftz 워게임 상에서 다음 레벨로 이동하기 위한 바이너리다 

쉘이라던가 다른 바이너리로 실행시켜 level2의 권한으로 명령어를 실행하면 된다

쉘을 실행시킨후 id 명령어를 사용하였다 유저의 권한이 level2로 변경된것을 볼 수 있다

이 후에 my-pass 바이너리를 실행시키면 level2의 비밀번호가 등장한다 .

1. 프로그램 수행 관련 명령

  $ gdb -q [파일명]

    => gdb를 조용히(?) 켠다

  $ run [args] 

    => 디버깅할 프로그램의 수행 시작

  $ set args [args]

    => 프로그램이 시작 될 때, 전달할 인자 설정

  $ next [n]

    => breakpoint를 걸은 프로그램에서 다음 n(default=1)개의 문장을 수행하고 멈춘다.

    => 함수인 경우 함수 전체를 수행합니다.

  $ step [n] 

    => next [n]과 비슷합니다.

    => 차이점으로, 함수의 경우 함수에 들어가 한 문장씩 수행합니다.

  $ continue [n]

    => Ctrl+C이나 breakpoint에 멈추어진 프로그램의 수행을 계속합니다.

    => 여기서 n이 지정될 경우 n번째 breakpoint에서 수행을 멈추게 됩니다.

2. 브레이크 포인트 

  $ watch [EXP]

    => expression EXP 에 대한 watchpoint를 설정합니다.

    => EXP의 값이 변할 때마다 프로그램의 수행을 멈춥니다.

  $ delete [N]

    => breakpoint를 제거합니다. 인자값이 없으면 모든 bp를 제거합니다.

    => delete breakpoint 1 ( 예시 )

  $ enable [N .. ]

    => breakpoint를 enable 시킵니다. N은 breakpoint 숫자입니다.

3. 상태 확인

  $ info breakpoints [N]

    => 설정된 breakpoint 상태를 보여줍니다.

  $ info args

    => 현재 스택 프레임의 인자 변수를 보여줍니다.

  $ info display

    => 프로그램이 멈출 때 출력할 expression을 보여줍니다.

4. 이 외의 명령어

  $ quit

    => gdb를 종료합니다.

  $ make [args]

    => make를 실행합니다.

  $ set disassembly-flavor intel

    => intel 형식으로 어셈블리를 봅니다. ( set dis int 줄임 가능 )

  $ disassembly [func_name]

    => 함수의 어셈구문 코드를 확인합니다.

  $ print [$register or func_name]

    => 스택에 저장된 값을 보여줍니다.

  $ x/x [$register]

    => 해당 레지스터에 들어있는 값을 Hex로 표현

  $ x/5s [$register]

    => 해당 레지스터에 들어있는 값을 String으로 5개까지 표현

  $ x/d [$register]

    => Decimal

  $ x/i [$register]

    => Instructions

  $ list

    => Source File이 어딨는지 보여줌

  $ where

    => 어디에서 실행되었는지 보여줌

  $ main info sec

    => 실행가능한 섹션들을 보여줍니다.

#include <sys/types.h>
#include <sys/shm.h>

int shmget(key_t key, int size, int shmflg)
void *shmat( int shmid, const void *shmaddr, int shmflg )
int shmdt( const void *shmaddr)
int shmctl(int shmid, int cmd, struct shmid_ds *buf)

struct shmid_ds
{
    struct         ipc_perm shm_perm;    // 퍼미션
    int            shm_segsz;            // 메모리 공간의 크기
    time_t         shm_dtime;            // 마지막 attach 시간 
    time_t         shm_dtime;            // 마지막 detach 시간 
    time_t         shm_ctime;            // 마지막 변경 시간
    unsigned short shm_cpid;             // 생성프로세스의 pid
    unsigned short shm_lpid;             // 마지막으로 작동한 프로세스의 pid
    short          shm_nattch;           // 현재 접근한 프로세스의 수
};

int shmid;
key_t keyval;

keyval = 1234;
shmid = shmget(keyval, 1024, IPC_CREAT | 0666)); 
if (shmid == -1)
{
    return -1;
}

#include <sys/ipc.h> 
#include <sys/shm.h> 
#include <string.h> 
#include <unistd.h> 


int main()
{
    int shmid;
    int pid;

    int *cal_num;
    void *shared_memory = (void *)0;


    // 공유메모리 공간을 만든다.
    shmid = shmget((key_t)1234, sizeof(int), 0666|IPC_CREAT);

    if (shmid == -1)
    {
        perror("shmget failed : ");
        exit(0);
    }

    // 공유메모리를 사용하기 위해 프로세스메모리에 붙인다. 
    shared_memory = shmat(shmid, (void *)0, 0);
    if (shared_memory == (void *)-1)
    {
        perror("shmat failed : ");
        exit(0);
    }

    cal_num = (int *)shared_memory;
    pid = fork();
    if (pid == 0)
    {
        shmid = shmget((key_t)1234, sizeof(int), 0);
        if (shmid == -1)
        {
            perror("shmget failed : ");
            exit(0);
        }
        shared_memory = shmat(shmid, (void *)0, 0666|IPC_CREAT);
        if (shared_memory == (void *)-1)
        {
            perror("shmat failed : ");
            exit(0);
        }
        cal_num = (int *)shared_memory;
        *cal_num = 1;

        while(1)
        {
            *cal_num = *cal_num + 1;
            printf("child %d\n", *cal_num); 
            sleep(1);
        }
    }

    // 부모 프로세스로 공유메모리의 내용을 보여준다. 
    else if(pid > 0)
    {
        while(1)
        {
            sleep(1);
            printf("%d\n", *cal_num);
        }
    }
}

$ ipcs -l
------ Shared Memory Limits --------
max number of segments = 4096
max seg size (kbytes) = 32768
max total shared memory (kbytes) = 8388608
min seg size (bytes) = 1

------ Semaphore Limits --------
max number of arrays = 128
max semaphores per array = 250
max semaphores system wide = 32000
max ops per semop call = 32
semaphore max value = 32767

------ Messages: Limits --------
max queues system wide = 1706
max size of message (bytes) = 8192
default max size of queue (bytes) = 16384

$ ipcs -m

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          root       777        135168     2                       
0x00000000 819201     yundream   600        393216     2          dest         
0x00000000 950274     yundream   600        393216     2          dest         
0x00000000 983043     yundream   600        393216     2          dest         
0x00000000 917508     yundream   600        393216     2          dest         
0x00000000 1015813    yundream   600        393216     2          dest         
0x00000000 1048582    yundream   600        393216     2          dest         
0x00000000 27590663   yundream   600        393216     2          dest         
0x00000000 35684360   yundream   666        4343780    2          dest         
0x00000000 35717129   yundream   666        282808     2          dest  

// 500M로
# echo 536870912 > /proc/sys/kernel/shmmax

출처  : :http://www.joinc.co.kr/modules/moniwiki/wiki.php/Site/system_programing/IPC/SharedMemory

int $0x80은 운영체제에 할당된 인터럽트 영역으로 system call을 하라는 뜻이다

2.1 16진수와 2진수


컴퓨터 프로그래밍의 원리적인 이해를 위해 2진법과 16진법에 대해 알아 본다. 16진수(hexadecimal)는 0~9의 숫자와, a~f의 6개의 문자를 사용한다. C 언어에서는 16진수의 상수를 표현할 때, 10진수의 상수표현과 구분하기 위해, 상수 앞에 0x를 붙인다.

2진수

(binary)
16진수(hexadecimal)
10진수(decimal)

0000
0
0

0001
1
1

0010
2
2

0011
3
3

0100
4
4

0101
5
5

0110
6
6

0111
7
7

1000
8
8

1001
9
9

1010
a
10

1011
b
11

1100
c
12

1101
d
13

1110
e
14

1111
f
15




위 표에서 알 수 있듯이, 16진수의 1자리는 2진수의 4자리 즉 4비트로 표현되는 것을 알 수 있다. 따라서 16진수와 2진수는 서로 상호 변환이 쉽게 이루어진다. 예를 들어 8비트 2진수 10110110이란 수는 이를 하위의 4비트씩 그룹으로 묶으면, 1011과 0110의 2그룹으로 나눌 수 있다. 그리고 각각의 그룹에 위의 변환표를 적용한다. 즉 1011은 16진수에서 b이고, 0110은 16진수에서 6이다. 따라서 10110110은 16진수로 b6가 된다. 이제 왜 위의 표를 암기해야 하는지 알 수 있을 것이다. 아무리 16비트, 32비트 등 8비트 이상의 많은 비트의 2진수도 이와 같은 방법으로 16진수 간단히 변환될 수 있다. C 언어방식대로, 16진수 앞에는 0x를 붙여 표기한다. 따라서 10110110의 16진수 표기는 0xb6이 된다. 이번에는 반대로 16진수를 2진수로 바꾸어 본다. 예를 들어 0x8a라는 16진수를 2진수로 변환해 본다. 이 때, 0x8a에서 접두어 0x를 빼고, 8a에 대해, 각각의 16진수 한자리씩 위의 변환표를 이용하여, 2진수로 변환한다. 8은 1000, a는 1010이므로, 이 2개의 2진수 1000과 1010을 붙여 쓰면, 10001010의 8비트 2진수 표현이 된다.



2.2 비트와 바이트


컴퓨터는 하드웨어적으로 수많은 스위치들의 결합으로 이루어진다. 스위치는 회로적 연결상태(ON)와 회로적 단락상태(OFF)의 2가지 논리적 상태(logical state)로 동작한다. ON상태가 논리적인 1을 의미하며, OFF상태가 논리적 0을 의미한다. 엄밀히 말하면, 하나의 스위치도 컴퓨터라고 말할 수 있다. 다만 이 컴퓨터는 0 또는 1값만을 저장할 수 있는 하나의 메모리만 가지고 있을 뿐이다. 동작 또한 단지 그 값을 0으로 또는 1로 바꾸는 메모리 쓰기 동작과 현재의 상태를 알려주는 읽기 동작 밖에 할 수 없는 것이다. 단 하나의 스위치 이지만, 여기서 중요한 정의를 내릴 수 있다. 첫째, 메모리라는 정적기능와 메모리 읽기 쓰기라는 동적기능이 그것이다. 여러분에 C를 설명하기 전에 컴퓨터의 구조에 대해 설명하고자 한다. 이의 이해를 통해 보다 체계적으로 컴퓨터 메모리 구조와 연산원리를 이해할 수 있으리라 기대된다. 이 하나의 스위치를 비트(bit)라 한다. 이 하나의 비트로 저장할 수 있는 데이터는 0~1범위의 데이터를 단 하나 저장할 수 있을 뿐이다. 이제 이를 좀 더 확장하여, 이 비트가 2개 있다고 가정한다. 이 경우 2가지 선택이 있을 수 있다. 먼저 이를 각각 메모리로 활용하면, 즉 서로 다른 데이터로 구분하면, 2가지 데이터를 기억할 수 있다. 각각 하나의 데이터는 0~1의 범위만을 가질 뿐이다. 이 경우를 2개의 1 비트 데이터 저장용량을 갖는다고 말할 수 있다. 다른 방법으로는 이 2개의 비트를 하나로 묶어 하나의 데이터로 만드는 경우이다. 이 때 2개의 비트가 가질 수 있는 경우의 수는 4가지로 늘어난다. 이 두개의 비트를 b0와 b1이라 할 때, 그 경우의 수는 다음 표와 같다



표 2 2비트의 표현

b1
b0
2진수
10진수

0
0
00
0

0
1
01
1

1
0
10
2

1
1
11
3




이 표로부터 2비트 데이터로 표현할 수 있는 수의 범위는 10진수로 0~3인 것을 알 수 있다. 그리고 또한 스위치 하나의 추가가 2진법에서 자리 수의 증가를 의미하는 것을 알 수 있다. 따라서 만약 스위치가 8개로 늘어나고, 이 8개의 스위치가 하나의 데이터를 표현한다면, 이 8개의 비트가 표현할 수 있는 경우의 수는 256이 된다. 따라서 8비트 데이터가 표현할 수 있는 수의 범위는 10진수로 0~255인 것을 알 수 있다. 이 8개의 비트(bit)를 묶은 것을 바이트(byte)라 한다. 실제 컴퓨터에서는 바이트 단위로 데이터가 저장된다.



2.3 메모리 용량과 주소


이제 좀더 컴퓨터의 스위치의 개념을 확장하여, 2,048개의 비트를 갖는 컴퓨터를 가정한다. 1,024개 비트의 용량을 1K라 할 때, 이 컴퓨터는 2K 메모리 용량을 갖는다. 이를 바이트 단위로 환산하면, 256바이트의 메모리 용량을 갖는다. 다시 말해, 0~255까지의 수를 표현할 수 있는 바이트 데이터를 256개의 종류로 저장할 수 있다. 컴퓨터는 데이터를 구분하기 위해 메모리 주소(memory address)를 사용한다. 이제 이 256개의 메모리에 0에서 255까지의 번호를 붙여 데이터를 구분할 수 있다. 이 번호를 메모리 주소라 한다. 메모리 주소는 좀 더 많은 수를 표현하기 위해 16진법을 사용하여 표현한다.

이제 다시 메모리 이야기로 되돌아 가자. 2,048개의 비트를 갖는 메모리는 256바이트의 메모리 용량을 갖는다고 하였다. 이 때 이 메모리의 주소는 0번지에서 255번지를 갖게 되는데, 이를 16진수로 표현하면, 0x0번지에서 0xff번지의 주소를 갖는다라고 말한다. 이제 비트 수를 늘려나가 보자. 이제 주소를 기준으로 메모리의 용량을 계산하여 보자. 만약 메모리 주소가 0xffff의 4자리의 16진법으로 표현될 수 있다면, 이 주소번지로 구분할 수 있는 메모리 용량은 256*256=65,536개의 바이트가 된다. 이를 우리는 줄여서 64K라 한다. 컴퓨터 역사와 비교해 볼 때, 1980년대 초 애플컴퓨터 시대의 메모리 용량이 이러하였다. 이제 메모리주소의 16진법의 자리수와 메모리 크기와의 관계를 아래의 표에 정리해 본다.



표 3 메모리 주소와 메모리 용량

메모리 주소 범위
메모리 용량(bytes)
표기(bytes)
시기/컴퓨터

0~0xf
16



0~0xff
256



0~0x3ff
1,024
1K


0~0xfff
4,096
4K


0~0xffff
65,536
64K
1980's/ Apple

0~0xfffff
1,048,576
1,024K or 1M
1984/IBM-XT

0~0xffffff
16,777,216
16M
1990's/IBM-AT

0~0xfffffff
268,435,456
256M
2000's/Pentium

0~0xffffffff
4,294,967,295
4,096M or 4G
near future




이러한 메모리 주소 범위와 메모리 용량을 10진수로 표현하는 프로그램을 다음과 같이 작성한다.



리스트 1 메모리 용량

1: #include

- 복귀 주소 (Return Address)

 프로시저가 해당 기능을 끝마친 후에 이 프로시저를 호출한 바로 다음 코드의 내용이 실행되어질 수 있도록 해당 정보를 가지고 있음

 프로시저가 호출되기 바로 직전에 저장해 놓고 호출한 프로시저가 끝마치게 되면 이 내용을 사용하고, 해당 프로시저가 끝나게 되면 복귀 주소 내용 역시 필요 없어짐

 프로시저 안에서 또 다른 프로시저의 호출 또는 재귀 호출과 같은 형태의 흐름이 가능함 (복귀 주소로 돌아오기 전에 또 다른 복귀 주소가 중첩하여 여러 개 존재할 수 있음)

 => 이러한 복귀 주소의 특성을 고려하여 컴퓨터 시스템에서는 스택이라는 메모리 공간을 정의해놓고, 복귀 주소 정보를 저장하고 있다.

- 스택 로컬 변수 저장

 프로시저 내에서 사용하는 로컬 변수는 그 프로시저가 호출되어 실행될 때까지만 유효함

 즉, 프로시저가 호출될 때에만 그 프로시저에서 사용할 로컬 변수의 메모리 공간이 필요하고, 프로시저가 복귀하게 되면 이 영역에서 사용한 로컬 변수들 역시 쓸모없는 데이터가 되어버리기 때문에, 복귀 주소처럼 스택 구조에 저장

 스택 구조에서 쓰레기 값 영역에 대해 다음 번 프로세서가 덮어쓰기 형태로 사용하기 때문에 효율적으로 스택 메모리를 사용할 수 있음

- 스택 파라미터 전달

 프로그램에서 어떠한 데이터를 프로시저에게 전달하고자 할 때 전달하고자 하는 데이터들을 어디엔가 저장하여 놓거나, 데이터가 저장된 위치를 발견하여 프로시저 내에서 사용하는 단계, 혹은 프로시저가 복귀 되어질 때 전달받은 데이터를 다시 해제하는 방법이 있음

 프로시저로의 데이터 전달 역시 전달하고자 하는 프로시저 내에서만 사용하면 되기 때문에 스택 영역에 저장

 파라미터가 있는 프로시저의 경우 프로시저가 호출되기 전에 전달하고자 하는 파라미터들을 스택에 저장하여 놓은 후 프로시저로 제어 흐름을 바꿈

 프로시저 내에서 중간에 스택의 내용을 변경하는 코드가 있는 경우를 해결하기 위해 스택이 변경되는 경우까지 고려하여 그 이후의 코드에 대해 스택의 위치를 새로 계산하여 올바른 파라미터를 가리킬 수 있도록 하고 있으며, 스택 프레임이라는 것을 구성하여 해결하고 있음

 * 스택 프레임

   호출된 프로시저의 복귀 주소를 기준으로 고정된 변위 값을 통하여 파라미터를 다루는 것

   파라미터 참조 기준을 push나 pop 등에 의해 스택 포인터의 값이 변경될 수 있는 스택 포인터(ESP) 기준이 아니라, 명령어에 의하여 영향을 받지 않는 EBP 레지스터를 기준으로 하여 문제를 해결함

   스택 프레임 구성은 로컬 변수 참조에도 편리함을 제공

 ESP, EBP 어셈블리 예제)

push ebp // 이전 스택의 베이스 주소를 저장

mov ebp, esp // 현재 스택의 꼭대기를 새로운 스택의 베이스로 설정 (새로운 스택 시작)

보통 EBP는 데이터 접근을 위한 기준 주소를 저장, ESP는 최상위 주소를 유지하는  용도로 사용

​

- 파라미터 전달 방법 (Calling Conventions)

 콜링 컨벤션 : 스택을 이용하여 파라미터를 전달할 때 스택에 파라미터를 어떤 순서로 넣을 것인지, 전달된 파라미터를 어느 곳에서 해제할 것인가에 따른 여러가지 방법

 * __cdecl

   C 또는 C++ 프로그램에서 파라미터 전달 시 디폴트로 사용하는 방식으로, 파라미터 전달은 오른쪽에서 왼쪽 방향으로 이루어지며 프로시저를 호출한 쪽에서 파라미터에 대한 해제까지 책임짐

 * __stdcall

   Windows API의 프로시저에서 사용하는 콜링 컨벤션 방식으로, 오픈쪽에서 왼쪽 방향으로 스택에 저장하며 파라미터의 해제는 프로시저가 복귀 되기 전에 이루어짐

   함수의 독립성이 뛰어나다는 장점이 있음 (프로시저를 부르기 전에 스택에 파라미터를 쌓아놓고 그 프로시저를 부르기만 하면 그 함수가 리턴되어진 후 호출한 프로시저에 대해 신경쓰지 않아도 되며, 스택을 해제하는 코드가 호출한 프로시저 안에 있으므로 여러 곳에서 호출되더라도 스택을 해제하는 코드는 하나만 존재하므로 코드의 크기가 줄어듬)

 * __fastcall

   처음 두 개의 파라미터는 스택을 사용하지 않고 ecx와 edx 레지스터를 사용하며, 그 이상의 파라미터에 대해서만 오른쪽에서 왼쪽 방향으로 스택에 저장하며, 스택 제거는 __stdcall과 동일함

- Windows에서의 스택 구조

 어떤 프로그램이 함수를 부르거나 로컬 변수를 저장하기 위해서는 스택 공간이 필요하며, 윈도우즈에서는 이러한 공간을 스레드가 생성되는 단계에서 함께 만들며, 스레드 생성시 디폴터로 1MB의 메모리를 예약하여 놓고 이 중 1개의 페이지인 4KB만을 실제 메모리와 매핑시켜 놓음으로써 사용 가능하게 하고 또 하나의 메모리는 가드 페이지라는 형태로 만들어 둠

 기본적인 1MB 메모리에서 상위 첫 페이지의 4KB 영역은 Committed 영역으로 프로그램에서 바로 스택 영역으로 사용되어질 수 있는 영역이며, 그 아래 한 페이지인 4KB 영역은 가드 페이지로 윈도우즈에 의해 페이지 보호가 이루어지고 있으며, 그 외의 영역은 단지 예약만 해놓은 상태로 실제적인 물리적 메모리가 할당되지 않은 상태임 (예약 해놓음으로써 이 프로세스 공간에 대한 메모리 할당을 스택 용도 외로 사용하지 못하게 함)

- 함수에서의 레지스터 사용

 컴퓨터에서 수행되는 대부분의 연산은 레지스터를 이용해 이루어지는데, 레지스터의 개수는 제한적이기 때문에 함수 내에서의 또 다른 함수 호출 시 레지스터간의 충돌을 고려해야 함

 Windows의 컴파일러들은 이러한 문제를 피하기 위해 Caller-save/Callee-save 레지스터와 같은 규칙을 사용하여 함수들간의 레지스터 사용의 충돌을 피함

 * Caller-save 레지스터 (scratch 레지스터 혹은 volatile 레지스터)

   함수 내에서 어떠한 임시적 저장 없이 마음대로 쓸 수 있는 레지스터로, 호출한 이전 함수에 어떠한 영향도 미치지 않는 레지스터들로 정의

   ex) RAX, RCS, RDX, R8~R11, ST(0)~ST(7), XMM0~XMM5, High half of XMM6~XMM15

 * Callee-save 레지스터

   호출한 함수에 영향을 미칠 수 있기 때문에 해당 레지스터를 사용하기 전에 반드시 저장을 해놓고 사용해야 하는 레지스터로, 해당 함수가 끝났을 때 반드시 이전의 값으로 돌려주어 이 함수를 호출한 함수에 어떠한 영향을 미쳐선 안 되는 레지스터들로 정의

   ex) RBX, RSI, RDI, RBP, R12~R15, XMM6~XMM15

- Name Mangling (Name Decoration)

 함수를 선언하거나 전역 변수 등을 선언하였을 때, 사용되어진 이름들은 실제 컴파일 단계에서 일정한 규칙을 가지고 그 이름을 변경하는데 이를 네임 맹글링 혹은 네임 데코레이션이라 부름

 링커(Linker)가 다른 범위에 있는 같은 이름의 함수와 변수들에 대하여 구별할 수 있도록 함으로써 해당 함수 전체의 모듈에서 동일한 방법으로 사용되어지는지 체크할 수 있기 때문에 컴파일러 입장에서 중요한 작업이며, Namespace 안에 있는 변수의 이름에 대해서도 그 Namespace와 합해진 형태의 네임 맹글링을 만들게 됨