News for hackers. Stuff that matters.
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.