1. Renaming

1.1 ClassRename

class renaming은 class의 이름를 "Base64Coder"처럼 식별할 수 있는 문자대신, "pabd63bb"와 같이 무슨 의미인지 알 수 없게 바꾸어 준다. 따라서 역공학으로 해당 파일을 보더라도 무슨 역할을 하는 지 알아차리기 힘들어 역공학을 방해한다. [1]

ClassRename 난독화를 하고 해당 앱을 리패키징하여 jadx로 비교하였다.

class의 이름이 Base64Coder에서 pabd63bb로 바뀐 것을 알 수 있다.

기존앱을 virustotal로 검사하면 30개의 백신에서 탐지가 된다.

하지만 ClassRename을 하고 난 뒤에는 20개의 백신에만 탐지가 된다.

1.2. MethodRename

Method Rename은 method의 이름을 식별하기 힘들게 변경하는 것이다. 따라서 역공학시 해당 메소드가 어떠한 역할을 하는지 명시적으로 알기 어려워져 분석하기 어려워진다.[1]

리패키징을 해준뒤 jadx로 기존앱과 비교하면

c.ca/a 자바 클래스 파일의 메소드 f가 m8fa14cdd로 변경됨을 알 수 있다.

백신탐지 비교 시

(왼쪽 : 기존 앱, 오른쪽 : MethodRename 적용)

Method Rename을 적용한 경우에 백신 탐지가 덜 되는 것을 알 수 있다.

2. Encryption

2.1. ConstStringEncryption

소스 코드의 문자열 상수를 암호화한뒤 decrypString함수를 통하여 복호화하여 원래의 문자열 상수를 얻도록 한다. 따라서 역공학 분석시, 암호화된 문자열이 어떠한 것을 가리키는 지 인식하기 힘들어 역공학을 어렵게한다.[2]

app_5의 connector파일을 보면 "http://" String(왼쪽사진)이 암호화(오른쪽사진)되어 있는 것을 알 수 있다.

(jadx 사용)

\

백신탐지 비교시

왼쪽 : 기존앱, 오른쪽 : ConstStringEncryption적용)

ConstStringEncryption을 적용한 경우에 백신 탐지가 덜 되는 것을 알 수 있다.

2.2. AssetEncryption

Asset 디렉토리에 있는 리소스를 복제, 수정으로부터 보호한다.[4]

smali/android/annotation 안에 DecryptAsset.smali가 생긴 것을 알 수 있다.

[그림] DecryptAsset.smali

또한 com.decryptassetmanager.DecryptAsset 파일이 생겼음을 알 수 있다.

[그림] com.decryptassetmanager.DecryptAsset

Assets에 접근 시 복호화하여 파일을 불러온다.

백신탐지 비교 시

(왼쪽 : 기존 앱, 오른쪽 : AssetEncryption 적용)

AssetEncryption을 적용한 경우에 백신 탐지가 덜 되는 것을 알 수 있다.

3. Code

3.1. Goto

java에는 없는 goto bytecode를 추가함으로써, control-flow를 수정하고 control-flow를 이해하기 어렵게 한다. [3]

[그림]"smali/android/view/a.smali" 비교

처음에 메소드의 끝을 가리키는 goto가 있고, 메소드 끝에 메소드의 처음을 가리키는 goto가 추가되어 bytecode 흐름이 달라졌다.

백신탐지 비교시

(왼쪽 : 기존앱, 오른쪽 : Goto옵션 적용)

Goto 옵션을 적용한 경우에 백신 탐지가 덜 되는 것을 알 수 있다.

3.2. Reorder

Reorder는 역공학하여 분석하기 어렵도록, 메소드의 명령어 흐름을 복잡하게 한다. 왼쪽의 그림이 Reorder된 app_3의 BandManager.smali이다. [2] 오른쪽의 기존과 method와 다르게 추가된 내용도 생기고 흐름도 goto문이 생기는 등 복잡하게 바뀐 것을 알 수 있다.

[그림]"smali/com/BandManager.smali"비교

백신탐지 비교시

(왼쪽 : 기존앱, 오른쪽 : Reoreder 적용)

Reoreder 옵션을 적용한 경우에 백신 탐지가 덜 되는 것을 알 수 있다.

3.3. Nop

Nop 명령어를 추가하여 bytecode 흐름을 수정한다. 따라서 control flow를 이해하기 어렵게 한다. [3]

왼쪽의 Nop 옵션이 적용된 app_2/smali/c/ca/a.smali 파일을 보면 오른쪽의 기존 파일과 다르게 nop 명령어들이 추가된 것을 알 수 있다.

[그림] "smali/c/ca/a.smali"비교

백신탐지 비교 시

(왼쪽 : 기존앱, 오른쪽 : nop 옵션 적용)

nop 옵션을 적용한 경우에 백신 탐지가 덜 되는 것을 알 수 있다.

3.4. ArithmeticBranch

ArithmetiBranch 옵션은 의미 없는 코드를 삽입하여 명령어 흐름을 복잡하게 만들다. 따라서 역공학시 분석을 하기 어렵게 한다. [2] 왼쪽의 ArithmeticBranch 옵션이 적용된 app_4/smali/com/example/eroplayer/MainActivity을 보면 오른쪽의 기존 파일과 다르게 junk code가 삽입된 것을 알 수 있다.

[그림] “smali/com/example/eroplayer/MainActivity.smali" 비교

백신 탐지 비교 시

ArithmetiBranch 옵션을 적용한 경우에 백신 탐지가 덜 되는 것을 알 수 있다.

일반적인 개발자의 입장에선, 안드로이드 난독화는 역공학을 어렵게하여, 개발자가 만든 소스코드, 파일 등을 보호할 수 있게 해주는 좋은 수단이다.

악성 앱 개발자의 입장에선, 안드로이드 난독화는 control-flow를 바꾸거나, 암호화, renaming등으로 백신이 악성코드를 탐지하게 어렵게 악용하는 수단이다. 

참고 논문

[1] 난독화에 강인한 안드로이드 앱 버스마킹 기법 김 동 진Š , 조 성 제° , 정 영 기* , 우 진 운**, 고 정 욱***, 양 수 미**** Android App Birthmarking Technique Resilient to Code Obfuscation Dongjin KimŠ , Seong-je Cho° , Youngki Chung* , Jinwoon Woo**, Jeonguk Ko***, Soo-mi Yang****

[2] 안드로이드 어플리케이션 역공학 보호기법 하 동 수*, 이 강 효*, 오 희 국*

[3] Android Code Protection via Obfuscation Techniques: Past, Present and Future Directions Parvez Faruki, Malaviya National Institute of Technology Jaipur, India Hossein Fereidooni, University of Padua, Italy Vijay Laxmi, Malaviya National Institute of Technology Jaipur, India Mauro Conti, University of Padua, Italy Manoj Gaur, Malaviya National Institute of Technology Jaipur, India

[4] APK에 적용된 난독화 기법 역난독화 방안 연구 및 자동화 분석 도구 구현* 이 세 영,† 박 진 형, 박 문 찬, 석 재 혁, 이 동 훈‡ 고려대학교 정보보호대학원

cwe 119

메모리 버퍼의 경계가 있는데 경계와 관련된 연산에 대한 제한, 제약을 적절히 처리하지 못할때 생길 수 있는 약점

어떤 소프트웨어는 메모리 버퍼와 관련된 연산을 할 수 있다.

하지만 그 연산은 버퍼의 의도된 경계 바깥쪽의 영역을 read/wrtie할 수 있음

연산의 제약조건은 버퍼의 의도된 경계내에서 연산해야

버퍼의 경계내의 메모리를 읽고 쓰기 해야됨

어떤 언어는 직접적으로 메모리 위치를 참조하는데 그 위치가 실제로 유효한지 아닌지 확인 하지 않음

프로그램이 참조할 수 있는 유효한 주소인지 체크하지 않아 다른 변수나 자료구조 내부 프로그램 메모리 영역을 읽거나 쓸 수 있음 = >연산 제약을 제대로 처리 하지 않았기 때문에

공격으로 연결되면 임의의 코드를 실행할 수 있고 임의의 제어흐름으로 변조, 민감한 정보 읽기, 시스템이 망가짐

cwe 119 = > 버퍼 오버플로우라고도 함

버퍼 오버플로우는 사람마다 다른 의미로 사용가능

어떤 도구는 버퍼의끝을 넘어서서 write하는것

다른 개발자는 버퍼의 경계밖(버퍼의 시작점, 끝 밖의 공간)에서 읽거나 쓰는것.

또 어떤 사람들은 버퍼의 끝 이후에 어떠한 행동을 하는 것(읽기, 쓰기 가능)

사람마다 다르기때문에 혼란스러운 용어임

따라서 메모리 경계에서 부적절한 연산 제한이 올바른 표현이다.'

이러한 약점의 결과는 CIA가 깨짐

인가되지 않은 코드,명령실행, 메모리 변조 가능

한바이트만 조작할 수 있음

가용성, 기밀성

어떤 메모리를 읽을수 잇고 시스템이 비정상적으로 종료될수 잇음 (dos) cpu같은 자원을 소모(메모리도 가능)

메모리 경계를 넘어서면 메모리의 붕괴를 가져와 시스템이 붕괴됨

해당 프로그램이 공격을 받아서 무한루프상태로 갈수도 있다.

기밀성

read memory

주어진 자료구조 범위를 넘어서서 읽으면 민감한 정보를 읽을 수도 잇다.

메모리의 현재 버퍼의 위치와 같은 정보

어떻게 완화??

소프트웨어 보안은 개발생명 전 주기에서 고려

각 단계에서 취약점을 완화할 숭 ㅣㅆ다

요구사항분석 => 언어선택을 잘 해야. cwe119에 강한 언어를 사용하며 ㄴ좋다, c보단 자바와 같은 언어(자체적으로 메모리 관리를 함) ada나 c#은 오버플로우 보호기법을 적용하고 잇음

그렇지만 이러한 언어들은 binary가 아님 실제 실행시 native코드로 변환 되어야함. 따라서 native code와 상호작용하는 인터페이스는 오버플로우 약점에 취약(자바 가상머신은 c로 만들어져잇음)

언어를 윗단에서 좋은 언어를 사용하더라도 완전하게 해결하는 것은 아님

아키텍쳐및 설계

라이브러리나 프레임워크를 잘 사용

검증이된 라이브러리나 프레임 워크 사용 => safe c String 라이브러리, strsafe.h

string 관련 오버플로우 문제를 해결 => 완벽X 

많은 오버플로우는 string고 ㅏ연관 없음, 하지만 string관련 문제를 해결가능

cwe119취약점을 방어할 숭 ㅣㅆ다.

빌드 컴파일 단계

컴파일 할때 최신 컴파일러사용, 컴파일 옵션을 버퍼 오버플로우를 탐지할 수 잇게 사용

MS visual studio 에선 GS flag, Fedora/red hat에선 fortify source gcc flag사용 

공격이나 취약점을 조기에 탐지할 숭 ㅣㅆ음

하지만 완변하지 ㄴ않음

구현단계 

자신이 작성중인 버퍼가 원하는 대로 작동하는지 두번이상 확인

strcpy -> strncpy

gets->fgets

memcpy보다 안전한 것 사용

안전한 라이브러리 함수 사용

운영단계

운영 환경을 좀더 안전하게 만들어라

관리자는 aslr , position-independent executable (pie)와 같은 기능을 사용해서 특정한 주소를 공격자가 예측하지 못하게 해라

공격자는 버퍼의 주소를 예측하기 어려움

NX비트 활용 (hw기법)

임의의 코드가 스택이나 데이터 세그먼트에 들어갈 확률이 높은데,  data execution protection(nx) 를 하면 코드 세그먼트가 아닌 스택이나 데이터 세그먼트 코드는 실행하기 못하게함.기본적으로 프로세스의 메모리 레이아웃에서는 코드, 텍스트 세그먼트의 코드만 실행해야함. 공격자들은 자기가 실행하고 싶은 코드를 스택이나 ㄴ=데이터 세그먼트에 넣음, 

기본적으로 코드(텍스트) 세그먼트는 read only 여서 코드 주입 불가

#include <stdio.h>

int main(){
	int l;
    short s;
    char c;
    
    l = 0xdeadbeef;
    s=l; //short에 int
    c=l; //char에 int
    
    
    printf("l=0x%x (%d bits)\n", l, sizeof(l) * 8);
    printf("l=0x%x (%d bits)\n", s, sizeof(s) * 8);
    printf("l=0x%x (%d bits)\n", c, sizeof(c) * 8);
    
    
    return 0;
}
    

short : 16bit = 2byte이고, b -> 최상위비트가 1이므로 0xffffbeef가 된다.

char : 8bit = 1byte이고, e -> 최상위비트가 1이므로 0xffffffef가 된다.

signed int n;

+65535 = 0x0000ffff

+65536 = 0x00010000

unsigned short s = +65536 (?)

./ex2 65536 hello

#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[]){
	unsigned short s;
    int i; 
    char buf[80];
    
    if(argc < 3) return -1;
    
    i = atoi(argv[1]); //65536
    s=i; //65536 => 오버플로우로 0이됨
    
    //s는 0이므로 if 통과
    if(s>=80){
    	printf("oh no you don't!\n");
        return -1;
        }
        
    printf("s=%d\n", s);
    memcpy(buf, argv[2], i); //memcpy에선 i가 unsigned int형으로 변환됨
    //buf의 크기는 80인데 65536만큼 복사하려함 (dest, source, size)
    buf[i] = \0';
    printf("%s\n", buf);
    return 0;
}

65535 = 0x0000ffff

65536 = 0x00010000

부동소수점 정밀도 문제 => 실수는 무한히 많은데 이 실수를 유한 개의 비트로 표현하기 위해서는 근삿값으로 표현해야 하기 때문이다. =>부동소수점 반올림 오차

(컴퓨터가 실수를 저장할때 가수부와 지수부로 나누어 저장을 한다.)

(int형으로의 캐스팅은 반올림하지 않고 소수점이하를 잘라버린다.)

혼돈 : 암호문의 통계적 특성과 암호키 값과의 관계를 가능한 복잡하게 하는 기법, 암호문을 보고 원문을 유추하기 힘들다.

- 평문의 통계적 특성들을 잘 숨겨야한다.

- 복잡한 치환 알고리즘을 사용한다.

- 예시 : hill cipher

- 암호문의 각 문자는 키의 일부분에 의존함.

확산 : 암호문의 통계적 특성이 평문의 통계적 특성과 무관하게 하는 기법, 알고리즘의 패턴을 추론하기 힘들다.

- 평문의 통계적인 구조가 암호문에 골고루 흩어지게함

- 암호문에서 평문의 통계적 특성이 안나타남

- 평문 블럭 또는 암호화키의 bit하나가 달라지면 암호문에서 큰 변화가 됨

시저암호화 비즈네로 암호화는 혼돈과 확산의 속성을 갖고 있지 않다. 따라서 빈도수 공격에 취약하다.

많은 현대 암호화들은 혼돈과 확산의 속성을 가지고 설계되었다.

DES : 혼돈과 확산을 가지는 블록 암호화이다.

AES : 혼돈과 확산을 가지며, substituion-permuatation network이다.

Block 암호화 : 64/128 bit block

- DES(64)

- AES(128)

- SEED

Block 단위로 처리되어 빈도수와 중복패턴을 줄여주기 때문에, block의 크기는 클수록 안전하다. 

=> 시저암호는 블럭단위로 처리하지 않아 빈도수 공격에 취약하고 hill 암호화는 블럭단위로 처리하여 빈도수 공격에 안전하다.

Stream 암호화 : 1 bit 혹은 byte 단위로 처리한다.

- RC4 stream cipher

- otp => 빠르게 하기 위해 xor 연산을 한다. 키가 반복될시 위험하다. 

Block 암호화 Stream 암호는 처리단위가 다르다.

DES와 AES 둘다 대칭키 암호화알고리즘이다.

DES는 64bits block이지만 AES는 128bits block이다.

키의 길이 또한 AES가 더 길다.

DES는 Substituion, permutation을 사용하지만, AES는 substitution, shift, bit mixing을 사용

DES 알고리즘은 비공개이고 AES는 공개되었다.

=> kerckhoff's principle: 키 제외 나머지는 모두 공개,  키의 길이가 길수록 안전성이 높아진다. (전사적 공격이 어려워짐)

대칭키

- 키 분배의 문제가 발생된다.

따라서

Diffie-Hellman 키 교환 : 안전하지 않은 통신 채널로도 키를 공유할 수 있게 된다.

Alice는 a, g, p를 정하고 Bob에게 g, p, A를 전달한다.

Bob은 b를 정하고 B를 Alice에게 전달한다.

Bob과 Alice는 각각 A, B로 같은 S를 얻는다.

위와 같은 방식으로 대칭키를 분배할 수 있다.

- 대칭키, 비대칭키 키의 개수

먼저, 대칭키는 n명이 있을때 n(n-1)/2만큼의 키가 필요하다 => O(n^2)

비대칭키는 n명이 있을때 2n만큼의 키가 필요하다 => O(n)

따라서 비대칭키가 필요한 키의 개수가 적다.

비대칭키를 사용하지 않고 대칭키를 사용하는 이유는 대칭키는 계산량이 비교적 적은 반면 비대칭키(공개키)는 계산량이 많기 때문이다.

비대칭키는 서명에도 사용된다.

A의 개인키로 암호화한다면 A의 공개키로 복호화 가능하므로 A라고 확인 할 수 있다.

대칭키 : 서로 비밀키를 공유, 키의 개수 n(n-1)/2, 메시지 암호화에 사용, 덜 복잡하여 빠르다. 기밀성, DES, AES, SEED, IDEA

공개키 : 인증, 서명, 짧은 메시지 암호화에 사용, 공개키로 암호화시 보낸사람을 확인하는 서명이 필요하다. 알고리즘이 복잡하여 느리다. 기밀성, 인증, 부인방지(전자서명), 공개키 관리(Public Key Insfrastructure), RSA, ECC, ElGamal

codebook & chiper

code : 어떤 메시지를 암호화하는데 사용하는 방법(단어나 구가 다른 어떤것으로 변환하게 하는 방법)

codebook : 단어나 구절을 암/복호화 하는데 사용하는 문서

cipher : 개별적인 문자, bit 수준에서 메시지 암호화

메세지가 코드에 의해 변환되고 그 뒤 chiper에 의해 변환된다.

chiper : 암호, 암/복호화 시스템/알고리즘

평문 : plaintext, clear text

암호문 : chipertext, cypertogram

Cryptography : 암호기법 (암호화 방법)

Cryptanalysis : 암호해독 (키 없이 복원) => Cryptanalyst (암호문 깸)

Cryptology : 암호학(키로 암/복호화) => Cryptographers (암호문 생성)

Cryptography : 암호기법 (암호화 방법)

메시지를 쉽게 이해할 수 없는 형태로 바꾸고, 다시 원래의 형태로 복원하는 것.

기밀성, 데이터 무결성, 부인방지, 인증을 포함하는 정보보안을 제공하는 수단이나 방법

Symmetric key, Asymmetric key

key => 기밀성, 무결성, 인증 등을 하기위해 사용하는 암호화 알고리즘의 input

키를 안전하게 보관하는 것이 중요 => TPM(trusted platform module), secure co-processor, smartcards...

keyspace

모든 가능한 키들의 집합이다.

keyspace가 크면 안전하지만 bit길이가 길어지고, 그만큼 계산량도 많아진다.

crypto(암호화)

Only the key is secret => 케르크호프스의 원칙

공격자는 시스템에대해 알고 오직 키만 모른다.

암호화 알고리즘은 비밀이 아니며, 오직 키만 비밀이다.

비밀 알고리즘은 노출 되었을때 위험해지고, 언젠가는 노출된다.

따라서 open하여 취약점들을 없앤다.

Substitution(대치,치환)/Transposition(전치(위치를 바꿈))

Substitution(대치, 치환)

1:1 혹은 1:多 대응

하나의 symbol을 또 다른것으로 대체함

예시)

1. caeasar 암호(= shift chiper, Additive cipher)

shift chiper, Additive cipher

k = key만큼 shift함

ex) key = 7

C = (P + k) mod 26

P = (C - k) mod 26

Brute-force attack

위의 방법으로 암호화된 암호문을 Key가 1일때, 2,3,4,5,...26 일때의 경우를 모두 조사하면 평문을 찾을 수 있다.

따라서 위의 암호화 방법은 안전하지 않으므로 keyword를 추가하여 복잡하게 만들 수도 있다.

2. keyword 추가(전수조사 막기위해)

예를 들어 keyword가 ZEBRAS이면

ZEBRAS를 먼저 놓고, Z, E, B, R, A, S를 제외한 알파벳을 놓아 평문을 치환한다.

=> 가능한 keyCaesar 암호화보단 깨기 어려워진다.

또는

알파벳을 순차적으로 대응하지 않고 섞어서 대응하여도 복잡해진다.

하지만, 위의 방식들은 모두 1대1 대응이므로 문자의 빈도수를 세면 유추가능해진다.

항상 고정적으로 하나의 평문 문자가 하나의 암호문 문자로 대응되어 유추하기 쉽다. => 단일문자 치환 암호

(자주나오는 모음이나 diagram(2개문자), tigram(3개문자))

3. 비즈네로 암호 (빈도수 유추 막기위해)

예시) keyword - pascal

먼저 평문의 알파벳을 순서에 맞는 숫자에 대응하고

키워드 문자를 숫자에 대응하여

C = (P + K) mod 26 하여 암호문을 구한다.

s -> H, h- >H

s -> H, s -> S

와 같이 1대1 대응이 아니라 1대多 대응이 된다.

따라서 빈도수 공격을 완화시킬 수 있다.

비즈네로 암호는 이러한 방법을 사용한다.

실제론, 아래와 같이 비즈네르 table을 이용하여

키워드(Darkly)를 대응시켜 (K, P)와 같이 대응되는 문자를 테이블에서 찾아 암호문을 만든다.

하지만 이 방법도 키워드가 반복되므로 주기(키 길이)를 예측 할 수 있어 유추 가능해진다(암호 원리 파악 가능).

(평문 내용과 키워드 위치가 반복된다, 언어구조와 빈도 정보로 유추)

따라서 keyword의 길이를 평문길이만큼으로 하는 one-time-password을 사용하면 해결할 수 있지만, keyword를 관리하는 것이 어렵다.

4. one time pad

깨질 수 없는 안전한 암호 기법이다. 그 이유는 ...

1. 키(s)의 길이가 평문과 같거나 길다. => 암호문은 평문에 대한 어떠한 정보도 제공하지 않는 것처럼 보인다.

2. 키(s) 정보는 두 당사자만 알고 있다.

3. otp는 랜덤 생성해야하며 한번만 사용하므로 이전에 사용한 키는 사용되지 않는다.

하지만 키의 분배가 어려운 문제가 있다. 따라서 이론적으로만 안전하다.

c= m xor s, 평문을 키와 xor연산하여 암호문을 얻는다.

(평문이 8개의 문자를 사용하여 8bit 키를 사용함)

복호화 역시 같은키로 한다.

하지만 여기서 Alice와 Bob이 키를 주고 받을때, 중간에 이중첩자 Charlie가 다른키를 Bob에게 알려준다면, Bob은 복호화문을 이해하기 어렵거나 확인을 위해 Alice에게 직접 찾아가야한다.

혹은 Alice가 포로로 잡혓을때, 적들에게 잘못된 키를 알려준다면 적들은 해당 키로 복호화한 평문이 진짜인지 아닌지 판단할 수 없다.

다른 방법으론,

5. keyword 뒤 평문을 배치하여 키 길이를 맞춘다. (키 = keyword + 평문) (keyword 반복 문제 해결)

현대 암호에서는 이러한 방식을 응용한다.

2bit의 평문을 S-Box(substitution box)를 통하여 4bit로 확장시킨다.

정리하면,

monoalphabetic cipher(단일문자 치환 암호)는 전체 메시지에 대해 고정된 치환(1대1 대응)을 하여 빈도 수 공격으로 유추 가능해진다.

polyalphabeti cipher(복합 문자 치환 암호)는 평문에서 문자의 위치에 따라 대체되는 문자가 다르다 (1:多 대응),

하지만 기본적으로 문자 단위로 처리되므로, 키워드 반복시 주기를 알 수 있고, (모음), (모음은 자음에 의해 분리된다), (diagrams(연속되는 2개의 문자)), (Q뒤에는 U가 따라옴)과 같은 정보로 유추할 수 있다.

6. polygraphic substituion ciper (다중문자 대치) => Hill Cipher => Block 사용

하나의 평문 문자를 또 다른 암호문자 하나로 대응하면 즉, 문자 하나씩 암호문으로 변환할 경우에 빈도수 공격에 취약해진다.

다중문자 대치는 이웃한 문자를 그룹으로 만들어 그룹단위로 취급한다. => block 단위block의 크기를 n이라 하면

_n = 2일 경우) _

평문 : MISSISSIPPI

Block : MI SS IS SI PP IK

(Block 크기를 위해 더미 k를 추가함)

MI -> EQ, SS->GC ....와 같이 치환한다.

n, 즉 block이 커질 수록 빈도수 공격에 강해진다.

Playfiar cihper (n = 2) => 2x2 hill ciper이다.Y = Ax mod26(Y = 암호문, A = 키, x = 평문)다음과 같이 표현할 수 있다.

평문 : AT, Key : CDDG 인 경우)C -> 3, D->4, D->4, G->6

따라서

k를 표현할 수 있고, 평문 AT를 k로 암호화하면(k는 정방행렬로 만들어야한다. 암호화는 행렬의 곱이고 복호화는 역행렬을 만들어 곱을한다. 따라서 계산식을 쉽게 만들 수 있어야한다.)

5, 10 => FK가 나온다.(mod 26인 이유는 알파벳을 숫자로 표현했기 때문)

n을 3으로한 경우)

3x4 즉, 블럭의 크기를 12로 하여도 된다. => block 크기 가변적

복호화는 k의 역행렬을 곱하고 mod26을 하여 평문을 얻을 수 있다.

긴 평문 예시)

예시 - WANT_HELP.

WAN/ T_H/ ELP/ ... (더미 .. 추가)

22 0 13/ 19 28 7/ 4 11 15/ 26 26 26 (알파벳을 숫자로 바꿈)

키 = A

25 23 21/ 23 14 1/ 17 4 14/ 19 11 12

암호문 : ZWV XOB REO TLM

Transposition(전치(위치를 바꿈))

문자들의 순서를 바꾼다.

Columnar Transposition

1. simple

컬럼의 크기를 정하고 그에 맞게 평문을 자른다.

ENEMY TANKS APPROACHING HILL EIGHT SIX THREE

만약 컬럼의 개수의 배수가 아니면 더미를 추가한다.

그후, 컬럼별로 가져온다.

ENOHHR NKAITE ESCLSE MAHLIS YPIEXT TPNITO ARGGHP

만약 block의 크기가 5라면 5씩 잘라 표현한다.

ENOHH RNKAI TEESC LSEMA HLISY PIEXT TPNIT OARGG HPxxx (더미 추가)

2. 컬럼 순서 지정

컬럼에 순서(key)를 지정하여 순서에 따라 컬럼을 읽는다.

혹은 알파벳(key)으로 순서를 줄 수도 있다.,

=> EATI THIH MEXN ETMG MEDT

3. Double Transposition (행과 열 둘다 사용)

평문 : attackxatxdawnx (공백 대신 x를 사용하였다.)

먼저 행을 (3,5,1,4,2)의 순서로 바꾸고 열을 (1,3,2)순으로 바꾼다.

열로 읽었을 경우 : xwaxa txtak antdc

행으로 읽을 경우 : xta wxn att xad akc

4. Route Transposition Cipher

4.1. Rail-Fence Cipher

예시 rail 2개)

평문 = Meet me after the toga party

예시 rail 3개)

평문 = WE ARE DISCOVERED. FLEE AT ONCE

WECRL TEERD SOEEF EAOCA IVDEN

4.2. 위 방법외에 입력위치를 다르게 할 수 도 있다.

ex)

REINFORCEMENTS ARRIVING NOW

NMRGI FEEAR NNEOC NSIIO RRTVW

혹은 삼각형 모양으로도 할 수 있다.

4.3. Triangular Pattern

RMIFE VEONI RIRTN NCSGE ANROW

P- box

현대의 전치암호는 P(permutaiotion) box를 사용한다.

그냥 순서를 바꿔주는 p-box,

압축을 해주는 p-box

확장을 해주는 p-box

현대 암호인 AES는 Pbox를 사용한다.

튜링

튜링 머신

what can be computed. => 실제로 어디까지 계산가능한가?

어떤것, 어디까지 계산을 할 수 있는지 조사하는데 도움을 줄수 잇는 단순한 추상화된 컴퓨팅 기기

컴퓨터가 어디까지 가능한지(computability)를 나타내는 기본적인 모델임.

튜링 테스트

Can Machine think?

기계가 생각을 할 수 있는 가?

A : 기계 (질문시 사람인척 할 것임)

B : 사람

C(사람) : A, B가 사람인지 기계인지 판단(text기반 질문으로)

만약 C가 A, B를 구분하지 못한다면, A(기계)는 인공지능을 가진것으로 판단한다.

Renaming

- ClassRename

obfuscapk를 사용하여 app_1.apk를 ClassRename 난독화를 한다.

python3 -m obfuscapk.cli -o ClassRename ../../sample_apps/app_1.apk

그 후 jadx로 원본 앱과 비교하기 위해 패키징을 해준다.

apktool b app_1/ -o app_1_ClassRenamed.apk

jadx로 같은 파일을 확인하면, class의 이름이 Base64Coder에서 pabd63bb로 바뀐 것을 알 수 있다.

class renaming은 class의 이름를 "Base64Coder"처럼 식별할 수 있는 문자대신, "pabd63bb"와 같이 무슨 의미인지 알 수 없게 바꾸어준다. 따라서 역공학으로 해당 파일을 보더라도 무슨 역할을 하는 지 알아차리기 힘들어 역공학을 방해한다. [1]

기존앱을 virustotal로 검사하면 30개의 백신에서 탐지가 된다.

하지만 ClassRename을 하고 난 뒤에는 20개의 백신에만 탐지가 된다.

- MethodRename

python3 -m obfuscapk.cli -o MethodRename ../../sample_apps/app_2.apk

리패키징을 해준뒤 jadx로 기존앱과 비교하면

 c.ca/a 자바 클래스 파일의 메소드 f가 m8fa14cdd로 변경됨을 알 수 있다.

Method Rename은 method의 이름을 식별하기 힘들게 변경하는 것이다. 따라서 역공학시 해당 메소드가 어떠한 역할을 하는지 명시적으로 알기 어려워져 분석하기 어려워진다.[1]

백신탐지 비교

(왼쪽 : 기존 앱, 오른쪽 : MethodRename 적용)

Encryption

- ConstStringEncryption

소스 코드의 문자열 상수를 암호화한뒤 decrypString함수를 통하여 복호화하여 원래의 문자열 상수를 얻도록 한다. 따라서 역공학 분석시, 암호화된 문자열이 어떠한 것을 가리키는 지 인식하기 힘들어 역공학을 어렵게한다.[2]

python3 -m obfuscapk.cli -o ConstStringEncryption ../../sample_apps/app_5.apk

app_5의 connector파일을 보면 "http://" String(왼쪽사진)이 암호화(오른쪽사진)되어 있는 것을 알 수 있다.

(jadx 사용)

백신탐지 비교

(왼쪽 : 기존앱, 오른쪽 : ConstStringEncryption적용)

- AssetEncryption

python3 -m obfuscapk.cli -o AssetEncryption ../../sample_apps/app_2.apk

smali/android/annotation 안에 DecryptAsset.smali가 생긴 것을 알 수 있다.

new-instance v0, Ljava/io/FileInputStream;

=> FileInputStream 객체 생성

invoke-static {p0, p1}, Lcom/decryptassetmanager/DecryptAsset; >decryptAssetFileUsingContext(Landroid/content/res/AssetManager;Ljava/lang/String;)Ljava/io/File;

=> decryptAssetFileUsingContext메소드 호출, java/io/File로 반환

invoke-direct {v0, v1}, Ljava/io/FileInputStream;-><init>(Ljava/io/File;)V

=> FileInputStream 객체를 생성하여 파일을 읽어들인다.

decryptAssetFileUsingContext 메소드

 AES방식으로 암호화되고 ,

invoke-virtual {p0, p1}, Landroid/content/res/AssetManager;->open(Ljava/lang/String;)Ljava/io/InputStream;

파일을 열고

invoke-static {v0}, Lcom/decryptassetmanager/DecryptAsset;->readBytes(Ljava/io/InputStream;)[B

값을 읽고

invoke-virtual {v1, v7}, Ljavax/crypto/Cipher;->doFinal([B)[B

복호화 하는 것 같다.

백신탐지 비교

(왼쪽 : 기존 앱, 오른쪽 : AssetEncryption 적용)

Code

- Goto

java에는 없는 goto bytecode를 추가함으로써, control-flow를 수정하고 control-flow를 이해하기 어렵게 한다. [4]

python3 -m obfuscapk.cli -o Goto ../../sample_apps/app_2.apk

"smali/android/view/a.smali" 비교

처음에 메소드의 끝을 가리키는 goto가 있고, 메소드 끝에 메소드의 처음을 가리키는 goto가 추가되었다.

백신탐지 비교

(왼쪽 : 기존앱, 오른쪽 : Goto옵션 적용)

- Reorder

Reorder는 역공학하여 분석하기 어렵도록, 메소드의 명령어 흐름을 복잡하게 한다. 왼쪽의 그림이 Reorder된 app_3의 BandManager.smali이다. [2] 오른쪽의 기존과 method와 다르게 추가된 내용도 생기고 흐름도 goto문이 생기는 등 복잡하게 바뀐 것을 알 수 있다.

python3 -m obfuscapk.cli -o Reorder ../../sample_apps/app_3.apk

"smali/com/BandManager.smali"

백신탐지 비교

(왼쪽 : 기존앱, 오른쪽 : Reoreder 적용)

- Nop

Nop 명령어를 추가하여 bytecode 흐름을 수정한다. 따라서 control flow를 이해하기 어렵게 한다. [4]

python3 -m obfuscapk.cli -o Nop ../../sample_apps/app_2.apk

"smali/c/ca/a.smali"

왼쪽의 Nop 옵션이 적용된 app_2/smali/c/ca/a.smali 파일을 보면 오른쪽의 기존 파일과 다르게 nop 명령어들이 추가된 것을 알 수 있다.

백신탐지 비교

(왼쪽 : 기존앱, 오른쪽 : nop 옵션 적용)

- ArithmeticBranch

ArithmetiBranch 옵션은 의미 없는 코드를 삽입하여 명령어 흐름을 복잡하게 만들다. 따라서 역공학시 분석을 하기 어렵게 한다. [2] 왼쪽의 ArithmeticBranch 옵션이 적용된 app_4/smali/com/example/eroplayer/MainActivity을 보면 오른쪽의 기존 파일과 다르게 junk code가 삽입된 것을 알 수 있다.

python3 -m obfuscapk.cli -o ArithmeticBranch ../../sample_apps/app_4.apk

"smali/com/example/eroplayer/MainActivity.smali"

일반적인 개발자의 입장에선, 안드로이드 난독화는 역공학을 어렵게하여, 개발자가 만든 소스코드, 파일 등을 보호할 수 있게 해주는 좋은 수단이다.

악성 앱 개발자의 입장에선, 안드로이드 난독화는 control-flow를 바꾸거나, 암호화, renaming등으로 백신이 악성코드를 탐지하게 어렵게 악용하는 수단이다. 

이번 과제를 하면서, 개발자의 자산을 보호하는 것도 중요하지만, 악성코드를 탐지를 위해 난독화를 탐지하는 기술도 중요하다고 느꼈다.

참고논문

[1] 난독화에 강인한 안드로이드 앱 버스마킹 기법 김 동 진Š , 조 성 제° , 정 영 기* , 우 진 운**, 고 정 욱***, 양 수 미**** Android App Birthmarking Technique Resilient to Code Obfuscation Dongjin KimŠ , Seong-je Cho° , Youngki Chung* , Jinwoon Woo**, Jeonguk Ko***, Soo-mi Yang****

[2] 안드로이드 어플리케이션 역공학 보호기법 하 동 수*, 이 강 효*, 오 희 국*

[4] Android Code Protection via Obfuscation Techniques: Past, Present and Future Directions Parvez Faruki, Malaviya National Institute of Technology Jaipur, India Hossein Fereidooni, University of Padua, Italy Vijay Laxmi, Malaviya National Institute of Technology Jaipur, India Mauro Conti, University of Padua, Italy Manoj Gaur, Malaviya National Institute of Technology Jaipur, India

역공학을 방지함

Why? 

- sw 자체가 수익임 따라서 불법복제를 막아야함

- 중요한 logic 유출 방지

- DRM 기술 또한 저작권 보호를 위해 역공학이 필요함

- sw 개발 플랫폼은 기본적으로 역공학 대책을 제공하고 있음

ex) 구글 proguard 제공

java, c#언어는 디컴파일, disassemble하기 편함 => binary 코드들에 비해서 byte코드들이 봉합되기 더 쉬움

따라서 안드로이드에서는 proguard (최적화 난독화 기법 제공)

- obfuscator (난독화 도구)

프로그램에 있는 정보를 수정, 제거함으로써 가독성을 감소 시켜주는 도구 => 분석하기 어려워짐 

Anti-reversing 방법

1.  symbolic 정보를 제거함

소스코드를 컴파일할 때 symbol정보를 제거함 (함수이름, 변수이름 ...) => 컴파일러가 컴파일 단계에서 시행함 따라서 디버깅하기 어려움

2. 코드 암호화

코드를 암호화하여 정적분석을 막음 

3. anti-Debugging

4. 프로그램 난독화

난독화 = 여러가지 기법을 뜻함

일반적으로 프로그램의 가독성을 떨어뜨리거나, 취약점을 제거하거나, 정적분석을 어렵게 하기 위해 사용되는 기법

따라서, 난독화를 하면 역공학이 어려워짐

ex) 레이아웃 변경, 프로그램 로직 변경, 데이터를 변경, 구성자체를 변경  => 프로그램을 분석하기 어렵게 함

- code 난독화

기능은 유지하면서, 사람이 코드를 분석하기 어렵게 변경하는 것

- 난독화 도구

ProGuard, DexGuard, Allatori ...

NHN 토스트 앱가드 -> 식별자 난독화(이름 재지정), 문자열 암호화, 제어흐름 난독화 등

* de-obfuscator : 난독화된 악성코드를 분석시 사용, 난독화를 해제시켜주는 도구

코드 난독화 기법 분류

- 레이아웃 난독화

예시) 식별자 난독화 (identifier renaming)

package iAmDriving{
	public class LetsNavigate{...}
}

pacakge iAmConnecting {
	public class MyBluetoothHandle{...}
}

pacakge userIsActive{
	public class MainActivity{...}
}



|
V


package a{
	public class a{...}
}

pacakge b {
	public class b{...}
}

pacakge c{
	public class c{...}
}

- 제어흐름 난독화 : 제어흐름 은닉, 추가코드 삽입(의미없는), disassemble 복잡하게 만듬

의미 없는 switch 문장 추가

중복되는 operator 추가

제어흐름의 순서 조작

제어흐름 flatten시킴(ex 여러개 함수를 하나의 함수로)

- 데이터 난독화 (자료구조 난독화)

data aggregation : 배열 변수를 합쳐서 (일차원 두개 합쳐서, 이차원으로), 클래스 상속을 조작하여 이해하기 어렵게함

data storage and encoding : encoding변경(기법 변경), 데이터 수정 

data ordering : 메소드나 array의 순서를 조작

- 예방적 변환

anti De-compilation

String encryption

Revere Engineering(Backwards, back engineering)

Forward Engineering

요구사항분석 -> 설계 -> 구현

요구사항분석 <(요구사항 복구)- 설계 <(설계 복구)- 구현

역공학은 이를 역으로 복구하는 것을 reverse engineering이라 함

• 오래된 프로그램을 유지보수해야할 때, 분석하여 설계원칙과 요구사항을 알아내야하므로 역공학을 사용하기도 함

예시) 안드로이드 컴파일 과정은 Forward Engineering의 일부임

소스코드를 자바로 작성(.java) ->컴파일 -> java Bytecode ->Proguard(최적화, 난독화) -> dex(davik executable)로 변환 -> android runtime에 의해서 기계어로 번역되어 자동

.java ->java Bytecode (.class) -> minimized Bytecode -> Dex Bytecode (.dex) -> Machine code

최신 안드로이드에선 Android Runtime 사용(native code 로 동작, 성능상의 이유), kotlin도 사용

안드로이드 역공학

apk = android application package (dex, resource 등 파일이 들어가 있음)

de-complier를 이용하여 dex는 smali (중간 어셈블리 언어)로 바뀌어짐,

asset = resource관련

META-INFO = sign관련

smali to java를 이용하여 smali코드를 java코드로 바꾸어줌

따라서 java 소스코드를 볼 수 있다.

역공학은 주로 어떤 정보가 이용가능 하지 않을 때(오래전에 만들었거나 소스코드가 공개되지 않을때), 실행코드로부터 놓친 지식이나, 아이디어, 설계 원리를 파악하기 위해 수행한다.

시스템의 일부로 어떤 기능, 어떤 설계원리가 있는지 분석하는 과정이라 할 수 있다.

악성코드 분석가들은 역공학이 필요 => 악성코드는 소스가 공개되어 있지 않기 때문

Software Reverse Engineering

sw뿐만아니라 hw에도 적용될 수 있음

• 프로그램을 분해해서 그 내부 구조를 파악 하는 것.
• 기술과 컴퓨터, sw개발에 대한 이해가 필요함
• code breaking, puzzle solving, programming, logival analysis 필요

Binary reverse engineering

• 소스코드를 사용할 수 없을 때 사용하는 기법
• reverse code engineering

역공학이 필요한 경우

• 연구목적
• 취약점을 분석하기 위해
• 이미 배포되어 사용되는 프로그램들에 패치를 해야 할 때(binary level에서 패치할때 필요함, 보안과 관련잇음)
• 프로그램 내의 비밀 정보를 획득하기 위해(공격자 관점)
• 프로토콜을 분석하기 위해 (공격을 위한 정보 탐색)
• 보호기법을 우회하기 위해 (copy 목적)

역공학 응용

1. 보안에 관련해서 사용

• 악의적인 프로그램의 binary auditing
• 암호 알고리즘 역공학 => 연구자들이 암호화 제품을 평가해야함(얼만큼 안전한가).
• Digital Right Management (DRM) - 디지털 컨텐츠 권리 관리, 저작권 관리

(비용을 지불한 만큼만 사용할 수 있게)

(cracker들을 copy protection 기법을 우회하려 함)

1.1 악성 프로그램

• 멀웨어 작성자, 분석가 둘다 역공학함
• 멀웨어 작성자 => os나 다른 sw의 취약점을 파악하여, 악성코드를 감염(전파)시키려함.

(바이러스는 양성 프로그램에 기성하여 돌아감, 매크로 프로그램을 조작시켜 자신을 전파 시켜야함)

(악성코드는 자기자신을 전파시키기 위해 os나 다른 sw의 취약점을 이용함 ex)Morris Internet Worm)

• anti-virus 개발자

악성코드를 분해하여 분석하기 위해 => 치료가능

1.2 Auditing Program Binaries

소스코드를 사용할 수 없는 경우 & 중요한 프로그램일 경우

중요한 프로그램의 취약점을 찾을 때

ex) bug bounty, 모의 해킹

1.3 DRM

불법 복제 방지위해 copy protection 기술을 사용함.

DRM도 그와 유사 (DRM은 적용되는 컨텐츠가 주로 디지털 미디어 컨텐츠임)

공격자들은 DRM기술을 우회하기 위해 역공학을 사용함.

2. sw 개발에서

• sw 품질 향상, 평가하기 위해
• 유지보수를 위해

Tool or Methods

• disassembler, decompiler => 정적 분석 (실행할 필요 X)

(IDA Pro, JADAX(Dex to Java Decomplier), dex2jar, apktool)

(ILDasm (disassembler for MS Intermediate language, MSIL)

• Debugger ( 동적 코드 분석 )

(JEB)

• Hex Editor

binary(실행 파일 분석)

• PE Analyzer

MS windows는 PE포맷을 사용 (안드로이드는 Dex 사용)

Mono Runtime 가상머신에서 사용하는 중간 언어인 CIL이 있는 dll파일들을 디컴파일하였다.

Assembly-CSharp.dll 파일이 C# 개발자 코드의 컴파일 결과이므로 dnSpy 프로그램을 사용하여 Assembly-CSharp.dll을 수정하였다.

먼저 CompleteProject 파일 안의 정보들을 보고 “Player~~~~” 관련 코드가 플레이어와 관련된 코드라 추측을 하였다. 그리고 각각 “Movement”, “Shooting”, “ScoreManager” 코드에서 변수 이름으로 관련 변수들이 의미하는 것을 추측하였다.

그 후 해당 변수에 들어가 있는 값들을 수정해 주었으나, 실제 게임 구동 시 적용이 되질 않았다.

ctrl+shift+R 키를 통하여 해당 변수가 사용되는 함수들을 찾아보고 해당 함수안에서 변수에 곱을 하여 값을 조작하여 Damage, Speed, Score, Heath를 조절하였다.

- Damage 조절

- Speed 조절

- startHealth 조절

- Score 조절

실행 결과

[방어 방법]

이러한 해킹을 막기위해선 ProGuard나 DexGuard와 같은 소스코드 난독화 도구를 사용하여 소스코드를 난독화한다. Renaming(클래스 및 메소드 이름 변경), Control Flow(제어 흐름 변환), String Encryption(문자열 암호화), API Hiding(API 은닉), Class Encryption(파일 내용 전체를 암호화하였다가 동적으로 복호화), Dex Encription(Dalvik Executable 파일 암호화)같은 기법을 사용하여 APK파일을 디컴파일하더라도 코드를 읽기 난해하게하여 공격을 어렵게 만든다.

원본 apk파일의 해쉬값을 서버에 저장하여 설치된 apk의 해쉬값과 비교하여 동일한지 판단하여 유효성을 체크한다.

앱에 서명을 하여 원본 서명과 설치된 앱 간의 서명을 비교하여 위변조한 앱인지 체크한다.

Apk 파일에 META-INF는 apk 배포시 서명한 내용이 들어가는데 파일을 변조할 경우 패키지 손상오류가 뜨며 기기에 설치되지 않는다. apk파일을 리패키징할 때 서명을 해주지 않아 설치가 되지 않는다.

에뮬레이터의 경우 root권한이 설정되어 있어 이를 우회하는 것으로 생각하였으나, root권한을 끈 경우에도 설치가 되는 것으로 보아 에뮬레이터는 앱의 서명을 확인하지 않는 것으로 생각된다.

인터넷 검색을 통하여 앱 서명이 이루어지지않은 앱을 구하여 테스트를 해보았다.

서명을 하지 않은 앱들은 실기기(galaxy note5 Android 7.0)에서 “패키지가 손상된 것 같습니다”라는 에러가 뜨면서 설치가 되지 않는다.

반면 LD player의 경우 두 앱이 잘 설치가 된다.

따라서 LD player의 경우 앱 서명 체크를 하지않아 설치가 된다고 생각을 하였다.

[프로그램 동작]

Badfile을 읽어서 bof의 인자로 전달해준다. Bof 함수는 badfile을 읽고 buffer에 쓰는데 경계체크를 하지 않으므로, 버퍼의 크기를 초과해서 쓰게 된다.

이 곳이 retlib파일의 취약점이 된다.

따라서 버퍼 오버플로우를 일으켜 bof함수의 리턴주소를 system함수로 조작할 수 있게 된다.

Exploit은 badfile을 열고 buf를 쓴다. Retlib의 buffer over flow 취약점을 이용하므로, retlib의 bof 함수의 return 주소에 system 함수의 주소를 넣고, 인자로 “/bin/sh”을 준다.

그리고 return 주소로 exit를 준다. 따라서 bof함수가 정상적으로 return 되지 않고 system 함수를 호출하고 인자로 “/bin/sh”을 넘겨주어 shell이 실행되게 된다.

Retlib이 setUID가 설정되어있고, Non-executable stack이므로 code reuse 공격을 사용하여 libc의 system함수를 이용하여 /bin/sh을 root권한으로 실행한다.

Retlib.c의 bof함수를 disassemble하여 보면 버퍼 위로 더미데이터가 8바이트가 있는 것을 알 수 있고, 따라서 bof함수의 리턴주소의 위치는 buffer[24]임을 알 수 있다.

따라서 리턴 주소를 조작할 수 있게 된다.

그리고 fread하기전 인자들을 전달하는 것을 볼 수 있다.

[ebp+0x8] =badfile의 주소, 0x12c = 300, 0x1 = sizeof(char), [ebp-0x14] = buffer의 시작주소를 전달하는 것을 볼 수 있다.

buffer[24]의 위치는 원래 return address이므로 여기에 system의 주소를 넣고 그 위(buffer[28])에 exit의 주소, 그 위(buffer[32])에 /bin/sh의 주소를 넣어준다.

gdb에서 print와 find 함수를 이용해 system함수의 위치는 0xb7e42da0, exit 함수의 위치는 0xb7e369d0, “/bin/sh”의 위치는 0xb7f6382b임을 알 수 있다. 따라서 다음과 같이 exploit.c를 작성하였다.

Exploit을 실행하고 retlib을 실행하면 스택이 다음과 같이 바뀌게 된다.

Bof의 리턴주소 = system함수의 주소 -> system함수 호출

Bof 리턴주소 위 4byte = exit 함수의 주소 -> 호출된 system 함수의 리턴 주소가 된다.

Bof 리턴주소 위 8byte = /bin/sh의 주소 -> 호출된 system 함수의 인자로 들어가게된다.

retlib의 bof에서 오버플로우가 발생하고 위와 같이 덮여 쓰여지게 된다.

Non executable stack이라 하더라도 executable code region의 system함수를 불러오므로 shell을 실행할 수 있게 된다.

이 파일은 setuid bit가 설정되어있고 owner가 root이므로 root의 권한으로 실행되게 된다.

따라서 ruid는 seed이지만 euid는 root임을 알 수 있다.

[취약점 보완]

컴파일러 수준에서 스택 쉴드를 사용한다. Shadow 스택을 사용하여 함수가 리턴될 때 call stack, shadow stack을 비교하여 일치하지 않을 경우 종료하게 한다.

- ASLR을 이용하여 주소를 랜덤화 한다.

- 스택 가드기법(-fstack-protector)를 사용하여 스택 변수와 스택 프레임 포인터 사이에 보호값을 넣는다.

- 프로그래머가 명시적으로 복사할 크기를 지정해주어 버퍼 오버 플로우가 일어나지 않게 한다.

fread(buffer, sizeof(char), 12, badfile)을 하여 12바이트만 읽어오게 한다.

또는 버퍼의 크기를 badfile의 크기보다 크게 설정해준다.

- 코드로 리턴주소와 버퍼 사이에 guard를 설정하여 값이 변경되었는지 확인한다.

이 방법은 공격을 막을 순 있으나, bof 스택 내의 버퍼와 리턴주소 사이를 건드려야하므로, 정상적으로 “Returned Properly”를 출력하지 않고 프로그램이 종료된다.

- Dash가 setUID 프로세스 내에서 권한이 내려가듯 위험한 코드가 실행되기전 권한을 낮추어 버린다.

이 방법도 공격을 막을 순 있으나 bof 함수를 실행을 막지는 못하므로 정상작동하진 않는다.

[프로그램 동작]

Exploit.c에서 badfile에 buffer를 쓴다. 그리고 stack.c에서 badfile를 열고 str에 읽는다. Badfile의 값이 써진 str을 bof의 인자로 넘겨준다.

Stack.c에서 bof 함수는 인자로 받은 str을 buffer에 복사한다. 하지만 strcpy는 NULL을 만나기 전까지의 문자열을 복사하고 복사할 문자열의 길이는 검사하지 않는다. 따라서 buffer의 크기가 24이고, str의 길이는 517이므로 buffer의 스택을 넘어선다.

이때 bof 함수의 return address에 shellcode의 주소를 넣어 shellcode가 실행되게 한다.

Gdb를 통해 strcpy가 실행되는 곳에 break를 하였고, bof함수를 disas하여 strcpy에 0x20크기의 buffer인자가 전달되는 것을 알 수 있다.

따라서 buffer의 크기는 32byte임을 알 수 있다.

gdb를 통하여 ebp가 0xbfffeab8임을 알 수 있고, ebp의 주소에서 0x20만큼 빼주어 buffer의 시작 위치를 알 수 있다. 그리고 이를 토대로 bof의 return address가 실제와 일치하는지 disas main을 하여 비교를 하면 0x08048574로 같음을 알 수 있다.

Buffer의 크기는 32이고 saved edp for bof의 크기는 4이므로 buffer[36]부터가 return address of bof임을 알 수 있다. Exploit.c에서 “memcpy(buffer+sizeof(buffer)-sizeof(shellcode), shellcode, sizeof(shellcode));”를 하여, buffer의 맨 끝에 shellcode를 넣었다.

따라서 정확한 shellcode의 주소를 몰라도 return address 이후와 buffer 이전의 아무 주소 값이나 return address of bof에 넣어준다면 shellcode는 buffer의 맨 끝에 있으므로 실행이 될 것이다.

시스템이 Little endian이므로

주소값을 반대로 넣어준다. Buffer의 크기는 32byte이고 saved ebp or bof 는 4byte이므로 *(buffer +36)이 return address를 가리키므로, *(buffer +36)부터 차례로 주소를 넣어준다.

이것을 실행하면 원하는 shellcode가 동작하는 것을 볼 수 있다.

[취약점 메모리 구조]

Bof 함수의 strcpy(buffer, str)이 취약점이다. 먼저 bof 함수 인자인 str이 쌓이고 그 다음에 Return Address of bof, Saved ebp of bof, buffer가 쌓인다. Buffer는 32byte이고 saved ebp of bof는 4byte, return address of bof 4byte, str 517bye이다.

Str의 크기가 buffer보다 크고, strcpy는 문자열의 길이를 체크하지 않으므로 str의 값들이 buffer스택 위로 덮어쓰여진다.

- Exploit 실행 후 메모리 구조

Exploit이 실행되면, overflow로 인하여 bof의 return address에 0xbfffeb68(return address 위의 랜덤주소, buffer의 마지막에 shellcode가 있다)이 들어간다.

그리고 NOP 명령어가 실행되다가 buffer의 끝에 있는 shellcode를 실행한다.

[취약점 보완]

프로그래머가 스택의 다른 영역을 침범하지 않게 코드상으로 영역을 명확히 명시하거나 입력 받는 데이터의 크기를 확인하거나 buffer overflow에 취약한 함수를 사용하지 못하게 한다.

 Buffer overflow에 취약하지 않은 함수를 사용한다. Strcpy(buffer, str)을 strncpy(buffer, str, sizeof(buffer)-1)함수로 대체 사용하여 복사할 크기를 지정하여 overflow가 생기지 않도록 한다.

Strncpy를 사용하여 복사할 크기를 지정해주었을 때 공격이 실패하고 정상적으로 “Returned Properly”가 수행되는 것을 알 수 있다.

또는 sizeof(buffer)을 BUF_SIZE이나 24로 명확하게 적어준다.

인자로 받는 데이터의 크기를 체크한다. bof함수의 인자로 int size값을 받아 str의 크기를 체크하여 오버플로우를 방지한다. Bof(char*str, int size)의 형태로 받는다.

크기가 buffer보다 클 때 warning을 출력하고 exit한다.

스택 쉴드 기법을 사용하여 함수가 호출될 때 그 함수의 Return Address를 특수 스택에 저장을 하고 함수 종료 시 저장해둔 Return Addresss와 비교를 하여 값이 다르면 프로그램을 종료시킨다.

해제한 ASLR(Address Space Layout Randomize)기법을 다시 사용하여 각 프로세스 안의 스택이 임의의 주소에 위치하도록 한다.

해제한 NX bit를 활성화하여 스택/힙 영역의 실행권한을 제거하여 쉘의 실행을 방지한다.

해제한 Stack Guard기법을 사용하여 스택에 Canary 값을 넣고 이 값이 변조되었는지 검사하여 오버플로우를 체크한다.

LDplayer와 여러 디바이스의 property를 비교하여 차이점을 찾으려 하였다.

하지만 각 스마트폰 제조사, 모델에 따라 각기 다른 property명과 값을 가지고 있어 범용적으로 기기가 real device인지 emulator인지 구분하기 힘들었다.

또한 확실히 구분되는 아키텍쳐 정보는 x86기반의 안드로이드 기기가 나오면서 이것으로 구분하기는 힘들었다. 따라서 실제 가진 기기의 property정보를 바탕으로 emulator와 비교하여 galaxy note 3와 LDplayer를 구분했다.

아래 사진을 보면 real device에서는 가지는 property이지만 emulator에선 가지지 않는 property를 정리하였다. 그리고 각 기기별로 그 이름이 다 다른 것을 알 수 있다.

(각 테스트 기기는 galaxy S10, galaxy S9, galaxy Note 3, Xperia Z3 Compact 이다.)

(getprop한 정보를 word에 옮겨 비교하였다.)

[Bluetooth 관련 property]

[GPS 관련 property]

[Camera 관련 property]

따라서 위와 같이 공통적이지 않은 property로 emulator인지 구분할 경우 모든 기기의 property를 다 알고 있지 않은 이상 적용하기 어려워 테스트 기기 한정으로 적용을 시켜 테스트하였다.

(위 프로퍼티를 갖고 있지 않은 다른 디바이스에선 emulator라고 탐지하게 된다.)

boolean isProbablyAnEmulator(){ // checking Emulator
    return get("service.camera.running").equals("") && get("ro.bluetooth.tty").equals("");
}

위 property외에 usim 관련, 네트워크 관련 property들은 공통적인 이름을 가지고 있으면서 다른 값을 가지는 것을 확인하였다.

Real Device는 대부분 무선 인터넷환경(wlan)을 이용하니 이 부분을 확인하면 좀 더 쉽게 emulator를 탐지할 수 있을 거라 생각한다. 그리고 LDplayer의 경우 eth0을 사용하고, 다른 컴퓨터 환경에서도 같은 gateway, ipaddress를 가지는 등 이 정보를 가지고도 판단할 수 있을 거라 생각한다.

하지만 해당 정보들 모두 최신 emulator에서 값을 조정할 수 있기 때문에, 완벽한 방법은 아니다. 

(adb shell getprop를 하였을 때 수업시간에 배운 selinux가 실제 안드로이드 디바이스에 적용이 되있음을 알 수 있었다.)

0x28 = 40바이트를 할당하므로 dummy는 없음을 알 수 있다.

Main 함수의 에필로그를 보면 위 그림과 같이 동작하는 것을 알 수 있다.

Mov esp, ebp => esp를 ebp로 옮긴다.

Pop ebp => esp가 가리키는 값을 ebp에 저장하고 esp를 증가

Pop eip => esp가 가리키는 값을 eip에 저장

Jmp eip =>eip 주소로 이동

Jmp eip에서 system함수로 이동을 하게 하면 되지만, ret 위의 값이 조작이 불가하므로 esp가 조작된 ebp를 가리키게 해야한다.

따라서 리턴주소를 에필로그로 하면 esp가 조작된 ebp를 가리키게 할 수 있다.

Strncpy로 buffer를 채우므로, 먼저 조작된 ebp가 buffer를 가리키게 한다. 그 다음 리턴 주소를 에필로그로 바꾼다. 그러면 다시 에필로그를 실행하므로 Mov esp, ebp를 한다.

따라서 esp는 buffer를 가리키게 된다.

Pop ebp-> Pop eip-> Jmp eip를 하므로, 버퍼를 위 그림과 같이 리턴 주소에 system함수의 주소를 넣고, 그 위에 system함수의 리턴주소, 그 위에 인자를 넣어주고 남은 공간은 더미로 채운다.

에필로그 = 0x80484df

System = 0x40058ae0

“/bin/sh” => 0x400fbff9

Buffer = 0xbffffab0

에필로그 = 0x80484df => 08 04 84 df

System = 0x40058ae0 => 40 05 8a e0

“/bin/sh” => 0x400fbff9 =>40 0f bf f9

Buffer = 0xbffffab0 => bf ff fa b0

$(python -c 'print "A"*4 + "\xe0\x8a\x05\x40" + "A"*4 + "\xf9\xbf\x0f\x40" + "\x90"*24 + "\xb0\xfa\xff\xbf" + "\xdf\x84\x04\x08"')

실행 후

0xbffffaa0에 들어간 것을 알 수 있었다.

따라서 buffer주소를 바꾸어 주었다.

Bf ff fa a0

$(python -c 'print "A"*4 + "\xe0\x8a\x05\x40" + "A"*4 + "\xf9\xbf\x0f\x40" + "\x90"*24 + "\xa0\xfa\xff\xbf" + "\xdf\x84\x04\x08"')

(PuTTY가 출력되는 이유는 모르겠다, zombie_assassin을  gdb하였을때, Operation not permitted가 발생하여 cp하여 소유자가 assassin인 zombie_assassi2파일을 사용하였다. )

코드에서 먼저 memcmp을 하여 argv[1] + 44 위치에 strcpy의 주소가 있는지 체크를 한다.

그리고 strcpy(buffer, argv[1])을 하여 argv[1]을 buffer로 복사한다.

그 다음 memset(buffer+40+8, ‘A’, 4)를 하여 buffer 위 ret위를 “AAAA”로 채운다..

Argv[1] + 44 위치에 strcpy 주소를 넣으므로, 메인함수의 ret이 strcpy가 되게된다.

“AAAA”가 저장된 곳이 strcpy의 ret이고, 그 위 4byte는 strcpy함수의 destination, 그 위 4byte는source가 된다.

source 에 system 함수의 주소를 넣고, destination에 “AAAA”(strcpy의 ret) 주소를 넣으면 strcpy의 ret은 system함수가 된다.

그리고 system함수의 인자를 주기 위해 buffer에 system함수주소(4) + ret(더미) + “/bin/sh”주소(system함수의 인자)를 채우고 buffer 주소를 source에 넘기면 system함수의 인자도 동시에 줄 수 있다.

Sub $0x2c, %esp => 44byte를 할당하므로 buffer위에 더미 값은 할당되지 않는다.

P strcpy, p system으로 각 주소를 얻는다.

Strcpy = 0x8048410, system = 0x40058ae0

“/bin/sh”의 주소를 얻는 코드를 작성하여 주소 값을 얻는다.

/bin/sh =>0x400fbff9

혹은

환경 변수를 추가하여 찾을 수도 있다.

Buffer = 0xbffffaa0

&ret+4 = 0xbffffad4

Strcpy = 0x8048410, system = 0x40058ae0, /bin/sh = 0x400fbff9, Buffer = 0xbffffaa0, &ret+4 = 0xbffffad4를 구하였다.

따라서 payload를 적으면  $(python -c 'print "\xe0\x8a\x05\x40" + "A"*4 + "\xf9\xbf\x0f\x40" + "\x90"*32 + "\x10\x84\x04\x08" + "A"*4 + "\xd4\xfa\xff\xbf" + "\xa0\xfa\xff\xbf"')가 된다.

실행 결과

Segmentation fault가 나와 명령어를 다시 살펴보았다.

예상한 값이 들어가지 않은 것을 알 수 있었다.

/bin/sh 뒤에 NOP명령어를 32바이트 주었는데 중간에 이상한 값이 들어가 있었습니다. 이 원인을 찾고자 하였다.

Break를 memset 이후로 걸고 주소값을 찾았다.

buffer => 0x bf ff fa b0 (그림 잘못표기함)

Ret+4 -> 0x bf ff fa e4

$(python -c 'print "\xe0\x8a\x05\x40" + "A"*4 + "\xf9\xbf\x0f\x40" + "\x90"*32 + "\x10\x84\x04\x08" + "A"*4 + "\xe4\xfa\xff\xbf" + "\xb0\xfa\xff\xbf"')

Buffer의 시작 주소를 0xbffffaa0

Ret + 4 주소를 0xbffffad4로 바꾸어 실행해보았습니다

하지만 작동하지 않았다.

하지만 여전히 원인을 찾지 못하여 이때까지 실행한 결과를 적는다...

추가로 LOB Redhat은 bash의 버전이 낮아서 \xff를 \x00으로 처리하므로

Bash2로 변경하였다.

#include<stdio.h>

void echo()
{       
        char buf[4]; // small
        gets(buf);
        puts(buf);
}       

int main()
{
        printf("Type a string:");
        echo();
        return 0;
}   

=> gets시 4byte보다 큰 값이 입력되면 버퍼가 넘치게 된다. 따라서 saved ebp, return address에 덮여씌여지게 된다.

만약 abcdef입력시)

Basic Data Types

- Integral

- Floating point

배열의 할당

char 배열의 주소 크기는 1 byte

int 배열의 주소 크기는 4byte (한 원소당 4byte를 차지하므로)

double 배열의 주소 크기는 8byte

-포인터 배열

32bit 구조는 address bus가 4byte이므로 주소도 4byte

64bit 구조는 address bus가 8byte가 가능하다. 하지만 8byte는 큰 공간이므로 메모리 낭비라고 생각하여 6byte씩 표현하는 경우도 있다.

Array operations

예시

int val[5];

주소 : x -> x+4 ->x+8 ->x+12->x+16

val[4] = 3

val = x

val+1 =x+4

&val[2] = x+8

val[5] = ?

*(val+1) = 5

val +i = x+4i

예시1)

#include <stdio.h>
typedef int zip_dig[5];
int main() {
    zip_dig cmu = {1, 5, 2, 1, 3};
    zip_dig mit = {0, 2, 1, 3, 9};
    zip_dig ucb = {9, 4, 7, 2, 0};

    printf("%p \n", cmu);
    printf("%p \n", mit);
    printf("%p \n", ucb);

    /*-----------------------------------*/
    printf(“%d, ”, cmu[8]);
    printf(“%d, ”, cmu[11]);
    printf(“%d, ”, ucb[-5]);
    printf(“%d\n”, ucb[-15]);
}

(32bit로 컴파일)

stack protector가 설정되어있으므로 낮은 주소부터 할당이 된다.

연속으로 배열이 할당이되고 낮은 주소부터 할당이 되는 것을 알 수 있다.

0x14 =>20byte 만큼 주소가 차이난다.

-fstack-protector을 하면 64->78->8c로 스택이 자라고

-fno-stack-protector을 하면 bc -> a8 -> 94로 낮은주소로 스택이 자란다.

(64bit로 컴파일)

주소체계도 다르고, 0x20만큼 주소가 차이나는 것을 알 수 있다. 32byte만큼 주소차이가 난다.

(오타, 0x7ffe1eadaa40이 아니라50이다....)

예시 2)

#include <stdio.h>
typedef int zip_dig[5];
int main() {
    zip_dig cmu = {1, 5, 2, 1, 3};
    zip_dig mit = {0, 2, 1, 3, 9};
    zip_dig ucb = {9, 4, 7, 2, 0};

    printf("%p \n", cmu);
    printf("%p \n", mit);
    printf("%p \n", ucb);

    printf("%d, %d, %d, %d\n",mit[-5], mit[-4], mit[8], mit[9]);
}

(stack proctector)

=>

0x20만큼 주소가 차이남 (5개의 원소)

(no stack protector)

=>

-fno-stack-protector(스택 보호기법 해제) -> 높은위치에서 낮은 위치로 성장

5c -> 48 ->34

주소체계와 접근하는 방식이 달라짐!

(64bit의 경우)

(64bit no stack protector)

예시 3)

#include <stdio.h>
typedef int zip_dig[5];
int main() {
    zip_dig cmu = {1, 5, 2, 1, 3};
    zip_dig mit = {0, 2, 1, 3, 9};
    zip_dig ucb = {9, 4, 7, 2, 0};

    printf("%p \n", cmu);
    printf("%p \n", mit);
    printf("%p \n", ucb);

    printf("cmu[8] : %d \n", cmu[8]);
    printf("cmu[12] : %d \n", cmu[12]);
    printf("mit[8] : %d \n", mit[8]);
    printf("mit[-4] : %d \n", mit[-4]);
    printf("ucb[-4] : %d \n", ucb[-4]);
    printf("ucb[-12] : %d \n", ucb[-12]);
    printf("\n");
    printf(" *(cmu+9) : %d \n", *(cmu+9));
    printf(" *(cmu+11) : %d \n", *(cmu+11));
    printf(" *(mit-4) : %d \n", *(mit-4));
    printf(" *(ucb-5) : %d \n", *(ucb-5));


}

예시 4)

#include <stdio.h>
void main() {
    int k = 100;

    int a[4] = {0, 1, 2, 3};
    int b[4] = {4, 5, 6, 7};
    int c[4] = {8, 9, 10, 11};

    a[-1] = 0xAA;
    a[7] = 0xBB, a[10] = 0xCC;
    c[-2] = 0xDD, c[-6] = 0xEE;

    printf("k = %d (0x%x)\n", k, k);

    for(int i=0; i<12; i++) {
        printf ("%3d (0x%x) ", a[i], a[i]);
        if ((i+1) % 4 == 0) printf ("\n");
    }

}

=> 인덱스에 음수가 가능

=> 인덱스가 본래 의미한 것보다 더 큰 값도 가능(다른 위치도 배열의 인덱스로 접근가능)

따라서 c는 메모리 관련 취약점이 많음

(64bit)

(64bit stack보호 기법해제)

Byte ordering

=> 취약점을 분석할때 컴퓨터 구조에 맞는 데이터를 투입해야하므로 알아야함

little endian은 최소 유효 byte가 낮은 주소를 차지한다.

big endian은 최소 유효 byte가 높은 주소를 차지한다.

type별 크기

=> big/little endian에 따라 c[0]이 낮은주소/높은주소 일 수 있다.

이더리움 지갑 ‘마이이더월렛(MEW)’ 해킹

- 2018년 4월 이더리움을 보관하는 개인지갑인 마이이더월렛 해킹사건이 발생하였다.

- 해당 사건은 마이이더월렛의 DNS 서버를 해킹하여 사용자들이 해커가 만든 가짜 사이트로 접속하였다.

공격과정은 다음과 같다.

해커들은 BGP(Border Gateway Protocol) 메시지를 위조하여 DNS를 하이재킹하였다. 따라서 특정 도메인(마이이더월렛)에 연결되는 IP주소를 다른 주소(가짜 사이트)로 변경시켜 정상적인 사용자들이 마이이더월렛에 접속 요청시 가짜사이트로 연결되었다.

해커들은 ISP업체를 해킹하여 Amazon Cloud 서비스로 가는 IP 트래픽을 가로챈다.

MyEtherWallet.com은 AWS DNS 서버 중Route 53을 사용하고 있었으므로, 해커는 해당 IP 트래픽이 AWS에서 서비스하는 DNS서버가 아닌 가짜 DNS서버로 보내어지게 하였다.

그리고 해커들은 가짜 DNS서버를 해킹하여 피싱사이트로 연결되게 하였다.

정상적인 사용자들은 가짜 DNS 서버에서 제공하는 IP주소로 피싱사이트를 접속하였다. 정상사이트라고 생각한 사용자들은 로그인하기 위해 지갑의 개인키를 입력하여 해커는 다른 사용자들의 지갑 개인키를 획득한다. 획득한 개인키로 지갑안의 암호화폐를 훔친다.

해당 사고 사례는 이웃에 있는 BGP peer들이 보내는 IP prefix정보를 무조건 신뢰하는 BGP프로토콜의 취약점을 이용하였다.

AS 10297을 가진 ISP인 eNet을 해킹하여 AWS에 속한 IP Prefix (205.251.192.0/24
205.251.193.0/24, 205.251.195.0/24, 205.251.197.0/24, 205.251.199.0/24)를 AS 10297에 속한 prefix로 announce하여 eNet의 BGP peer에 해당 IP주소가 왔을 때, 가짜 DNS로 연결하고 피싱사이트로 연결되게 되었다.

1.     ISP를 해킹하여 BGP hijacking

2.     DNS서버 해킹

3.     IP 트래픽이 해킹한 DNS서버에 연결되게 함

4.     해킹 DNS서버에 연결되면, ‘MyEtherWallet.com’의 피싱 주소로 가리키게 함

5.     정상적인 사용자는 MyEtherWallet 지갑의 개인키 입력

6.     정상적인 사용자의 MyEtherWallet 지갑의 개인키 획득 후 암호화폐 탈취

BGP, DNS hijacking을 하여 정상적인 DNS 서버인 척 가장하였으므로 Spoofing 공격으로 분류할 수 있다. 그리고 ISP eNet의 AS(Autonomous System)에 속하지 않는 IP Prefix를 속하게 수정하였으므로 Tampering 공격으로도 분류할 수 있을 것이다.

참고 사이트)

https://m.blog.naver.com/aepkoreanet/221262570102

https://blog.cloudflare.com/bgp-leaks-and-crypto-currencies/

https://www.kentik.com/blog/aws-route-53-bgp-hijack-what-kentik-saw/

https://speakerdeck.com/stevepotayteo/defense-techniques?slide=54

https://m.etnews.com/20180425000438

https://www.facebook.com/groups/114962092511047/permalink/166401220700467/

- Software Security가 중요한 이유?

Software는 종류가 다양하고,

----------------------------------------------------------------------------------

 Systems software : OS, compiler, loader

 Business software : Payroll, accounting

 Scientific and engineering software

 Computer-aided design, simulation, weather prediction, …

 Internet software:  B2C: business-to-customer (e.g., amazon.com)

 Facebook, Google Chrome, …

 PC software : Spreadsheets, word processing, games, …

 Embedded software

 Cars, microwave ovens, cable boxes, light switches,

 “smart dust”, …

 Mobile applications 

----------------------------------------------------------------------------------

컴퓨터 보안의 많은 것들은  SW로 구현이 된다.

알고리즘, access control 등 대부분이 SW로 구현되기 때문에 Software Security가 중요하다.

따라서 구현할 때 쓰는 sw가 취약하면 의미가 없으므로, SW가 취약하면 보안은 무조건 깨진다.

만약, 강력한 암호 알고리즘을 도입한다해도 구현하는 SW가 문제 있다면 그 보안은 의미가 없을 것이다.

따라서 SW는 빈약한 보안의 기초가 될 수 있다.

(SW가 빈약하면 보안 자체의 기초가 흔들린다.)

* Software 위기의 원인

- 예산 초과

- 시간 초과

- 비효율적인 SW

- 저품질의 SW

- 때때로 요구사항을 만족 못함

- 관리불가(유지보수가 힘듬 (코드가 복잡하므로))

- 원하는 결과를 내놓지 않음 or 소스코드를 넘겨주지 않음(문제 확인이 어려움)

이러한 문제를 해결하기 위해 Software Engineering이 나오게 되었다.

* Software

Software는 실행가능한 프로그램이고, 소스코드, 라이브러리, 문서(유저 요구사항, 실제 명세서, 가이드/메뉴얼 등)이다.

그 중 핵심 기능은

데이터를 처리, 전송, 저장하는것이고

정보를 생산, 관리, 드러내는 것이다.

* Bugs, Defects, Weaknesses, and Vulnerabilities

----------------------------------------------------------------------------------

Improper initialization

Side effects

Scoping

Operator precedence

Divide-by Zero

Infinite loop

Type confusion (illegal downcasts) 

Deadlock

Integer Overflow / Underflow

Memory leak

Use-after-free

Buffer overflow = Buffer overrun

Time-of-check-to-time-of-use flaw

Format string bug

---------------------------------------------------------------------------------- 

위와 같이 다양한 종류가 있다.

취약점 보단 덜 위험하지만 문제를 일으킬 수 있다.

- bug와 취약점의 차이

bug : 의도치 않은 방향으로 잘못 행동하는 프로그램 내의 결함이다.

취약점 : bug 중에서도 공격자에 의해서 악용될 수 있는 것, 공격자가 접근할 수 있어야하고 공격자가 공격할 능력이 있어야하고 시스템 내에서 결함이 있어야한다.

SW Bugs 예시)

-------------------------------------------------------------

(초기값)

typedef unsigned int uint;

int getmin(int *arr, uint len){
	int min;
    for(int i=0;i<len;i++)
    	min = (min < arr[i]) ? min : arr[i];
    return min;
 }

min에 대한 초기값이 설정되어 있지않아 정상적으로 실행되지 않을 수 있다.

inn min = 0과 같이 초기 값을 설정해주면 된다.

(side effects)

if(foo == 12 || (bar = 13))
	baz == 12;

bar = 13은 항상 참이다.

foo와 baz의 값이 선언되어있지 않고 비교되고 있다.

(범위)

int a;
void calc(int b){
	int a = b*12;
    if(b+24 == 96)
    	a = b;
}

printf("a=%d\n", a);

=> 전역변수, 지역변수 둘다  a로 선언하여 모호하다.

=> calc함수내의 a는 함수가 종료되면 없어지므로 전역변수 a의 값이 출력된다.

(control flow)

int x,y;

for(x=0;x<xlen;x++)
	for(y=0;y<ylen;y++);
    	pix[y*xlen + x] = x*y;
        

두번째 for문에 ;처리하여 원하는 결과가 출력되지 않는다.

if (isbad(cert))
	goto fail;
    
if (invalid(cert))
	goto fail;
    	goto fail;
    
    
L10 : printf("Hello, world\n");
		goto L10

goto fail;

goto fail;

을 하면 if문을 통과하고 두번째 goto fail이 항상 실행된다.

goto를 잘 못 사용하면 무한루프(L10으로 계속 이동)에 걸릴 수 있다.

(control flow - loop)

float x = 0.1;
while(x!=1.1){
	x=x+0.1;
    printf("X=%f\n", x);
}

부동 소수점은 ==으로 비교하면 안된다.

실수는 무한히 많은데 이 실수를 유한 개의 비트로 표현하기 위해서는 근삿값으로 표현해야 하기 때문이다. =>부동소수점 반올림 오차

#include <stdio.h>
#include <float.h>    // float의 머신 엡실론 값 FLT_EPSILON이 정의된 헤더 파일
#include <math.h>     // float의 절댓값을 구하는 fabsf 함수를 위한 헤더 파일

int main()
{
    float num1 = 0.0f;
    float num2 = 0.1f;

    // 0.1을 10번 더함
    for (int i = 0; i < 10; i++)
    {
        num1 = num1 + num2;
    }

    // num1: 1.000000119209290
    if (fabsf(num1 - 1.0f) <= FLT_EPSILON)    // 연산한 값과 비교할 값의 차이를 구하고 절댓값으로
                                              // 만든 뒤 FLT_EPSILON보다 작거나 같은지 판단
                                              // 오차가 머신 엡실론 이하라면 같은 값으로 봄

        printf("true\n");    // 값의 차이가 머신 엡실론보다 작거나 같으므로 true
    else
        printf("false\n");

    return 0;
}

FLT_EPSILON(머신 엡실론)을 사용해서 오차를 감안하여 실수를 비교해야한다.

어떤 실수를 가장 가까운 부동소수점 실수로 반올림하였을 때 상대 오차는 항상 머신 엡실론 이하이다.

머신 엡실론은 반올림 오차의 상한값이며 연산한 값과 비교할 값의 차이가 머신 엡실론보다 작거나 같다면 두 실수는 같은 값이라 할 수 있다.

double, long double을 사용한다면 머신 엡실론은 DBL_EPSILON, LDBL_EPSILON을 사용한다.

1. 연산한 값과 비교할 값의 차이를 구한다. 

(값의 차이는 math.h 헤더 파일의 fabsf 함수를 사용하여 절댓값으로 만드므로 차이가 음수여도 상관없다.)

2. FLT_EPSILON 보다 작거나 같은지 판단

3.연산한 값과 비교할 값의 차이가 머신 엡실론보다 작거나 같다면 두 실수는 같은 값이라 판단

(control flow - loop)

int k = 1
int val = 0;

while (k = 10) {
	val++;
	k++;
}

printf (“k = %d, val = %d \n”, k, val);

while(k=10)

k=10은 항상 참이므로 무한 루프가 된다.

(Null pointer 역참조)

int *ptr = NULL;

printf(“Value of ptr: %d\n”, ptr);

int *p = 0; //NULL 대입

*p = 1; //NULL 포안터 역참조, 주소 0에 접근하는 포인터생성후 값 할당 시도함


/* -------------------------------------*/
int length;
char *buff;
scanf (“%d”, &length);

buff = (char *) malloc(length+1); // always Not NULL?

strcpy(buff, “Hello World! Welcome!”);

첫번째 코드는 포인터 변수 P에 NULL을 대입하고 주소가 0인 포인터에 값을 할당하려하였다.

따라서 세그멘테이션 결함이 발생한다.

if(p==NULL){

     exit(1);

}

과 같이 NULL 포인터를 체크해주어야한다.

두 번째 코드는 

malloc시 시스템에 메모리가 부족하거나 메모리 할당 조건이 맞지않아 메모리 할당을 하지 못하면 null을 반환하게 된다. 따라서 buff에 null 포인터가 들어가게된다. 따라서 malloc이 null을 반환하였는지 체크하여야한다.

void Pointer(int *ptr) {
	*ptr = *ptr + 5;
}
main(void) {
	int num = 10;
	Pointer(&num);
	Pointer(NULL);
}

Pointer(NULL)

null을 인자로 넘겨주면 Pointer함수에서 null에 값을 대입하려하여 null 포인터 역참조 에러가 발생한다.

(연산자 우선순위)

node *find(node **curr, val){
	while(*curr != NULL)
    	if(*curr->val == val) return *curr;
        else
        	*curr = *curr->next;
}

(*curr)->val로 하여야한다.

#include<stdio.h>

void main(){
        int x,a,b,c,d,e,f;

        a=7;b=6;c=5;d=4;e=3;f=2;

        x = a&b+c*d&&e^f==7;

        printf("X = %d\n", x);

}

x = 1

연산자 우선순위는

(*) -> (+) -> (==) -> (&) -> (^) -> (&&) 

이다.

따라서

(a&(b+(c*d)))&&(e^(f==7))가 된다.

(a&(b+(c*d))) => 7&(6+(5*4)) =  20&7 (10100 & 00111) => 100(2) = 4

(e^(f==7)) => 3^(2==7) => 11 xor 00 = 11(2) => 3

3&&4는 참이므로 1이된다 (3과 4는 참이므로)

따라서 x에는 1이 들어가게된다.

(Integer Security)

char cresult, c1, c2, c3;
c1 = 100; c2 = 90; c3= -120
cresult = c1 + c2 + c3;
printf(“%c, %d, %c, %d\n”, cresult, cresult, c3, c3);

changmin@ubuntu:~/Desktop/c$ ./d
F, 70, �, -120

char형은 8비트이다. 

c1+c2=190에서 char범위를 벗어난다.

임시적인 정수 승격으로 c1, c2, c3는 int형으로 변환되고 

(임시적인 정수승격 : 일반적으로 CPU가 처리하기에 가장 적합한 크기의 정수 자료형은 int형이다. 즉, int형 연산의 속도가 다른 자료형의 연산속도에 비해서 동일하거나 더 빠르다. 따라서, int보다 작은 크기의 정수형 데이터는 int형 데이터로 형 변환이 되어서 연산된다.)

계산이 끝난뒤에 값이 잘리게 된다.

따라서 c1+c2+c3는 70이된다. 

char 범위는 -128~127이므로 70이 출력된다.

short s1 = 32000; 
short s2 =1500;
s1 = s1 + s2;
printf("%h, %d\n", s1, s1);

changmin@ubuntu:~/Desktop/c$ ./e
%, -32036

(%h =>short 형으로 출력,  invalid conversion specifier -Wformat-invalid-specifier 라고 되는데 %h 형식을 지원하지 않는듯 하다..... short형은 %hd를 사용해야하는 것 같다.)

32000+1500은 short범위를 벗어나므로 오버플로우가 발생한다.

(out-of-bounds write)

배열의 크기를 벗어나거나

memcpy시 마지막 인자가 unsigned int형으로 변환되면서 언더플로우가 발생될 수 있다.

(returnChunckSize(desBuf)의 반환값이 -1일때 -1-1은 -2가 되고 unsigned int로 변환시 언더플로우발생으로 매우 큰수가 된다.)

* 부호버그

부호가 없는 정수를 부호가 있는 정수로 바꾸거나

부호가 있는 정수를 부호가 없는 정수로 바꾸려할 때 발생한다.

예시)

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
	char buf[20];
	int i = atoi(argv[1]);
    //atoi는 아스키를 int로 바꾸어준다.
	
    memcpy (buf, argv[2], i*sizeof(int));
	
    printf("the number is:%d=%d\n",i, i*sizeof(int));
    printf("the buffer is: %s\n",buf);
}

-----------------------------------------------------------------------------------------

changmin@ubuntu:~/Documents$ ./test3 1 AAAA
the number is:1=4
the buffer is: AAAA�vbV

=> 1 AAAA를 입력하면, 

i는 1이되고 i*sizeof(int)는 4가된다.

"�vbV"는 memcpy가 null을 추가하지 않고 복사하기때문에 그런것같다.

-----------------------------------------------------------------------------------------
changmin@ubuntu:~/Documents$ ./test3 111 AAAA
the number is:111=444
the buffer is: AAAA
*** stack smashing detected ***: <unknown> terminated

Aborted (core dumped) 

111 AAAA를 입력하면

i는 111이되고 i*sizeof(int)는 444가된다.

따라서 argv[2]에서 444만큼 가져와 buf 에 copy하려한다.

---------------------------------------------------------------------------------------
changmin@ubuntu:~/Documents$ ./test3 -1 AAAA
Segmentation fault (core dumped)

-1 AAAA를 입력하면 

i는 -1이되고 i*sizeof(int)는 -4가된다.

memcpy 원형을 보면

#include <string.h>
void *memcpy(void *dest, const void *src, size_t num);

인데 size_t는 unsigned int 타입이다.

따라서 -4가 아니라 언더플로우가 일어나 엄청나게 큰 수로 바뀌게 된다.

따라서 버퍼 오버플로우가 발생한다.

gdb를 사용하여 테스트해보면

(위와 같은 코드이다.)

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
	char buf[20];
	int i = atoi(argv[1]);
    //atoi는 아스키를 int로 바꾸어준다.
	
    memcpy (buf, argv[2], i*sizeof(int));
	
    printf("the number is:%d=%d\n",i, i*sizeof(int));
    printf("the buffer is: %s\n",buf);
}

(파이썬을 설치하지 않아 A 44번 B 4번을 일일이 입력했다...)

(gdb) r 12 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
Starting program: /home/changmin/Documents/test3gdb 12 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
the number is:12=48
the buffer is: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
*** stack smashing detected ***: <unknown> terminated

Program received signal SIGABRT, Aborted.
0xf7fd5059 in __kernel_vsyscall ()

=> argv[0]에 12, argv[1]에 A*44+B*4를 입력하였다.

=>buf의 크기는 20인데 memcpy에서 12*4(i*sizeof(int))를 하여 48크기만큼 memcpy하려하여 버퍼가 넘치는 버퍼 오버플로우가 발생한다.

이번엔 argv[0]에 -1073741810을 입력하였다.

(gdb) r -1073741810 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/changmin/Documents/test3gdb -1073741810 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
the number is:-1073741810=56
the buffer is: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
*** stack smashing detected ***: <unknown> terminated

Program received signal SIGABRT, Aborted.
0xf7fd5059 in __kernel_vsyscall ()

=> -1073741810 * 4 (i*sizeof(int))값이 memcpy의 인자로 들어가는데 usigned int로 바뀌면서 값이 56으로 변환이 된다. 따라서 버퍼의 크기 20을 넘게된다.

* CWE-195의 부호변환 에러

=> readdata함수는 unsigend int형을 반환한다.

=> 함수 안에서 if문을 보면, 조건 만족시 amount에 -1을 넣고 그 값을 반환한다.

=> usigned int 형으로 바뀌어 반환되므로 언더플로우가 발생한다.

=> 이 경우 또한 usigned  int형을 반환하는데 amount가 음수값이 된다면 언더플로우가 발생할 것이다.

=> if문에서 numHeaders가 100보다 큰지 체크한다.

=> 하지만 int형이 numHeaders가 INT_MAX보다 큰값이 된다면 오버플로우로 음수가 될 것이다.

=> 따라서 ExitError를 실행하지 않고 malloc을 한다.

=> 하지만 malloc에서 unsigned int형으로 바뀌면서 언더 플로우가 발생된다.

int copy_something(char *buf, int len){
	char kbuf[800];
	
    if(len > sizeof(kbuf)){ /* [1] */
		return -1;
	}
	
    return memcpy (kbuf, buf, len); /* [2] */
}

=> if문에서 len의 값이 음수라면 return의 memcpy에서 언더플로우가 발생된다.

=> short형으로 선언된 len이 음수라면 if문을 만족하여 memcpy시 언더플로우를 일으키게된다.

=>(len이 SHORT_MAX보다 크면 오버플로우로 음수가 될 것이다.)

int table[800];

int insert_in_table (int val, int pos) {
	if ( pos > sizeof(table) / sizeof(int) ) {
		return -1;
	}

	table[pos] = val;
	return 0;
}

 일이 벌어

만약 pos값이 0x8000 0000(0x8 = 1000(2))이거나 0x9000 0000(1001(2))이면

최상위 비트가 1이므로 음수가 된다. 

따라서 table[음수값] =val; 이 되어버린다.

=> 위와 같은 일이 벌어지면 무결성이 깨지게 된다.

* 64 bit 구조에서 32 bit 프로그램으로 컴파일 하는 법

gcc -m32 -o test test.c

-m32 옵션 컴파일시 bits/libc-header-start.h: No such file or directory 오류

=> sudo apt-get install gcc-multilib g++-multilib

* 형식 지정자

%d => 부호가 있는 정수, decimal signed int

%u => 부호가 없는 정수, unsigned int

%i => any integer (decimal, octal, hexadecimal)

%hd => half decimal, decimal의 반틈이므로 2byte, short 이다.

%hu => unsigned short(unsigned int의 half)

%hhd => char (half의 half이므로 8bit=1byte), 8비트 단위의 부호가 있는 정수 출력

%hhu => unsigned char, 8비트 크기의 부호가 없는 정수 출력

%ld => decimal signed long

%lu => unsigned long

%o => octal integer, 8진수

%x => hexadecimal integer, 16진수

* printf (“%d, %u, %hd, %hu, %c\n”, -1, -1, -1, -1, -1);

changmin@ubuntu:~/Documents$ ./test
-1, 4294967295, -1, 65535, � 

%d => 부호가 있는 정수이므로 -1이 출력

%u => 부호가 없는 정수이므로 언더플로우 발생하여 큰수가 됨

%hd => 2byte, 부호가 있는 short이므로 -1 출력

%hu => 2byte, 부호가 없는 short이므로 언더플로우 발생하여 unsigned short가 표현할 수 있는 최대 수가 됨

* 오버플로우 or wraparound

어떤 정수 값이 지정된 16bit 크기에 저장될 수 없게 커지게 되면 overflow가 발생한다.

(매우작은수가 되거나 음수가 되버린다. 0이 되버리기도 한다 (표현할 수 없는 상위 비트는 날려버리기 때문))

오버 프로우가 발생하면 자원관리와 실행흐름에 문제가 생긴다.

결과적으로 약점이 생기고 C.I.A(기밀성, 무결성, 가용성)이 깨진다.

가용성 : 오버플로우로 인해서 예측하지 못하는 행동으로 연결될 수 있다(crash 유발가능). loop에서 인덱스로 사용될 경우 무한루프가 될 수도 있다. => DoS유발가능

무결성 : 데이터에서 중요한 값이 손상될 수 있다. 또한 buffer overflow를 일으킬 수 있다.(배열의 인덱스가 넘친다거나), 메모리 손상 유발 가능

기밀성, 접근제어 : 약점이 buffer overflow를 유발하고 그로인해 임의의 코드를 실행할 수 있게 된다. 따라서 보안 정책의 범위를 벗어나게 된다.

integer 오버플로우는 직접적으로 실행흐름을 바꾸거나 악용될 가능성은 적다.

하지만, 어떤 경우는 heap overflow 즉, 버퍼 오버플로우를 유발 할 수 있다. 

따라서 임의의 코드를 실행할 수 있게 되는 더 나쁜 상황이 된다.

오버플로우 예시)

#include<stdio.h>
#include<stdio.h>

void main(void){
	unsigend short us = 65535; //unsigned short max값
    short ss = 32767; // short max값
    
    unsigned char uc = 255; //max
    signed char sc = 127; //max
    
   printf("unsigned_short = %d (%u), signed_short = %d (%u)\n", us, us, ss, ss);
   //unsigned short= 65535 (65535), signed short = 32767 (32767)
   
   //%d, %u 는 signed int, unsigned int범위임으로 short 정상출력됨
   
   printf("unsigned_char = %d (%u), signed_char = %d (%u)\n\n", uc, uc, sc, sc);
   //unsigned char = 255 (255), signed char = 127 (127)
   
   //%d, %u 는 signed int, unsigned int범위임으로 char 정상출력됨
   
   printf("unsigned_short = %hd, %hu, %hhd, %hhu\n", us, us, us, us);
   //unsigned short= -1, 65535, -1, 255
   
   //%hd는 signed int의 절반이므로 2byte, short범위이다. ->
   //->65535가 1111 1111(2)이므로 2의 보수표현으로 생각하여 -1로 출력됨
   
   //%hu는 unsigned int의 절반이므로 정상 출력된다.
   
   //%hhd는 signed int의 절반의 절반이므로 1byte범위이다. ->
   //->16bit를 8bit로 출력하므로 앞으 8bit는 잘리고 1111 1111 1111 1111(2)->
   //->1111 1111(2), 위와 동일하게 2의 보수 표현으로 생각하여 -1이 출력됨
   
   //%hhu는 unsigned int의 절반의 절반이므로 정상 출력된다.
   
   printf("unsigned_short+1 = %hd, %hu, %hhd, %hhu\n", us+1, us+1, us+1, us+1);
   //unsigned short+1 = 0, 0, 0, 0
   
   //unsigned short의 최대값에 1을 더하면 short의 범위를 벗어나게 된다.
   //16bit를 넘어서서 할당된 16bit로 표현이 불가하여 0으로 출력된다.
   
   printf("signed_short = %hd, %hu, %hhd, %hhu\n\n", ss, ss, ss, ss);
   //signed short = 32767, 32767, -1, 255
   
   //%hhd는 signed int의 절반의 절반이므로 1byte(8bit), ->
   //->short(16bit)인데 8bit로 출력하므로 위와 동일하게 앞 8비트가 잘리고 2의 보수표현으로 -1
   
   printf("unsigned_char = %hd, %hu, %hhd, %hhu\n", uc, uc, uc, uc);
   //unsigned char = 255, 255, -1, 255
   
   //%hhd는 부호가 있는 8bit이고, 부호가 없는 8bit를 출력할때 2의 보수 표현으로 -1이 출력
   
   printf("unsigned_char+1 = %hd, %hu, %hhd, %hhu\n", uc+1, uc+1, uc+1, uc+1);
   //unsigned char+1 = 256, 256, 0, 0
   
   //%hhd, %hhu 둘다 8bit인데 unsigned_char+1이 되면 1 0000 0000(2)가 되므로
   // 0000 0000(2)로 0이된다.

}

* usigned와 signed 차이

2의 보수를 취하여 최상위 비트가 1이면 음수로 취급한다.

ex) 2+ (-3)

3 => 0011

1의 보수 => 1100

2의 보수 => 1101

따라서 0010 + 1101 = 1111

1111은 -1이된다.

8bit의 경우

0111 1111(2) ~ 1000 0000(2)가 범위가 된다 (1111 1111(2) 는 -1 => 위 원형 그림 참고)

127 ~ (-128)

- 2의 보수 덧셈

(-4) + (-1)

1100 + 1111 => 1 1011 => 1011 = -5

(-4) + (+4)

1100 + 0100 => 1 0000 = 0

(+5) + (+4)

0101 + 0100 => 1001 (-7) =오버플로우발생

(-7) + (-6)

1001 + 1010 => 1 0011 => 0011 (3)= 오버플로우 발생

* Overflow / Underflow

overflow : INT_MAX = 2147483647 (0X 7FFF FFFF), 값이 INT_MAX보다 크면 segmentation fault가 유발된다.

underflow : INT_MIN = 0x 8000 000 (0x8 = 1000(2)), 값이 INT_MIN보다 작으면 segmentation fault

INT_MAX = 2174483647(0x7FFF FFFF)

INT_MIN = -2147483648(0x8000 0000)

UINT_MAX = 4294967295(0xFFFF FFFF)

오버플로우 예시) 

#include <stdio.h>
int main(void){
	unsigned int num = 0xffffffff;
    
	printf("num = %u (0x%x)\n", num, num);
	printf("num + 1 = 0x%x\n", num + 1);
    
	return 0;
}


/* EOF */
The output of this program looks
like this:
num = 4294967295 (0xffffffff)
num + 1 = 0x0

num은 INT_MAX이다. 

%u = unsigned int이므로 num = 4294967295 (0xffffffff)

num+1은 INT_MAX 범위를 벗어나므로 0x 1 0000 0000 => 0x 0000 0000 => 0x0이 된다.

#include <stdio.h>
int main(void) {
	int n;
	n = 0x7fffffff;
	
    printf(“n = %d (0x%x)\n", n, n);
	printf(“n + 1 = %d (0x%x)\n", n + 1 , n + 1);
	
    return 0;
}

/* EOF */
The output of which is:
n = 2147483647 (0x7fffffff)
n + 1 = -2147483648 (0x80000000)

n은  signed int에서 MAX 양수이다.

%d => 2147483647 (0x7fffffff)

n + 1 => 0x8000 0000가 된다. 이진수로 변환하면 1000 0000 0000 0000 0000 0000 0000 0000(2)이므로 

2의 보수 표현으로 -2147483648이 된다.

- 더하기/빼기/곱에서도 발생함

#include <limits.h>

 unsigned int ui1, ui2 , usum ;

/∗ Initialize ui1 and ui2 ∗/

 usum = ui1 + ui2 ;
 
/* ui1 = 0x7FFFFFF2
 ui2 = 0x6FFFAAAA */

0x7FFF FFF2 + 0x6FFF AAAA를 덧셈하면 INT범위를 벗어나 오버플로우 발생

signed int si1, si2, result;

 /* initialize si1 and si2 */

 result = si1 – si2;
 
 /* si1 = 0xFFFFBEEF
 si2 = 0x6ABCCAFE */

0xFFFF BEEF - 0x6ABC CAFE를 하면 음수 - (양수)로 언더플로우가 발생한다.

(0xF = 1111(2) = 15)

signed int si1 , si2 , result;

/∗ Initialize si1 and si2 ∗/

result = si1 * si2 ; 

곱의 경우도 오버플로우가 발생한다

#include <limits.h>
	int i;
	unsigned int j;
	
    i = INT_MAX; // 2,147,483,647
	i++;
	
    printf (“i = %d \n”, i);
	
    j = UINT_MAX; // 4,294,967,295
	j++;
	
    printf (“j = %u \n”, j);

출력

i = -2,147,483,648

j = 0

i=INT_MAX의 경우 +1을 하여 오버플로우

j=UINT_MAX의 경우 +1을 하여 오버플로우로 0이됨

#include <stdio.h>
	int main(void){
	int l, x;
    
	l = 0x40000000;
	printf("l = %d (0x%x)\n", l, l);
    
	x = l + 0xc0000000;
	printf("l + 0xc0000000 = %d (0x%x)\n", x, x);
    
	x = l * 0x4;
	printf("l * 0x4 = %d (0x%x)\n", x, x);
    
    x = l - 0xffffffff;
	printf("l - 0xffffffff = %d (0x%x)\n", x, x);
    
	return 0;
}

l = 1073741824 (0x4000 0000)

l + 0xc000 0000 = 0 (0x0)

(0xc = 12 = 1100(2) 따라서 최상위 비트가 1이므로 음수임)

l * 0x4 = 0 (0x0)

0x4를 곱하면 큰수가 됨

l - 0xffffffff = 1073741825 (0x4000 0001)

(0xFFFF FFFF = -1)이므로 +1이 됨

언더 플로우 예시)

i = signed int, j = unsigned int

i = INT_MIN;
i--;
printf("i = %d\n", i);

j = 0;
j--;
printf("j = %u\n", j);

INT_MIN에서 1을 빼면 언더플로우로 INT_MAX가 된다.

0x80000000 + 0x7fffffff (-1) = 0x7ffff ffff

( 0x0000 0001 = 1 -> 0xFFFF FFFE (1의 보수)-> 0xFFFF FFFF(2의보수) =-1)

CWE-190의 오버플로우 예시)

table_ptr = (img_t*)malloc(sizeof(img_t)*num_imgs);

malloc은 오버플로우 발생 가능성이 있다.

sizeof(img_t)*num_imgs => img_t 구조체의 크기는 10kb이고 num_imgs는 부호가 있는 정수이다.

num_imgs가 큰 수일 경우, 이 둘을 곱하면 오버플로우가 발생할 수 있다. 

xmalloc => malloc을 개선함(요청된 메모리의 크기를 할당할 수 없으면 에러를 표시하고 프로그램을 종료함)

xmalloc(nresp*sizeof(char*)) 

만약 nresp 가 1,073,741,284이면

1,073,741,284 * 4 = 4,294,967,296로 

UINT_MAX = 4,294,967,295, 최대범위를 벗어나게 된다.

따라서 오버플로우로 response는 0이 되고,

밑의 for문은 4,294,967,296번 루트를 돌고

response[i] = packet_get_string(NULL)은 실제 할당받은 공간은 작은데 계속 할당을 받게 된다.

while loop에서 bytesRec을 체크하는데

byteRec은 byteRec에 getFromInput(buf + bytesRec)을 더한 값이다.

만약 byteRec이 오버플로우가 일어나 작은 값이 된다면 문제가 발생한다.

int myfunction(int *array, int len) {
	int *myarray, i;
	
    myarray = malloc(len * sizeof(int)); /* [1] */
	
    if(myarray == NULL){
		return -1;
	}
    
	for(i = 0; i < len; i++) { /* [2] */
		myarray[i] = array[i];
	}
    
	return myarray;
}

[1]경우 len이 큰 경우 오버플로우가 일어나 작은값이 malloc 될 수 있다.

따라서 [2]에서 len은 크지만 myarray가 작으므로 문제가 발생한다. 

int catvars(char *buf1, char *buf2, unsigned int len1, unsigned int len2) {
	char mybuf[256];

	if ( (len1 + len2) > 256 ) { /* [3] */
		return -1;
	}
    
    memcpy(mybuf, buf1, len1); /* [4] */
    
    memcpy(mybuf + len1, buf2, len2);

	do_some_stuff(mybuf);
	
    return 0;
}

[3]경우 len1 + len2가 값이 커서 오버플로우가 발생하면 if문을 통과하고 밑의 memcpy를 수행한다.

buf1에서 len1크기만큼 mybuf로 복사하므로 버퍼 오버플로우가 발생할 수 있다.

첫번째 memcpy를 통과하더라도 두번째 memcpy에서도 위에서 설명한 것처럼 문제가 발생할 수 있다.

만약 len1이 0x0000 0002이고 len2가 0xffff ffff라면 

첫번째 memcpy는 통과하지만 두번째 memcpy에선 len2가 unsigned int로 바뀌면서 큰값이 되어 버퍼 오버플로우가 발생할 수 있다.

* Integer Overflow를 막는 방법 예시

(자바 코드)

int sum(int a, int b) {
	int c = a + b;

	if (a > 0 && b > 0 && c < 0)
		throw new MyOverfowException(a, b);
	return c;
}


int prod(int a, int b) {
	int c = a * b;
	
   	if (a > 0 && b > 0 && c < 0)
		throw new MyOverfowException(a, b);
	return c;
}

c = a+b 연산을 한 후

a>0, b>0이고 c<0이면 오버플로우가 발생한 경우므로 예외 처리한다.

밑의 곱의 경우도 마찬가지이다.

static void update_value(char op) {
	if (op == '+') {
		if (value + 1 > value) value ++;
		else printf (“too big! \n”);
	} else {
		if (value - 1 < value) value --;
		else printf(“too small! \n”);
	}
}

int addOvf(int* result, int a, int b) {
	if( a > INT_MAX - b) return -1;
	else {
		*result = a + b;
		return 0;
	}
} 

-덧셈 연산을 한 후 오버플로우가 발생하는지 체크한다.

if (value + 1 > value)

     value ++; 

-덧셈 연산전 오버플로우가 발생하는지 확인한다.

a > INT_MAX - b 이면 오버플로우이다.

(max값에서 b를 뺀값보다 a가 크다면 a와 b를 더하면 max값 보다 클것이다.

즉, 현실세계에서 보면  a+b > INT_MAX 이므로, 합이 MAX값을 넘어서 컴퓨터에선 오버플로우가 발생)

(INT_MAX는 limit.h에 선언되어 있다.)

if( a > INT_MAX - b)

     return -1;

다른 방법으로 SW개발 전 단계에서 고려하는 것이다.

-요구사항 분석 : 안전한 언어나 안전한 컴파일러를 사용한다.

-설계 : 안전한 라이브러리나 프레임워크를 사용한다(SafeInt or IntegerLib)

-구현 : 사용하는 범수가 범위내에 있는지 확인한다. 최대값과 최소값 범위를 체크한다.

#include <stdio.h> /* ex2.c ʹ loss of precision */
int main(void) {
	int m;
	short s;
	char c;
    
	m = 0xcafe76ef;
	s = m;
	c = m;
    
	printf("l = 0x%x (%d bits)\n", m, sizeof(m) * 8);
   	printf("s = 0x%x (%d bits)\n", s, sizeof(s) * 8);
	printf("c = 0x%x (%d bits)\n", c, sizeof(c) * 8);
    
	return 0;
}

changmin@ubuntu:~/Desktop/c$ ./aaa 
l = 0xcafe76ef (32 bits) 
s = 0x76ef (16 bits) 
c = 0xffffffef (8 bits) 

s는 16bit=2byte만을 표현할 수 있고, 0xcafe 76ef가 4byte=32bit이므로  상단 16bit가 날라가고 0x76ef가 남는다.

0x7 => 0111(2)이므로 최상단 비트가 1이 아니여서 양수이다. 따라서 앞자리는 모두 0이된다. (%x시 32비트로 출력이된다. => 이부분은 아직 잘 이해하지 못하엿다....)

따라서 0x000076ef

c는 8bit=1byte를 표현할 수 있으므로 0xef만 남게된다.

0xe = 14 = 1110(2)로 최상단 비트가 1이므로 음수이다. 

0xe는 음수임을 나타내므로 결과 값의 나머지 앞 부분도 음수 표시위해 1, 즉 모두 f가 된다.

컴퓨터의 핵심 : 데이터나 정보를 저장하고 처리하는 전자적인 기기

• DATA
  • Raw Data = 가공되지 않음
  • Unorganized = 조직화되지 않음
  • Unprocessed = 처리되지 않음
  • Chaotic or Unsorted = 혼란한 상태
  • Input to a Process = 어떤 Process의 입력

• Information
  • Useful & Relevant = 유익하고 적절한 형태로 되어있음
  • Organized = 조직화됨
  • Processed = 처리되어있음
  • Ordered or Sorted = 정렬되어있음
  • Output of a Process = 어떤 프로세스의 출력

많은 조직에서 정보와 데이터는 중요한 자산이다!!

• Information Technology : 데이터나 정보를 처리하거나 배포하기위해서 컴퓨터 시스템이나 네트워크를 개발하거나 사용하는 기술

• SW Engineer
  컴퓨터 소프트웨어에 대해서 설계하고 개발하고 테스트, 유지보수하는 일을 함, 이러한 원칙들을 적용함
  전체 과정에 참여 => 주로 팀단위 활동
  HW 시스템의 구성요소를 알 필요가 있음 => ex) hdd인지 ssd인지 ...등
  SW 개발시 필요한 도구를 만듦
  큰 규모에 관련된 이슈를 해결할 필요가 있음 => 전체과정을 관여하기 때문에

• SW Developer
  다양한 유형의 컴퓨터에 소프트웨어를 빌드함
  전체 과정중에서 한 부분에서 관여함(주로 구현부분) => 주로 개별활동
  완전한 프로그램을 작성
  만들어진 도구를 사용(편집기 컴파일러 디버거...등)
  제한된 규모에 관여를 함 => 한 부분에 관여하므로

• Information System
  Hardware, Software, Networks, Data, People, Processes의 집합
  <-> Information Technoloy : HW, SW, Networks, Data

• Data를 가공하면 정보가됨 => 회사의 절차나 정책은 정보를 어떻게 처리, 배포할것인지 관련됨 따라서 데이터와 정보가 중요함

• Security??
  위협, 위험, 취약점이 없는 안전한 상태, 공격자가 존재하는 상황에서도 원하는 특성을 만족하는 것.
• 
  
  • Interception : 중간에 가로챔(도청)
  • Interruption : 중간에 막음
  • Modification : 중간에 데이터를 변조함
  • Fabrication : 제 3자가 송신자인척 보냄 (위조) => 인증이 필요 => id/pw, 공인인증서, 생채 인증 등..
  • 기밀성 : 권한을 가진 사람만 정보 접근 => 도청 방지 => 비인가적인 읽기 막아야
  • 무결성 : 인가된 사람만 수정가능, 정보의 출발지 확인(위조 방지) => 비인가적인 쓰기 막아야 =>정보의 정확성, 안정성 보장
  • 가용성 : 인가된 사용자는 그 정보에 항상 접근할 수 있음 => DDoS 방지 => 데이터는 정상적인 사용자가 필요로할때 언제든 이용가능해야한다.

=> 공격자가 존재하는 상황에서 C.I.A를 집행함

• cia로만 충분하지 않음 => 인증필요
•  
• 네트워크 보안도 중요 => 네트워크 프로토콜(보안 강화된) 중요, 암호알고리즘
•  
• 인증되었어도 허가된 행동만 수행하도록 해야함 => 인가 (authorization)
• 
  멀티 유저 시스템에서 인가가 필요함(root, suepr user, normal user, guest)
•  
• 부인방지
  You did that => 하지 않았다고 부인하는것을 방지
•  
• 책임 추적성(Accountability)
  who, when, where, why, how, what
  모든 transcation에 대해 기록하고 제공해야함
  행동들이 추적간능해야한다.
•  
• Information Security
  인가되지 않은 접근, 기록, 수정, 변조, 파괴 등으로부터 정보를 보호
  => 허가되지 않은 공격으로부터 정보를 보호
  (Destruction : 일부 삭제 or 교체)
•  
• Computer Security
  적대적인 환경으로부터 컴퓨터 시스템을 보호하는 것
  (계획된 사용은 허용, 불법적인 사용을 막음)
  컴퓨터 시스템 자신과 컴퓨터 시스템이 저장하거나 접근하는 데이터를 보호하는 것.
•  
• 컴퓨터 보안과 정보보안의 차이
  컴퓨터보안 : 디지털 형태로 된 데이터나 정보에 초점을 두고 보호, 디지털로 된 정보, 시스템, 네트워크 디지털을 다루는 시스템이나 네트워크를 보호하는 것
  정보보안 : 아날로그, 디지털 정보를 보호, 디지털로된 정보, 디지털로된 시스템 네트워크뿐만아니라 아날로그로 된 정보까지도 보호대상임

공격, 위협으로부터 보호

• 공통점 : 컴퓨터 시스템이나 네트워크를 보호,

• Software Security
  악의적인 공격하에서도 SW기능이 정상적으로 동작하도록 설계,개발, 테스팅하는 개념
  취약점을 차단하는것과 다름 => 취약점 : 보안상의 허점
  뚫리고 난 후 사후대책을 하는 것은 아님(reacting)안전한 SW를 개발하는 모든 것
  보안을 위해서 SW를 설계 구현 테스트하는 과정
  Pro-Active, 능동적인 접근 방식 : 미리 예방함 => SW를 구성할때 보안을 내재화(각 개발 단계마다, 만들때부터 보안 고려)

• Security engineering과 관련있음 => 모든 과정에 관련, 시스템 설계시 보안 측면에 초점을 둔 엔지니어링의 특별한 분야
  보안 요소 : 문제의 요소가 되는 것을 처리하는데 필요한 보안요소들 => 자연적인 재해, 악의적 공격 등

• SW에 의해서 유발되는 보안 위험을 이해하고 예방하고 보완하는 것임

• Microsoft Security Development Lifecycle
  보안에 관련된 설계 결함, 코딩 단계의 결함을 줄이는 것 => 취약점, 해커에 의해서 악용될 수 있는 취약점을 줄이는것
  (* 공격자가 방어자보다 유리함, 공격자는 취약한 점 하나만 찾으면 되지만 방어는 모든 취약점을 찾아서 막아야함)=> 취약점을 제거, 제거하지 못한다면 심각도를 줄임-Secure by Default
  공격에 문제가 없는 시스템을 만듦

• -Secure in Deployment and Communication
  배치, 설치, 통신시 안전하게 함

• -Secure by Design
  설계시부터 보안 고려

• 남아있는 취약점들의 심각도를 줄임

SDL은 SW 개발 주기에 보안에 관련된 점검과 대책을 추가함
전 과정에서 보안을 고려 + 보안 교육

• Software Security != Security Software
  Software Security => 어떤 sw를 개발/구현 할 때 모든 단계에서 보안을 내재화
  Security Software => SW로 개발된 보안 도구, 보안제품/서비스가 sw로 개발됨

• Types of Cybersecurity attacks
  -Phising
  범죄자가 희생자를 믿게만들고 범죄를 수행함(주로 링크 클릭)
  -Pharming
  정상사이트를 위조하여 가짜 사이트를 만듦
  -중간자 공격
  송신자가 보낸 내용을 가로채서 변조함, 네트워크 통신을 조작하여 통신 내용을 도청하거나 조작하는 공격기법
  -Drive by download attack
  희생자 모르게 어떤 악의적인 프로그램이 설치되게함(동의없이 다운 or 설치)
  -Malvertising
  인터넷 광고로 위장하여 악성코드를 설치함(광고를 보면 악성코드가 설치됨) malware + advertising
  -Rogue antiviurs
  백신 프로그램을 사칭하여 결제를 유도함

정리)
What is the difference between information security and computer
security?

=> information security : 어떤 형태의 정보든지에 상관없이 관련된것

computer security => 디지털 형태의 정보만 관심을 가짐

What is the difference between software security and security software?

software security => 개발 단계에서부터 보안을 신경써서 소프트웨어를 개발하는것

security software=> 악성코드를 탐지하는 소프트웨어

What is malvertising?

=>광고처럼 보이는 공격

What is rogue software?

=>악성코드가 있는것 처럼 속이고 결제를 요구하는 소프트웨어(가짜백신)

• Good Security Standards follow the 90/10 rule
  보안 문제의 10%는 기술적으로 해결가능하지만, 90%sms 사용자에게 달려있다. 보안 문제는 모든사람의 책임이라는 의미이다.
• Interruption,Interception, Modification, Fabrication Security threats 예시
  Interruption(가로막기) => TCP flood, Ping flood, DoS DDoS
  Interception(가로챔) => packet sniffing, key logging
  Modification(변조) => android 리패키징 공격, 임베디드 시스템의 펌웨어 변조
  Fabrication(위조, 가장함) => DNS Spoofing, Replay attack

암호알고리즘, 프로토콜, 접근제어는 소프트웨어로 구현이됨
따라서 소프트웨어가 만약에 문제가 생기면 보안취약점으로 연결이되어 보안사고를 유발함

• 데이터 기밀성을 보장하는 법?
  • 암호기법
    AES(대칭키), RSA(비대칭키)
  • 강한 접근제어사용
    Never access(중요데이터, 관리자가 아닌경우), No read, No view
  • 중요한 데이터가 임의의 장소에서 나타나지 않게 함
• 데이터 무결성을 보장하는 법?
  • documenting system activity
    로그로 남김
  • 강한 access control
    no write , no append or reald only
  • 암호학적 해쉬함수
    mac, sha-256, md5 => one-way 함수 (역으로 계산 불가) => 해쉬값으로 입력을 찾기 어려움
    출력값의 길이는 같음 => 고정된 길이 출력
    입력의 미세한 변경이 출력에 큰 변화를 끼침
• 가용성 보장?
  • anti-DDoS system
    Content Delivery Networks(CDNs)
    -> 컨텐츠를 효율적으로 전달하기 위해서 여러 노드를 가진 네트워크에 데이터를 저장하여 제공함
    인터넷 서비스 제공자에 직접연결되어 데이터를 전송하기 때문에 컨텐츠에 대한 병목을 줄일수 있음(분산저장)
    Scrubbing center (scrub => 불순물 제거)
    -> 네트워크 트래픽을 분석하여 악의적인 트래픽을 제거
  • 백업 절차를 잘 만듦
    데이터 삭제 공격을 막기 위해
• Security Threat
  • 회사나 개인의 자산을 임의로 노출시키거나 변조, 손상, 이용할 수 없게 하는 행동이나 방치해 두는 것
  • 보안 위협의 요소
  • target : 데이터, 정보, sw, hw ... (취약한 자산)
  • agent :의도를 가지고 위협유발 or 비의도적 위협유발을 하는 사람
  • event : 타겟의 취약점을 악용하는 행위 (정보 파괴, 변조, 오남용 등) => 악의적, 우연적
• 취약점
  계산 로직의 약점, 코드의 약점, 하드웨어 내의 로직 약점 => 악용시 기밀, 무결, 가용성에 영향을 미침
  약점이 발현되면 취약점임
• => 취약점이 제거되면 위협이 없어짐
• passive and active attack
• Passive attack => interception
  시스템 자원에 영향을 주지 않으므로 알아차리기 힘듬
  기밀성 깨짐

Active attack => 시스템 자원을 변경시킴 따라서 탐지하기 용이한 편
변조, 조작 => 무결성 가용성 깨짐

• Security Threat Model
  보안 운영을 계획하고 최적화 하는 방법 => 조직에서 위협들을 방어하기 위한 방법
  보안 위협(취약한 자산이 타겟)을 없애기 위해서 목적을 제시하고 방어계획을 설계해야함어떤 위협이 있는지, 취약한 자산은 무엇이 있는지 그 위혐들에 대해서 어떻게 우리가 대응할 것인지 이러한 것들을 전반적으로 생각하여 최적화 시키는 것임
  => 위협을 방어하기 위해서 사용할 수 있는 방식이나 수단
  • 위협
    멀웨어 => 바이러스, 스파이웨어, 애드워어
    제로데이 취약점 => 아직 패치가 나오지 않은 새로 발견된 취약점
    DDoS 공격
    Phising
  • 보안 위협 구성요소
    • 타겟
    • agent
    • event
• 조직이 균형잡힌 방어기법, 끊임없이 진화하느 ㄴ방어기법을 구축할 수 있게 도와줌

-해커들의 창은 기업 및 기관의 방패보다 항상 빠르게 진화하므로 피해를 최소화하기 위해서 모의훈련으로 대비를 해야한다. => 모의훈련 (공격자처럼 생각 = 예방을 잘 할 수 있고 취약점을 잘 찾을 수 있다.)

-방어보다 공격이 유리하다. => 방어는 보든 부분(서버, pc, 스마트폰, 네트워크..)을 방어해야하지만 

공격은 취약한 부분 하나만 있으면 된다. (취약점 : 공격에 악용될 수 있는 발판, 약점, 결함, 실수..)