Slashdot Mirror


Nvidia Blames Apple For Bug That Exposes Browsing In Chrome's Incognito (venturebeat.com)

An anonymous reader points out this story at VentureBeat about a bug in Chrome's incognito mode that might be a cause for concern for some Apple users. From the story: "If you use Google Chrome's incognito mode to hide what you browse (ahem, porn), this might pique your interest. University of Toronto engineering student Evan Andersen discovered a bug that affects Nvidia graphics cards, exposing content that you thought would be for your eyes only. And because this only happens on Macs, Nvidia is pointing the finger at Apple."

165 comments

  1. You're doing it wrong by xxxJonBoyxxx · · Score: 3, Funny

    >> I didn’t expect the pornography I had been looking at hours previously to be splashed on the screen

    I think you're either doing it wrong or you're not looking at the right stuff. (Hours? Really?)

    1. Re:You're doing it wrong by WarJolt · · Score: 5, Funny

      >> I didn’t expect the pornography I had been looking at hours previously to be splashed on the screen

      I think you're either doing it wrong or you're not looking at the right stuff. (Hours? Really?)

      Not everyone's a minute man, Johnny Boy.

    2. Re:You're doing it wrong by rsborg · · Score: 3

      >> I didn’t expect the pornography I had been looking at hours previously to be splashed on the screen

      I think you're either doing it wrong or you're not looking at the right stuff. (Hours? Really?)

      "Hours previously" could simply mean "last night" (~8 hrs ago when you wake up).

      --
      Make sure everyone's vote counts: Verified Voting
    3. Re:You're doing it wrong by Anonymous Coward · · Score: 0

      I don't get what you're saying... He said that he didn't expect that stuff he looked at hours ago would appear on his screen out of nowhere. He didn't say he was looking at it for hours.

  2. It's your own fault Apple by Anonymous Coward · · Score: 2, Insightful

    You insist on having your own slow ass OpenGL implementation for our cards, I guess you fucked up on security too.

    1. Re:It's your own fault Apple by Anonymous Coward · · Score: 2, Informative

      You insist on having your own slow ass OpenGL implementation for our cards, I guess you fucked up on security too.

      Patches from your proprietary GL implementation donated to the OpenGL Open Source project welcome, nVidia... don't bitch that it's slow when you're able to fix the slow yourselves.

    2. Re:It's your own fault Apple by Anonymous Coward · · Score: 3, Insightful

      You insist on having your own slow ass OpenGL implementation for our cards, I guess you fucked up on security too.

      Patches from your proprietary GL implementation donated to the OpenGL Open Source project welcome, nVidia... don't bitch that it's slow when you're able to fix the slow yourselves.

      You don't understand. *Apple* insists on having their own OpenGL implementation for GPUs they use (so they have identical GL api support on intel, amd and nvidia). They don't use Nvidia proprietary driver code, nor Open Source code, and since they don't care about performance (because of metal), their implementation is slow-ass...

      Now get off my lawn ;^)

    3. Re: It's your own fault Apple by Anonymous Coward · · Score: 5, Interesting

      IOS saves screenshots of the applications for the task selector thingy and also for "fast" application switching where the screenshot is used for the zooming effect and as placeholder while the real application is still being (re)loaded. There is a separate screenshot for each orientation. It is possible that you launch or switch to the the browser or some other application and IOS will display a possibly very old screenshot of your private porn browsing session or some other private stuff that you had closed and purged from the logs ages ago. During the application switch effect the old screenshot is visible only momentarily but the same images can also be viewed from the task selector.

      1. Device at orientation A: open browser, enter private mode and browse for some pron.
      2. Switch to the home screen (screenshot it saved) and change to orientation B
      3. Go back to browser and close all pron tabs
      4. Switch to the home screen (screenshot is saved but this one is for orientation B)
      5. Change back to orientation A and enter the task selector or go back to the application. The old private browsing screenshot should be visible.

    4. Re: It's your own fault Apple by Anonymous Coward · · Score: 0

      No, whats actually happening is data isnt getting cleared from memory, not screenshots.

    5. Re:It's your own fault Apple by Anonymous Coward · · Score: 0

      > You don't understand. *Apple* insists on having their own OpenGL implementation for GPUs they use (so they have identical GL api support on intel, amd and nvidia). They don't use Nvidia proprietary driver code, nor Open Source code, and since they don't care about performance (because of metal), their implementation is slow-ass...

      Does it make a difference?

      I usually avoid Nvidia these days because I've been burned (perfectly working old card no longer supported in Nvidia drivers). If Apple wants to do it by themselves, at least you have one less degree of secrecy -- though open like F/OSS it certainly isn't.

      We keep talking about that and being labeled as fanatics. OK, suit yourselves... but those who buy Apple, don't come crying: you chose the golden jail yourselves. Anytime you choose a platform because it's dominant, because it's faster, because it suits your use habits, because free solutions still have to evolve etc. you're putting a collar on your neck and putting a mass-produced stamp on yourself which says "Be different!" (how idiotic is this? IIRC, even Jobs was initially against it, because it's wrong on so many levels).

      BTW, in a related issue:

      Don't fight against things like DRM (*). OK, it's your choice. But then, don't complain when they take the content from you, like Amazon did.

      (*) Fighting is simple: buy non-DRM content only. It's not "important content" for them, it's a milking cow. If we don't buy they'll lose interest on it and sell it. Then maybe we can get it from a less tyrannic provider.

    6. Re: It's your own fault Apple by TheRaven64 · · Score: 4, Interesting

      The question is where the image is leaking from. It's either from the copy owned Chrome itself, or from the copy owned by the window server. Apple's window server keeps a copy of the frame buffer to allow the system to kill the underlying application (if it advertises support for sudden termination) and have it resurrect in the same state without the user being aware. This is part of the mechanism on Darwin for handling low-memory situations: an application that has no unsaved state is killed and is then restarted when the user attempts to interact with it. This copy of the window contents may last for longer than the attached application (I don't know what the policy is for garbage collecting them).

      --
      I am TheRaven on Soylent News
    7. Re: It's your own fault Apple by Anonymous Coward · · Score: 0

      Use of uninitialized buffers and such can cause similar problems but it is separate consern from the snapshotting which is a feature.

    8. Re:It's your own fault Apple by ChunderDownunder · · Score: 1

      Apple are welcome to base their drivers around Nouveau and Mesa. :)

    9. Re: It's your own fault Apple by Anonymous Coward · · Score: 0

      I guess the problem comes from the fram buffer itself - not from application-owned memory. Memory that is freed up does not go away - it still exists on the GPU card. Where it retains whatever it was used for - until overwritten. The GPU driver has functions for zeroing such memory, but OSX is not using it. Whenever an app deallocates memory (or is killed) its gpu memory ought to be zeroed before it can be handed out to something else. (Main memory is already treated this way, so you can't write a program that allocates memory and search it for passwords entered into earlier programs.)

      This is not merely about having embarassing porn exposed - someone may use a mac for top secret work, close the application, and hand it over to someone with lower clearance.

    10. Re: It's your own fault Apple by thoromyr · · Score: 1

      I take it you've never worked with secured material or systems. What you suggest would be an extreme violation of rules. If the system is cleared for TS then it is never to be provided to someone with a lower clearance. Heck, only dealing with secret requires special handling. For example, secret must be protected in a safe. At least some years ago the common practice was to use removable hard drives -- office is secured during work, and at the end of the day all of the hard drives were secured in the safe.

      The idea that you can simply "close the application" and hand over a system approved for TS to someone without a TS clearance is absurd in the extreme.

    11. Re: It's your own fault Apple by John+Bokma · · Score: 1

      I've tried this twice and it doesn't work. iOS 9.2, Chrome. This used to be an issue in 7, maybe 8? Even without the rotation.

    12. Re:It's your own fault Apple by tepples · · Score: 1

      Fighting is simple: buy non-DRM content only.

      Which feature films are non-DRM? And do they cover a wide variety of genres?

    13. Re: It's your own fault Apple by suutar · · Score: 1

      Depends on the system. Some systems are specifically designed to handle multiple levels of material and control access based on the authorizations of the logged in user. The code has been modified to tag all information in the system with its security level and prevent data transfer from a high security window to a lower security window by pretty much any means other than manual transcription.

      As I recall they were intended for use on ships, where space limitations makes having entirely separate systems less feasible. Also, this was about 20 years ago; they may have changed their policies since then.

    14. Re: It's your own fault Apple by Anonymous Coward · · Score: 0

      Everything you say could be true, but if you don't honour "Incognito Mode" then there's not much that's incognito about that mode, is there now?

      Fast app switching is a reasonable rule but you make exceptions when you have to. There's nothing stopping iOS from using a generic app screen as a placeholder for an Incognito Mode app.

    15. Re: It's your own fault Apple by jmac_the_man · · Score: 1

      This is not merely about having embarassing porn exposed - someone may use a mac for top secret work, close the application, and hand it over to someone with lower clearance.

      Sincerely, the guy in charge of Hillary Clinton's email server.

    16. Re: It's your own fault Apple by mikael · · Score: 1

      I've got a similar problem happening with one of my applications with a mobile GPU (980m). Resizing a texture causes all sorts of odd contents to appear in the mip-map levels of that texture.

      --
      Vintage computer adverts: http://www.vintageadbrowser.com/computers-and-software-ads
    17. Re: It's your own fault Apple by Anonymous Coward · · Score: 0

      Whenever something is allocated or resized by the driver, that memory should be zeroed before execution is handed back to the application. Especially when offscreen frambuffers (Framebuffer Objects) are now being used for composition for web browsers.

    18. Re:It's your own fault Apple by Anonymous Coward · · Score: 1

      > Which feature films are non-DRM?

      Maybe we could have lists of non-DRM movies (probably just Creative-Commons right now) and perhaps DRM ones so we can avoid them.

      > And do they cover a wide variety of genres?

      Even if we establish a DRM-free area in just one genre (e.g. sci-fi), that would still be worthwhile.

      This is prosumerism, if we cannot buy them, we can make them.

    19. Re:It's your own fault Apple by Anonymous Coward · · Score: 0

      > Apple are welcome to base their drivers around Nouveau and Mesa. :)

      You can say Apple is evil, but they're not incompetent like some small software company... ;-)

      Ever heard of Webkit? Besides, a big part of Nvidia's advantage is having good proprietary drivers. If Apple went open source on video, I bet some competitor might get the upper hand. Then again maybe not, as Intel might not like it....

      American "capitalism"... pfft!

  3. Except it's not. by Anonymous Coward · · Score: 5, Insightful

    This isn't just on Apple's OS. While I have nothing like Mr. Andersen's writeup to prove it, I've seen this kind of bug happen on Windows.

    1. Re: Except it's not. by kthreadd · · Score: 4, Informative

      I've seen it on GNU/Linux with Nvidia cards and their non-free driver for several years. This is not new and its not just Chrome.

    2. Re:Except it's not. by tgv · · Score: 2

      Me too, and on tablets as well, in "Edge", no less. Usually it's very short lived. According to me the lesson is: applications need to erase all memory before closing a "private" session if the OS doesn't guarantee it.

    3. Re: Except it's not. by Anonymous Coward · · Score: 0

      You've seen data propagate from the Chrome browser to Diablo III for years?

      This is no different than variables in RAM not cleared, which I've seen for decades, if that's your measure of comparison. But it's not a "problem" except for bad programming practice. If Diablo III wanted a clear buffer, they should have cleared it, but apparently their program functioned normally. But Chrome claims that nothing gets stored in their Incognito mode locally, and it seems some things can still be accessed, so Google is the one that is at fault for not clearing the buffer when you close the Incognito window or close the application.

    4. Re:Except it's not. by Anonymous Coward · · Score: 0

      Do you have a screenshot of this Windows bug?

    5. Re:Except it's not. by Anonymous Coward · · Score: 0

      what if app crashes?

    6. Re: Except it's not. by Anonymous Coward · · Score: 0

      Variables in RAM not being cleared? DOS and other (primarily single user) OSen from that era, yes, but for the rest it is ancient history.
      All self-respecting OSes (and even Windows) nowadays clear memory used by one application before allocating it to another.

      And it's not just Chrome. Every application that displays something on the screen, including the OS itself, can be affected in this case, because it's litereally the screen contents that remain in display memory.

    7. Re:Except it's not. by AmiMoJo · · Score: 3, Interesting

      Unlikely, because Windows does enforce clearing of newly allocated memory, including on the GPU. The drivers would fail WHQL certification if they didn't. The probably didn't bother on Mac OS either because of an oversight or to get a little more performance.

      It might be possible within specific apps if they mismanage GPU memory, but certainly not across apps as described in TFA. Well, unless there is some unknown bug, but Nvidia are saying there isn't and it is tested for WHQL certification.

      Gonna need to see some more evidence than an anecdote I'm afraid. All available evidence says that Windows is unaffected.

      --
      const int one = 65536; (Silvermoon, Texture.cs)
      SJW, n: "Someone I don't like, and by the way I'm a fuckwit" - AC
    8. Re:Except it's not. by gsslay · · Score: 1

      And it isn't just Chrome either. In fact it has nothing to do with Chrome. It applies to any application you may have that might display content/information that you don't want to be randomly visible at a later time.

    9. Re: Except it's not. by Anonymous Coward · · Score: 0

      Defense in depth

    10. Re:Except it's not. by drinkypoo · · Score: 1

      Unlikely, because Windows does enforce clearing of newly allocated memory, including on the GPU. The drivers would fail WHQL certification if they didn't.

      I see pieces of other applications while starting or quitting applications all the time through my nVidia driver, and sometimes those things are old. nVidia is definitely not scrupulous about clearing video memory on Windows.

      --
      "You're right," Fisheye says. "I should have set it on 'whip' or 'chop.'"
    11. Re:Except it's not. by Anonymous Coward · · Score: 0

      Well, since it's anecdote vs anecdote, I'm on an nVidia based system running windows and have never seen it happen. So proof?

    12. Re: Except it's not. by tibit · · Score: 1

      This is a huge side-channel that can be exploited to communicate between "isolated" processes. You can e.g. have some malicious javascript working on an off-screen webgl context, inside of a sandbox, and it can use this to communicate with malware running elsewhere on the same host. This is pretty bad IMHO.

      --
      A successful API design takes a mixture of software design and pedagogy.
    13. Re: Except it's not. by tibit · · Score: 4, Informative

      The OS has very little control here, since the memory is not handled as memory, but as graphics resources. What's passed around isn't memory pages but texture buffers etc. These are managed by the graphics driver, and the OS expects the driver to do the right thing. I don't even think it's possible for the OS to handle this properly without there being clear API protocols that give the OS enough knowledge about what resources are passed around, and when they should be zero-initialized.

      --
      A successful API design takes a mixture of software design and pedagogy.
    14. Re:Except it's not. by tibit · · Score: 1

      Windows does enforce clearing of newly allocated memory, including on the GPU

      It doesn't. Really. It only clears the paged memory when pages change ownership or are first initialized. A set of pinned pages is retained by the graphics driver for as long as the driver wishes, and it's completely up to the driver to clear those when the logical ownership of the resource stored on any given page is assigned to a new process. Furthermore, it might not even be that a single page in the GPU memory belongs to one process only. It might store textures or other buffers from two or more processes, after all. It's really up to the driver to do the right thing here.

      --
      A successful API design takes a mixture of software design and pedagogy.
    15. Re: Except it's not. by chmod+a+x+mojo · · Score: 1

      I don't know if it still does, but the opensource radeon driver used to do something similar this as well... when you logged in to X. It all started when they committed the fix for the screen briefly displaying jumbled garbage when when logging in. Yeah, it didn't display garbled garbage on the screen, but showed a screen from an old browsing session instead, that was also cached somewhere on disk so was persistent even between full power downs.

      Hell Chromebooks did it as well when context switching between chromeOS and the Linux distro installed through Crouton, and they used the Intel onboard video. Unfortunately it isn't just NVidia that has these problems. That is a point in NVidias favor that it isn't their fault that this is happening though.

      --
      To err is human; effective mayhem requires the root password!
    16. Re:Except it's not. by drinkypoo · · Score: 1

      Well, since it's anecdote vs anecdote, I'm on an nVidia based system running windows and have never seen it happen. So proof?

      Nobody has provided any proof in this discussion, so it seems like demanding it is setting a relatively high bar. It's the kind of thing that's difficult to demonstrate if you're not recording all of your video output. I see it happen after programs have crashed.

      --
      "You're right," Fisheye says. "I should have set it on 'whip' or 'chop.'"
    17. Re: Except it's not. by Carewolf · · Score: 1

      I've seen it on GNU/Linux with Nvidia cards and their non-free driver for several years. This is not new and its not just Chrome.

      That is because OpenGL does not require NVidia to do the right thing. Most other driver do, but NVidia doesn't because it might impact performance, and they are not forced to doit. As far as I an parse their blame on Apple, they are basically saying Apple is not requiring them to blank textures either, so NVidia doesn't. It is Apple's fault for not forcing NVidia.

    18. Re:Except it's not. by BitZtream · · Score: 1

      I've experienced the issue in multiple iOS revisions and devices as well

      --
      Persistent Volume manager for Kubernetes - https://github.com/dwimsey/openshift-pvmanager
    19. Re:Except it's not. by HMage · · Score: 0

      Can confirm, there's a writeup about that too -- http://www.websecuritywatch.co...

      --
      Eugene 'HMage' Bujak
    20. Re: Except it's not. by Anonymous Coward · · Score: 0

      That is because OpenGL does not require NVidia to do the right thing. Most other driver do, but NVidia doesn't because it might impact performance, and they are not forced to doit. As far as I an parse their blame on Apple, they are basically saying Apple is not requiring them to blank textures either, so NVidia doesn't. It is Apple's fault for not forcing NVidia.

      Actually NVidia doesn't write the GPU drivers on Apple systems. Apple writes their own drivers for NVidia hardware (and Intel and AMD graphics). This is so all graphics cards have the same API support level and they aren't tied to one specific vendor (e.g., like they used to be tied to ATI). So it isn't that Apple is requiring (or not requiring in this case) the blanking of textures, it's that Apple engineers didn't bother to blank the textures when they wrote the driver for NVidia GPU hardware.

      In this specific case, that makes it *Apple* software's fault in this case because the hardware does not blank the textures by itself, it's NOT NVidia hardware's fault.

    21. Re: Except it's not. by Anonymous Coward · · Score: 0

      I saw it a couple of times with an old Nouveau driver. Displayed data from an image viewer application when logging out and the X server was restarting. Doesn't happen nowadays though.

    22. Re: Except it's not. by mikael · · Score: 1

      There was an article some time ago on how you could get an application to scan the USB devices for keyboards and other devices, figure out the location of the device driver in memory and the character buffers used by interrupts, then pass this information onto a CUDA or OpenCL application and do all the snooping on the GPU. The application containing the original USB scanner could then terminate.

      --
      Vintage computer adverts: http://www.vintageadbrowser.com/computers-and-software-ads
    23. Re: Except it's not. by PitaBred · · Score: 1

      Except that Apple wants to write most of the driver, you'd be right. Nvidia doesn't get to write the driver for the Macs, that's why there are never any direct graphics driver updates from any GPU provider for Apple hardware, it all goes through them. Apple gets the blame because they're the ones doing the development.

    24. Re:Except it's not. by david_thornley · · Score: 1

      Thing is, if GP is correct, it does happen. If it never happens to you, that's not good evidence that it never happens. A single data point can prove the existence of something.

      --
      "When you have eliminated the unacceptable, whatever is left, however improbable, must be the truthiness" - Holmes
    25. Re: Except it's not. by Anonymous Coward · · Score: 0

      Screenshot and get 100000 blog views then. Or stfu. Never seen it happen on any windows nvidia computer. Never seen it happen with hw accelerated overlays either since 1999

  4. Re:Chrome? by Anonymous Coward · · Score: 1

    So are you implying that this bug is due to wanting to keep images in RAM for advertising purposes?

  5. Simple explanation by mcrbids · · Score: 2, Insightful

    So, your program allocates some memory. Should it initialize the memory to make sure it's all a bunch of zeros? Apparently, Nvidia doesn't think so.

    So, a program running on your OS requests some memory. Should the OS initialize the memory before handing it to the application? Apparently, Apple doesn't think so.

    Either answer is right.

    --
    I have no problem with your religion until you decide it's reason to deprive others of the truth.
    1. Re:Simple explanation by Anonymous Coward · · Score: 2, Informative

      It needs to be cleared by the OS 100%. The OS can't expect/assume this is done elsewhere, or stuff like this happens.

    2. Re:Simple explanation by Anonymous Coward · · Score: 0

      If you want to get a strict view on memory data it shall be cleared as soon as it's released, not necessarily cleared at allocation.

      However clearing unused memory (RAM or Disk) is also impacting performance. The performance penalty can be easier to hide when freeing memory than when allocating it - but you need a nice background thread to take care of that.

    3. Re:Simple explanation by Anonymous Coward · · Score: 0

      Apple is responsible for creating all the hardware driver and the OS specs. nVidia writes their video driver to the specs given to them by Apple.

      It's not nVidia's job to decide whether the OS or the video driver is responsible for clearing memory. It's quite legitimate for nVidia to assume that if memory was to be cleared then it would be stated in the spec, and they would code that in.

    4. Re:Simple explanation by Kjella · · Score: 3, Informative

      So, your program allocates some memory. Should it initialize the memory to make sure it's all a bunch of zeros? Apparently, Nvidia doesn't think so. So, a program running on your OS requests some memory. Should the OS initialize the memory before handing it to the application? Apparently, Apple doesn't think so. Either answer is right.

      Not really. An application will typically allocate and release memory all the time, being forced to clear it every time is massive overkill and a performance problem. The driver exposes the GPU memory, the OS allocates it to applications just like with RAM. It's the only one that knows when memory switches application context and must be cleared. So there's really only one sane solution.

      --
      Live today, because you never know what tomorrow brings
    5. Re:Simple explanation by Anonymous Coward · · Score: 0

      It needs to be cleared by the OS 100%. The OS can't expect/assume this is done elsewhere, or stuff like this happens.

      It needs to be cleared by the application 100%. The application can't expect/assume this is done elsewhere, or stuff like this happens.

      Never assume freshly-allocated memory is in a known state. That's part of programming 101.

    6. Re:Simple explanation by dgatwood · · Score: 5, Insightful

      Not really. An application will typically allocate and release memory all the time, being forced to clear it every time is massive overkill and a performance problem. The driver exposes the GPU memory, the OS allocates it to applications just like with RAM. It's the only one that knows when memory switches application context and must be cleared. So there's really only one sane solution.

      The usual solution is basically:

      • Whenever you add a new page into an application's address space, you map a zero-filled page as copy-on-write. If the page never gets touched, it is zero-filled, and you take the performance hit only when it ceases to be all zeroes.
      • Small allocations are allocated using a pool allocator backed by those pages.

      This works well as long as the CPU is in charge, ensuring that any dirty data must have originated in some other part of the app (by reusing a pool region). Where it starts to get hairy is when you have a GPU that has access to all of RAM and uses a separate page table with separate COW flags, etc.

      I'm not certain what went wrong in this particular case. However, I do remember a really annoying change in about 10.6 or 10.7 where Apple stopped using a vertical blanking interrupt to control various aspects of the GPU's operation and maybe some other parts of the OS. This improved battery life, IIRC, but the result is that you'll often see the GPU draw a frame of video before the previous contents of VRAM have gotten wiped. I would not be at all surprised if that was what happened here.

      As for whose responsibility it is to clear the memory, my gut says that if Chrome wants to guarantee that its video buffers are cleared, Chrome is responsible for doing it. Otherwise, it should assume that VRAM is a shared resource, and anything it puts in VRAM can potentially be accessed by any other app at any time for any reason. With that said, I'm open to other opinions on the matter.

      --

      Check out my sci-fi/humor trilogy at PatriotsBooks.

    7. Re: Simple explanation by Anonymous Coward · · Score: 0

      Yeah, let's implement all this security focused process isolation stuff, but then share memory around like your mother at a biker bar. It's 101 because it only covers the basics without going into the "why".

    8. Re: Simple explanation by Anonymous Coward · · Score: 1

      The application doesn't know the physical addresses. If it's memory got paged out, it probably got put back at a different location. Only the OS can do it. The application does have the information or access.

    9. Re:Simple explanation by meerling · · Score: 1

      That's what was taught back in the 80s, so the idea isn't exactly new.
      (For as far as I know it was taught a lot earlier, but I started in the 80s.)

    10. Re:Simple explanation by BoberFett · · Score: 3, Informative

      It's not just about a moment of graphical corruption, that's an annoyance. But a process being able to access the RAM leftovers from a previous process is begging for memory based attacks. Even though it's on the GPU, it's a vulnerability. What's to say that GPU wasn't just displaying banking info? The OS should not assume the application is friendly and blanking the VRAM. That security is on the OS.

    11. Re:Simple explanation by x0ra · · Score: 1

      I fail to see how this can increase security, as you just need to fault by writing a single byte and you've got a mostly dirty page.

    12. Re:Simple explanation by Anonymous Coward · · Score: 0

      Well, things can get really nasty fast:

      1. The kernel *will* sanitize any page of memory you ask it with zeros. Linux will actually alocate a zero page in COW (copy on write), so if you never write to it you will get a page full of zeros that costs just a memory map change ;-)

      2. The userspace memory management/allocator (e.g. C library malloc/alloca/etc) will get zeroed pages from the kernel to use as "heap", it *will* likely reuse such pages, and it will *not* zero them out in some cases (e.g. in C wether it should be zeroed out or not is part of the ABI of a given *alloc* function).

      3. GPU drivers are all about speed, and zeroing out frame-buffer memory that is likely to be entirely overwritten is something nvidia doesn't want to do (never mind everyone else finds a way to do it).

      4. Security dictates that you *will* zero out memory when it is first allocated to a *new process* and not part of an IPC channel that has been previously set up. So there is no way nvidia is right on this one. This requirement trumps any craze-ass API specification that leaves this undefined, so it really doesn't matter whether OpenGL or DirectX states that the buffer memory will be zeroed out on first request or not, it *has* to be.

    13. Re:Simple explanation by Lonewolf666 · · Score: 2

      It is nice if the OS does the clearing, but the application programmer should not rely blindly on it.

      For the application programmer, it depends on how much a data leak in the application would hurt.
      -If the OS specifies that memory is cleared, relying on it it is IMHO OK for low security applications.
      -For high security applications, always clear the memory. Don't trust that the OS does it.

      --
      C - the footgun of programming languages
    14. Re:Simple explanation by AmiMoJo · · Score: 2

      Clearing allocated memory before handing it to applications is required by POSIX and generally a really, really good idea from a security point of view. The performance hit is minimal (modern CPUs and RAM can write gigabytes per second easily) and can be mitigated, e.g. by using a pre-allocated pool for small allocations.

      All modern operating systems clear allocated memory. It's basic security to stop one app stealing data from another, or even worse the kernel. You could do it the other way around and try to remember to always clear sensitive data before deallocation, but aside from the high probability that someone will forget to do it, it is very hard to figure out what is really sensitive. Something seemingly unimportant might be useful for an exploit you didn't anticipate. So clear on allocation is the best, safest solution and has minimal down sides.

      --
      const int one = 65536; (Silvermoon, Texture.cs)
      SJW, n: "Someone I don't like, and by the way I'm a fuckwit" - AC
    15. Re:Simple explanation by angel'o'sphere · · Score: 1

      There is a reason why C has memory allocation functions like alloc, malloc, calloc, nalloc ...
      and there is a reason why C++ says: CTORs are only called if the class defines a CTOR.

      --
      Cost free eBook I read (by iBook/Kobo/Amazon/ObookO/Gutenberg etc.): "The Green Odyssey" by Philip Jose Farmer.
    16. Re:Simple explanation by Anonymous Coward · · Score: 0

      There are two kinds of memory allocation. A program will usually handle the allocation of small amounts of memory within its own code - when you ask for 12 bytes, or a new object, that will be handled by the run-time library, and happens inside the process's address space. But when the program needs a bigger chunk of space, it has to ask the OS for it. It will also ask the OS for a chunk of memory if you need to expand the heap. Allocations of memory from the OS may be restricted to pages.

      The OS has the responsibility to ensure that there is no unintentional sharing of data between processes. If it doesn't clear the memory, then a rogue process could allocate a very large amount of memory and scan it for things like passwords.

      On Windows, this is handled by giving any process which allocates pages a block of virtual memory where the page table contains a series of pointers to the system zero page (a page full of zeros), which is marked COW (Copy On Write). So the first time the process writes to the page a copy is made of the zero page, and the process's write goes to a fresh page. So you ask for four megabytes, and get a page table containing 1024 pointers to a single zero page. It's a simple design, and blocks the inadvertent transfer of data.

      A process does need to worry about initialising memory that's NOT coming from the OS, of course. So if you allocate 12 bytes, you can't guarantee its initial state

    17. Re:Simple explanation by Anonymous Coward · · Score: 0

      No, the OS has to do it. Though I always initialize my own memory in my code, as a security conscious dev, I realize that if the OS doesn't do it, this opens a massive security hole if malicious software wants to play the "data leak game". To say the application should ultimately be responsible is naive. What happens if there's an unexpected seg fault? If you say "well, the developer should be better" remember that random bit flips can occur. What if the user kill -9s it? No, the OS should always clear it before allocating it. Security 101.

    18. Re:Simple explanation by The+MAZZTer · · Score: 1

      All modern OSs will initialize the memory because there is a clear security issue with allowing one application access to the old contents of a random block of memory. It could contain passwords or who knows what else.

      On the other hand, GPU memory is primarily used for rendering graphics. The security implications are less severe if information leaks. Has there ever been any guarantee information won't leak? So why do users assume that it won't? It is likely NOT cleared for speed reasons. Everyone wants a fast GPU cheap. Well, that's one way to get speed boost on allocation operations I'm sure.

      It really should be Chrome's responsibility to zero out their GPU memory when they're done with it, to prevent information leakage. That's what incognito mode does with regards to history, cache, and cookies, so why not GPU memory?

    19. Re:Simple explanation by tibit · · Score: 2

      The OS has the responsibility to ensure that there is no unintentional sharing of data between processes.

      In general, it's impossible for the OS to guarantee that, since drivers are nominally accessible by multiple processes at once. Say a serial port driver has a bug and doesn't wipe the buffer between closing and reopening of the device: OS can't help here, it's a driver bug that leaks data between processes here. Same goes for graphics drivers.

      Here's what happens: GPU memory is allocated in chunks of wildly varying sizes. To maximize the amount of usable GPU memory, the objects (buffers) owned by various clients of the driver can be allocated adjacent to each other. I.e. the driver doesn't (and shouldn't) have higher-level subdivisions, such as pages, that are owned by one process only. The driver bug is that the GPU memory a buffer is using not cleared before being passed to a different process. This is a very performant sidechannel that leaks data between supposedly isolated processes. This is very bad indeed.

      The Chrome bug is that it accepts buffers and doesn't clear them before selecting them as textures.

      --
      A successful API design takes a mixture of software design and pedagogy.
    20. Re:Simple explanation by tibit · · Score: 1

      This of course is true, but what is handled by the graphics driver is not memory, but OpenGL primitives like buffers. The OS has absolutely no bearing on any of that, it's up to the driver to do the right thing. Just as a graphics driver can pass unclean buffer primitives around, a serial driver bug might not clear a communications buffer, or a fancy keyboard driver with OLED displays in the keys might leak the data from your porn setup where the function keys have pics of your fave pornstars on them :)

      Basically, there's no way for the OS to guarantee that a driver won't subvert the security. By no way I mean neither a practical way nor even a theoretical way, unless the feature set of the hardware was very limited.

      --
      A successful API design takes a mixture of software design and pedagogy.
    21. Re:Simple explanation by Carewolf · · Score: 1

      So, your program allocates some memory. Should it initialize the memory to make sure it's all a bunch of zeros? Apparently, Nvidia doesn't think so. So, a program running on your OS requests some memory. Should the OS initialize the memory before handing it to the application? Apparently, Apple doesn't think so. Either answer is right.

      Not really. An application will typically allocate and release memory all the time, being forced to clear it every time is massive overkill and a performance problem. The driver exposes the GPU memory, the OS allocates it to applications just like with RAM. It's the only one that knows when memory switches application context and must be cleared. So there's really only one sane solution.

      No. The driver knows as well. There is a concept called OpenGL contexts, and they can be configured to share texture data with eachother, the problem is that the driver leaks texture-data between contexts that shouldn't be sharing texture data. They perfectly well know those contexts should not be sharing texture data.

    22. Re:Simple explanation by myowntrueself · · Score: 1

      If you want to get a strict view on memory data it shall be cleared as soon as it's released, not necessarily cleared at allocation.

      However clearing unused memory (RAM or Disk) is also impacting performance. The performance penalty can be easier to hide when freeing memory than when allocating it - but you need a nice background thread to take care of that.

      LOL I think, given Apples graphics performance overall, they don't really care about performance and optimizing THIS would make fuck all difference to the SHIT performance of their graphics.

      --
      In the free world the media isn't government run; the government is media run.
    23. Re:Simple explanation by Anonymous Coward · · Score: 0

      OTOH if the API makes no guarantee that the memory will be zero'ed, then the application should scrub sensitive information before freeing the memory.

    24. Re:Simple explanation by gstoddart · · Score: 1

      Arguably, when you request memory from a modern OS, basic security says it shouldn't be filled with random stuff from other programs.

      This has been true since at least the 90s.

      Multi-processing environments have been solving this for years, like they're supposed to.

      --
      Lost at C:>. Found at C.
    25. Re:Simple explanation by dgatwood · · Score: 1

      Copy on write does not work that way. It copies the originally mapped page, which is a single pre-zeroed physical page that is kept around specifically for that purpose. That copy operation completes (thus wiping the victim physical page) before the OS returns control to the process.

      --

      Check out my sci-fi/humor trilogy at PatriotsBooks.

    26. Re:Simple explanation by dgatwood · · Score: 1

      It's not just about a moment of graphical corruption, that's an annoyance. But a process being able to access the RAM leftovers from a previous process is begging for memory based attacks. Even though it's on the GPU, it's a vulnerability. What's to say that GPU wasn't just displaying banking info? The OS should not assume the application is friendly and blanking the VRAM. That security is on the OS.

      In principle, I agree with you. In practice, though, this sort of bug is really easy to make when designing something as complex as a VM system, and is a really easy way to leak data. It is the sort of thing that a browsing mode designed to keep all browsing data temporary really ought to behave defensively, explicitly taking steps to prevent such leakage, regardless of what the OS does or does not do to prevent it. For that matter, older GPUs don't even support memory virtualization, so browsers can't count on the OS even being able to prevent arbitrary apps from screen scraping; the best they can do is minimize the attack window by not keeping data in VRAM any longer than necessary.

      Also, what I saw described was not necessarily indicative of improper access, I don't think. The original story (assuming I looked at the right original story) was about somebody's previously viewed porn showing up atop some video game. The fact that the process eventually gained the rights to write to a page (thus filling the buffer) does not necessarily mean that the process already has the rights to read from that page (thus gaining access to whatever was already in the buffer). If it is a virtual framebuffer or similar, there's a possibility that the OS was in the middle of the wipe when the window manager began some compositing operation, but that the original process (into which the memory was halfway through being mapped) didn't have access to those pages yet.

      --

      Check out my sci-fi/humor trilogy at PatriotsBooks.

  6. It's perfectly trustworthy for what it is. by Anonymous Coward · · Score: 0

    A session that doesn't store cookies/etc. Very useful if you need to log into the same place with two different sets of credentials at the same time.

    Anything else?

    Your ISP can already tell what you're doing, and no browser will change that.

    And Facebook and Google can already tell what you're doing, because according to some flash-based advertisements that wobble and emit noise, your computer may be broadcasting an IP address. Browser ain't gonna do shit against basic TCP/IP.

    1. Re: It's perfectly trustworthy for what it is. by Anonymous Coward · · Score: 0

      *cough*Tor browser*cough*

    2. Re: It's perfectly trustworthy for what it is. by Anonymous Coward · · Score: 0

      And here come the apologists. Nvidia should hide you, but unfortunately, they think it's a bug

  7. Re:Chrome? by Anonymous Coward · · Score: 5, Insightful

    No, his reason is that sweet sweet +5 insightful. We don't need your facts around here.

  8. Re:Chrome? by Anonymous Coward · · Score: 0

    it happens with anything that uses 3d acceleration on OS X (for me, even on AMD cards), and given cocoa does that it tends to be just about everything. this topic isn't noteworthy for anyone other than apple who I guess should probably do something about it but if you have a mac you know about this already.

  9. Re:Chrome? by Anonymous Coward · · Score: 0

    His extension was exposed. *ba dum tssss* Thank you and remember to tip your waitress!

  10. Good luck with that. by Anonymous Coward · · Score: 0

    No way no one would not believe that.

  11. Lucky he wasn't streaming Diablo by Anonymous Coward · · Score: 0

    Had Evan Andersen been streaming his gameplay, then everyone on the Internet would know that he visits porn sites!

  12. Not cool by lucm · · Score: 1

    Does that mean I have to throw away my porn iPad and go back to my porn ChromeBook?

    I hate that. Just moving the bookmarks will take forever.

    --
    lucm, indeed.
    1. Re:Not cool by SeaFox · · Score: 2

      Does that mean I have to throw away my porn iPad and go back to my porn ChromeBook?

      I hate that. Just moving the bookmarks will take forever.

      Joke Fail.
      You're using Chrome on both, so bookmarks are synced through your Google account.

    2. Re:Not cool by angel'o'sphere · · Score: 1

      Erm, is actually anyone using that feature?
      I for my part don't I like it that different devices have different book marks. The bookmarks I really want to share are on delicious anyway.

      --
      Cost free eBook I read (by iBook/Kobo/Amazon/ObookO/Gutenberg etc.): "The Green Odyssey" by Philip Jose Farmer.
    3. Re:Not cool by Anonymous Coward · · Score: 0

      It's more than just that fail. If you're hiding the fact that you surf porn sites, why would you leave those sites bookmarked?

    4. Re:Not cool by lucm · · Score: 1

      You'd really put porn bookmarks in the cloud?

      I don't use Chrome sign-on ever, even for regular browsing.

      --
      lucm, indeed.
    5. Re:Not cool by lucm · · Score: 1

      Who said anything about hiding? It's containment. The best way to browse porn websites is probably a VM but it's not as convenient as a mobile device.

      --
      lucm, indeed.
    6. Re:Not cool by SeaFox · · Score: 1

      I don't use Chrome sign-on ever, even for regular browsing.

      If you're that paranoid, you shouldn't be using Chrome to start with.

  13. Easy Fix for the Paranoid: Cold Reboot by slacka · · Score: 3, Interesting

    I've done some GLSL programming and it's not unreasonable for clearing a GPU buffer to take 1/20 to 1/10 the time as the actual operation on that buffer. How many Nvidia users (read gamers) would prefer to take a 5% performance hit to prevent occasional glitches like this?

    This has absolutely nothing to do with Nvidia's drivers. It is a glitch in Diablo III and maybe something Chrome could address for the paranoid out there. Meanwhile, if you're really that worried about someone seeing a glimpse of your porn hours earlier, just turn your computer off/on before allowing anyone to use it next. Problem solved.

    1. Re:Easy Fix for the Paranoid: Cold Reboot by afourney · · Score: 4, Interesting

      It's not a 5% hit. You only have to clear the buffer once on exit. And, Nvidia is right:This is something the OS should do (just like it closes filehandles, and frees other resources on exit). Why not leave it up to the app? Because, apps don't always exit cleanly.

    2. Re:Easy Fix for the Paranoid: Cold Reboot by _merlin · · Score: 3, Informative

      The thing is, for security the operating system should scrub memory before before supplying it to an application. Otherwise you get all kinds of data leakage. The virtual memory system does this when an application requests more pages. SPARC CPUs generate an interrupt when they run out of "clean" register windows. NTFS ensures sectors that are allocated but not written in a files read as zeroes (FAT32 on Windows 95 didn't, you'd read back whatever was there on the disk). By the same token, the OS should scrub GPU resources before supplying them to an application. You don't need to do this on every allocation, only when the allocation comes from RAM that was not previously assigned to that application.

    3. Re: Easy Fix for the Paranoid: Cold Reboot by guruevi · · Score: 0

      There is not a single OS that does this; the application is responsible for cleaning up after itself. For a test: open a file on a drive, then remove the drive - result: zombie process, the OS does not clean up and cannot kill such process because an OS is in charge of allocating resources and shouldn't intervene in other programs' business. If a program requests a resource and doesn't clean it up, the OS keeps it in tact (causing memory leaks)

      Many programmers have forgotten or never learned how real hardware actually works. Writing zeroes takes up resources. Requesting memory only gives you a zero-mapped page (OS knows it's 0 but does not clear or reserve it in actual memory), not a zeroed out page, once you write the page it reserves and then overwrites whatever was on the chip. That's how you can request 50GB of memory (virtual memory) but never actually need 50GB of physical RAM.

      Graphics card memory is even funnier to deal with because you need to map 1:1 memory in RAM to copy it to GPU memory (that's what your browser does because it's simple and the OS handles it and it's safe). But with the right privileges your program can instruct the CPU to access the GPU memory directly (which is what games do through eg OpenGL) but you're by and large bypassing any OS "protections". Either way neither the OS nor the card are aware of the context the card or it's memory is being accessed at any particular time. It is very feasible that you can access previously mapped application memory through things like CUDA or low level GPU access methods without the OS being aware.

      --
      Custom electronics and digital signage for your business: www.evcircuits.com
    4. Re: Easy Fix for the Paranoid: Cold Reboot by Dog-Cow · · Score: 4, Interesting

      There isn't a single OS that doesn't do this. You wrote a bunch of crap that has nothing to do with what the GP wrote.

    5. Re: Easy Fix for the Paranoid: Cold Reboot by Anonymous Coward · · Score: 0

      Blatantly untrue. No OS I've ever worked on clears old allocated data, it's generally up to the application. I'm not going to be an idiot and state that no OS ever does this, but then i'm not an idiot who will state that all OS's will do this either.

    6. Re: Easy Fix for the Paranoid: Cold Reboot by Anonymous Coward · · Score: 1

      Huh, all the real operating systems made since nineties have had resource tracking and cleanup on exit. The memory, GUI resources, sockets, etc are always freed by OS upon exit of the application. The same should apply to any OpenGL stuff also, or does the Apple system really run out of GPU memory is a application crashes or forgets to free the resources it had allocate?

    7. Re: Easy Fix for the Paranoid: Cold Reboot by alexhs · · Score: 1

      Your first paragraph is completely wrong. You've been moderated accordingly and Dog-Cow told you as much, but I will provide an explanation.

      The application is mostly not responsible for cleaning up up after itself, except for some shared resources (for example, POSIX shared memory).
      In your "test", you don't actually get a zombie process. Ironically, a zombie process would mean that resources have been cleaned.

      A zombie process is a process that has/was terminated, and only the in-kernel process structure containing some statuses is kept until the parent process acknowledges that the child process has terminated. Other resources (memory, file handles, etc.) have already been reclaimed.

      In your test nothing specific is likely to happen.The program will continue to run and will get a write error if he's trying to write to the opened file. It can be killed normally. What you probably were thinking about, is about what happens if you're actively writing to the file when you're removing the drive. In that case, the program will end up in uninterruptible sleep state (shown as the 'D' state in Linux's ps). That's nothing like zombie (that would be shown as <defunct>).
      In D state, the program has made a (synchronous) system call, and is sleeping while the system is performing the request. As the disk has been removed, the write request never returns. In that state, the OS will refuse to kill the process, because doing so would risk to crash the system if the syscall ever returns to a now non-existent process.

      Your second paragraph is correct.

      I suspect parts of your third paragraph are incorrect (specifically, the "need" to map 1:1), but I'm not an expert in the domain. AFAIK, there are framebuffers that are 1:1, and then you manipulate graphics objects through handles that are actually managed by the graphics driver (and don't need to be mapped).

      --
      I have discovered a truly marvelous proof of killer sig, which this margin is too narrow to contain.
    8. Re:Easy Fix for the Paranoid: Cold Reboot by AHuxley · · Score: 1

      Think of all the apps running at the same time that could be looking in at something thats still open.

      --
      Domestic spying is now "Benign Information Gathering"
    9. Re:Easy Fix for the Paranoid: Cold Reboot by edtice1559 · · Score: 1

      If you're calling this a bug in Diablo, you are kind of missing the point. If the data is left in memory, another process on the machine would be able to retrieve that data for malicious purposes. An actual exploit of this vulnerability would be quite tricky, but it does end up happening. This is really a simpler version of the famous Heartbleed bug. What we've seen returned in *this* case is just some graphical data, but there's no reason to believe that it couldn't be something like a private key that's available. If the GPU was being used for TLS acceleration as an example. This type of bug has been exploited very successfully in the past which is why the OS clears out main memory before handing it to a process. There is another informative post in this thread about how the Linux kernel does this very efficiently. It shouldn't be necessary to wait for a vulnerability to be brutally exploited before deciding to fix it.

    10. Re: Easy Fix for the Paranoid: Cold Reboot by Anonymous Coward · · Score: 0

      No, the GPU comments are complete nonsense.
      GPU memory/buffers are completely separate and not directly accessible by the CPU.
      They can in advanced APIs often be mapped, but it is entirely up to the driver whether that map is done via actually mapping PCI space, via a full copy GPU -> main RAM and back (and whether using DMA or something else) or using copy-on-write or other methods.
      The only thing close to this is that GPUs often did not have memory protections, so if you used the GPU's assembly language or just did out-of-bounds accesses in OpenCL you might have been able to access GPU memory owned by a different process.
      That just means if you run graphics content on hardware without memory protection you will not get memory protection/separation between processes.
      But I don't think this applies to modern GPUs anymore.

    11. Re:Easy Fix for the Paranoid: Cold Reboot by BitZtream · · Score: 1

      Clearing the buffer on app context request or at context release is a one time event.

      And no, it doesn't take long, it is in fact the quickest way to touch every pixel. Anyone who's telling you it takes too long is using the wrong API to do it.

      --
      Persistent Volume manager for Kubernetes - https://github.com/dwimsey/openshift-pvmanager
    12. Re:Easy Fix for the Paranoid: Cold Reboot by mikael · · Score: 1

      That would mean that the application has to keep allocated every texture, framebuffer and memory block ever reserved by the GPU. If anything, the GPU is going to have to maintain a "must-be-wiped" list of memory blocks that are cleared when the application is closed or when they are reused.

      --
      Vintage computer adverts: http://www.vintageadbrowser.com/computers-and-software-ads
  14. Re:Chrome? by non0score · · Score: 1

    Just like a pharma company doesn't really need you to take every drug they manufacture, Google doesn't need to get your info with every software they make. You either think that the vast majority of Google engineers are moral-less bastards, or do I sense a hint of sour grapes?

  15. Blame Chrome by pushing-robot · · Score: 5, Interesting

    Chrome advertises its Incognito mode as leaving no traces behind. Therefore, it should be responsible for wiping its framebuffer, just as it clears caches, cookies and history. It's like writing a file shredder that doesn't actually overwrite files, then blaming the OS and hard drive manufacturer for the oversight.

    It might be nice if framebuffers and such were zeroed on release, but like overwriting files, it's a time/energy/security tradeoff. Besides, the screen isn't really protected anyway; IIRC applications on most OSes can capture the screen without even admin privileges. After apps are sandboxed into seeing only their own windows we can talk about securing the framebuffer.

    --
    How can I believe you when you tell me what I don't want to hear?
    1. Re:Blame Chrome by Anonymous Coward · · Score: 0

      You hit the nail on the head man. I need 2... count them 2 fucking extensions to clear my Chrome cache from those facebook wannabees. They lie, but ever since Mozilla sold out they're the best thing next to Edge. We're all fucked aren't we? I hate it all.. the spying, the telemetry, the analytics....

      I've been online since the 2400 baud procom days of BBS sites. Am I too old to adapt? Have I finally hit the wall where enough is enough? I just can't take all this bullshit and spying and MORE BULLSHIT anymore. The internet is withering on the vine to me. It was once so beautiful.

    2. Re:Blame Chrome by freedom_surfer · · Score: 1

      Yeah, seems to me incognito mode should do this as its shutting down a tab 'to remove all traces'. That said, apps should probably zero out before they start as well since they are the ones that look unkempt when they display legacy data.

    3. Re: Blame Chrome by guruevi · · Score: 3, Insightful

      There are also some limitations to what a program promises vs what it can do. File shredding is an optimal example: modern SSD do not even write to the same physical location every time you write to the same file. Battery backed controllers fool the OS in thinking a certain action was completed while it really wasn't committed to disk yet. If you pull a disk between the shredding event and the cache flush, you could easily read things. Heck, if your magnetic drive says a portion of it's drive are "bad blocks" the data on those blocks doesn't get overwritten, SSD's have cells that can physically go "read-only", with the right tools you can read the data in the "bad blocks" or "read only" cells.

      --
      Custom electronics and digital signage for your business: www.evcircuits.com
    4. Re:Blame Chrome by x0ra · · Score: 1

      You obviously have no idea how OS internals are working....

    5. Re: Blame Chrome by Entrope · · Score: 1

      If the OS (or OpenGL driver) changes an application's memory allocation from physical pages A-F to pages U-Z, it doesn't tell the application or give the app a chance to clear the memory first. The app *cannot* guarantee that its memory is cleared before being handed to another process.

    6. Re:Blame Chrome by edtice1559 · · Score: 1

      The issue isn't another app seeing the framebuffer used by Chrome incognito. That's probably harmless. The issue is that, if the pages aren't being zeroed properly, there may be other sensitive information that leaks. What if somebody comes up with GPU accelerated TLS? Sure they *should* zero the pages too. The problem is that there are *a lot* of places where applications would need to zero memory. And it turns out that it's way too easy to screw this up. Hence the feature has been moved to the operating system to ensure that it's done consistently. Silly for everybody to reinvent the wheel anyway.

    7. Re:Blame Chrome by mjwx · · Score: 1

      Chrome advertises its Incognito mode as leaving no traces behind. Therefore, it should be responsible for wiping its framebuffer, just as it clears caches, cookies and history. It's like writing a file shredder that doesn't actually overwrite files, then blaming the OS and hard drive manufacturer for the oversight.

      Copy/paste from Chromes incognito mode. The emphasis is theirs.

      Pages that you view in incognito tabs won't stick around in your browser's history, cookie store or search history after you've closed all of your incognito tabs. Any files that you download or bookmarks that you create will be kept. Learn more about incognito browsing

      Going incognito doesn't hide your browsing from your employer, your internet service provider or the websites that you visit.

      So they dont advertise that it leaves no traces behind. In fact it's quite obvious that it does leave things behind.

      --
      Calling someone a "hater" only means you can not rationally rebut their argument.
    8. Re: Blame Chrome by stikves · · Score: 1

      SSD's have a very good secure erase mode, but it is very low level. I had to do it once, when I forgot the password on my Samsung portable SSD. Basically the drive sends a concurrent pulse to all cells, and then drains them (that's what I understood). It took a very short time, and since it happens to the entire drive, and the initial data was encrypted anyways, I don't think any data woul dbe recoverable after that point.

      But this is not an advertised feature, and I had to speak with the customer service to get the right tools.

    9. Re: Blame Chrome by guruevi · · Score: 1

      It wouldn't clear any blocks that are so worn out that they've gone read only would they? There are states in SSD's where the cells individually have become ROM's

      --
      Custom electronics and digital signage for your business: www.evcircuits.com
    10. Re: Blame Chrome by BoberFett · · Score: 1

      Exactly. Applications CANNOT be expected to zero memory. The OS absolutely MUST be required to do that, to be considered in any way secure.

      They've been doing with system RAM for a long time. That practice needs to be standard for VRAM as well.

  16. Apple and Chrome: 2 pieces of shit by Anonymous Coward · · Score: 0

    No surprises here.

  17. Re:Chrome? by mishehu · · Score: 1

    Why, is she a cow?

  18. Re:Chrome? by thegarbz · · Score: 4, Informative

    Somehow, the idea that people would trust incognito mode in a browser made by a company whose profits mainly come from targeted advertising strikes me as really hilarious.

    Why? They are two different and not incompatible processes. The company performs analytics and collects information about you to store on its servers. The incognito mode is designed to ensure a trace of the browsing session is not left on your PC.

    There is a very big difference between the form of data collection here as well as the result of it. Mother is not going to know I search for dirty things based on Google's data collection.

  19. incognito starts remembering history by endangeredcritters · · Score: 3, Interesting

    There is a far simpler way to defeat chromes incognito mode, just use it for awhile. After some unknown (not forever) period of use, it will start to not forget history even after it's been shutdown and restarted. At least in 'Version 44.0.2403.107 (64-bit)' running in Linux Mint.

    1. Re:incognito starts remembering history by thegarbz · · Score: 1

      Nice try. I've been caught on that "watch this GIF long enough and something amazing will happen" jokes before. You won't fool me again!

  20. Apple Creates The Stock Driver by Anonymous Coward · · Score: 0

    Is NVIDIA really to blame for all of this? I mean, on most Macs with NVIDIA cards, the default driver has been written by Apple. Only a few users download the so-called official drivers from NVIDIA. Most Mac users are pretty clueless about such things as keeping graphics card drivers up to date.

    And, if you are allocating a framebuffer, wouldn't it be a form of best practice for the software developer to clear the contents rather than assuming the driver will do it?

  21. It doesn't just happen on Apple by polgair · · Score: 2

    I've got an older GTX 760 running on an HP Z820. I run ubuntu on this thing and use nvidia-352 drivers. When I log out of gnome3 and log back in through lightdm, I see the same exact symptoms. I can see what was previously displayed on my framebuffer, including firefox and chromium windows.

  22. This, this, this! by tlambert · · Score: 5, Insightful

    Chrome advertises its Incognito mode as leaving no traces behind. Therefore, it should be responsible for wiping its framebuffer, just as it clears caches, cookies and history. It's like writing a file shredder that doesn't actually overwrite files, then blaming the OS and hard drive manufacturer for the oversight.

    This, this, this!

    If it's incognito, it should not trust anyone else to ensure the privacy of the user's data, not even the OS. We already know that it's possible to use CPU cache bugs as a covert channel to snoop on other processes running on your computer; if the application claims to maintain security, it needs to zero the memory itself.

    As an aside, a GPU is a better machine for zeroing pages than the main CPU, and won't pipeline stall or time stall the main CPU by doing it, and GPUs are traditionally really good at manipulating large amounts of memory. So one has to wonder: why doesn't nVidia expose a primitive that Chrome can then use to zero the pages of a frame buffer, before or after it is used?

    1. Re:This, this, this! by Anonymous Coward · · Score: 0

      OK, I was buying the OS responsibility argument, and I still think the OS cannot duck this issue. However you raise an interesting point.

      Incognito Mode perhaps ought to, in the name of security and functional integrity, add it's own wipe process. Regardless of whether the OS does data wiping or not. It might be necessary as a second line of defense and to protect the integrity of the whole incognito functional concept.

      As to people raising the performance issues. Yeah, it happens, so what? Perhaps you could argue that at a system level, this speaks to design priorities and how they can sometimes conflict (or at the least, that you need to make choices). However in relation to Incognito Mode specifically, there's no logical way to justify not zeroing your pages. It's Incognito Mode, not Performance Mode.

      Also, the matter of data leakage between tasks and processes has been known since forever. I remember discussing this 15-20 years ago on OS/400 and discovering that indeed, the OS there routinely zeroed memory before allowing programs to allocate that memory. Whatever data leakage concerns exist on a single user/multi-tasking device, exist all the more on a multi-user/multi-tasking device.

    2. Re: This, this, this! by Anonymous Coward · · Score: 0

      No. Chrome cannot guarantee that any attempts it may make at clearing buffers will be successful. Chrome might crash or be killed and never get a chance to clear those buffers. As things stand currently, the leaked buffers may even be outside of the control of chrome, e.g. because a call similar to realloc() may hav returned a new pointer and made the old one unreachable. In my opinion, it is clearly the OS's responsibility, possibly with a suitable API for the driver to ensure that no leaks.

  23. Been like this forever and a day... by Anonymous Coward · · Score: 0

    Just after Christmas 2008, I got a then new Macbook Pro. I noticed this issue cropping up often when launching full screen games, fragments from many different windows from previously run programs filled the screen, often with pictures, stills from videos, and text.

    That machine just died late last year, and I always kept the OS up to date.

    At this point I really don't have high confidence in the competence of Apple's software people.

    1. Re:Been like this forever and a day... by Anonymous Coward · · Score: 0

      Apple is just a marketing company, technology is a byproduct done for the ads and product placements in TV shows.

  24. Re:Chrome? by Anonymous Coward · · Score: 0

    Looks like you have no clue what incognito mode even does.

  25. Re:Chrome? by Anonymous Coward · · Score: 1

    Nope, she's a rary!

  26. Re:Chrome? by Anonymous Coward · · Score: 0

    If you do anything long enough you get good at it and eliciting a response from people is no exception. Politicians, comedians and trolls all work to learn what makes people do something and quick ways to do it. Cheap snark is always good for mod points.

    The best thing you can do though is get your comment in early. Nobody reads more than the first few so if you're at the top, get ready for everyone who was about to post the same thought as you to give you votes.

  27. Skim reading by wonkey_monkey · · Score: 1

    *opens link*

    ... pornography ... splashed on the screen ...

    *closes window*

    --
    systemd is Roko's Basilisk.
  28. Not just Macs by Anonymous Coward · · Score: 1

    If you enable 3D mode in your VirtualBox VMs, then you will see the screen buffer contents when you reboot them, Tried this with RHEL7 guests on Linux host, the host has NVIDIA card.

    Also, with same NVIDIA setup, if I boot from RHEL into Ubuntu, I can see the RHEL screenbuffers in Ubuntu when logging into the desktop.
    NVIDIA isn't clearing the buffers properly.

    1. Re:Not just Macs by Anonymous Coward · · Score: 0

      Not just NVIDIA, the radeon drivers do the same

    2. Re:Not just Macs by MachineShedFred · · Score: 1

      This is Nvidia being Nvidia. They fucked up in their drivers, AGAIN, and are buying time by pointing blame and spewing nonsense until a new driver comes out next week that randomizes frame buffer addresses for different applications. Then they will crow about how they fixed someone else's problem, because they are such nice people.

      This story is 60% bullshit, with 40% slashdot dupe added in, as we already saw this one on Windows earlier in the week.

      --
      Slashdot still doesnâ(TM)t support Unicode after it was added to the HTML standard in 1997.
    3. Re:Not just Macs by HMage · · Score: 0

      Yup, here's a link that explains this behaviour -- http://www.websecuritywatch.co...

      --
      Eugene 'HMage' Bujak
    4. Re:Not just Macs by Anonymous Coward · · Score: 0

      This case is Apple being Apple. Apple writes all the GPU drivers for MacOS (and iOS), not the hardware vendor (AMD, Intel, and Nvidia GPU drivers are written by Apple) because of NIH at Apple.

      Your comment is 60% bullshit, with 40% Fan-boi ignorance added in.

  29. Re:Chrome? by Anonymous Coward · · Score: 0

    and this is modded down.. why? sounds like a reasonable way to do things to me.

  30. Another failure of the blob model by FithisUX · · Score: 0

    and a reason for me to stay away from NVIDIA blobs (unless they fully document their hardware).

  31. Almost exact same vulnerability as Heartbleed by Anonymous Coward · · Score: 0

    It seems to me to be obvious that NVIDIA is correct and the MacOS behavior is wrong. MacOS is apparently leaking information between users by not zeroing pages. This is almost exactly the same vulnerability as Heartbleed where an exploit could read "too far" and access sensitive memory that had not been zeroed or protected properly.

    Who's to say the screen buffer that MacOS does not have all sorts of sensitive credentials and other private information? If the browser wasn't in incognito mode, would this kind of leakage really be ok??

  32. Only part of the problem. by dlingman · · Score: 2

    There are two real issues here.

    The first is that malicious programs could open up, grab screen buffers, and get access to stuff that had been on the screen to use for their nefarious purposes.

    This is bad, and unless we get decent support to isolate the frame buffers (and other graphic memory) between apps at either the driver or hardware layer, it's not going away anytime soon. Dont want this? Power cycle (all the way off - not just hiberante) between application launches would do it.

    The second is sloppy programming on the part of non-malicious applications. That's what is being talked about in the application. Diablo apparently asked for a frame buffer, and then presented it, as is, to the user without putting what it wanted in place, trusting for it to be in a particular state. Which it wasn't.

    You want a black screen to show to the user, then write zeros into your buffer before you show it to the user. Decent compilers/languages will tell you if you've tried to read from unitialized variables, and you should never trust that anything you've asked for dynamically is in a safe state, unless you've explicitly requested that it's cleared before being handed to you. Why should a resource from the graphics card be treated any differently?

    NVidia is right about one thing here - most of the time, nearly all of the time, the thing you do with that buffer you're given is to write your stuff into it, completely overwriting it, and it would slow things down if they had to guarantee that it was cleared before handing it out to you. If your program doesn't care enough to do so itself, that's not really their fault.

    It would be nice if, on program exit, all GPU resources used by that app were flushed, but again, that would involve the OS needing to be told of all the GPU resource allocations and deallocations so it could clean up properly, and that too would probably slow things down. Not a lot, but enough to be annoying when your game stutters.

    1. Re:Only part of the problem. by Anonymous Coward · · Score: 0

      To me, the problem is the shared memory model (DMA Access) that the PCI-E gave to add-in cards. Maybe we should go back to the AGP slot configuration and not allow the video cards to share CPU/Memory resources or the better fucking option is for the Video Driver to quit assigning memory on the card - it's a fucking shared resource and let the OS handle that aspect. The only thing the GPU driver needs to worry about then, is controlling the GPU itself and it also means they can quit offering more expensive memory on their video cards other then quantity.

      Give me a card with the option of adding in 8/16/32GB of memory that my system can use and I'd be a much happier camper simply because I could then decide how much memory I need on the motherboard itself. Hell most of the Motherboard Makers would absolutely love to drop memory slots entirerly and use a PCI-E slot to provide all of the system memory (means we'd finally have some decent Ram Disk options).

    2. Re:Only part of the problem. by Anonymous Coward · · Score: 0

      "This is bad, and unless we get decent support to isolate the frame buffers (and other graphic memory) between apps at either the driver or hardware layer, it's not going away anytime soon."

      We tried that in Windows NT4 (no DMA to video memory.) It caused way too many fucking headaches.

  33. Re:Chrome? by ArchieBunker · · Score: 1

    I keep hearing slashdot talk about all the evil shit that Chrome does behind the scenes. So let's see some sniffer logs or some evidence of Chrome doing something its not supposed to. I'll wait.

    --
    Only the State obtains its revenue by coercion. - Murray Rothbard
  34. This does NOT happen only on Macs. by Anonymous Coward · · Score: 0

    This has happened and continues to happen REGULARLY on my Windows 7 system with every GPU from the GeForce 7950 GTOC to the GTX 460.

    It's NOT an Apple issue. It's solidly an nVidia issue.

    1. Re:This does NOT happen only on Macs. by MachineShedFred · · Score: 1

      More than that, Nvidia has a web driver available for OS X for Quadro-series cards, but it works just fine with GeForce series cards (from anyone, and not just Apple) as well. Download it and test - if it still happens, then Nvidia is just as full of shit as always.

      --
      Slashdot still doesnâ(TM)t support Unicode after it was added to the HTML standard in 1997.
  35. also by Anonymous Coward · · Score: 0

    That also happens on my iPad using the dolphin browser, fwiw.

    1. Re:also by Anonymous Coward · · Score: 0

      That also happens on my iPad using the dolphin browser, fwiw.

      Of course Apple wouldn't ever think about crippling any non-Safari browsers on their platforms would they? That would just be evil.

      (Maybe I just answered my own question).

  36. This isn't new by Anonymous Coward · · Score: 0

    Mac graphics has done this for years. It happens with the embedded Intel graphics as well on my old Mac mini. There must be a system level frame buffer somewhere that's not being fully released. This "issue" has been around for more than a decade. I used to see it capturing video on machines, during system startup just before the desktop would appear, and hapless other times during application launch or termination.

    As was stated in the linked article, this can only be "exploited" with physical access to the machine and a login. It cannot be exploited remotely, so the chances of this being a problem for someone are slim at best.

  37. It's *everyone's* fault by ilsaloving · · Score: 1

    As far as I'm concerned, it's *everyone's* fault. What we have here are a bunch of companies that are playing an immature pass the buck game.

    Chrome's incognito is supposed to be secure. Wouldn't any reasonable person expect a wipe of used VRAM to be included as part of cleanup process when an incognito window is closed? I know I would. But they don't, because they expect it to be handled by the driver.

    NVidia's driver should be wiping memory that has been released by the calling app. It's *their* driver. Therefore they also share responsibility, unless Apple wrote their own NVidia driver and kept NVidia out of the dev process,

    OSX should be taking care to wipe any volatile resources in between passing them from one process to another. That's just basic security.

    Microsoft probably already does this, because they've had to deal with idiot vendors for decades who don't do the right thing.

    1. Re:It's *everyone's* fault by Anonymous Coward · · Score: 0

      Except that the video driver doesn't know when an app releases video memory. The GPU memory is managed by the OS, not the video driver.

    2. Re:It's *everyone's* fault by Anonymous Coward · · Score: 0

      NVidia's driver should be wiping memory that has been released by the calling app. It's *their* driver. Therefore they also share responsibility, unless Apple wrote their own NVidia driver and kept NVidia out of the dev process,

      As noted many times, Apple writes the MacOS GPU driver for the Nvidia card (as they do with the AMD and Intel GPUs). Apple gets a reference/example driver from the OEMs, occasionally ask questions about the code, but only feed back hardware bug reports to these GPU companies (about 1/2 of the reported hw bugs turn out to be Apple driver bugs/misunderstandings).

      So although the GPU-OEM companies are marginally in the dev process, none of the companies knows what's actually shipped in the drivers except Apple.

      As for the Microsoft side of the world, the GPU-OEMs write the production drivers and Microsoft merely WHQLs the drivers for "api-compliance". Much of the real QA that might discover this stuff comes from GPU-OEM internal QA groups and large suppliers (e.g., HP, Dell) as part of their driver Release-To-Manufacturing qualification tests (since these suppliers are the ones that get the first line of application program compatiblity complaints and they build up test suites for this kind of crap).

  38. Shouldn't Chrome should be doing this? by Imazalil · · Score: 1

    Isn't it very likely that users would have 'regular' Chrome running almost all the time and periodically open up incognito tabs to do banking or just browse pr0n. Once finished, they would close the incognito tabs/windows but would most likely keep Chrome itself running for a good while longer.

    Another use case is working in MS Word on two documents at once. One is top secret, the other is not, you finish with the top secret one and close it, but you keep working on the other document, keeping Word open.

    In those situations neither the OS or the graphics driver would get the ok to clear out memory as the application itself is still running. The OS could (maybe) protect memory assigned to specific apps, if that is possible with video RAM?

    Maybe running separate processes for each window/tab sidesteps this?

    I have no idea, but certainly this isn't as simple as clearing video RAM after closing an app since the app isn't closed

  39. Reproducer by colin_faber · · Score: 1

    I've seen this, and have been able to reliably reproduce the issue with mplayer, many many times.

  40. lame again.. by Anonymous Coward · · Score: 0

    https://github.com/x0r1/jellyfish
    pls read the above project doc's from 6+ months ago..

    DHI, at it again.. :)

  41. Clear on exit by phorm · · Score: 1

    "You only have to clear the buffer once on exit."

    One of the cases I've heard of this is during a crash. In that case, you may have no clean exit in which to clear the buffer.

  42. Sharing malware, no thanks by lucm · · Score: 1

    I'm not paranoid, it's based on an unpleasant incident.

    Two years ago, many of my friends complained that they were receiving spam from one of my Outlook.com email addresses. It was weird because it was not the sign-in address for my Outlook.com account; the spam was sent using one of my aliases that I used only with a Google account for non-important stuff (Chrome, Youtube, Google search preferences and such but no Gmail) on one specific machine.

    I didn't know how this happened, so I turned off that laptop (which was a spare machine anyways), planning to do a bit of investigation later. Spam stopped. Life caught on, and I forgot about that laptop. About two months later I bought a new desktop computer, and I decided to use that same Google account to sign-in in Chrome and other Google services. My Chrome bookmarks came back from the cloud, but also my friends told me that spam from that Outlook.com alias had resumed! So I wiped that machine and also wiped the laptop and never used that Google account anymore. Nor did I use Chrome sign-in again.

    I don't know exactly what happened. I guess some kind of nasty Chrome extension made its way into my Google account and used my sign-in address (which was an Outlook.com alias) to spam my contacts, and it got stored with my Google stuff. One way or the other, I'm no longer sharing bookmarks, extensions and similar stuff between my machines.

    --
    lucm, indeed.
  43. Want to watch video game documentaries all day? by tepples · · Score: 1

    Which feature films are non-DRM?

    Maybe we could have lists of non-DRM movies (probably just Creative-Commons right now)

    The Creative Commons movies I can think of are Blender tech demos such as "Big Buck Bunny" and "Sintel". These are shorts, not feature-length.

    Even if we establish a DRM-free area in just one genre (e.g. sci-fi), that would still be worthwhile.

    I was trying to allude to FSF's guide to DRM-free video, which links to GOG.com's movie section. And last time I checked, GOG.com's movie section was full of video game documentaries and little else.

    This is prosumerism, if we cannot buy them, we can make them.

    I have a couple questions that would need to be answered before that can become practical: Who pays for their production? And who would pay the damages if, say, it turns out that costume design or music created for the film is an accidental infringement on someone else's work?