7 ms·
Yes. You could also memset any memory to zero once you're done with it, which isn't a bad idea for applications with high security requirements.
by kayamon 11y ago
Yes. You could also memset any memory to zero once you're done with it, which isn't a bad idea for applications with high security requirements.
- rcthompson 11y agoIf you're modifying memory immediately before freeing it (i.e. after the last time you read it), don't you have to be extra super careful to do so in a way that the compiler won't optimize the operation into nothingness? (I don't program in compiled languages very much, so I don't know the details about this.)
- kayamon 11y agoActually yeah, that's a very good point. Sometimes compilers are just too clever. I think some systems have a "secure memset" function that can be used for things like this - i.e. one that's guaranteed not to be optimized out.
- ape4 11y agoYes, memset_s(). Which makes me think there should be a free_s().
- TheLoneWolfling 11y agomemset_s, or a mythical free_s, is not enough. The compiler can, and will, make copies of data behind the scenes. And not erase said copies. What we really need is a keyword / modifier that says that when X passes out of scope no state related to X may be leaked. Ideally, that can be applied to a function / block as well as a variable. (Or rather, not necessarily no state. Read "as little state as possible", preferably with modifiers that panic unless the compiler can ensure specific things.)
- mpu 11y agoThe C standard works at an abstraction level that makes it unsuitable for security applications, I would advocate for a new language here. It needs serious PL research with informarion flow reasoning, what we need is just a new kind of language much more machine aware (yes, more low-level) than C.
- TheLoneWolfling 11y agoAgreed on some level. On the other hand, something as simple as a keyword marking a variable as "as secure as possible given hardware constraints (read: should wipe any temporary copies and the variable itself after it goes out of scope, should attempt to prevent it from being written to non-volatile storage, that sort of thing)" (sort of like how inline works), with compilers required to bail if the constraint cannot be done to the level specified, would be a massive step in the right direction.
- thaumaturgy 11y agoYes, you're correct. See e.g.: http://www.eliteraspberries.com/blog/2012/10/zero-and-forget--caveats-of-zeroing-memory-in-c.html http://www.eliteraspberries.com/blog/2012/10/zero-and-forget... (which has a link to some HN discussion at the end of the article).
- TheLoneWolfling 11y agoYes. There is, quite literally, no way to ensure data is not leaked (namely, that data is zeroed / etc) in portable C / C++.
- alain94040 11y agoOr in assembly, for that matter. You never what data the CPU is duplicating behind your back: store buffers, prediction, etc.
- TheLoneWolfling 11y agoAt least with assembly most of the time you can't ever get that data back. Although not always. With C it's far too easy to get the data back. Also, you missed the worst example: CPU cache.
- TheLoneWolfling 11y ago...Except, of course, the the compiler can and will optimize away any such memset. Do not attempt to write secure software with C / C++. It is a Bad Idea(TM). Because what you wrote is not what gets run. For instance: there is no way to write a portable secure memset in portable C / C++. (You can write a "secure" memset that works in all current compilers, but that is not the same thing. What doesn't get optimized now can and will be optimized tomorrow.)
- deleted 11y ago[deleted]
- kosmic_k 11y agoSo what is someone working with embedded devices for IoT supposed to do? Much of that work is based on ARM C/C++ Compilers.
- pjc50 11y agoIn practice, of course, memset actually works, because it's a function and the compiler's usage tracing is nowhere near able to spot that you don't reference those zeros that you write. (IoT security is doom for other reasons though, mostly UI, updatability and cloud services)
- vardump 11y agoReally? In my experience most compilers treat it pretty much like an intrinsic and generate specialized set of instructions if they can.
- TheLoneWolfling 11y agoFor now. And then that code you wrote now silently becomes deadly a few years down the line.
- pjc50 11y agoI would be very interested to see the compiler that can optimise away memset across a shared library boundary.
- pjc50 11y agoFor key material, you also ought to page-lock it in memory to prevent it ever being swapped out.