3D Client Programmer

슬라이스 복제 (이전에 봤던 같은 곳을 가르켜서 값이 같이 변경되는 것을 방지)

slice1 := []int{1, 2, 3, 4, 5}
slice2 := make([]int, len(slice1)) // slice1과 같은 길이의 슬라이스 생성

for i, v := range slice1
{
    slice2[i] = v    // slice1의 모든 요소값 복사
}

slice1[1] = 100    // slice1 [1, 100, 3, 4, 5]
                   // slice2 [1, 2, 3, 4, 5]

append를 이용한 슬라이스 복제

slice1 := []int{1, 2, 3, 4, 5}

// append를 이용한 slice1 복사
slice2 := append([]int{}, slice1[0], slice1[1], slice1[2], slice1[3], slice1[4])

copy를 이용한 슬라이스 복사

slice1 := []int{1, 2, 3, 4, 5}
slice2 := make([]int, len(slice1)) // slice1과 같은 길이의 슬라이스 생성

copy(slice2, slice1)

- 출처 : Tucker의 Go 언어 프로그래밍

슬라이싱(Slicing)은 배열의 일부를 포인터로 가져오는 기능이다.

// array[startIdx:endIdx]

arr := [5]int{1, 2, 3, 4, 5}
arr[1:3] // [2, 3] - (1)부터 (3-1)까지의 값을 가져온다.

배열의 슬라이싱

func main()
{
    array := [5]int{1, 2, 3, 4, 5}
    slice := array[1:2]           // 슬라이싱으로 2 값의 포인터를 가져온다
    
    array[1] = 100                // array : [1, 100, 3, 4, 5]
                                  // slice : [100]
                      
    slice = append(slice, 500)    // array : [1, 100, 500, 4, 5]
                                  // slice : [100, 500]
}

위와 같이 array의 값들 중에서 원하는 값을 포인터로 가져올 수 있다.

슬라이스의 슬라이싱

func main()
{
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := slice1[1:2]          // 슬라이싱으로 2 값의 포인터를 가져온다
    
    slice1[1] = 100                // slice1 : [1, 100, 3, 4, 5]
                                   // slice2 : [100]
                      
    slice1 = append(slice1, 500)   // slice1 : [1, 100, 500, 4, 5]
                                   // slice2 : [100, 500]
}

슬라이싱의 문법

slice1 := []int{1, 2, 3, 4, 5}
slice2 := slice1[0:3] // [1, 2, 3] 처음부터 3-1까지 슬라이싱

// 첫번째 0 인덱스는 제외가 가능하다.
slice3 := slice1[:3] // [1, 2, 3] 처음부터 3-1까지 슬라이싱

slice4 := slice1[2:len(slice1)] // [3, 4, 5] 2부터 끝까지 슬라이싱

// 마지막 인덱스는 제외가 가능하다
slice5 := slice1[2:] // [3, 4, 5] 2부터 끝까지 슬라이싱

// 위에 것을 응용하면 전체 슬라이싱이 간편하다
slice6 := slice1[:] // [1,2, 3, 4, 5] 전체 슬라이싱

// 인덱스 3개로 슬라이싱
//slice[시작 : 끝 : 최대]
slice := []int{1, 2, 3, 4, 5}
slice1 := slice[1:3:4] // [2, 3] 이고 capacity는 4(최대)-1(시작)인 3

- 출처 : Tucker의 Go 언어 프로그래밍

slice에서 append()를 사용할 때 발생하는 문제 1

slice1 := make([]int, 3, 5)     // [0, 0, 0] len : 3, cap : 5
slice2 := append(slice1, 4, 5)  // [0, 0, 0, 4, 5] len : 5, cap : 5

slice1[1] = 100                 // slice1 : [0, 100, 0] len : 3, cap : 5
                                // slice2 : [0, 100, 0, 4, 5] len : 5, cap : 5
                    
slice1 = append(slice1, 500)    // slice1 : [0, 100, 0, 500] len : 4, cap : 5
                                // slice2 : [0, 100, 0, 500, 5] len : 5, cap : 5

append()를 이용했는데 slice1과 slice2가 같은 저장 공간을 사용하는 것 처럼 보인다.

slice에서 append()를 사용할 때 발생하는 문제 2

slice1 := []int{1, 2, 3}        // [1, 2, 3] len : 3, cap : 3
slice2 := append(slice1, 4, 5)  // [1, 2, 3, 4, 5] len : 5, cap : 6

slice1[1] = 100                 // slice1 : [1, 100, 3] len : 3, cap : 3
                                // slice2 : [1, 2, 3, 4, 5] len : 5, cap : 6
                    
slice1 = append(slice1, 500)    // slice1 : [1, 100, 3, 500] len : 4, cap : 6
                                // slice2 : [1, 2, 3, 4, 5] len : 5, cap : 6

append를 이용했는데 slice1과 slice2가 다른 저장 공간을 사용하는 것 처럼 보인다.

이 두개의 차이를 이해하려면 slice의 동작에 대해 이해를 해야한다.

문제 1의 코드를 보면 capacity 값이 2개가 남아있는 상태로 만들어졌었다. 그렇기 때문에 append()로 4,5를 추가해도 slice1의 메모리 주소가 복사되서 같은 저장 공간을 사용하는 것 처럼 보인 것이다.

즉 slice1과 slice2는 다른 저장공간을 가지고 있지만 안에 값은 포인터로 같은 곳을 가르키고 있다.

문제 2의 코드를 보면 capacity 값이 0인 상태로 append()를 했기 때문에 새로운 메모리 공간을 생성한 이후에 slice2에 저장이 되었기 때문에 slice1과 slice2는 전혀 다른 메모리 공간이 된 것이다.

즉 slice1과 slice2는 다른 저장공간을 가지고 있고 안에 값도 다른 포인터를 가르키고 있다.

- 출처 : Tucker의 Go 언어 프로그래밍

Golang에서는 Slice는 C++의 Vector와 Pointer를 섞은 듯한 느낌이다

각각의 선언방법 확인

// c++ array
int array[10]

// golang array
var array [10]int

// c++ vector
std::vector<int> vec;

// golang 
var slice []int

slice 사용 예제

// slice 선언 예
var slice []int // 크기가 0인 int형 slice
var slice []int{1,2,3} // [1,2,3]
var slice []int{1, 5:2, 10:3} // [1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3]
var slice = make([]int, 3) // [0, 0, 0] 크기가 3인 int형 slice

// 주의사항
var array = [...]int{1,2,3} // 크기가 고정인 배열 선언
var slice = []int{1,2,3} // slice 선언

// slice 길이
sliceLen = len(slice)

// 슬라이스 순회
var slice = []int{1,2,3}
for i := 0; i < len(slice); ++i
{
    slice[i] += 10
}

// range를 이용하면 c++로 치면 tuple 처럼 값을 가져온다.
// i는 index
// v는 요소의 값
for i, v := range slice
{
    slice[i] = v * 2
}

// append 이용해서 값 추가
var slice = [int]{1,2,3}
slice = append(slice, 4)
slice2 := append(slice, 5, 6, 7)

// string의 값 바꾸기
var str string = "Hello World"
var slice []byte = []byte(str)

slice[2] = 'a' // == Healo World

슬라이스와 배열의 동작 차이

func changeArray(array2 [5]int)
{
    array2[2] = 200
}

func changeSlice(slice2 []int)
{
    slice2[2] = 200
}

func main()
{
    array := [5]int{1,2,3,4,5}
    slice := []int{1,2,3,4,5}
    
    changeArray(array)
    changeSlice(slice)
    
    fmt.Println("array:", array)    // {1, 2, 3, 4, 5}
    fmt.Println("slice:", slice)    // {1, 2, 200, 4, 5}
}

위 코드에서 결과를 보면 changeArray()는 값복사, changeSlice()는 주소 복사가 일어난 것을 알 수 있다.

- 출처 : Tucker의 Go 언어 프로그래밍

APC (Asynchronous Pprocedure Call) 을 사용할 때 개발자가 사용할 수 있는 함수이다.

참조 자료

https://repnz.github.io/posts/apc/user-apc/

https://repnz.github.io/posts/apc/kernel-user-apc-api/

https://repnz.github.io/posts/apc/wow64-user-apc/

https://sevrosecurity.com/2020/04/08/process-injection-part-1-createremotethread/

https://sevrosecurity.com/2020/04/13/process-injection-part-2-queueuserapc/

https://infohouse.tistory.com/14

프로그램이 에러로 인해 죽는다거나 했을 때 감지하는 방법이 없을까하고 찾다보니 

c++의 signal을 이용하면 가능한 것을 확인했다.

#include <iostream>
#include <csignal>
#include <thread>

using namespace std;
using namespace std::literals::chrono_literals;

void signalHandler(int signum)
{
    cout << "interrupt signal (" << signum << ") received. \n";
}

int main()
{
    signal(SIGSEGV, signalHandler); // segment violation
    
    while(1)
    {
        cout << "sleep..." << endl;
        std::this_thread::sleep_for(1ms);
        
        static int count = 0;
        ++count;
        
        if (count > 100)
        {
            struct n
            {
                int a;
            }
            
            n* nn = nullptr;
            printf("int a : %d \n", nn->a); // nullptr 참조 후 프로그램 죽음.
        }
    }
}

결과

ref : http://seorenn.blogspot.com/2011/02/sigsegv.html

- 사용자가 디버그모드로 접근했는지 확인 방법

https://learn.microsoft.com/ko-kr/windows/win32/api/debugapi/nf-debugapi-isdebuggerpresent

- TLS Callback Function을 사용하는 방안

https://maple19out.tistory.com/70

- SEH를 이용하는 방안

https://flack3r.tistory.com/entry/SEH%EB%A5%BC-%EC%9D%B4%EC%9A%A9%ED%95%9C-%EC%95%88%ED%8B%B0%EB%94%94%EB%B2%84%EA%B9%85