HN Simulatornew | past | comments | lists | submit | barbegal's commentslogin

Salesforce has the license to that name and their AI tools use Einstein branding https://www.bloomberg.com/news/articles/2024-03-27/salesforc...

More interested to see how you can use just a single byte overflow to trigger RCE. Definitely achievable but sounds tough.

There was an even more restrictive single NUL byte heap overflow in glibc in 2014 that the ProjectZero folks managed to turn into ACE and thus an LPE in setuid binaries[1]. The final section that talks about bickering over exploitability seems particularly pertinent today.

[1]: https://projectzero.google/2014/08/the-poisoned-nul-byte-201...


The simplest core mechanism of these kinds of exploits is that you can groom the heap by triggering lots of similar-sized allocations, so you have a good guess as to what the heap will contain where your wild write occurs, and then you can trigger specific allocations to land juicy victim structs in the heap where you want them.

It's an evolution of the old "nop sled" idea from stack overflows (and viruses before that), where you don't know exactly what the stack addresses you're targeting are, but you can in your exploit trigger payload include data that will carpet bomb the stack with NOP instructions so that you have a big window to guess.


I was under the impression that everyone adopted the OpenBSD randomized memory heap by default. Does this imply that it's not enough to prevent this sort of attack from working? If this is even slightly repeatable then the mechanism doesn't seem to be sufficiently random. I'm not an expert on low level memory allocation but at a high level it seems like we need to do a better job of randomizing the heap if this sort of thing is still possible.

All the heaps are (probably) randomized. I haven't seen an exploit for this (but know them to exist). ASLR is not a reliable countermeasure for these kinds of flaws. Here's a good starting point:

https://azeria-labs.com/grooming-the-ios-kernel-heap/


To be able to effectively turn a single byte overwrite into ACE is still challenging because you will corrupt outside of your buffer, but this corruption must be meaningful.

I would be curious to see how they were able to exploit it here.


There was an article on this topic in Phrack 55 back in 1999: https://phrack.org/issues/55/frame-pointer-overwriting#artic...

Exploitation conditions are likely more challenging today but that’s the earliest reference I know for exploiting a single byte overflow.


The commit message for the Ruby fix says it's a heap buffer, so frame pointer smashing would not apply here.

Exactly, these advanced heap exploitation techniques are a relatively new development (last decade or so) and were not even remotely known in 1999. Most of the developments were driven by browser exploitation.

The next byte in the heap might be the size of an allocation, so if you overwrite it and then free that other allocation, the heap code will think that there is a very large free area there instead of a small one, once you allocate that, you now have a very large heap overflow and can do more fun things. That is just one idea, there are many other ways.

Actually only 7MW assuming a 4ohm speaker coil. Impressive but I've seen bigger bangs on youtube with even more energy https://www.youtube.com/watch?v=OC7sNfNuTNU

styro was inspired by photonicinduction, by his own admission

"Only" 7MW XD. The coil doesn't remain a coil for long, though, and it's hard to predict the behavior of the rapidly expanding ball of plasma.

This simulates the chip but do I still have to write the simulation of my actual board which often has equally complex ICs on it and mixed analog and digital?


Unfortunately yes, we are limited in the mixed signal domain right now, that is by design. you would need to interact with ICs at a data level or pin level transactions. This would be digital levels nothing analog.

This was kind of part of our original offerings to have a firmware mixed signal co-simulation. Run firmware--> see Spice level simulations happen. But this was a case where the speed to fidelity trade off really didnt make sense... yet. We were spreading ourselves thin on a long horizon project with nothing to show for it during the YC term.

We will come to revisit this problem for sure as we have heard many of our customers ask similiar question for analog IC purposes. Just have to take it one step at a time.


one spot where pin-level leaks is the ADC. tons of "firmware bugs" are really a big divider that can't recharge the sample cap in time, so readings come out low or depend on the previous channel. even just modeling source resistance vs sampling time would catch a lot of that


This. And Claude writes my firmware and does a pretty damn good job, and it can even test with a bench setup. So honestly, I don't think this simulator has much viability. It's a bitter message but I think the earlier they recognize this the better.


Yes I totally agree claude can write some damn good firmware! but at an enterprise development team scale for testing needs simulation. It has and always will for any critical embedded system. I think its the other way around that the viability will only get greater. Only this year did people start trusting LLMs with firmware so the bet based on what we saw at industry, the better the AI the better you want the simulation it can use for your development.

The other contributing cause is the actual lack of silicon in supply and we are seeing it especially for the automotive industry, which is only spiking demand for better simulations to unblock teams.

If you want to ship with agents at scale you need a good testing pipeline now more than ever. We don't replace the bench setup test, we look to enhance what you bring to it.

But that doesn't take away from the fact that, yes you could just let your LLM continuously loop on some hardware setup, rinse and repeat for weeks. If you have the hardware and the time to spare.


But what if (due to the availability of AI) it becomes more common that hardware vendors provide simulation models with their hardware? That's the direction I'm hoping we will move in. And if it doesn't happen, perhaps FOSS enthusiasts will provide these models ...


I would say that is true, that hardware vendors should and can provide simulation models with their hardware. We know they can because they rely entirely on simulation to test their chips before tapeout.

We even tried to work with chip vendors (won't name here but they are 2 out of the 10 biggest microcontroller designers), but in reality, them providing their own simulation is a little bit counterintuitive for them.

They make their money on selling chips, and their thought is that providing a simulator would make it so that people buy less chips. If they do provide a simulator, it would be hella expensive, like through the Synopsys Virtualizer, which costs $500k per seat.

For RISC-V and open-source MCUs, they are easy to simulate. Just run the RTL through something like Verilator, and you have a fully working simulation.

We do hope that chip companies eventually do exactly that. We are also firmware engineers, and our goal is to make the simulation software we needed while working in the field. Either we make it, or they make it. Win-win in my opinion.


Certainly a win if someone makes it, but I think that with the help of AI, soon anyone with a datasheet can make those simulation models. And even if it's not that simple, open source folks will do it.


There is some evidence that Gabapentin can assist with benzodiazepine withdrawal https://ispub.com/IJPHARM/4/2/3283#


Without a human to benchmark against it's really tough to gauge how good these models are vs how good the task definitions and existing codebases are.

My intuition from the example full instructions are that the tasks are poorly specified which results in ~60% failures due to bad assumptions and missing requirements.


18 O enriched water is available to buy but the pricing suggests it's quite expensive to separate 16 O from 18 O. And you get much less variability in the ratio of isotopes from mixing compared to separating a single isotope as much as possible.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: