News for hackers. Stuff that matters.
Re:Don't run 'strings' on untrusted files by Animats on Saturday October 25, 2014 @01:47PM (#8508817)
It's time to start converting the low-level Linux/UNIX utilities to a language with subscript checking. Go, or Rust (if and when it's finished), or D, or something. We have some good options now.
Re:Don't run 'strings' on untrusted files by f- on Saturday October 25, 2014 @02:23PM (#8508930)
The Linux kernel and the core utilities needed for an user-friendly OS add up to a mind-boggling amount of code, written by thousands of hobbyists over the course of decades. That code base has the benefit of actually existing, being familiar to a lot of people, and (mostly) behaving in predictable ways that are consistent from one un*x-like system to another.

So in that sense, it's somewhat counterproductive to just say "somebody oughta rewrite this stuff", unless (like RMS) you're willing to dedicate a good chunk of your life to that mission - or think that your post will inspire somebody else to do the same.

Re:Don't run 'strings' on untrusted files by WalterBright on Saturday October 25, 2014 @03:41PM (#8509155)
As I wrote some time ago,

http://www.drdobbs.com/architecture-and-design/cs-biggest-mi...

it is easy to add bounds checking arrays to the C language. The trouble is, nobody is interested in doing it.

It'd be a heckuva lot easier than changing languages.

Re:Don't run 'strings' on untrusted files by Animats on Sunday October 26, 2014 @03:17AM (#8510446)
(Bright, of course, is the creator of D.)

I agree completely about C. I've been saying this for years. There are three big problems that cause crashes in C programs: "How big is it?", "Who owns it?", and "Who locks it?". The result is over three decades of segfaults and buffer overflows.

There have been three or four variants on C which address some of those issues. I've proposed one myself. None got any traction. The only thing that might work is if someone developed a safe variant of C which could be machine-generated from existing C code, and didn't add significant overhead. GCC already has a fat-pointer subscript checking option, but nobody uses it. That approach is usually slow, with a subscript check on every reference. If you do it right, most subscript checks get hoisted out of loops. Go does that for many FOR statements.

Rust is one of the very few languages which addresses all three of those issues without resorting to garbage collection. I really hope the Rust crowd doesn't screw it up.

Re:Don't run 'strings' on untrusted files by WalterBright on Sunday October 26, 2014 @05:06AM (#8510589)
> GCC already has a fat-pointer subscript checking option, but nobody uses it

My experience with adding extensions to C++ is that nobody will use them, not even the people who proposed the extension, unless it is adopted by the Standard. The same goes for C.

The feature I proposed for C has been in D since the beginning, and has a very strong track record of success - both in user acceptance and in eliminating bugs. Whether the runtime bounds checking is actually done or not is controlled by a compiler switch - but most users choose to leave it on.

Re:Don't run 'strings' on untrusted files by dbaupp on Sunday October 26, 2014 @06:03AM (#8510682)
There are a lot of GCC extensions that are not in the standard. https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html

Things that are definitely used are __attribute__'s and labels-as-values.

Re:Don't run 'strings' on untrusted files by CamperBob2 on Saturday October 25, 2014 @03:55PM (#8509210)
How would that fix the problem at hand? The code in question isn't using array notation. At the end of the day, it's not a case of using C when another language would be better, it's a case of crappy coding.
Re:Don't run 'strings' on untrusted files by WalterBright on Saturday October 25, 2014 @04:03PM (#8509234)
It helps because instead of rewriting the whole app, just the function parameter types are redone where pointers to data are changed to bounds checked arrays, on a case by case basis.

It isn't a magic bullet, but as buffer overflows are (I presume) the most common cause of C security exploits, this would help a lot.

Re:Don't run 'strings' on untrusted files by CamperBob2 on Saturday October 25, 2014 @04:41PM (#8509322)
Maybe, but my fear would be that the act of rewriting it to use array notation will introduce yet more bugs. Some of the comments point out that the problem exists because nobody cared enough to fix it for several years. Having seen that nobody cared enough to fix it, it's not clear that anyone will care enough to fix it properly.
Re:Don't run 'strings' on untrusted files by wyager on Saturday October 25, 2014 @01:59PM (#8508852)
>to a language with subscript checking

Or, more generally, memory safety.

Of the three you described, Rust makes the strongest memory safety guarantees. Neither D nor Rust require a complicated runtime. I'd say this isn't really Go's intended area of usage.

Also, Go is missing things like ASLR and DEP (last time I checked), which means that if you link to any vulnerable non-Go code using cgo (which is almost inevitable when writing core utils), or if you find a good bug in the Go runtime, it's trivial to get code execution.

Re:Don't run 'strings' on untrusted files by Animats on Saturday October 25, 2014 @03:00PM (#8509012)
Address space randomization is security theater. It slows down attackers, but doesn't stop them. See "stack spraying". What it does prevent is replication of security bugs, which allows vendors to ignore them.
Re:Don't run 'strings' on untrusted files by vezzy-fnord on Saturday October 25, 2014 @03:16PM (#8509058)
If it slows them down and makes their lives harder, then it is a worthy mitigation. That's what a mitigation is, after all: it reduces severity and effectiveness. It's not a full stopgap. Even still, ASLR implementation quality has left much to be desired throughout the years.
Re:Don't run 'strings' on untrusted files by wyager on Saturday October 25, 2014 @03:06PM (#8509023)
Counter-ASLR measures are not always viable. Regardless, Go also lacks DEP, which is the more important of the two.
Re:Don't run 'strings' on untrusted files by imanaccount247 on Saturday October 25, 2014 @03:22PM (#8509081)
No it isn't. If trying to exploit some daemon requires thousands of tries instead of one try, I am thousands of times more secure. Because they will almost certainly fail the first time, causing the daemon to crash, and then have no more tries. It is only security theater if you live in the land of "lets use broken software that crashes all the time and then run a monitoring tool to automatically restart it". That is the problem.
Re:Don't run 'strings' on untrusted files by thecatsass on Saturday October 25, 2014 @01:54PM (#8508837)
Or, the authors of Linux/UNIX utilities should have implemented and should be implementing bound checking. It seems excessive to switch languages rather than encourage stronger programming habits.
Re:Don't run 'strings' on untrusted files by _delirium on Saturday October 25, 2014 @02:16PM (#8508909)
Are there any examples of that being successfully done? Even djb's software, intentionally written to be minimalist and as secure as possible, has had exploitable overflows (both qmail and djbdns have suffered from this). Every Linux and BSD distribution (even OpenBSD) has suffered buffer overflows so severe that arbitrary internet users could get remote root access. Etc.
Re:Don't run 'strings' on untrusted files by AnthonyMouse on Saturday October 25, 2014 @06:24PM (#8509589)
> Even djb's software, intentionally written to be minimalist and as secure as possible, has had exploitable overflows (both qmail and djbdns have suffered from this).

Which of these are you describing as a buffer overflow?

http://www.cvedetails.com/vulnerability-list/vendor_id-9069/...

Re:Don't run 'strings' on untrusted files by vezzy-fnord on Saturday October 25, 2014 @03:12PM (#8509044)
The Cyclone dialect of the C language comes to mind: https://en.wikipedia.org/wiki/Cyclone_%28programming_languag...

Unfortunately, it's a dead project, and as far as I recall, never compiled on 64-bit architectures.

Re:Don't run 'strings' on untrusted files by _delirium on Saturday October 25, 2014 @03:48PM (#8509180)
That's one approach, yeah. I used to think it was a likely one, but I now think three others are more likely:

1. A language that is low-level and safe but also gives you enough interesting & new to build some buzz/interest, rather than "just" safety. Rust is a candidate here, perhaps.

2. Static analyzers in C advance to the point where a subset of C large enough to be useful can be routinely checked for common types of errors. And it then becomes socially expected that at least core OS stuff will be written in that "checkable" subset of C, treating "unable to prove safety" warnings as errors, or at the very least as suspicious.

3. Mitigate it at the OS level with finer-grained access controls. Utilities like strings(1) or objdump(1) are the easy case here: they do not need to actually have permissions other than "read a file" and "print to output". Even in the worst case, arbitrary code execution in objdump(1) should not be able to delete your home directory, join a botnet, or email your ssh key somewhere, because objdump(1) does not need those permissions. FreeBSD's libcapsicum looks promising, in the sense that it is actually being implemented in the base system, rather than just being yet another ACL proposal going nowhere (Solaris/Illumos also has an actually-shipped privileges system, but I don't know how extensively the base install itself uses it).

Re:Don't run 'strings' on untrusted files by vezzy-fnord on Saturday October 25, 2014 @04:12PM (#8509255)
1. "Just" safety is hardly peanuts given the status quo. In fact, "just" safety would be much more practical. It'd be much easier to port all the existing code to a C dialect (like Cyclone) than rewrite from scratch in something like Rust.

2. I find compiler instrumentation (think AddressSanitizer and Mudflap) to be more promising than static analysis. Much of the latter is still stuck in the lint era and give out too much noise. That said, tools like Coverity have come a long way and I know a lot of FOSS projects use them frequently. I personally haven't.

3. Capsicum is quite promising, indeed. I like that it extends the existing file descriptor metaphor and offers sandboxing based on namespaces instead of system calls (unlike seccomp), as opposed to the crufty POSIX 1003.1e capabilities which are underdeveloped and still limited to executable processes, AFAIK. That said, we shouldn't just rely on sandboxing, jailing and capability-based security. We need to fix underlying application bugs, as well (the applications that implement the capabilities and sandboxing themselves, particularly so!)

Re:Don't run 'strings' on untrusted files by Animats on Sunday October 26, 2014 @11:27PM (#8513621)
No. Three decades of C have clearly demonstrated that trying to make programmers be "very careful" will not work.

(This evening, I'm struggling with a broken "gedit" on Ubuntu. It turns out that editing a sufficiently large file will break "gedit". Not just crash it once, mess its configuration up so badly that future uses of "gedit" hang the entire GUI.

Known bug since 2012. https://bugs.launchpad.net/ubuntu/+source/gedit/+bug/1021720 Status: unassigned.

If the program terminated with "subscript out of range at line 1354 of 'editmain.c'", this would have been fixed by now.)

Re:Don't run 'strings' on untrusted files by lmm on Saturday October 25, 2014 @03:12PM (#8509042)
Humans are unreliable, especially when doing uncreative work. Anything that can be automated should be.
Re:Don't run 'strings' on untrusted files by JamesSwift on Saturday October 25, 2014 @03:33PM (#8509124)
I agree, but I think by now we should have accepted that the programmer is their own worst enemy. Laziness is a virtue and all that : )
Re:Don't run 'strings' on untrusted files by blinkingled on Saturday October 25, 2014 @01:54PM (#8508835)
It's not the utilities themselves that are the bigger problem - rather a library the utility uses. libbfd in this case. Problem with writing libraries in anything other than C of course is that they are not very usable by a large variety of software.
Re:Don't run 'strings' on untrusted files by steveklabnik on Saturday October 25, 2014 @02:07PM (#8508879)
It's pretty easy to call into a Rust library from C. The lack of a garbage collector makes embedding Rust quite nice.

Lately I've even been playing with a Ruby gem that's a C extension that calls into a Rust .a that exposes itself via extern C.

Re:Don't run 'strings' on untrusted files by Animats on Saturday October 25, 2014 @03:04PM (#8509018)
I just hope the Rust developers don't screw up. We badly need a safe, fast, low-level language to replace C.

Once Rust settles down, the next step is academic work to automatically translate existing C into Rust.

Re:Don't run 'strings' on untrusted files by pjmlp on Saturday October 25, 2014 @03:50PM (#8509192)
Ada, Modula-2, Object Pascal, Oberon, Modula-3, ...

Sadly, the list of better system programming languages that the industry decided to ignore is quite big.

Re:Don't run 'strings' on untrusted files by dbaupp on Saturday October 25, 2014 @06:03PM (#8509541)
Ada (and I guess the other ones) are unlikely to be memory safe in the presence of arbitrary pointers without a GC. That is, having a pointer/reference deep into a vector or some nested element of a tree requires a garbage collector or is unsafe (runs the risk of becoming dangling). So, while they are possibly better than C in many ways there are others in which they are lacking.

This lack of references means code is forced to do more copies or data-structure lookups.

(I dont actually know Ada or those other languages, but I did do some research a while ago and discussed this publically here and on /r/programming a few times, and have never been corrected, so I guess it is close to correct.)

Re:Don't run 'strings' on untrusted files by kyllo on Saturday October 25, 2014 @06:29PM (#8509601)
having a pointer/reference deep into a vector or some nested element of a tree requires a garbage collector or is unsafe (runs the risk of becoming dangling)

Yes, this is a problem, certain data structures need to be intrusive in order to be fast. Rust for example is a highly memory-safe language but its "unsafe" mechanism needs to be used in order to implement performant data structures for this reason.

http://www.reddit.com/r/rust/comments/2jec05/problem_with_im...

Re:Don't run 'strings' on untrusted files by dbaupp on Saturday October 25, 2014 @08:12PM (#8509856)
That is not what I'm talking about. e.g. (in Rust)

  let map: TreeMap<uint, SomeHugeThing> = make_map();

  let value: Option<&SomeHugeThing> = map.find(&123);
`map` is a (recursive) tree that associates a `uint` key with a value of type `SomeHugeThing`, imagine that is, e.g. 1KB, or otherwise expensive to copy. The `value` is a direct pointer to the memory of the value associated with the key 123 (if it exists), that is, it is extremely cheap to manipulate `value` because it is basically a machine pointer directly into the memory of the TreeMap. Rust gives you the power for that to be perfectly safe without a GC: there's no risk that changes to the `map` structure will cause the `value` pointer to be invalidated.

As far as I know, Ada etc. do not allow for this without a GC. That is, there's no way to have a safe pointer directly into the memory controlled by some dynamic data structure. Instead, one would have to search the `map` each time the value is wanted, or turn on GC.

> its "unsafe" mechanism needs to be used in order to implement performant data structures for this reason.

Implement some performant data structures. There's a lot of data structures that can be implemented performantly without begin intrusive (sure, one might want to use `unsafe` occasionally to optimise them fully, but the `unsafe` is almost always not being used to make it intrusive).

Also, I don't understand the relevance of that link, the top comment (which is mine, btw) clearly demonstrates that `unsafe` is not necessary.

Re:Don't run 'strings' on untrusted files by pjmlp on Sunday October 26, 2014 @02:28AM (#8510390)
Ada specification allows for a GC, but few implementations provide one.

Oberon and Modula-3 have GC and had real usable OS implemented in them, not just some kind of concept OS.

However those languages already offer the following in terms of security over C:

- String data type

- Open arrays (aka slices nowadays)

- Reference parameters (no need to pass pointers to functions/procedures)

- Bound checked arrays (you can bounds checking off, if you really need it)

- Pointer arithmetic is explicit operation

- Casting between types is explicit

- Enumerations are their own types, there is no implicit conversion to/from ints.

While they still don't cover all use cases in terms of memory safety, they already cover quite a few scenarios that in C just lead to unsafe code without the help of a static analyser.

Re:Don't run 'strings' on untrusted files by vezzy-fnord on Saturday October 25, 2014 @04:23PM (#8509280)
All but one of these are Wirthian languages. They all had overhead for their time period, and many of them were academic rather than pragmatic (consequently becoming influential for language designers).

Ada? You're trying too hard. It used to be a government standard and wasn't ignored in the least (see: http://www.seas.gwu.edu/~mfeldman/ada-project-summary.html)... much to a lot of people's chagrin. It's widely regarded as an example of a monster language, but it is still absolutely used where the safety is critical.

Re:Don't run 'strings' on untrusted files by pjmlp on Saturday October 25, 2014 @04:54PM (#8509366)
> They all had overhead for their time period, and many of them were academic rather than pragmatic

What overhead? The one spread by C crowed without experience in the said languages?

I used a few commercial compilers for those languages. They were quite comparable in terms of generated code quality to C compilers of the same generation, back in the day.

C was also a research language until AT&T made the code available.

> It's widely regarded as an example of a monster language, but it is still absolutely used where the safety is critical.

Actually, I would dare to say that Ada 2012 is smaller than C++14.

Its use has increased in Europe thanks to what is being discussed here, namely the amount of money lost in security issues thanks to the industry adoption of C due to its relation to UNIX.

I included Ada in the list, because most developers aren't aware that it still exists and is being used. Or that GNAT is just one of many compilers that are still available.

Re:Don't run 'strings' on untrusted files by blinkingled on Saturday October 25, 2014 @02:15PM (#8508903)
Things get uglier when I want to then call the whole shebang from - let's say - Go! Go -> C -> Rust. Now I am paying the penalty for 2 runtimes!
Re:Don't run 'strings' on untrusted files by steveklabnik on Saturday October 25, 2014 @02:54PM (#8508995)
Nope, you can use Rust without the runtime, so you're not _forced_ into paying the overhead.
Re:Don't run 'strings' on untrusted files by blinkingled on Saturday October 25, 2014 @02:59PM (#8509004)
So the Rust library you write is fully self sufficient without calling into any Rust stdlib functions or without using any runtime initialization mechanisms like ctors and dtors? That sounds too good to be true - If I am calling Rust then I am getting the Rust runtime just like if I can strlen I am getting the C library.
Re:Don't run 'strings' on untrusted files by dbaupp on Saturday October 25, 2014 @05:45PM (#8509502)
You can use a significant portion of Rust with only libc (i.e. no different to C) and this will be increasing. Things like "constructors" and destructors do not need the support of a runtime at all, they're entirely just conventional static function calls.

That is to say, the only overhead/problem with calling using C vs. using C and Rust is the increased binary size of having additional code included. There's no loss of flexibility (as long as you're not trying to run on a tiny microcontroller).

Re:Don't run 'strings' on untrusted files by blinkingled on Saturday October 25, 2014 @08:10PM (#8509845)
That does sound great overall - and I will take a deeper look at Rust - but this thread is about rewriting the core Linux utilities in Rust - if I had to do that with full featured Rust it would be hard enough. But if I had to restrict myself to a subset to avoid the "runtime penalty" for programs embedding my Rust shared library implementation of libbfd - then the rewrite just went from nearly impractical to completely impractical in terms of the efforts required.
Re:Don't run 'strings' on untrusted files by dbaupp on Saturday October 25, 2014 @08:26PM (#8509895)
> But if I had to restrict myself to a subset to avoid the "runtime penalty" for programs embedding my Rust shared library implementation of libbfd

The point is there is no 'runtime' penalty with Rust†. It doesn't have a compulsory garbage collector, it doesn't have a compulsory complicated IO manager, it doesn't have a compulsory multiplexed threading system. In some circumstances lacking any of those will be a downside, of course, but not having it built-in and compulsory means Rust gains flexibility. In several ways, there's actually lower overhead with Rust, because it is a modern language designed around the advances and research that has happened, e.g. dynamic (de)allocation can be faster due to putting some sizedness requirements on the very lowest level APIs (which one rarely calls directly, so the programmer will never notice the restrictions, just the improved speed).

My comment was trying to address the Go <-> C <-> Rust bridge, pointing out that C and C <-> Rust are essentially the same, other than the extra code one must have from writing in two languages rather than one. If one was to forgo the C (which is possible, Rust can easily be used to write a library directly exposing a C ABI), there won't be much difference at all between C and Rust.

In summary, in future, any restrictions required would not be very significant, and, even now before Rust's runtime has been excised, the restrictions will be things like "no network IO", one still gets access to all sorts of fancy iterators and data structures without requiring any runtime.

†Strictly speaking, this isn't quite true right now, but there is a concrete plan currently being executed to make it true.

Re:Don't run 'strings' on untrusted files by blinkingled on Saturday October 25, 2014 @09:12PM (#8509972)
Wow, in that case Rust is looking like it could be hell of a lot better C replacement! If I could just write all my libs in Rust using the full power of the language and then just call them easily from any language without ungodly overhead or complexity like in case of say Java/JNI, that's nothing short of fascinating!

Thanks for taking the time to explain.

Re:Don't run 'strings' on untrusted files by dbaupp on Sunday October 26, 2014 @02:11AM (#8510358)
It's not all brilliant though, there's still a lot of useful tooling that Rust needs to develop to make it really nice, e.g. there's no nice way to create a C header file describing a Rust library (since C headers are the lingua-franca of FFI libraries, in many ways), https://github.com/rust-lang/rust/issues/10530 .

And, being a young language, it's not too hard to be doing something no-one else has ever done, especially with this low-level stuff. :) (Meaning compiler bugs and some "I don't know" answers.)

Re:Don't run 'strings' on untrusted files by steveklabnik on Sunday October 26, 2014 @02:29PM (#8511800)
By the way, you may be interested in https://github.com/uutils/coreutils
Re:Don't run 'strings' on untrusted files by Dylan16807 on Saturday October 25, 2014 @03:37PM (#8509140)
You can use the core library to get standard functions with no runtime. I'm not sure what you're saying about constructors and destructors. There's nothing special about calling strlen that adds overhead.
Re:Don't run 'strings' on untrusted files by bronson on Saturday October 25, 2014 @03:14PM (#8509049)
C is fully self sufficient without calling into libc. Otherwise all the libc alternatives couldn't exist.

Sure, you don't get to call strlen (actually, you do if the compiler treats it as an intrinsic), but that's no big deal.

Re:Don't run 'strings' on untrusted files by blinkingled on Saturday October 25, 2014 @03:38PM (#8509142)
So we would need to write Rust libraries without using Rust stdlib? Not exactly a great advantage in that case. Especially so when you are rewriting a ton of C code.
Re:Don't run 'strings' on untrusted files by bronson on Saturday October 25, 2014 @06:37PM (#8509617)
So what are you complaining about? Do you want to use runtime libs or not? It sounds like you're dissatisfied either way.
Re:Don't run 'strings' on untrusted files by blinkingled on Saturday October 25, 2014 @08:01PM (#8509828)
It's about the context - rewriting ton of code that is in C libraries right now. If that had to be done using Rust without its runtime libs it is an huge disadvantage to solve the issue at hand.
Re:Don't run 'strings' on untrusted files by SwellJoe on Saturday October 25, 2014 @02:36PM (#8508956)
How high is that penalty, relative to, say, loading a variety of C shared libraries? At some point safety and security trumps saving a few kilobytes of memory...in a server environment, that point probably has already been passed a decade ago. Of course, if the penalty is hundreds of megabytes, then the equation might add up differently.

But, we already have a huge number of system tools and utilities running in a huge number of languages. Python has become the lingua franca of Linux management tools; Perl was in that role in the past, and still exists in a lot of places; bash and shell are integral. All have separate runtimes, and sometimes interact with system-level C libraries, either directly or through command line interfaces.

Is it really that big of a deal to have a Rust or Go shared library in a system that already has a half dozen different languages and a variety of shared and unshared libraries existing at once? I suspect it would be unnoticeable on a modern system. I'd choose safety over shaving a few kilobytes of memory used.

There would be a cost in having that interface friction for developers...and we'd be paying that cost for years. But, it seems like both Rust and Go have planned for the languages to be integrated with C libraries from the beginning, so it seems less of a problem. If I were going to attempt such a thing, I'd probably start with the front end utilities that use the libraries and then work my way down to converting the libraries (even though the libraries, in this case, are where the problems lie). But, maybe it's possible to make Go or Rust code that provide the same C interface as the existing libraries...I don't know enough to even guess.

Re:Don't run 'strings' on untrusted files by dllthomas on Saturday October 25, 2014 @03:28PM (#8509103)
Arguably 3.
Re:Don't run 'strings' on untrusted files by gizmo686 on Saturday October 25, 2014 @01:58PM (#8508851)
Most languages have some type of "extern C" as part of their FFI. It should be possible to use C as a langua franca between two non C languages.
Re:Don't run 'strings' on untrusted files by blinkingled on Saturday October 25, 2014 @02:12PM (#8508893)
> It should be possible to use C

Ugh, wouldn't that fall in "just because you can do something doesn't mean you actually should" category? :) Suppose I wrote the library in Go and exported some type of C wrapper and then I loaded that in Rust using Rust->C mechanism - that will load the Golang runtime in Rust! And you still got non-trivial C code to deal with anyways!

Re:Don't run 'strings' on untrusted files by gizmo686 on Saturday October 25, 2014 @04:23PM (#8509278)
If you want to interface two languages, then I do not see a way arround involving the runtime of both languages (in the same way that linking to C code still uses the C runtime). However, using my method does not actually involve any C code. "extern C" makes the compiler produce object code that can be called as if it was produced by C code; it does not produce any C code that would compile to the given object code.

Of course, it will also produce C headers to give the type information of the exported symbols, but I wouldn't call that code.

Re:Don't run 'strings' on untrusted files by stevekemp on Sunday October 26, 2014 @07:00AM (#8510767)
There was a project to rewrite common binaries in Perl a few years back, the "perl power tools project".

https://metacpan.org/pod/PerlPowerTools

I'd rather see that than a language such as Rust, D, or Go.