Google"s Project Zero initiative tasks its security researchers with finding flaws in various software products developed by the company itself as well as other firms. Back in 2016, it revealed a serious vulnerability present in Windows 10, and reported a "crazy bad vulnerability" in Windows in 2017.
Now, the firm has disclosed another security flaw in Microsoft Edge, after the Redmond giant failed to fix it in the allotted time.
Back in February 2017, Microsoft stated that it would be using Arbitrary Code Guard (ACG) in Microsoft Edge with the Windows 10 Creators Update to mitigate arbitrary native code execution. Although most modern web browsers rely on Just-in-Time (JIT) compilers, this created complications with ACG, which forced Microsoft to transition the JIT functionality of Chakra into a separate process that runs in an isolated sandbox, which according to the company, was a difficult task to accomplish.
For those unaware, Microsoft"s JIT process is responsible for compiling JavaScript to native code, creating a shared map object, mapping it to the content process and reserving the memory. Then when pages need to be written to memory, it calls the VirtualAllocEx() function to allocate memory to it from the space it reserved in the content process, and commits it.
Now, the problem with this technique is that if the content process can predict the address on which the JIT process is going to call its VirtualAllocEx() function next - which can be done fairly easily, according to Google - and it is compromised, the content process can:
- Unmap the shared memory mapped above above using UnmapViewOfFile()
- Allocate a writable memory region on the same address JIT server is going to write and write a soon-to-be-executable payload there.
- When JIT process calls VirtualAllocEx(), even though the memory is already allocated, the call is going to succeed and the memory protection is going to be set to PAGE_EXECUTE_READ.
This is understandably a considerable security concern, and one which the Google security researcher has exploited, as detailed in his highly technical debug log which you can view here. In it, the researcher has successfully bypassed ACG and created an executable page in memory.
It is important to note that the bug has been classified as a "Medium" severity flaw and was disclosed to Microsoft by Google in November 2017. The standard 90-day-deadline was awarded to the company to fix the issue before it was disclosed to the public.
According to the Microsoft Security Response Center (MSRC), the problem turned out to be more complex than initially believed, due to which it was given an additional 14-day grace period by Google. Although the company missed this deadline in its February Patch Tuesday too - which forced Google to make the flaw public - Microsoft is confident that it will resolve the issue by March 13, aligning the shipment of the fix with the Patch Tuesday in March.
Update: Google has reached out to Neowin to clarify that the bug in Microsoft Edge cannot be exploited without taking advantage of another flaw first. The latest comment from Google"s security researcher is as follows:
This issue is a security mitigation bypass and cannot be exploited on its own. An attacker would first need to exploit a separate vulnerability to gain some capabilities in the Edge content process (such as the ability to read and write arbitrary memory locations), after which they could use this vulnerability to gain additional capabilities (namely, the ability to run arbitrary machine code).