http://www.jungol.co.kr/bbs/board.php?bo_table=pbank&wr_id=155&sca=1030
# include <stdio.h>
int main(void)
{
int v1, v2, v3;
char* sPrompt = "%d %d %d";
char* mPrompt = "sum : %d\navg : %d\n";
int sum_ = 0x0;
int div_ = 0x0;
__asm
{
// scanf("%d %d %d", &v1, &v2, &v3)
lea edi, dword ptr[v3];
push edi;
lea edi, dword ptr[v2];
push edi;
lea edi, dword ptr[v1];
push edi;
push dword ptr[sPrompt];
call dword ptr[scanf];
pop ebx;
pop ebx;
pop ebx;
pop ebx;
mov eax, dword ptr[v1];
add eax, dword ptr[v2];
add eax, dword ptr[v3];
mov dword ptr[sum_], eax;
xor edx, edx; // edx = 0
mov ebx, 0x3;
div ebx;
mov dword ptr[div_], eax;
push dword ptr[div_];
push dword ptr[sum_];
push dword ptr[mPrompt];
call dword ptr[printf];
pop ebx;
pop ebx;
pop ebx;
}
return 0;
}
'어셈블리' 카테고리의 다른 글
정올 어셈블 문제 - 배열관련 - 아직 완변하지 않음 (0) | 2018.06.14 |
---|---|
xor (0) | 2018.06.14 |
어셈블리 (push / pop) (0) | 2018.06.14 |
2018_05_30_키트리_침해대응 (0) | 2018.05.29 |
2018_05_30_01 (0) | 2018.05.29 |
정올 어셈블 문제 - 배열관련 - 아직 완변하지 않음
# include <stdio.h>
# define SIZE 10
int main(void)
{
char cData[SIZE] = { 0, };
char* Prompt = "%c ";
int temp = 0x0;
int indx = 0x0;
__asm
{
mov ecx, 0xa;
mov dword ptr[temp], ecx;
L:
// scanf("%c", cData + i);
mov dword ptr[temp], ecx;
mov ebx, dword ptr[indx];
lea edi, dword ptr[cData + ebx];
push edi;
push dword ptr[Prompt];
call dword ptr[scanf];
pop ebx;
pop ebx;
mov ebx, dword ptr[indx];
add ebx, 0x1;
mov dword ptr[indx], ebx;
//
mov ecx, dword ptr[temp];
loop L;
}
for (int i = 0; i < SIZE; i = i+2)
{
printf("%c", *(cData + i));
}
printf("\n");
}
'어셈블리' 카테고리의 다른 글
정올_문제_ (2) | 2018.06.22 |
---|---|
xor (0) | 2018.06.14 |
어셈블리 (push / pop) (0) | 2018.06.14 |
2018_05_30_키트리_침해대응 (0) | 2018.05.29 |
2018_05_30_01 (0) | 2018.05.29 |
// operator : xor : 배타적 논리의 합
# include <stdio.h>
int main(void)
{
unsigned int xorV = 0X0;
unsigned int v1 = 0x13; // 19 : 0001 0011
unsigned int v2 = 0x7; // 7 : 0000 0111
char* prompt = "xor => %d\n";
//-------------------------------
// 0001 0100 => 20
__asm
{
mov eax, dword ptr[v1]; // eax = v1
xor eax, dword ptr[v2]; // eax ^=v2
mov dword ptr[xorV], eax;
push dword ptr[xorV];
push dword ptr[prompt];
call dword ptr[printf];
pop ebx;
pop ebx;
}
}
'어셈블리' 카테고리의 다른 글
정올_문제_ (2) | 2018.06.22 |
---|---|
정올 어셈블 문제 - 배열관련 - 아직 완변하지 않음 (0) | 2018.06.14 |
어셈블리 (push / pop) (0) | 2018.06.14 |
2018_05_30_키트리_침해대응 (0) | 2018.05.29 |
2018_05_30_01 (0) | 2018.05.29 |
어셈블리 (push / pop)
# include <stdio.h>
int main(void)
{
__asm
{
push 10;
push 11;
push 12;
push 13;
push 14;
pop ebx;
pop ebx;
}
return 0;
}
'어셈블리' 카테고리의 다른 글
정올 어셈블 문제 - 배열관련 - 아직 완변하지 않음 (0) | 2018.06.14 |
---|---|
xor (0) | 2018.06.14 |
2018_05_30_키트리_침해대응 (0) | 2018.05.29 |
2018_05_30_01 (0) | 2018.05.29 |
오늘 공부한 내용 날림 나 혼자 보려고 끄적인 것 (0) | 2018.01.22 |
2018_05_30_키트리_침해대응
http://www.jungol.co.kr/bbs/board.php?bo_table=pbank&wr_id=215&sca=10b0
# include <stdio.h>
void GuGuDan(int param1, int param2);
int main(void) {
int minV = 0x0;
int maxV = 0x0;
char* sPrompt = "%d %d";
__asm {
LEA EDI, DWORD PTR[maxV];
PUSH EDI; // &maxV;
LEA EDI, DWORD PTR[minV];
PUSH EDI; // &minV;
PUSH DWORD PTR[sPrompt]; // "%d %d"
CALL DWORD PTR[scanf];
// FUNCTION parameter
PUSH DWORD PTR[maxV];
PUSH DWORD PTR[minV];
// sub function(GuGuDan) call
CALL DWORD PTR[GuGuDan];
// stack 정리
ADD ESP, 0x8
POP EBX;
POP EBX;
POP EBX;
}
return 0;
}
void GuGuDan(int param1, int param2) {
char* sData = "%d x %d = %d\n";
int Gu_ = 0x0;
int d1 = 0x1;
int r = 0xA;
//printf("param1 => %d\n", param1);
//printf("param2 => %d\n", param2);
__asm {
MOV ECX, 0xA;
L:
MOV EAX, dword ptr[param1]; // EAX = param1
MUL dword ptr[d1]; // EAX *= d1
PUSH EAX; // (EAX)
PUSH dword ptr[d1]; // (d1, EAX)
PUSH dword ptr[param1]; // (param1, d1, EAX)
PUSH dword ptr[sData]; // ("%d x %d = %d\n", param1, d1, EAX)
CALL dword ptr[printf];
// printf("%d x %d = %d\n", param1, d1, EAX)
ADD ESP, 0X10; // 스택 정리
// d1 increament
ADD dword ptr[d1], 0x1;
MOV EAX, dword ptr[r];
DEC EAX;
MOV dword ptr[r], EAX;
MOV ECX, dword ptr[r];
loop L;
}
Gu_ = 0x0;
d1 = 0x1;
r = 0xA;
__asm {
MOV ECX, 0xA;
L1:
MOV EAX, dword ptr[param2]; // EAX = param1
MUL dword ptr[d1]; // EAX *= d1
PUSH EAX; // (EAX)
PUSH dword ptr[d1]; // (d1, EAX)
PUSH dword ptr[param2]; // (param1, d1, EAX)
PUSH dword ptr[sData]; // ("%d x %d = %d\n", param1, d1, EAX)
CALL dword ptr[printf];
// printf("%d x %d = %d\n", param1, d1, EAX)
ADD ESP, 0X10; // 스택 정리
// d1 increament
ADD dword ptr[d1], 0x1;
MOV EAX, dword ptr[r];
DEC EAX;
MOV dword ptr[r], EAX;
MOV ECX, dword ptr[r];
loop L1;
}
} // end of GuGuDan function
'어셈블리' 카테고리의 다른 글
xor (0) | 2018.06.14 |
---|---|
어셈블리 (push / pop) (0) | 2018.06.14 |
2018_05_30_01 (0) | 2018.05.29 |
오늘 공부한 내용 날림 나 혼자 보려고 끄적인 것 (0) | 2018.01.22 |
네이버 풀이 (0) | 2017.12.22 |
2018_05_30_01
http://www.jungol.co.kr/bbs/board.php?bo_table=pbank&wr_id=193&sca=1090
# include <stdio.h>
int main(void) {
int numBer[] = { 1,2,3,4,5,6,7,8,9,10 };
int IndAddr = 0x0;
int TempEcx = 0x0;
char* sPrompt = "%d ";
__asm {
MOV ECX, 0XA;
Mov DWORD PTR[TempEcx], ECX;
L:
MOV EBX, IndAddr;
PUSH DWORD PTR[numBer + EBX];
PUSH DWORD PTR[sPrompt];
CALL DWORD PTR[printf];
POP EBX;
POP EBX;
MOV EAX, DWORD PTR[TempEcx];
DEC EAX;
MOV DWORD PTR[TempEcx], EAX;
MOV ECX, DWORD PTR[TempEcx];
MOV EBX, IndAddr;
ADD EBX, 0X4;
MOV DWORD PTR[IndAddr], EBX;
Loop L;
}
}
'어셈블리' 카테고리의 다른 글
어셈블리 (push / pop) (0) | 2018.06.14 |
---|---|
2018_05_30_키트리_침해대응 (0) | 2018.05.29 |
오늘 공부한 내용 날림 나 혼자 보려고 끄적인 것 (0) | 2018.01.22 |
네이버 풀이 (0) | 2017.12.22 |
어셈블리 cdq (3) | 2017.12.01 |
오늘 공부한 내용 날림 나 혼자 보려고 끄적인 것
(어셈블리 명령어 정리)
[ compiler ]
어셈블리어 -------> 어셈블러 --------> 기계어
0x01 어셈블리 언어란? & 배우는 목적
0x02 어셈블리를 위한 기본 지식
(1) 기본적인 하드웨어
(2) 80x86 프로세서
[+] CPU 레지스터 종류:
[->] 범용 레지스터 (General register)
[->] 상태 레지스터
[->] 플래그 레지스터
[+] 레지스터의 구조
[->] 데이터 레지스터 (data register)
: EAX[Accumulator], EBX[Base], ECX[Counter], EDX[Data]
[->] 포인터 레지스터 (pointer register)
: ESP (Stack pointer), EBP (Base pointer)
[->] 인덱스 레지스터 (index register)
: ESI (Source Index), EDI (Destination Index)
[->] 세그먼트 레지스터 (Segment register)
: CS, DS, SS, ES
[*] 범용레지스터
[->] RAX(64) - EAX(32) - AX(16) - AH(8) - AL(8) : 누산기 레지스터라 불리며, 곱셈이나 나눗셈 연산에 중요하게 사용
int v1 = 0x4;
00A616BE mov dword ptr [v1],4
int v2 = 0x10;
00A616C5 mov dword ptr [v2],10h
int v3 = 0x0;
00A616CC mov dword ptr [v3],0
v3 = v1 + v2;
00A616D3 mov eax,dword ptr [v1]
00A616D6 add eax,dword ptr [v2]
00A616D9 mov dword ptr [v3],eax
[->] RBX(64) - EBX(32) - BX(16) - BH(8) - BL(8) : 베이스 레지스터라 불리며 메모리 주소 지정시에 사용
[->] RCX(64) - ECX(32) - CX(16) - CH(8) - CL(8) : 계수기(Counter)레지스터라 불리며 Loop 등의 반복 명령에 사용
# include <stdio.h>
# include <stdlib.h>
int main(void) {
int v = 0x0;
__asm {
mov ecx, 0x10;
T:
inc v;
loop T;
leave;
retn;
}
}
[->] RDX(64) - EDX(32) - DX(16) - DH(8) - DL(8)
[->] ESI - SI
[->] EDI - DI
[->] ESP - SP
[->] EBP - BP
ESP [0019FEB8] = EBP [0019FF04]
주소 지정 방식의 이해
[+] 즉시 지정방식(Immediate addressing)
[+] 레지스터 지정방식(Register addressing)
[+] 직접 주소 지정방식(Directly addressing)
[+] 레지스터 간접 주소 지정 방식
[+] 베이스 상대 주소 지정 방식
어셈블리어 명령어 정리
[+] push : stack에 데이터를 적재 시킬 경우
[+] pop : stack에 데이터를 제거 시킬 경우
# include <stdio.h>
int main(void)
{
__asm {
push 0x10;
push 0x11;
push 0x12;
push 0x13;
pop ebx;
pop ebx;
pop ebx;
pop ebx;
}
return 0;
}
ebp = 0019FF04
esp = 0019FEB8
[+] push ____________________
esp = 0019FEB4 => 0x10
esp = 0019FEB0 => 0x11
esp = 0019FEAC => 0x12
esp = 0019FEA8 => 0x13
-----------------------------
[-] pop ____________________
esp = 0019FEAC => 00000013
esp = 0019FEB0 => 00000012
esp = 0019FEB4 => 00000011
esp = 0019FEB8 => 00000010
-----------------------------
[+] mov
[+] lea
[+] inc
__asm {
mov eax, 0x11;
inc eax;
}
[+] dec
__asm {
mov eax, 0x10;
dec eax;
}
[+] add
# include <stdio.h>
int main(void) {
__asm mov eax, 0x10;
__asm add eax, 0x11;
return 0;
}
[+] sub
[+] call => 프로시져 호출
# include <stdio.h>
void f(int param1, int param2);
int main(void) {
__asm {
push 0xb; // param2 <= 0xb
push 0xa; // param1 <= 0xa
call dword ptr[f];
pop ebx;
pop ebx;
leave;
retn;
}
} // end of main function
void f(int param1, int param2) {
char* p = "param1 => %d, param2 => %d\n";
__asm {
mov eax, dword ptr[ebp + 0x8];
mov ebx, dword ptr[ebp + 0xc];
push ebx;
push eax;
push p;
call dword ptr[printf];
pop ebx;
pop ebx;
pop ebx;
leave;
retn;
}
} // end of f function
[+] cmp
# include <stdio.h>
int main(void) {
int result = 0;
_asm {
mov eax, 0x10;
cmp eax, 0x10;
je equal_;
equal_:
mov eax, 0x10;
mov result, eax;
jmp END;
END:
leave;
retn;
}
}
[+] jmp => 특정한 곳으로 분기
*참고
je : jump equal
jne : jump not equal
jz : jump zero
jnz : jump not zero
ja : jump above
jae : jump above or equal
jna : jump not above - 크지 않을 때 점프
jnae : jump not above or equal
jb : jump below - cmp a, b 에서 a가 작을 때 점프
# include <stdio.h>
int main(void) {
int v1 = 0x10;
int v2 = 0x9;
int result = 0;
char* r = "result => %d\n";
_asm {
mov eax, dword ptr[v1];
cmp eax, v2;
jb jump_below;
jae jump_above_or_equal;
jump_below:
mov ebx, 10;
mov result, ebx;
jmp TheEnd;
jump_above_or_equal:
mov ebx, 11;
mov result, ebx;
jmp TheEnd;
TheEnd:
push result;
push r;
call dword ptr[printf];
pop ebx;
pop ebx;
}
return 0;
} // end of main function
'어셈블리' 카테고리의 다른 글
2018_05_30_키트리_침해대응 (0) | 2018.05.29 |
---|---|
2018_05_30_01 (0) | 2018.05.29 |
네이버 풀이 (0) | 2017.12.22 |
어셈블리 cdq (3) | 2017.12.01 |
랜덤 어셈블리 (0) | 2017.12.01 |
http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=1040101&docId=290822985
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
char* f_stc(char* param1, char* param2);
int main(void) {
char str1[50] = { 0, }; // 초기화
char str2[50] = { 0, }; // 초기화
// str_1 value input
printf("input string_1 : ");
fgets(str1, 50, stdin);
str1[strlen(str1) - 1] = '\0';
//printf("test %#x %c\n", &str1[strlen(str1) - 1], str1[strlen(str1) - 1]);
// str_2 value input
printf("input string_2 : ");
fgets(str2, 50, stdin);
str2[strlen(str2) - 1] = '\0';
f_stc(str1, str2);
return 0;
}
char* f_stc(char* param1, char* param2) {
char* pValue = NULL;
char* sprompt = "%s\n";
__asm {
MOV ESI, dword ptr[param2];
PUSH ESI; // ESI 값 보존 ------ (1)
MOV EDI, param1; // EDI = addr
MOV EAX, param1;
PUSH EAX;
CALL dword ptr[strlen]; // strlen(EAX)
MOV ECX, EAX;
POP EBX;
PUSH ECX; // ECX 값 보존 ------ (2)
L1:
ADD EDI, 0x1;
CMP byte ptr[EDI], 0x0;
JNE L1; // Jump Not Equal
//DEC EDI;
//MOV pValue, EDI;
PUSH EDI; // EDI 값 보전 ------ (3)
POP EDI; // -------------------(3)
POP ECX; // -------------------(2)
POP ESI; // -------------------(1)
REP MOVS byte ptr[EDI], byte ptr[ESI];
MOV byte ptr[EDI], 0x0;
}
printf("result => %s\n", param1);
} //
'어셈블리' 카테고리의 다른 글
2018_05_30_01 (0) | 2018.05.29 |
---|---|
오늘 공부한 내용 날림 나 혼자 보려고 끄적인 것 (0) | 2018.01.22 |
어셈블리 cdq (3) | 2017.12.01 |
랜덤 어셈블리 (0) | 2017.12.01 |
네이버 (0) | 2017.11.20 |
음 ... cdq 가 뭔지 궁금했다. 그래서 디버깅 해서 어떻게 동작하는지 눈으로 확인했다.
# include <stdio.h>
int main(void) {
__asm {
cdq;
mov eax, 0x10;
mov ebx, 0x3;
div ebx;
leave;
retn;
}
}
----------------------------------------------------
step .1
EAX = 0F842730 EBX = 00212000 ECX = 00000001 EDX = 00417558 ESI = 00411041 EDI = 00411041 EIP = 00411519 ESP = 0019FEB8 EBP = 0019FF04 EFL = 00000202
----------------------------------------------------
step .2 [cdq;] 라인이 실행되고 난 후
EAX = 0F842730 EBX = 00212000 ECX = 00000001 EDX = 00000000 ESI = 00411041 EDI = 00411041 EIP = 0041151A ESP = 0019FEB8 EBP = 0019FF04 EFL = 00000202
EDX 레지스터의 값이 0x0 로 초기화 됬다.
----------------------------------------------------
//--------------------------------------
# include <stdio.h>
# include <Windows.h>
# include <stdlib.h>
# include <time.h>
//--------------------------------------
void __init__(PVOID ptrValue);
void __RandomChoice__(PVOID ptrValue);
int main(void) {
__int32 number[50] = { 0, };
__asm LEA EDI, dword ptr[number];
__asm PUSH EDI;
__asm CALL dword ptr[__init__];
__asm POP ebx;
__asm CALL dword ptr[__RandomChoice__];
//TEST
/*
for (int i = 0; i < 50; i++) {
printf("%d ", number[i]);
}
*/
return 0;
} // end of main function
void __init__(PVOID ptrValue) {
int t_value = 0x1;
__asm {
MOV ECX, 50; // ecx = 50
// --------------------------------------------
MOV EBX, 0x0;
L: // COUNT
PUSH ECX; // 1
PUSH EBX; // 2
MOV EAX, dword ptr[t_value];
MOV EDI, dword ptr[EBP + 0x8];
POP EBX; // 1
MOV dword ptr[EDI + EBX], EAX;
ADD EBX, 0x4; // ebx += 0x4
PUSH EBX; // 2
INC EAX;
MOV dword ptr[t_value], EAX;
pop EBX;
POP ECX;
Loop L;
}
} // end of __init__ function
void __RandomChoice__(PVOID ptrValue) {
//srand((unsigned)time(NULL));
// rand()%10
__int32 x = 0x0;
char *str_value = "result is %d\n";
__asm {
//-------------------------------
push 0;
call dword ptr[time];
pop ebx;
//-------------------------------
push eax;
call dword ptr[srand];
pop ebx;
//-------------------------------
call dword ptr[rand];
mov ebx, 0Ah;
xor edx, edx;
idiv ebx;
add edx, 1;
mov dword ptr[x], edx;
//-------------------------------
push dword ptr[x];
push dword ptr[str_value];
call dword ptr[printf];
pop ebx;
pop ebx;
leave;
retn;
}
} // end of __RandomChoice__ function