Skip to Content.
Sympa Menu

sm-discuss - Re: [SM-Discuss] STRONGER POLICY for gpg signatures to replace MD5[*] and ALSO new SOURCE_HASH support

sm-discuss AT lists.ibiblio.org

Subject: Public SourceMage Discussion List

List archive

Chronological Thread  
  • From: Eric Sandall <eric AT sandall.us>
  • To: "Sergey A. Lipnevich" <sergey AT optimaltec.com>
  • Cc: sm-discuss AT lists.ibiblio.org
  • Subject: Re: [SM-Discuss] STRONGER POLICY for gpg signatures to replace MD5[*] and ALSO new SOURCE_HASH support
  • Date: Tue, 30 Aug 2005 10:16:55 -0700 (PDT)

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On Mon, 29 Aug 2005, Sergey A. Lipnevich wrote:
Quoting "Jeremy Blosser (emrys)" <jblosser-smgl AT firinn.org>:

What you're saying is that signing something doesn't mean anything
except that
it was signed by <person>. Why then your signature on a blank piece of paper
different from a signature on a contract?

Because of the legally agreed context of the contract. Contracts and other
legal documents usually make this explicit, with language like "we, the
undersigned parties...", and also an explicit list in the terms of the
contact of who is involved. That list combined with the non-repudiation of

Very nice. So you *are* implying that a contract must be read, right? What
happens if it's too long to read or written in a dialect you are not familiar
with?

Then we'll use plain English that most people in the world can
understand: "This verification is for guaranteeing the file you are
about to install is the same as the one our developer used. If it
fails, it is not the same file."

the signature is what binds the signee to the terms of the contact, not the
signature by itself. I can go out and sign my name on whatever contracts I
want but if I'm not a listed party to the contact it doesn't really mean
anything beyond that I wrote my name on a piece of paper.

My point exactly! So why do that? Why sign your name on a piece of paper if it
*doesn't mean anything*? That's what you do when you sign a tarball having no
idea what's inside.

Wrong and completely incorrect. You are assigning what you believe to
be the /only/ way of using GPG keys over what we are saying we are
using them for. We're not saying we've looked inside the tarball, what
we are saying (for the umpteenth time) is that the tarball you are now
installing, if it passes the GPG check, is the same tarball that the
developer tested. Nothing less, nothing more. Moving to GPG is
allowing us to change hashsums when one (md5sum) or two (sha1sum)
become outdated without changing our methods.

Even things like mailing invoices usually contain language to make it clear
if you're signing that you just received a box vs. have inspected and
agreed that the contents match the invoice. And even that doesn't say you

That's why I said that doing this is akin to signing a contract simply because
it has no grammar or spelling errors, without understanding the meaning. If I
have a reasonable way to make sure the contract says the right thing, I'd sign
it. But what if I don't? I can's sign such a contract.

If we want to use the contract terminology, then here's the contract
the GPG signing is meant to be using:

- ----
Herein lies a GPG key signed by <your name here> which verifies that
the tarball <tarball name here> for the spell <spell name here> which
you are about to install is the same tarball <tarball name here> that
<your name here> installed and updated the spell <spell name here>
with.
- ----

Note that we are /not/ saying we've inspected the contents, we haven't
done any security checks, we haven't made sure there aren't any bad
pictures of my brother in them. We /have/ only setup verification to
make sure that the user can verify that they received the same tarball
as the developer who updated the spell. This is the same as our prior
md5sums, but with the ability to change hashsums without a whole lot
of work.

But my original statement there has nothing to do with what is easiest. I
said that the primary use and meaning of a cryptographic signature is
transmission integrity verification. That has nothing to do with if there
are other methods to accomplish the same thing.

We're in complete disagreement about this one. I was countering your
statement,
not making provisions for what's easier. My point is that there are adequate
ways to ensure integrity without involving non-repudiation and authenticity.

If yours are adequate, and ours are adequate, why would we argue about
adequacy?

Well if it's a shared key than "framing" means nothing anyway, because
there's no longer non-repudiation at the individual level. And all of
these things already assume our own developers are trusted; if someone
wants to be malicious there are much easier things to attack. I believe
those with the access already share keys for the tarballs we distribute.

Let me give you an example. A spell contains a line:
$EDITOR $SCRIPT
What happens when EDITOR is not set? Right, the script runs. If this
script does
rm -fr * (no leading slash) but is run from root, chaos begins. If I
wrote this
piece of code and you signed it, who's responsible? My point is, "framing" can
be unintentional.

This can happen with md5sums as well and, hopefully, the developer
testing the spell would catch it.

So, am I getting my freedom back or I have to sign everything in sight with my
name and hope it doesn't destroy your PC? As I said, I'm not asking for
agreement, I'm asking to leave my options open.

We're not asking you to sign your soul away. I cannot see how you are
completely missing the point of what we're saying. You are /not/
signing tarballs saying that you have audited the code (unless you
have, then you can say that), nor that you guarantee this tarball
won't break your computer, nor that this tarball has no viruses,
trojans, worms, wife beaters, etc. in it, nor that this tarball has no
bugs, nor many other things. The only thing the GPG signatures are for
is to replace the dependency on specific hashsums (md5sum, sha1sum,
etc.) and to allow for trusting the vendor's as much as we currently
trust them (I don't recall anyone doing audits of source code of any
packages for SMGL and no one complained that signing (yes, it's
technically a signature) with the md5sum said that you had done that).

IMO, this whole argument is silly and due to a misunderstanding of the
intended usage of GPG signatures.

- -sandalle

- --
Eric Sandall | Source Mage GNU/Linux Developer
eric AT sandall.us | http://www.sourcemage.org/
http://eric.sandall.us/ | SysAdmin @ Inst. Shock Physics @ WSU
http://counter.li.org/ #196285 | http://www.shock.wsu.edu/
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.1 (GNU/Linux)

iD8DBQFDFJSIHXt9dKjv3WERAqo2AJ41Y0t7NN6CTuf6lggEtGsxNoU/dQCgomaS
QfpIm98TxfWy3lt0UVQIsyA=
=L/FW
-----END PGP SIGNATURE-----




Archive powered by MHonArc 2.6.24.

Top of Page