이더리움 지갑 ‘마이이더월렛(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로 변환시 언더플로우발생으로 매우 큰수가 된다.)

컴퓨터를 사용하다 갑자기 마우스와 키보드의 불이 나가면서 인식이 되질 않았다.

메인보드가 애즈락이라 그저 애ㅡ자락 한줄 알고 급하게 여러 포트를 테스트 해보았고 usb 3.0포트는 멀쩡하였다.

그래서 hoxy...하고 장치관리자에 들어가 포트를 보니 드라이버 오류가 있었다. 

AMD USB 3.10 확장 가능한 호스트 컨트롤러가 문제가 생겨있었다.

따라서 윈도 업데이트를 통하여 드라이버 업데이트를 하니 다행히 모든 포트가 인식이 된다.

(애ㅡ자락이라 드라이버 오류가 난것인가.. 윈도우 오류인가...)

* 부호버그

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

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

예시)

#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가 된다.

* CVS

반점을 구분한 값이라는 뜻

파일의 내용은 데이터가 , 으로 구분된 형식의 문자만으로 이루어져있다.

EX) 

1, A, 55

2, B, 26

3, C, 79

와 같이 데이터는 반점으로 구분되고 한행이 끝날때마다 줄바꿈을 한다.

* 파일 가져오기(LOAD DATA INFILE)

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

외부 파일을 읽기 위해선 시스템변수 변수를 변경해야한다.

SHOW variables LIKE 'local%';

SET GLOBAL loval_infile = 1;

"The MySQL server is running with the --secure-file-priv option so it cannot execute this statement"가 뜰 경우

sssunho.tistory.com/56

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

LOAD DATA INFILE 파일이름 INTO TABLE 테이블이름 옵션설정;

CVS외의 텍스트 파일도 읽을 수 있으며, 데이터간의 구분문자와 줄바꿈문자, ~~행부터 읽기 실행 등 읽어들일 데이터의 형식을 지정할 수 있다.

FILEDS TERMINATED BY 구분문자 =>기본설정은 \t (탭)

LINES TERMINATED BY 줄바꿈문자 => 기본설정 \n (줄바꿈)

IGNORE 처음에_건너뛸_행 LINES => 기본설정은 0

EX)

LOAD DATA INFILE 'C:\test.csv' INTO TABLE tb1N FIELDS

TERMINATED BY ',';

tb1N 테이블에 레코드가 추가됨

* 데이터를 텍스트 파일에 내보내기 (export)

내보낸 파일은 다른 데이터베이스나 시스템에서 사용하거나 백업용으로 사용한다.

SELECT * INTO OUTFILE '파일이름' 옵션설정 FROM 테이블 이름;

옵션 설정은 내보내기할 텍스트 파일의 형식을 지정한다.

ex)

SELECT * INTO OUTFILE 'C:\datat\out.csv' FIELDS TERMINAGETD BY ',' FROM tb1;

* 데이터베이스 백업/복원

-백업

dump : 데이터베이스의 모든 내용을 추출함

mysqldump 명령을 사용한다.

덤프로 출력된 정보는 일반 sql문으로 되어있는 텍스트이며, 데이터베이스의 모든 정보를 가져올 수 있다.

mysqldump -u 사용자이름 -p비밀번호 데이터베이스이름 > 출력파일이름

ex)

mysqldump -u root -p1234 db1 > db1_out.txt

-복원

mysqladmin -u 사용자이름 -p비밀번호 데이터베이스이름 < 백업파일이름

ex)

mysqladmin -u root -p1234 db2 < db1_out.txt

* 저장엔진 

  접속기능, SQL문의 내용을 사전에 조사하는 기능 => 상위부분

  상위 부분의 지시를 받아 실제로 검색이나 파일을 조작하는 기능 => 하위 부분 = 저장엔진

  테이블 별로 저장엔진을 지정할 수 있다.

 - 저장엔진확인법

  SHOW CREATE TABLE 테이블이름;

 ENGINE=InnoDB 임을 알 수 있다.

  - 저장엔진 변경

    ALTER TABLE 테이블 이름 ENGINE=엔진이름;

* 트랜젝션

A의 계좌에서 B의 계좌로 10만원을 송금

1. A의 계좌에서 10만원 뺌

2. B의 계좌에 10만원 넣음

만약 1번 시점에 오류가 발생하면, 2번이 실행되지 않고 

A의 계좌에서 10만원만 빠지고 그 돈은 사라질 것이다.

따라서 1,2번을 묶어서 하나로 처리한다. 

위와 같이 여러 단계의 처리를 하나의 처리처럼 다루는 것이 트랜젝션이다.

트랜젝션의 실행결과를 데이터베이스에 반영하는 것이 Commit이며 

반영시키지않고 되돌리는 것을 RollBack이라 한다.

 - 트랜젝션 시작

  START TRANSACTION이나 BEGIN, BEGIN WORK

트랜젝션을 시작하고 tb테이블을 삭제하였다.

이 시점에 테이블의 일부기능에 lock이 걸린다. 

따라서 다른 세션에서 INSERT 등의 명령을 실행할 수 없다.

트랜젝션을 시작한 콘솔창에서 COMMIT이나 ROLLBACK을 해야 다른 명령을 실행 할 수 있다.

ROLLBACK을 하면 삭제된 테이블이 다시 복구되는 것을 알 수 있다.

- 자동 커밋 기능

 일반적으로 MYSQL에서 명령을 실행하면 그대로 반영된다.

 명령을 실행하면 그대로 반영되는 기능이 자동 커밋기능이다.

 자동 커밋 기능의 기본 설정은 ON이다.

 자동 커밋 기능을 끄려면

 SET AUTOCOMMIT=0;

 으로 하면 된다.

 자동 커밋 기능을 끄면 ROLLBACK을 사용할 수 있다.

 SET AUTOCOMMIT=1;

을 하면 다시 자동커밋 기능을 켤 수 있다.

자동커밋 기능이 설정되어있는지 확인하려면

SELECT @@AUTOCOMMIT;

을 하면 된다.

0이면 OFF, 1이면 ON

트랜젝션을 COMMIT하지 않고 콘솔창을 닫을 경우엔 

트렌젝션을 시작하고 입력한 명령들은 취소된다.

즉, 커밋을 하지 않고 종료하면 그 내용은 파기된다.

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

• 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, 스마트폰, 네트워크..)을 방어해야하지만 

공격은 취약한 부분 하나만 있으면 된다. (취약점 : 공격에 악용될 수 있는 발판, 약점, 결함, 실수..)