ghkdtlwns987

asdf

2020/03/31 — Mon, 20 Nov 2023 00:00:51 +0900

# 24_np.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: np-backend
  namespace: project-snake
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
    - Egress                    # policy is only about Egress
  egress:
    -                           # first rule
      to:                           # first condition "to"
      - podSelector:
          matchLabels:
            app: db1
      ports:                        # second condition "port"
      - protocol: TCP
        port: 1111
    -                           # second rule
      to:                           # first condition "to"
      - podSelector:
          matchLabels:
            app: db2
      ports:                        # second condition "port"
      - protocol: TCP
        port: 2222

근황

2020/03/31 — Wed, 16 Nov 2022 00:12:28 +0900

비오비 교육생일 때 너무 바빠서 교육 들으면서 블로그를 적었던게 마지막이었던 것 같다.

(이마저도 비공개로 올림..)

공부를 안하고 있는게 아니라 요즘 블로그 대신 개인 노션으로 갈아타서 글을 안적고 있습니다.

근데 공부했던 걸 기록하고 더 많은 사람들이 봤으면 좋겠어서 다시 블로그를 쓰고자 합니다.

근데 티스토리 말고 velog 에다가 쓸 예정임...

https://velog.io/@ghkdtlwns987/

ghkdtlwns987 (황시준) - velog

포스트가 없습니다.

velog.io

한번씩 놀러오세요~

[안드로이드] drozer 설치

2020/03/31 — Fri, 21 May 2021 00:57:44 +0900

drozer 은 python2.7 버젼을 필요로 한다.

하지만 기존에 python2.7 버젼이 설치되어있을 경우

다음과 같이 에러가 뜬다

그렇기에 난 python 가상 환경을 구축해 설치했다.

먼저, virtualenv 가 설치 되어있어야 한다.

그렇지 않다면 설치하자.

$ pip install virtualenv

설치가 되었다면

$virtualenv env

위와 같이 구축이 완료되었다.

python 가상 환경이 구축되었으니,

source bin/activate

actiavte 환경으로 진입 후 pip를 이용해 drozer 설치

$pip install drozer

설치가 완료되었다.

이후 adb forward 를 통해 bridge 연결

drozer console connect 했더니 에러가 떳다 이제부턴 설치하란대로 하면 된다.

[자료구조] 그래프 1 (깊이 우선 탐색, 넓이 우선 탐색)

2020/03/31 — Tue, 11 May 2021 17:18:15 +0900

그래프에 대해 간단히 찍먹하는 느낌으로 알아보자.

먼저, 그래프를 공부하는데 정점과 간선에 대해 알아야 한다.

그림을 보면 알겠지만 정점은 노드 자체를 가리키고,

간선은 노드를 잇는 선을 간선 이라고 한다.

예를 들면

출처 : doopedia.co.kr

위 그림은 일명 다리 문제라고 불리는데,

여기서 A,B,C,D 는 정점이라 푸를 수 있고, 그 점들을 잇는 선을 간선이라 부를수 있다.

다음으론 방향 그래프와 무방향 그래프이다.

먼저 방향 그래프는 정점과 간선 사이에 방향을 표시해 놓은 그래프이고

무방향 그래프는 정점과 간선 사이를 그냥 연결만 되어 있다고 생각하면 된다.

표현 방법은 아래와 같다.

무방향 그래프

V(G1) = {0, 1, 2, 3}

E(G1) = { (0,1), (0,3), (1,3), (2,3)}

방향 그래프

V(G1) = {0,1,2,3}

E(G1) = { <0,1> , <0,3> , <3,1> , <2,3> }

다음으로는 정점의 차수를 구하는 방법이다.

먼저, 정점의 차수란 간선에 의해 연결된 정점의 수 이다.

이해를 돕기 위해 그림을 보여주고 넘어가겠다.

또한, 각 정점의 차수의 합은 간선의 개수의 2배와 동일하다.

다음으로는 단순 경로이다.

단순 경로는 경로 중, 반복되는 간선이 없는 경우이다.

이것도 그림으로 보면 이해가 갈 것 이다.

다음은 연결 그래프와 완전 그래프에 대한 개념을 알아보자.

먼저 연결 그래프이다.

연결 그래프는 모든 정점쌍에 대해 항상 경로가 존재하는 그래프이다.

그에비해 완전 그래프는

그래프에 속해있는 모든 정점이 서로 연결되어 있는 그래프이다.

앞서 간단하게 그래프에 대해 알아보았으니, 오늘의 목표인 깊이 우선 탐색(DFS), 과 넓이 우선 탐색(BFS) 를 알아보자.

먼저 깊이 우선 탐색(DFS) 이다.

깊이 우선 탐색은 최대한 깊숙히 내려간 후, 더이상 갈 곳이 없을 경우 옆으로 이동하는 방식이다.

출처 https://developer-mac.tistory.com/64

깊이 우선 탐색의 개념은 루트 노드나 부모 노드에서 시작해 다음 분기로 넘어가기 전에,

해당 분기를 완벽하게 탐색하는 방식이다.

즉, 한 분기만을 완벽하게 찾고, 만약 찾고자 하는 값이 없을 시, 바로 다음 분기의 자료들을 검색하는 방법이다.

깊이 우선 탐색은 스택, 혹은 재귀함수로 구현한다.

다음으론 너비 우선 탐색이다.

너비 우선 탐색은 최대한 넓게 이동하고, 더 이상 갈 수 없을 때 아래로 이동한다.

출처 https://developer-mac.tistory.com/64

너비 우선 탐색은 루트 노드나 부모 노드에서 시작해 인접한 노드를 먼저 탐색하는 방법이다.

주로 두 노드 사이의 최단 경로를 찾고 싶을 때 이 방법을 사용한다.

넓이 우선 탐색은 큐를 이용해 구현한다.

예를 들면 특정 값을 찾고자 할 때, 먼저 존재하는 노드들을 전체 검색하는 방식이다.

깊이 우선 탐색과 넓이 우선 탐색의 시간복잡도는 모든 노드를 검색한다는 전제 하에 동일하다.

하지만 인접 리스트와 인접 행렬을 사용하는데 차이가 있다.

N : 노드

E : 간선

인접 리스트 : O(N+E)
인접 행렬 : O(N²)

위와 같이 표현할 수 있다.

[자료구조] 허프만 코드

2020/03/31 — Mon, 10 May 2021 20:56:00 +0900

허프만 코드에 대해 알아보자.

이번 글은 허프만 코드를 주제로 했지만, 우선순위 큐(Priority Queue) 를 먼저 선행하고 와야 한다.

먼저 허프만 코딩이 무엇인지 알아보자.

허프만 코딩은 문자의 빈도 또는 확률정보를 압축하는 알고리즘이다.

예를 들어 aaaabbbc 라는 문자가 있다고 가정했을 때,

a = 4 , b = 3 , c = 1 로 표현하고

이를 통해 빈도가 높은 문자(a) 빈도가 낮은 문자(c) 로 표현할 수 있다.

여기서 a 에 111(2) 이란 값을 부여하고

b 와 c 는 111(2) 를 부여하면 중복되는 문제가 발생한다.

이는 복호화할 때 문제가 발생할 수도 있기 때문에, 값이 겹치면 안된다.

허프만 코드를 만들기 위해선 다음과 같은 과정을 거쳐야 한다.

1. 주어진 텍스트에서 각 문자의 출현 빈도수를 계산

2. 각 문자의 빈도수를 이용해 허프만 트리를 생성해 각 문자에 이진코드를 부여

3. 주어진 텍스트의 각 문자를 코드로 변환해 압축된 텍스트를 생성

글로 보는 것 보다는 직접 보는게 나을거 같아 바로 진행해 보겠다.

만약 aabzzzc 를 예로 들어보겠다.

1. 각 글자의 빈도수를 따져 순서를 정한다. 난 (z , a , b, c) 순으로 정함

2. 다음으로 빈도수가 적은 글자부터 부모노드를 만들어 나간다.

3. 노드를 잇는 선을 기준으로 왼쪽을 0, 오른쪽을 1로 정함 (반대로 설정 가능)

그렇다면

z 는 0(2)

a 는 10(2)

b는 110(2)

c는 111(2)

로 표현 할 수 있다.

[자료구조] 우선순위 큐(Priority Queue)

2020/03/31 — Mon, 10 May 2021 20:18:31 +0900

우선순의 큐에 대해 알아보자.

큐(Queue) 라고 하면 흔히 먼저 들어온게 먼저 나간다는(First in First out)구조이다.

하지만 우선순위 큐(Priority Queue) 는 들어간 순서에 상관없이 우선순위가 높은 데이터가 먼저 나오는 것을 의미한다.

우선순위 큐는 힙(Heap) 이라는 자료구조를 가지고 구현할 수 있다.

우선순위 큐는 배열을 이용해 구현할 수 있고,

연결리스트, 힙 기반 으로도 구현할 수 있다.

들어가기 전 각 기반에 따른 시간 복잡도에 대해 알아보자.

배열 기반 삽입 : O(n)

배열 기반 삭제 : O(1)

힙 기반 삽입 : O(log2n)

힙 기반 삭제 : O(log2n)

그럼 본격적으로 시작해 보겠다.

힙(Heap) 은 완전 이진 트리를 배열로 만든 자료구조이다.

이는 기존 트리와는 다르게 우선순위가 적용된다.

우선순위는 프로그래머가 임의대로 조정할 수 있다.

만약 1부터 10까지를 완전 이진 트리를 이용해 구현한다고 하자.

대충 이렇게 생겼다고 가정 하자.

여기서 이진트리에서 삽입이 발생했을 때의 과정은 생략하고,

우선순위가 적용된 상태에서 삽입과 삭제가 되는 과정을 설명하겠다.

우선순위는 최대 힙(max heap) 과 최소 힙(min heap)으로 구성할 수 있다.

먼저 최대 힙이란?

부모 노드가 자식노드보다 값이 큰 완전 이진트리를 의미한다.

모든 부모 노드가 자식보다 값이 커야한다.

최대힙의 루트 노드는 항상 최댓값을 가진다.

=> 루트 노드로 올라갈 수록 값이 커지는 구조이다.

먼저, 최대 힙(max heap)는 어떻게 생겼는지 확인해 보도록 하자.

다음을 보면 루트 노드(root node) 가 10으로 원소 중 가장 큰 값을 가지고 있는 것을 확인할 수 있다.

또한, 부모 노드는 자식 노드보다 값이 더 크다는 것 또한 확인할 수 있다.

다음으로는 최소 힙(min heap) 은 최대 힙(max heap) 과는 정 반대로

루트 노드와 부모 노드가 가장 작은 값을 지니게 된다.

=> 루트 노드로 올라갈 수록 작은 수를 지니게 된다.

대충 그림을 그려보면

위와 같다.

이상으로 최대 힙과 최소 힙에 대해 알아보았다.

다음으론 만약 값이 삽입 되었으면 어떠한 형태로 삽입되는지 알아보자.

최대 힙에서 20이 들어간다고 가정해보자.

다음과 같이 변한다.

여기서 최소 힙은 이와 반대라고 생각하면 된다.

다음은 삭제의 과정이다.

1~10 까지 존재하는 최대 힙(max heap) 에서 원소 1개를 삭제한다고 가정해 보자.

여기서 삭제하는 것은 힙(heap) 에서 pop 한 것과 같다.

만약 위의 트리에서 1개를 pop 하게 되면 루트 노드(root node) 를 삭제하는 것과 동일하다.

다음과 같이 정렬된다

[Heap Exploit Technique] fastbin_dup_into stack

2020/03/31 — Sun, 31 Jan 2021 18:58:50 +0900

//fastbin dup into stack
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

int main(){
        unsigned long long chunk_size = 0x21;
        unsigned long long * a = (unsigned long long*)malloc(8);
        unsigned long long * b = (unsigned long long*)malloc(8);

        printf("%p %p \n",a,b);

        free(b);
        free(a);

        unsigned long long * c = (unsigned long long*)malloc(8);
        printf("%p \n",c);

        *b = (unsigned long long)(((char *)&chunk_size) - sizeof(b));
        unsigned long long * d = (unsigned long long*) malloc(8);
        printf("addr : %p \n",d);
        printf("addr : %p \n",malloc(8));

        return 0;
}

다음 코드를 보면 fastbin 에 속하는 chunk 2개 할당 후 해제(free)

그 이후 malloc() 으로 8byte allocate,

이후 free() 시키게 되면 * c 는 fastbin 에 들어가게 된다.

*c 의 주소는 *a 의 주소를 할당받는다. (LIFO구조이긱 때문)

이후 *b의 chunk_size - sizeof(b) 로 만들어 주는데,

malloc() 요청시 요청한 size와 b->fd 에 들어가는 (addr - 8byte) 위치의 size값이 같아야 하기 때문이다.

이후 *d 의 주소에 malloc(8) 을 하게 되면 *b 가 가리켰던 주소를 d에 할당받고,

또다시 malloc() 하게 되면 b의 fd에 스택영역의 주소를 쓸 수 있다.

[Heap Techniques] Heap Memory leak (Unsorted bin)(main_arena)

2020/03/31 — Sun, 31 Jan 2021 18:17:26 +0900

Heap 으로 Memory leak 하는 방법은 무엇일까?

그 방법은 여러가지가 존재한다. (포인터에 특정 함수의 GOT 를 넣어 출력되게 하거나, File * 를 활용하거나... 등등)

이번에 Heap Exploit 할때, 가장 많이 쓰이는 방법을 하나 소개하려 한다.

small bin 이나 large bin 을 해제하게 되면 unsorted bin 에 들어가게 된다.

unsorted bin 에 들어가게 된 chunk 는 FD, BK 에 main_arena 의 주소가 들어가게 되는데,

main_arena 는 libc.so.6 라이브러리에 존재하는 구조체이기 때문에, libc_leak 이 가능해 진다.

다음은 드림핵에 나와있는 코드를 컴파일 했다.

내가 보여줄 환경은 glibc2.23 버젼이다. (glibc2.27 은 안됨)

// gcc -o leak1 leak1.c
#include <stdio.h>
#include <stdlib.h>
int main()
{
	char *ptr = malloc(0x100);
	char *ptr2 = malloc(0x100);
	free(ptr);
	ptr = malloc(0x100);
	printf("0x%lx\n", *(long long *)ptr);
	
	return 0;
}

한번 libc_base 를 구해보자.

위와같이 출력이 되는 이유는 무엇일까

unsorted bin은 small bin 이나 large bin 이 free() 되었을 시 들어가게 되는 bin인데, 만약, fastbin 을 선언하지 않고,

바로 small bin 이나 large bin을 선언하면 unsorted bin 의 fd,bk 는 main_arena + 88 이 들어가게 된다.

위 코드는 small bin 크기의 heap을 할당하고 free() 해서 unsorted bin 에 heap chunk가 들어가는데,

이때 헤제된 ptr chunk의 FD, BK 영역에 main_arena 영역의 주소가 쓰이게 된다.

이후에 unsorted bin 에 들어간 chunk의 크기보다 작거나 같은 크기의 chunk를 할당해 출력하면

main_arena 역역의 주소를 출력할 수 있다.

-> 이렇게 되는 이유는 malloc() 할 때, 데이터 영역을 초기화하지 않기 때문이다.

하지만 calloc() 과 같이 메모리를 할당하는 동시에 초기화하는 함수를 사용하면 위와같이 leak 하는 것은 안된다.

여기서 나온 값을 가지고 offset 을 구하면 되는데,

간혹 이 방법이 안통할 때가 있다.

그럴땐 libc_base = unsorted bin_leak - libc.symbols['__malloc_hook'] - 0x10 이다.

주소를 보면 main_arena + 88 에 위치한 추소는 malloc_hook + 0x10 에 존재하기 때문이다.

두 주소가 같은것을 볼 수 있다.

UAF vs Double free Bug간단 정리

2020/03/31 — Fri, 29 Jan 2021 14:49:51 +0900

UAF vs Double free Bug

UAF(Use After free) 는

malloc() 하고 free() 했을때 , 또다시 동일 size를 malloc() 하게 되면

기존에 존재하던 heap 영역을 재사용 할 수 있다.

근데 만약 heap 에 포인터가 존재한다면 그 포인터를 system() 과 같은 주소로 덮게 되면

exploit 이 된다.

하지만 UAF 는 glibc2.23 이상은 막혔다.

Double free Bug

DFB는 free() 를 연속으로 하게되면 발생하는 버그이다.

free(ptr1)
free(ptr1)

-> glibc 2.23 까지는 이와같이 free() 해도 무방했는데,

이제 더이상 위와같이 free()하게 되면 오류가 발생한다.

free(ptr1)
free(ptr2)
free(ptr1)

그래서 위와같이 free() 시켜주어야 한다.

DBF는 unlink 취약점과 관련이 있는데,

fd + 12 -> bk 가 들어가고,

bk + 8 -> fd 가 들어가게 되는데,

만약 fd의 위치에 function@got - 12 를 넣고

bk 의 위치에 system@plt 를 넣으면

exploit 이 된다.

혹은 heap overflow 가 가능할시,

P_flag의 값을 변경해서 flag 값과 prev_size값을 수정해주고, size 값을 변경하게 되면

실제로 free() 하지 않았는데도, 컴퓨터가 free() 되었다고 착각하도록 만드는 것이다.

이렇게 착각하게 되면 unlink 매크로가 실행되면서 exploit 이 가능해 진다.

[glibc2.23] Heap bins 정리 4 (largebin)

2020/03/31 — Thu, 28 Jan 2021 18:27:11 +0900

large bin

large bin 은 512 바이트 이상의 크기의 chunk가 해제 되었을 때 사용되는 bin이다.

large bin 은 이중연결리스트를 사용하고, FIFO 구조를 사용한다.

large bin 만의 특성이 있는데 이는 fd_nextsize , bk_nextsize 를 사용한다

     if (!in_smallbin_range (nb))		// large bin >= 512
        {
          bin = bin_at (av, idx);
          /* skip scan if empty or largest chunk is too small */
          if ((victim = first (bin)) != bin &&
              (unsigned long) (victim->size) >= (unsigned long) (nb))
            {
              victim = victim->bk_nextsize;
              while (((unsigned long) (size = chunksize (victim)) <
                      (unsigned long) (nb)))
                victim = victim->bk_nextsize;
              /* Avoid removing the first entry for a size so that the skip
                 list does not have to be rerouted.  */
              if (victim != last (bin) && victim->size == victim->fd->size)
                victim = victim->fd;
              remainder_size = size - nb;
              unlink (av, victim, bck, fwd);
              /* Exhaust */
              if (remainder_size < MINSIZE)
                {
                  set_inuse_bit_at_offset (victim, size);
                  if (av != &main_arena)
                    victim->size |= NON_MAIN_ARENA;
                }
              /* Split */
              else
                {
                  remainder = chunk_at_offset (victim, nb);
                  /* We cannot assume the unsorted list is empty and therefore
                     have to perform a complete insert here.  */
                  bck = unsorted_chunks (av);
                  fwd = bck->fd;
	  if (__glibc_unlikely (fwd->bk != bck))
                    {
                      errstr = "malloc(): corrupted unsorted chunks";
                      goto errout;
                    }
                  remainder->bk = bck;
                  remainder->fd = fwd;
                  bck->fd = remainder;
                  fwd->bk = remainder;
                  if (!in_smallbin_range (remainder_size))
                    {
                      remainder->fd_nextsize = NULL;
                      remainder->bk_nextsize = NULL;
                    }
                  set_head (victim, nb | PREV_INUSE |
                            (av != &main_arena ? NON_MAIN_ARENA : 0));
                  set_head (remainder, remainder_size | PREV_INUSE);
                  set_foot (remainder, remainder_size);
                }
              check_malloced_chunk (av, victim, nb);
              void *p = chunk2mem (victim);
              alloc_perturb (p, bytes);
              return p;
            }
        }

맨 위부터 분석 해 보자면 large bin에 들어있는 크기인지 검사한다.

이후 large bin 이 비어있는지, 혹은 가장 큰 chunk가 요청했던 크기보다 큰지 검사한다.

while (((unsigned long) (size = chunksize (victim)) < (unsigned long) (nb)))

이후 위 반복문을 반복하면서 사용자의 요청에 부합하는 chunk를 찾는다.

unlink (av, victim, bck, fwd);

fd , bk 의 연결리스트를 유지하기 위해 unlink 함수가 쓰인다.

  /* Exhaust */
              if (remainder_size < MINSIZE)
                {
                  set_inuse_bit_at_offset (victim, size);
                  if (av != &main_arena)
                    victim->size |= NON_MAIN_ARENA;
                }
              /* Split */
              else
                {
                  remainder = chunk_at_offset (victim, nb);
                  /* We cannot assume the unsorted list is empty and therefore
                     have to perform a complete insert here.  */
                  bck = unsorted_chunks (av);
                  fwd = bck->fd;
	  if (__glibc_unlikely (fwd->bk != bck))
                    {
                      errstr = "malloc(): corrupted unsorted chunks";
                      goto errout;
                    }
                  remainder->bk = bck;
                  remainder->fd = fwd;
                  bck->fd = remainder;
                  fwd->bk = remainder;

이후 large bin chunk 가 요청된 크기보다 큰 경우 remainder_size 를 검사해

MINSIZE 보다 크면 현재 chunk가 unsorted_chunk 에 들어가고

fd_nextsize 와 bk_nextsize 를 NULL로 초기화 한다.

                  set_head (victim, nb | PREV_INUSE |
                            (av != &main_arena ? NON_MAIN_ARENA : 0));
                  set_head (remainder, remainder_size | PREV_INUSE);
                  set_foot (remainder, remainder_size);
                }
              check_malloced_chunk (av, victim, nb);
              void *p = chunk2mem (victim);
              alloc_perturb (p, bytes);
              return p;
            }
        }

마지막으로 반환될 chuhnk의 prev_inuse 비트를 설정하고

분활되어 남은 remainder chunk 또한 prev-inuse bit 를 설정해 현재 반환될 chunk가 할당되었다는 것을 나타낸다.