20131002 어셈블리 -서준영

Context.c





#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MAX_PROGRAM_SIZE  0x10000    // 64kB
#define SECTION_SIZE    512
#define MAX_HEXA    160

typedef struct _context
{
  int efl;
  int eip;
  int edi;
  int esi;
  int ebp;
  int esp;
  int ebx;
  int edx;
  int ecx;
  int eax;

} Context;

typedef struct _CMDMAP
{
  void *vpCmd;
  void (*Fp)(void);    // 함수 포인터  
} CMDMAP;

static unsigned char Mem[MAX_PROGRAM_SIZE*2];
static unsigned char *Mem_End;
static unsigned char *Code;
static unsigned char *Stack;
static unsigned char *Data;
static unsigned char Load_Flag;
static unsigned char Display_Flag;

static int           File_DS;          
static Context       stat_old;          

void code_view(void);
void data_view(void);
void stack_view(void);
void help_view(void);
void load(void);
void Clear_mem(void);
void go(void);
void Cmd_printReg(void);

void hexaview(unsigned char *RData, unsigned int iSize);
void Print_reg(Context *stpReg);
void STST(Context *);    // multi tasking register value STORE
void LDST(Context *);    // multi tasking register value LOAD
unsigned char MD(int);
void MM(int, char);

CMDMAP stCmdList[] = {
      {"DATA"  , data_view},
      {"HELP"  , help_view},
      {"CODE"  , code_view},
      {"STACK", stack_view},
      {"LOAD", load},
      {"MC", Clear_mem},
      {"GO", go},
      {"R", Cmd_printReg},
      {0, 0}
                     };

Context stOldReg;

int main(void)
{
  unsigned char ucaCmd[255];
  int iRet;
  CMDMAP *stpCMD;
  
  Mem_End = Mem + sizeof(Mem);
  Code = (unsigned char *)((unsigned int)(Mem+MAX_PROGRAM_SIZE) & 0xFFFF0000);
  Data = Code + 0x2000;
  Stack = Code + MAX_PROGRAM_SIZE;

  printf("Loading.......\n");
  printf("Code Start Addr : 0x%08X\n", Code);
  printf("Data Start Addr : 0x%08X\n", Data);
  printf("Stack Start Addr: 0x%08X\n", Stack);

  STST(&stOldReg);
  Print_reg(&stOldReg);

  while(1)
  {
    fflush(stdin);
    putchar('>');
    putchar(' ');
    iRet=read(0, ucaCmd, sizeof(ucaCmd));
    ucaCmd[iRet-1]=0;
    strupr(ucaCmd);

    if(0 == strcmp(ucaCmd, "Q"))
    {
      break;
    }

    stpCMD = stCmdList;

    while(1)
    {
      if(0 == stpCMD->Fp)
      {
        printf("그런 명령은 없습니다.\n\n");
        help_view();
        break;
      }

      if(0 == strcmp(ucaCmd, stpCMD->vpCmd))
      {
        (stpCMD->Fp)();
        break;  
      }
      ++stpCMD;
    }
  }
  
  return 0;
}

void help_view(void)
{
  printf("메모리 디버거 명령어\n");
  printf("R         : Register Value Display\n");
  printf("P         : Memory Status Display\n");
  printf("MC        : Memory Clear\n");
  printf("MM        : Memory Modify\n");
  printf("MD        : Memory Display\n");
  printf("LOAD      : Program Load\n");
  printf("GO        : Loaded Program Execute\n");
  printf("CODE      : Code Area Display\n");
  printf("DATA      : Data Area Display\n");
  printf("STACK     : Stack Area Display\n");
  printf("HELP      : Help Message Display\n");
  printf("QUIT(Q)   : Exit Program\n");

}

void Print_reg(Context *stpReg)
{
  printf("EAX      VALUE : 0x%08X\tECX      VALUE : 0x%08X\n", stpReg->eax, stpReg->ecx);
  printf("EDX      VALUE : 0x%08X\tEBX      VALUE : 0x%08X\n", stpReg->edx, stpReg->ebx);
  printf("ESP ADDR VALUE : 0x%08X\tEBP ADDR VALUE : 0x%08X\n", stpReg->esp, stpReg->ebp);
  printf("ESI ADDR VALUE : 0x%08X\tEDI ADDR VALUE : 0x%08X\n", stpReg->esi, stpReg->edi);
  printf("EIP ADDR VALUE : 0x%08X\tEFL ADDR VALUE : 0x%08X\n\n", stpReg->eip, stpReg->efl);
}

void hexaview(unsigned char *RData, unsigned int iSize)
{
  unsigned char *ucP = RData;
  int iCnt;
  int iLoop;
  int iBytes = iSize;
  int prtCnt = 0;
  int iMax = 16;

  printf("-------------------------------------"
   "------------------------------------\n");
  printf("ADDRESS \t\t  HEXA\t\t\t               ASCII\n");
  printf("\n\t ");
  for (iCnt = 0; iCnt < 16; iCnt++)
    printf("%02X ", iCnt);
  putchar('\n');
  printf("-------------------------------------"
   "------------------------------------\n");
  
  if(0 == iSize%16)
    iSize = iSize/16;
  else
    iSize = (iSize/16) + 1;
    
  for (iLoop = 0; iLoop < iSize; iLoop++)
  {
    // 주소출력
    printf("%08X ", ucP+iCnt);
    
    // 16진수 출력
    for (iCnt = 0; iCnt < 16; iCnt++)
    {
      if (iBytes == prtCnt)
      {
        printf("   ");
      }
      else
      {
        printf("%02X ", MD((int)(ucP + iCnt)));
        prtCnt++;
      }
    }
    
    // 호출시 입력한 바이트 수만큼 출력했을 경우 아스키 문자도 출력제한
    if (iBytes == prtCnt)
    {
      iMax = iBytes%16;
    }

    // 아스키코드 출력
    for (iCnt = 0; iCnt < iMax; iCnt++)
    {
      if (0 == *(ucP+iCnt))
      {
        printf(".");
      }
      else if (32 > *(ucP+iCnt))
      {
        printf(".");
      }
      else if (127 < *(ucP+iCnt))
      {
        printf(".");
      }
      else
        printf("%c", MD((int)ucP + iCnt));
      
    }
    
    putchar('\n');
    ucP = ucP + iCnt;
  }
}

void code_view(void)
{  
  printf("\n-------------------------------------------------------------------------\n");
  printf("                      CODE  AREA  \n");
  hexaview(Code, MAX_HEXA);

  return ;
}
void data_view(void)
{
  printf("\n-------------------------------------------------------------------------\n");
  printf("                      DATA  AREA  \n");
  hexaview(Data, MAX_HEXA);

  return ;
}
void stack_view(void)
{
  printf("\n-------------------------------------------------------------------------\n");
  printf("                      STACK  AREA  \n");
  hexaview(Stack-159, MAX_HEXA);                      // 스택이 밑에서 부터 쌓이므로 스택에서 일정한 값을 빼준다 

  return ;
}

void Clear_mem()
{
  printf("메모리 초기화 됨\n");  

  memset(Code, 0x00, MAX_HEXA);
  memset(Data, 0x00, MAX_HEXA);
  memset(Stack, 0x00, MAX_HEXA);


  return;
}
/*
void Clear_mem()
{
  unsigned int uiCnt;

  for(uiCnt=0;uiCnt<(Mem_End-Code);++uiCnt)
  {
    MM((int)Code+uiCnt, 0x00);
  }
  Load_Flag=0;
}
*/

void load()
{
  int Fd;
  int Read_Num;
  int Header_Size;
  int iRet;

  int Total_Read = 0;
  unsigned char File_Name[255];

  IMAGE_DOS_HEADER *dhp;
  IMAGE_NT_HEADERS *php;
  IMAGE_FILE_HEADER *fhp;
  IMAGE_OPTIONAL_HEADER32 *ohp;

  printf("\n읽어 들일 파일 이름을 입력하시오: ");
  fflush(stdin);

  iRet = read(0, File_Name, 31);
  File_Name[iRet-1] = 0;

  Fd = open(File_Name, O_RDONLY|O_BINARY);  

  if(0>Fd)
  {
    printf("open error\n");
    return ;
  }
  else
  {
    Clear_mem();
  }

  File_DS = open(File_Name, O_RDONLY|O_BINARY);

  if(0>File_DS)
  {
    printf("파일을 찾을수 없거나 읽을 수 없습니다.\n");
    printf("파일이 존재하는지 확인해 주세요.\n");
    printf("(경로명 사이에 '\'를 '\\'로 바꾸어 보십시오)\n");
    return ;
  }
  else
  {
    Read_Num = read(File_DS, Code, MAX_PROGRAM_SIZE);
  }

  if(0>Read_Num)
  {
    printf("파일이 존재하지만 읽을 수 없습니다.\n");
    close(File_DS);
    return ;
  }
  else
  {
    dhp = (IMAGE_DOS_HEADER *)Code;
    php = (IMAGE_NT_HEADERS *)(Code + (dhp->e_lfanew));
    fhp = (IMAGE_FILE_HEADER *)((char *)php + sizeof(php->Signature));
    ohp = (IMAGE_OPTIONAL_HEADER32 *)((char *)fhp + sizeof(IMAGE_FILE_HEADER));
    Header_Size = ohp->SizeOfHeaders;
    Clear_mem();
  }

  if(0>lseek(File_DS, Header_Size, SEEK_SET))
  {
    printf("파일의 헤더정보 skip 실패\n");
    printf("파일을 적재할 수 없다.\n");
    close(File_DS);
    return ;
  }
  else
  {
    Read_Num = read(File_DS, Code, SECTION_SIZE);
  }

  if(0>Read_Num)
  {
    printf("파일이 존재하지만 읽을 수 없다\n");
    close(File_DS);
    return ;
  }
  else
  {
    Total_Read = Total_Read + Read_Num;
        Read_Num = read(File_DS, Data, SECTION_SIZE);
  }

  close(File_DS);

  if(0>Read_Num)
  {
    printf("파일이 존재하지만 읽을 수 없습니다\n");
    return ;
  }
  else
  {
    Total_Read = Total_Read + Read_Num;
       File_DS = 0;
        Load_Flag = 1;
        printf("파일을 성공적으로 메모리에 적재하였습니다.\n");
        printf("읽어 들인 파일의 크기는 [%d]Bytes입니다.\n\n", Total_Read);
  }

  return ;
}

void go()
{
  Context stNewReg={0, };

  stNewReg.eax=(int)&stOldReg;
  stNewReg.eip=(int)Code;
  stNewReg.esp=(int)(Stack);

  if(1==Load_Flag)
  {
    LDST(&stNewReg);
    printf("Kernel Panic\n");
  }
  else
  {
    printf("외부 프로그램이 적재되어 있지 않다.\n");
    printf("load 명령을 사용하여 프로그램을 적재 시켜\n");
    return;
  }




  return;
}

void Cmd_printReg()
{
  Context *stpReg = 0;

  STST(&stOldReg);
  
  Print_reg(&stOldReg);

  return;
}





ttt.c




char flstz[] = "1111222233334444";
int sum=0x78563412;

test ()
{
  int i;
  int j= 0x12345678;  
  sum = 0x12345678;
  for (i = 0; i < sizeof(flstz)-1; i++)
  {
    flstz[i] = 'a';
  }
}




실행 하고 load, go를 한 후....

code영역과 data영역

Stack 영역