On Mon, Apr 07, 2008 at 02:15:14PM -0400, "Robert C. Seacord" <[EMAIL
PROTECTED]> wrote:
> >The advisory suggests that people not use GCC.
> no, it does not. it suggests they may not want to use the latest
> versions. this is one possible work around. we never say "use another
> compiler".
Yes, it does, you are twisting words, let me quote:
Avoid newer versions of gcc
Application developers and vendors of large codebases that cannot be audited
for use of the defective length checks are urged to avoiding the use of gcc
versions 4.2 and later.
While using an older version of gcc is a way to follow that suggestion,
using another compiler is as well. So the advisory certainly *does*
suggest to not use GCC as _one_ way of working around this "vulnerability"
("not strictly speaking") in gcc.
If you think that the advisory should not suggest that users not use gcc,
then it should not say so.
As it is written, it clearly suggests that swiching compilers will help
to avoid this problem, and this is a great disservice for people, as it
might drive people to another compiler that cert *knows* does the same
optimisation but doesn't feel mentioning because it is not a "recent
change" or the compiler is "not popular enough" (some of the compilers
certainly are very popular, though, so this all sounds very hypocritical).
In any case, if the intention of the advisory was to make people go to
older rleases of gcc and not switch to other compilers, then it clearly
fails to say so. Instead, it *does* suggets that switching compilers is
one way around this issue.
> >"Some compilers (including, at least, GCC, PathScale, and xlc)
> >optimize away incorrectly coded checks for overflow. Applications
> >containing these incorrectly coded checks may be vulnerable if
> >compiled with these compilers."
> ok, i'll review again for tone. generally we don't try to make these
> notes overly broad; they are only meant to draw attention to a specific
> issue.
But the specific issue is that compilers do that optimisation, and that the
code is buggy. The issue here is clearly not gcc - about every optimising
compiler does this optimisation, and by singling out gcc it seems as if
somehow gcc would be the problem, when clearly the code is.
The biggets problem is that cert knows that this is a common problem, but
suggests that, among othersa, switching compilers would somehow solve this
- a greta disservice to people who rely on accurate information.
Again, the issue here is buggy code, not gcc.
--
The choice of a Deliantra, the free code+content MORPG
-----==- _GNU_ http://www.deliantra.net
----==-- _ generation
---==---(_)__ __ ____ __ Marc Lehmann
--==---/ / _ \/ // /\ \/ / [EMAIL PROTECTED]
-=====/_/_//_/\_,_/ /_/\_\
