Slashdot Mirror
Mozilla Will Fund Code Audits For Open Source Software (helpnetsecurity.com)
Reader Orome1 writes: The Mozilla Foundation has set up the Secure Open Source (SOS) Fund, whose aim is to help open source software projects get rid their code of vulnerabilities. Projects that want Mozilla's help must be open source/free software and must be actively maintained, but they have a much better probability to being chosen if their software is commonly used and is vital to the continued functioning of the Internet or the Web. Three open source projects -- PCRE, libjpeg-turbo, and phpMyAdmin -- have already gone through the process, and the result was removal of 43 vulnerabilities (including one critical).
I didn't read the article. This is bad because it's Mozilla.
Mozilla, much like Microsoft, can do no right, even when they do the exact opposite of the thing we called them out on before.
So when does Firefox get to go through "The Process."
Mozilla announcement: https://blog.mozilla.org/blog/2016/06/09/help-make-open-source-secure/
There's more important things like making sure my 301 tabs left open for two months straight with a dozen extensions and plugins run in less that 1GB memory!!!
Blah blah version bloat blah memory leak blah blah!
Mozilla? The same company that just threw away $15k to remove the term "slave" from documentation?
I wonder what kind of damage their "audits" will do to these projects.
Projects that want Mozilla's help must be open source/free software and must be actively maintained, but they have a much better probability to being chosen if their software is commonly used and is vital to the continued functioning of the Internet or the Web.
Ironically, this means Firefox may not be considered eligible due to the latter two conditions. /rimshot
#DeleteChrome
I may actually donate to that.
Mozilla can do right. They used to do it all of the time. The early years of Firefox and Thunderbird are great examples of this. Back then, Mozilla provided software that people actually wanted to use. In fact, this software was often so much better than its competitors that people would go out of their way to promote it to other people, which is why Firefox and Thunderbird became so widely used in the first place.
But just because Mozilla did do things right in the past doesn't mean they still do. The glory days of Firefox and Thunderbird are clearly long gone. Thunderbird was basically thrown in the trash. Firefox has been twisted into something that's unrecognizable by those of us who were early Mozilla supporters, early Firefox users, and among the biggest promoters of Firefox.
Let's face the facts: the Mozilla of today has screwed over Firefox users again and again and again and again, even when those Firefox users have begged Mozilla to stop. Australis, all of the other unwanted UI changes, the dumbing down of Firefox, the imitation of Chrome, the stupid version numbers, the embedded advertisements, Pocket, Hello, the poor performance, the excessive memory usage, and the removal of Brendan Eich are all examples of things that Firefox users didn't want, yet that they had to endure.
And let us avoid getting into their numerous recent failures, like Persona, Rust, Servo, and especially Firefox OS. We could go on and on about those for a very long time!
The people who speak out against the awful direction Mozilla has taken lately are the exact same people who were Mozilla's biggest supporters back when Mozilla still did stuff that made sense; back when they made products that people actually wanted to use. The people who criticize Mozilla today do want what's best for Mozilla: to return to the practices that made Mozilla so successful in the past. These critics want Mozilla to get back to making Firefox work for its users, rather than against them. These critics want Mozilla to promote an open web, rather than putting DRM into Firefox. They want Mozilla to restore itself to its former glory, and that means realizing what's broken today and working to fix it. That can't happen if people like you are too scared or oblivious to the very real problems that Mozilla faces today.
Tell me how Rust is a failure. Have you even coded a single line in Rust?
Considering that Microsoft's own compiler is inserting spyware into people's code by default, I'd say this is a smart move on the part of Mozilla.
Oh and by the way are you all going to get on the prosecute-Microsoft-bandwagon, now? Because now they're violating anti-hacking laws by inserting unwanted and malicious spyware into other people's software.
Are YOU using the TOOL, or is the TOOL using YOU? Think about it!
Are the problems with Rust really not obvious to you?
- Rust is essentially a proprietary language, even if the source code is available.
- There is only one implementation of Rust. You're fucked if there's a problem with it. You can't use an alternative compiler, even temporarily, because none exist!
- The only implementation of Rust is very buggy (over 2,000 open bugs right now!), despite it being written in Rust, which is a language that's supposed to make it harder to write buggier code!
- The "safety" Rust promises is only as good as the compiler that implements it, which as we can see from the over 2,000 open bugs is very questionable!
- Rust isn't as portable as C++ and many other languages.
- Rust's syntax is mediocre, and it some cases it's worse than C++.
- Rust's ownership semantics are inconvenient to use and difficult for many typical programmers to understand, even compared to C++'s RAII.
- Rust lacks proper class OO.
- Rust lacks proper exceptions.
- Rust's standard library is inadequate and incomplete.
- Rust's supposed benefits are typically no better than what you get when using C++11 or C++14, and modern C++ techniques.
- Rust's community, and it's strict (yet contradictory and hypocritical) Code of Conduct, make normal people feel very uneasy. No other programming language community goes so out of its way to police and control people like the Rust community does.
- Valid questions and legitimate criticism about Rust at discussion forums like Hacker News and Reddit are immediately met with oppressive and unjustifiable downvoting, likely done by the contributors to Rust who frequent those forums.
- Most Rust libraries are woefully incomplete, and many don't even compile properly with recent releases of the compiler.
- Nobody of significance is using it for anything important. The most notable users are Mozilla and Dropbox, neither of which is significant. The other users of Rust are minor and irrelevant startups, or weekend hobbyists. Languages like Go and Swift, on the other hand, are seeing widespread use by significant organizations like Google, Apple, IBM and others.
- Most of the hype around Rust is unsubstantiated.
- Rust's documentation is often less useful than it should be.
- Some of Rust's core contributors jumped ship from the Ruby community after it became clear that the hype surrounding Ruby and Ruby on Rails was wearing off.
- Servo, which is one of the flagship development efforts using Rust, has been progressing very slowly. Even if Rust isn't hindering Servo's speed of development, it apparently is not helping at all, either!
I'm sure there are more problems that I've forgotten to list.
It's very worrying that you accuse others of not knowing Rust, when it appears that it is you who does not know it well enough to understand its problems!
Any programming language with that many severe problems, especially when it has pretty much no users, should be considered a failure in my opinion.
As long as they dont fund audits for proper UX designs I can live with that.
See subject: It gets misused to create 'evil doppleganger' clones as Google found out with CHROME http://it.slashdot.org/story/1... - Google's "upcoming" latest PROPRIETARY ANDROID will be closed source in fact (probably due to what happened w/ Chrome above I wager).
* You can "audit" ALL DAY, but once that source is out there, this is a problem it faces, no questions asked...
(However, this IS pretty COOL of Mozilla Foundation to offer nevertheless...)
APK
P.S.=> It's always been the MAIN REASON I don't "do Open 'SORES'" of code I've written over time - I saw that one coming a MILE away... apk
int CodeAudit(*char code) {
if(ContradictoryAndHypocriticalCodeOfConductFound(code)) {
return TRUE;
else
return FALSE;
}
}
Is it a question of money? Lots of Open Source projects start out being what users want because the original developers were also its users. They had an itch to scratch so they built something that solved their problem. But once the developers moved on or got bored with it, the only ones interested in developing it were guys who wanted to make money off it somehow. All the new features concentrate around monetizing the program instead of making life easier for those who get it for free.
The only implementation of Rust is very buggy (over 2,000 open bugs right now!), despite it being written in Rust, which is a language that's supposed to make it harder to write buggier code!
It removes a class of bugs that are common in C and C++ that are the #1 cause of security bugs in those languages (and also cause weird behavior that can be hard to track down due to random corruption).
Any program of significant complexity is going to have bugs. There is no silver bullet. That doesn't mean the improvement Rust brings isn't worthwhile.
Rust's supposed benefits are typically no better than what you get when using C++11 or C++14, and modern C++ techniques.
Can you point to a notable open source C++ program, then, that follows these techniques?
So do Perl, Ruby, Python, Java, C#, PHP, Tcl, Lua, Erlang, Go, Swift, Haskell, OCaml, JavaScript, and numerous other languages with garbage collection or other forms of automatic memory management. So Rust is nothing special.
At least you're admitting there's nothing special about Rust. That's more than most of its supporters are smart enough to do. Most of them just keep on insisting it's "safer", despite the Rust implementation itself being bogged down with bugs.
The newer parts of many C++ projects are written using these techniques. Some examples you may have heard of are LLVM (funny, Rust's implementation uses this!), Boost, and Qt.
Face it, Rust has failed. It's no better than the existing languages its supporters claim it can replace, and in many ways is much worse.
I used phpMyAdmin for a long time and stopped using it when Adminer came out. IMO would much rather see the funds go to them.
Here we go again...
- Rust is essentially a proprietary language, even if the source code is available.
I'd guess you say this because there is no standards committee for Rust? Well yeah, maybe that makes it "proprietary", but that isn't something bad. Linux has a dictator as well, just like many other projects. In the context of programming languages, at least Go, Java and Swift are "proprietary but open source" as well.
The great thing about open source is that if upstream fucks up, people create a fork. Think of LibreOffice for example.
- There is only one implementation of Rust. You're fucked if there's a problem with it. You can't use an alternative compiler, even temporarily, because none exist!
Does Go have an alternative compiler? Does Swift have one? This is standard for younger programming languages.
- The only implementation of Rust is very buggy (over 2,000 open bugs right now! [github.com]), despite it being written in Rust, which is a language that's supposed to make it harder to write buggier code!
This incredibly weird and wrong argument has been posted by ACs on slashdot for some months now. I'll just put this link here: https://news.slashdot.org/comm...
In fact, its a bad sign for Rust to have "only" 2k open bugs, more successful projects have even more bugs in their trackers than Rust.
- The "safety" Rust promises is only as good as the compiler that implements it, which as we can see from the over 2,000 open bugs is very questionable!
The major security benefits added by Rust are thanks to things people coding e.g. in C have to do themselves, like free()-ing stuff.
As with self driving cars, this added automation only needs to be better than human in order to be the better alternative, not perfect. And I'm sure Rust is inside that range.
- Rust isn't as portable as C++ and many other languages.
Most common targets are already supported: https://github.com/rust-lang-n...
You can't write an operating system in Go, but you can do it in Rust. In fact there is even a project writing one.
- Rust's syntax is mediocre, and it some cases it's worse than C++.
This is about taste. I like Rust syntax. If you don't like it its your problem.
- Rust's ownership semantics are inconvenient to use and difficult for many typical programmers to understand, even compared to C++'s RAII.
There is a high entry barrier, yes. But I think for people who are generally not accustomed to lower level languages like C/C++ its easier to not have to worry about stuff like allocation, and have the compiler say "this is wrong" if there is a problem, instead of stuff compiling but then failing horrendously or doing stuff like memory leaks or even stuff like race conditions, which only mean a problem in a fraction of the cases.
- Rust lacks proper class OO.
That's true. I can avoid it, for me its not a problem.
- Rust lacks proper exceptions.
I consider this a feature. Exceptions are one of the major sources of bugs in C++. Its much better to have the Result type, where you can recover from errors much faster. Recovering from errors is faster in Rust than in C++!
- Rust's standard library is inadequate and incomplete.
The standard library of C++ is far more inadequate and incomplete than Rust's. I am missing many functions I have available in Rust when writing C++.
Some nice stuff is marked unstable but you can use the nightly compiler if you want to use it.
- Rust's supposed benefits are typically no better than what
Who cares if you *were* a big supporter if you've since turned into a ridiculous negative PR white hole over virtually nothing? Seriously, you guys have egos the size of the mainland States, but for all your bluster, your "support" never helped Firefox avoid its current fate, and blaming Mozilla for everything isn't going to cut it. You were supposed to be volunteering to improve Firefox, but you didn't. No, excusing yourself because they didn't accept your patch to revert some change you disliked doesn't count. No, trying to have it both ways doesn't work. You're not special. You left when the going got tough. Your "support" proved useless. Now you've probably done more damage than you ever did when you were on their side. And best of all, some of you *still* use Firefox in one shape or another, while being part of the problem causing their market share to slide down. On every vaguely-browser-related post on Slashdot you idiots venture out to trot out your nonsense, and it's gotten to the point where I think you're just paid to spout these screeds.
So do Perl, Ruby, Python, Java, C#, PHP, Tcl, Lua, Erlang, Go, Swift, Haskell, OCaml, JavaScript, and numerous other languages with garbage collection or other forms of automatic memory management. So Rust is nothing special.
But Rust is special, because it was designed to be used without garbage collection. Garbage collection isn't free and this is one of the main reasons that C/C++ is still used today.
At least you're admitting there's nothing special about Rust. That's more than most of its supporters are smart enough to do. Most of them just keep on insisting it's "safer", despite the Rust implementation itself being bogged down with bugs.
You clearly have a problem with reading comprehension. It is safer with the class of bugs I mentioned, the #1 source of security bugs and memory corruption bugs that waste a lot of time tracking down.
The newer parts of many C++ projects are written using these techniques. Some examples you may have heard of are LLVM (funny, Rust's implementation uses this!), Boost, and Qt.
Oh, so you won't get problems like this:
"This was precisely the root cause of the memory problem: MDNodeFwdDecl's constructor always tried to construct its ReplaceableMetadataImpl parent past the end of its allocated memory buffer, because its own operator new was not properly overloaded. Sometimes there are no visible side-effects because of this, and things seem to work. However, Valgrind always flags it."
In light of the current events regarding The Torproject, I call for an audit.
If it doesn't have GC, what sort of automatic memory management does it use to prevent things like allocating the same memory twice or use after free? Or does it just bloat memory like a fiend and hope the 64-bit system provides enough space?
It uses ownership. It's not anything that can't be done in C++, but the difference in the compiler enforces it.
Mozilla has money!