insanitybit

I'm a bit confused about what about this feels emergent or unanticipated.

> No human can go edit a brain to become better at math. This is just very, very surprising to me and extremely interesting. I would guess this upsets quite a number of interp theories and philosophical takes on what's going on with these networks.

Why would this have implications for theories or philosophical takes? I'm a bit surprised that you're surprised by this.

Well I'm not a random HNer lol I work in security.

Are you suggesting that they've come up with a novel technique that doesn't involve sharing a CPU core? I'm open to that.

From what I can tell, this is not the case, but I haven't read a detailed report (I don't know of one, would be cool if it's out there though).

> something that our systems are meant to prevent

What prevention method did they take? Like, did they run with hyperthreading enabled or something by accident?

Did they discover a new cache timing technique or is this just the standard stuff?

If they just had hyperthreading on maybe they need to hire someone who knows more about this stuff.

Two VMs should never be sharing a physical core. If they don't know this, yikes.

uv defaults to its own trust store afaik lol

The vast majority of web services are not written in memory unsafe languages so this is not surprising.

One of the exceptions (with regards to web facing attack surface in a memory unsafe language) is that people still use OpenSSL, which has a terrible history of memory unsafety, including the cited heartbleed.

It was.

I don't care, nor should anyone else

Sure, I think it was still under the same unsound tag regardless.

I don't think the definition of "memory safe" has ever required full end to end stack conformance with a proof. Very few languages have achieved that, though some have. Most people call Java memory safe, C#, Python, Typescript, etc - all of those fall short of a formally verified, sound type system with a verified toolchain.

lol I was writing `l` because I thought it was `labeled-unsound` for like a fucking decade

For a long time `loop {}` was undefined behavior. Lots of l-unsounds are really nuts but a few are not.

The reality is that if this were actually code that people wrote, well, it wouldn't have sat around for a decade.

lol do you think that cve-rs was required? there is literally an l-unsound tag on rustc's github, this isn't some embarrassing or secret thing.

Safe rust is safe, granting `unsafe` and compiler errors. This isn't a secret.

This doesn't work when every candidate holds the same position.

I mostly use Haiku for really, really basic stuff, never for actual engaging work. I've used it for first-pass analysis to triage bugs, for example - all it does is related N bugs together to see if any potentially relate. Then I have Sonnet investigate further.

No. It's because Greg doesn't like the CVE system and MITRE, the stupidest decision ever, made Greg a CNA, and this is his tantrum that he's been waiting 40 years to throw.

I think the current state of bug bounties demonstrates that it's about the eyes, not the number.

> 'with enough eyes all bugs are shallow'

This was always nonsense. It assumes that the eyes know what they're looking at. Most people don't know how to look at code and see attack paths.

I think the wording in this title is too strong. MicroVMs like Firecracker have stood up to agents, as noted.

Rust is not 1.5-4x slower at all. Git is not IO bound at all, it is not saturating your IO device, it just performs IO a lot.

Just use TLS / mTLS over the tunnel, no?

As someone building a language with an LLM, it is exactly an exploration of curiosity. I have a lot of ideas, I don't always know how to implement them, and I certainly lack the time. The LLM can write the code, I can guide it, and I can learn what does or does not work.

I agree, but I think most people actually don't think that's true when it comes to services that primarily do IO.

At work we're moving almost everything to Rust on our backend. Massively reduced memory usage and significant latency improvements relative to our Typescript codebase. Even for code that you'd expect to work well in TS, a near 1 to 1 port to Rust has considerably improved our best case and, in particular, our worst case latencies. And the memory we get back is huge, we may even drop our instance size down with the 800MB of RAM we're likely going to save.

Once a day I see a comment somewhere on the internet and go "Yes, perfect, this is the dumbest thing I'll read today. Great, that's out of the way". This is the one today!

Because Javascript theoretically can't just access files on disk. Control over the render would let you do that, if not for the process level sandbox, which constraints things like file access, system, calls, etc.

But the process is still more capable than the VM. The process can talk to other processes via IPC, for example.

That's why you don't go from "javascript -> computer is taken over", instead you go from "javascript -> renderer control -> computer is taken over".

I would assume in this case that there's full renderer control, not just a bypass of the in-process isolation.

> Could they have added a "no internet access" goal constraint?

They could have blocked network access and required that it use a tool. That would have made limiting and monitoring network access even easier.

I don't agree, although it is likely the case. But even if you don't teach an agent about a sandbox bypass, it doesn't matter. Does it know curl? Does it know DNS? Does it know proxying? Then it knows how to pull this off, and it doesn't even need to understand that it's "bypassing" because it thinks it's just iterating towards its goal.

In fact, I wonder if teaching it "this is a bypass" would help it to model when it's doing its job vs working around the job.

I doubt there are many things in this universe that are unambiguously good, but Chrome's sandboxing is certainly as close as anything.

You can make your arguments about noscript if you'd like (I have a great respect for the project) but I think it was essentially irrelevant to user security at the time, real users were really harmed by malware that exploited Firefox, Java, and Flash, and Chrome killed every one of those attack paths in virtually no time at all.

Computers were far more dangerous before Chrome. You watch old TV shows and it's a joke that people would visit a site and get hacked - that's unrecognizable today, it simply doesn't happen. It used to, Chrome changed that.