HNHacker News
TopNewBestAskShowJobs

justinschuh

1,416 karma · joined June 26, 2011

Defunct
submissionscomments
justinschuh··on How Chromium Works
We've invested quite a bit of energy in static analysis tools over the years, but so far the return hasn't been there. There are still ongoing efforts, and we'll see if those pan out, but up to this point we've just run into a very low hit rate and a false positive rate that drowns everything else out from a security perspective. Formal methods are a different question, but I can't imagine the size of the undertaking needed to convert even a subset of Chromium over to formal methods.

Instead, we've focused pretty heavily on more conventional anti-exploit mitigations applied to existing C++ code. Our sandboxing is the most obvious one, but we have a variety of other protections on top of typical stuff like ASLR and NX (e.g. heap partitioning, a safe integer handling toolkit, etc). We're also leading efficient control-flow integrity work in clang, and busily working it up to a stable release. And then we have fuzzing as part of our continuous integration, running across thousands of cores of instrumented builds.

justinschuh··on How Chromium Works
Like Aaron mentioned, the renderer was originally split into a separate DLL because we hit the limits of Microsoft's linker at the time. Later, we ended up relying on that split for disabling win32k inside the sandbox (otherwise we would have had to deal with a bunch of broken USER and GDI initializations).

As for the remaining DLLs, it mostly comes down to licensing concerns. We don't include proprietary code in our main binaries, and in order to simplify IP concerns it's often best to split such code into other DLLs. For example, you asked about libegl.dll and libglesv2.dll, which I believe include a licensed copy of the SwiftShader library.

It's also worth pointing out that the performance impact of having a single, static binary in Windows is much less significant than it used to be. So, were we starting Chrome today I'm not so sure we'd make the same decision.

justinschuh··on Why NASA Switched from Unity to Blend4Web
I think you're reading something different than what I intended. I don't work on V8, and what I know about their priorities is no different from what they've stated publicly. That is, the V8 team wants to improve asm.js performance by improving overall JS performance, and not special case behavior just for asm.js. I know that's not the route you took, but that was my point about "not everyone agrees with the path you chose" with Firefox. And regardless of what either of our personal views are, it's hard to objectively argue that the V8 team is wrong in focusing on areas that positively impact the overwhelming majority of their users.
justinschuh··on Why NASA Switched from Unity to Blend4Web
It's not hostility. It's just that you're a very passionate Mozilla employee and a very passionate creator of asm.js. And from past experience I expect that you'll be willing to continue a debate longer than I can. Plus, you already know that I have reservations about asm.js, and it's just not worth rehashing that debate (accepting that WebAssembly appears to be heading in a direction that addresses most concerns, so I should offer well earned kudos on that front).

Getting back to your point, pragmatically speaking, maintaining a port is a distinction with less difference than implied. First, any reasonably complicated NPAPI plugin needs to handle a range of browser-specific quirks, meaning that significant porting is unavoidable even if it's bundled into one binary. Second, Unity supports ActiveX in IE, so they're clearly already comfortable maintaining a browser-specific port that doesn't offer any of the security or platform portability benefits of NaCl.

Outside of that, there's just the one-sided nature of the argument. As a creator of asm.js you are obviously a huge proponent. However, you must appreciate that not everyone perceives it the way you do, and not everyone agrees with the path you chose for adding support into Firefox. So, the technical burdens on another browser are just not the same, and in the specific case of Unity in Chrome have to be balanced against the fact there was already a tremendous past investment in a high-quality implementation.

So, no, I completely disagree with the framing that "Chrome has left Unity no good option". Independent of any work in Chrome on better supporting asm.js, the fact is that Unity had at least one other good option. So, I'm sure Unity had their reasons for the path they chose, but it was and continues to be a very explicit choice.

justinschuh··on Why NASA Switched from Unity to Blend4Web
I want to be clear that I fully intend to spend my weekend with my family, and not arguing this with you. So, I'll avoid rehashing any of our past discussions regarding technical concerns with asm.js. However, as the person responsible for Chrome's NPAPI deprecation, I just want to set the record straight regarding Unity.

Unity previously had a high quality NaCl port (long before asm.js ever existed) and I fully expected that they would continue to support it. Plus, long prior to NPAPI deprecation the Unity NPAPI plugin was on our security blocklist due to a rash of vulnerabilities. So, I don't know why Unity chose to drop support for NaCl, but it occurred well after they became aware of our plans to remove NPAPI. And if you want a public record, you'll notice that Unity 4.3 was released (without NaCl support) months after our NPAPI announcement:

http://answers.unity3d.com/questions/574054/can-i-use-native...

justinschuh··on Hackers Exploit 'Flash' Vulnerability in Yahoo Ads
> If Flash doesn't run under NaCl why use the PPAPI? Wouldn't libc be much more convenient, since you don't have to port Flash to the PPAPI?

I think you might have a few misconceptions. Chrome employs an outer process sandbox using OS primitives like seccomp-bpf on Linux and token restrictions on Windows. This process level sandboxing is what we use for running all untrusted content in Chrome. NaCl runs inside this outer sandbox as well, but it also applies an inner sandbox enforcing code flow integrity by verifying binaries against a subset of allowed instructions. PPAPI provides a portability layer that also serves to broker access to resources for any of Chrome's sandboxing mechanisms. So, something like PPAPI is needed for any sandboxed Chrome code, regardless of the sandboxing mechanism.

> Furthermore, I would imagine using the PPAPI directly wouldn't do much to enforce security since Flash can do whatever it likes in it's virtual address space, including jumping past checks and assert instructions in the PPAPI?

PPAPI isn't a security layer. As I mentioned above, it's a portability layer that can be used to broker resource access to sandboxed code. And PPAPI Flash is definitely sandboxed; it's just in a process sandbox that doesn't have the additional restrictions of NaCl's CFI sandbox. To explain a bit more, sandboxing in general isn't a binary state. Rather, there are varying degrees of restrictions that can be employed depending on the content, and in the case of Flash there are certain implementation details and legacy requirements that prevent it from running under the full set of restrictions that Chrome can apply to other content.

> If Flash doesn't run under NaCl, does it run under the same user and privilege as Chrome?

No, as I mentioned above Flash is sandboxed and runs at a severely reduced privilege. However, depending on the platform Flash may run at slightly greater privilege than Chrome runs e.g. Web content. And on all platforms, the Flash sandbox is less restrictive than the NaCl CFI sandbox (mostly due to the absence of CFI, but there are a few other differences as well).

>> Several reports on Twitter suggested the exploit could be used to bypass Google Chrome‘s protective “sandbox” technology

> It's frustrating that there is no source. However, the above quote would suggest that Flash runs inside NaCl. Is this factually incorrect?

The Hacking Team leaks included a Windows kernel escalation exploit against font parsing code exposed by Windows GDI. The vulnerability has since been fixed by Microsoft, but it was previously exposed to any process that could access GDI, which includes Flash in Chrome (and every other browser for that matter).

This also highlights the point I made earlier about varying degrees of sandboxing on different platforms, because Chrome doesn't expose GDI to Web content. Rather, Chrome uses a capability present in Windows 8 and above to disconnect the win32k subsystem from sandboxed Web processes, shutting off GDI and all other Win32 attack surface entirely. However, the same approach is not viable for Flash because the Windows version of Flash is coupled very tightly with GDI.

justinschuh··on Hackers Exploit 'Flash' Vulnerability in Yahoo Ads
Flash in Chrome uses PPAPI plus some private APIs that were necessary to support Flash-specific features. It absolutely does not use a strict PPAPI sandbox and does not run under NaCl. To explain some differences, the Flash plugin is not bound to Web origins like NaCl plugins are, because Flash cannot strictly follow the Web origin model. And there are platform differences as well, such as on Windows where Flash requires GDI access but for other sandboxed content we block the entire win32k subsystem (including GDI).

My advice for security conscious people is to enable click-to-play in Chrome for Flash content, because it has a featureset and legacy dependencies that prevent it from ever being sandboxed as strongly as other content.

justinschuh··on Key for chromium's encrypted cookies store in Linux is “peanuts”
System credential managers are the established way to do this properly. They are user configurable, generally maintain credentials in a separate security context, derive a strong key from the user logon credential, can more easily support hardware security mechanisms, and introduce minimum user friction by default. That's why Chrome and most browsers prefer the system credential managers when available (on Linux: libsecret, Gnome Keyring, or KWallet).

The application specific "master password" is more of an anti-pattern for effective credential storage. The most glaring issue is that user friction is so high that it's rarely ever enabled, because it's just too inconvenient and confusing for most people. But beyond that it has the weaknesses typical to any credential manager not deeply integrated into the OS (e.g. credential management is handled entirely in the user's context, management is inconsistent between applications, etc.).

justinschuh··on Key for chromium's encrypted cookies store in Linux is “peanuts”
The obfuscation isn't really intentional IIRC. It's an artifact of the assumption that a proper base credential will be available from either libsecret, Gnome Keyring, or KDE Wallet. The fixed key is just a placeholder that gets used when none of those secure mechanisms is installed on the system. Although, that file has a number of outdated comments, which add to the confusion.
justinschuh··on Key for chromium's encrypted cookies store in Linux is “peanuts”
That's a bit out of date, because libsecret is supported as well: https://code.google.com/p/chromium/codesearch#chromium/src/c...

But yeah, it pretty much looks for any sort of secure credential manager and falls back to the fixed key only when nothing is available.

justinschuh··on Avast Anti-Virus for Mac Uses “Man in the Middle” Scheme to “Protect” You
> Of course, this is unacceptable - but there are very few alternatives. For the record, we - rawstream - don't do this as its crazy to compromise security like this. So we had to find other means.

So, then you're using extensions, BHOs, API hooking, or some combination thereof depending on platform?

justinschuh··on Researcher who exploits bug in Starbucks gift cards gets rebuke, not love
From my own experience, actually making the purchase is likely to be perceived negatively. He had already successfully demonstrated the race condition allowing the transfer, so he had enough to clearly make his point. That stated, were I in Starbucks' position I'd lead with a big "thank you" before explaining the liabilities and why he shouldn't go so far to make his point in the future.

Also, in the interest of full disclosure, I should state that my team has interacted with Homakov on a number of Chrome vulnerability reports. In my experience he's very sharp, he finds interesting bugs, and my impression is that he's generally trying to do the right thing. However, I can definitely see how his communication style might not come across very well, particularly to a security team that's not used to dealing with the security research community.

justinschuh··on Fort Huachuca bids farewell to Morse code training
Interesting... to me at least. I was stationed there for manual Morse school back in 1997.
justinschuh··on Chrome team planning to block all access from browser to localhost wss
Pretty much. It would probably be an interstitial on navigation (similar to how certificate errors are handled) and a page action for subresources (similar to the shield page action for mixed content).
justinschuh··on Chrome team planning to block all access from browser to localhost wss
FWIW, the title is beyond sensationalist, and outright wrong. The title on the link is "Block sub-resource loads from the web to private networks and localhost".
justinschuh··on Chrome team planning to block all access from browser to localhost wss
I'm sorry, I know this is an earlier comment but I wanted to correct this framing of the threat and proposed mitigations. My response to you here explains why these measures don't solve the attacks that we're trying to address: https://news.ycombinator.com/item?id=9211034
justinschuh··on Chrome team planning to block all access from browser to localhost wss
As I explained elsewhere, the origin header in WS(S) allows a server to overtly protect itself from a client. Unlike CORS, it doesn't allow the browser to make security decisions regarding requests, and so would not address any of the attacks we're trying to prevent.
justinschuh··on Chrome team planning to block all access from browser to localhost wss
We'd be blocking sub-resources and navigation from web to private. Of course, direct navigation via a bookmark or the omnibox would still work. And navigation or resource inclusion from private to the web would still work.

As I explained in another comment, we're also working on exception mechanisms (including per-page opt-in, possibly via CORS) to cover the valid use cases.

justinschuh··on Chrome team planning to block all access from browser to localhost wss
A subresource is basically additional content that a page includes via a URL (e.g. script, iframe, images). The problem underlying this is that any page on the web can currently probe and then attack devices and servers on your internal network or local host. So, the proposal is to block that by preventing remote websites from navigating to or including sub-resources from anything on your internal network or local host (unless some explicit opt-in or exception is configured).
justinschuh··on Chrome team planning to block all access from browser to localhost wss
I'm sorry, but I don't understand the argument you're making here. I've already explained that we plan to provide a portable mechanism for private and localhost opt in. It's just not going to be the mechanism you propose, since that mechanism doesn't address the vulnerabilities that we're concerned about.

To reiterate the issues with your proposal: Public DNS pointing to private/localhost is in fact a component of many of the attacks we're concerned about. HTTPS on localhost doesn't do anything because the transport is already secure (which should be simplified in a future change in Chrome's content handling). And given that the major concern is weak/permissive servers, we can't rely on the WS(S) server implicitly protecting itself by enforcing the origin header.

justinschuh··on Chrome team planning to block all access from browser to localhost wss
We'll be changing the mixed-content detection soon to treat localhost as a secure transport (because it is from the network perspective), which will address the mixed content issue.
justinschuh··on Chrome team planning to block all access from browser to localhost wss
Potentially, yes, and it's one of the ways we're looking at addressing per-page opt-in.
justinschuh··on Chrome team planning to block all access from browser to localhost wss
As I explained in my other comment, the origin header in websockets doesn't help in addressing the attacks we see, because it is a server-side measure.
justinschuh··on Chrome team planning to block all access from browser to localhost wss
That's not the way the origin header works. The origin header in websockets is provided from the client to the server, and the server must take overt measures to protect itself or scope origins that are allowed. Given that we're worried about unsafe servers, the origin header won't protect against the attacks we're seeing. What we need is a mechanism for the server to authorize the client explicitly, so that we can disallow the resource implicitly when authorization is not present.
justinschuh··on Chrome team planning to block all access from browser to localhost wss
As I already stated, we plan on having an explicit opt-in for these cases. However, what you're describing is an implicit opt-in (external DNS pointing to localhost, etc.), which can be trivially abused by third-parties in exactly the kind of attacks we're trying to prevent.
justinschuh··on Chrome team planning to block all access from browser to localhost wss
I mentioned this above, but we plan to let the localhost/private page support an explicit opt-in, maybe via CORS headers. Those details may not be captured in the bugs yet because currently no one is actively working on this.
justinschuh··on Chrome team planning to block all access from browser to localhost wss
I filed this bug (along with http://crbug.com/458362), and there's a bit of context that may be missed. First, this is to protect weak devices and services on private networks or localhost, that really can't be safely exposed to attacks pivoting from the web. It will block only sub-resource loads and navigation from the web to private networks. Navigating directly (via bookmarks or omnibox) or in the other direction (from private to web) is still fine. Essentially, this is applying similar rules to what's already in place for file URLs.

We also appreciate the concerns for legacy apps, local servers, etc. That's why we plan on supporting blocking UI overrides, opt-in by the page on localhost/private (maybe via CORS headers), and permanent exceptions via the command-line and enterprise policy. So, there might need to be some small tweaks, but all the use cases I've seen described in this thread should still work in a portable manner after these changes are made.

Also, to my knowledge no one is actively working on these changes yet. Hence why the details in the bugs are still a bit nebulous. Although that is likely to change pretty soon.

justinschuh··on Firefox Hello
Your response is utter nonsense. If you had any legitimate argument to make here you'd be citing something to support these wild accusations, but you have nothing of the sort.
justinschuh··on Firefox Hello
Do you really think a code drop from an obscurely named github repo qualifies as open development? Because it can just as easily be interpreted as hiding in the noise, particularly when the eventual asm.js unveiling was done as a giant PR blitz. Of course, you can argue that the secrecy was unintentional, but you can't really argue that it wasn't taken advantage of.

To your argument that Chromium is not developed fully openly, you must understand that Blink and Chromium contributors dwarf the v8 team by orders of magnitude, right (even the security team is a bigger)? And you understand that the difference in code size is even larger, right? I get that you're focused on JS because it's your area, but in the grand scheme it's only one of many, many important pieces. And if we're going to dig into it like this, do you really believe every part of Firefox would hold up to the same level of scrutiny? after all, Richard Stallman has made similar arguments about Firefox not being truly free.

Now for Dart. I just don't see Chromium approaching Dart the same way Mozilla approached asm.js. On the contrary, I strongly expect that dart.js will need to prove the viability and popularity of the language before Chromium includes any specific optimizations or support for it. As for the "leaks," I suggest you read the doc people are referencing and consider the timelines involved. Because, the content paints a very different picture, and the timelines don't at all align with what you're claiming.

As for why the Dart team follows their particular development practice, I don't know. They spun out of the original v8 team and aren't a part of Chrome team. However, I do know both Dart and v8 have some non-negligible testing and workflows tied to Google infrastructure. So, it may just be hard for them to switch, or maybe no one has ever made the case to do so. Honestly, have you tried just asking nicely rather than making accusations? I mean, you say you can't understand it, but your behavior seems to assume and voice the worst motivations for anything related to Google.

justinschuh··on Firefox Hello
Fair enough that v8 is an odd case, but it's an external dependency that predates Chrome/Chromium with its own core team, development processes, third-party obligations, and ecosystem. And accepting that, v8 does have third-party contributors (see their policy here: https://code.google.com/p/v8-wiki/wiki/Contributing). Plus, do you really take issue with the occasional quietly developed code drop, because isn't that pretty much how your team introduced asm.js support in Firefox?

Beyond JS engines, you must appreciate that dependencies and business relationships can get very odd when shipping something as big and complicated as a browser. Chrome/Chromium absolutely experiences this, but so does Mozilla. Take HTML EME, where Adobe's technical requirements have pretty much forced Mozilla to break Andreas' and Brendan's original promises on how much the closed-source CDM will be sandboxed. Then there's the h.264 situation, which is an odd multi-step dance to deliver binaries from Cisco, and is significantly more convoluted than Chrome's use of ffmpeg.

Regardless, I don't believe you're really trying to make the argument that Chromium is not a publicly developed open source project with a huge pool of non-Google contributors. Because you know that to simply be an indisputable fact, even if there is additional complexity around certain dependencies and platforms.

← PreviousPage 2 of 13Next →