First pass at the plugin. Friggin huge commit.

4 files changed, 195 insertions, 47 deletions

diff --git a/keymanifest.py b/keymanifest.py
index df41f1e..25fa423 100644
--- a/keymanifest.py
+++ b/keymanifest.py
@@ -7,7 +7,7 @@ Key Manifest
 @date: May 05, 2010
 """
 
-from keys import load_public_key
+from keys import PublicKey
 
 
 class KeyManifest(dict):
@@ -33,4 +33,4 @@ class KeyManifest(dict):
         return inst
 
     def __getitem__(self, key):
-        return load_public_key(dict.__getitem__(self, key))
+        return PublicKey.from_string(dict.__getitem__(self, key))
diff --git a/keys.py b/keys.py
index 8d3a5b2..33cb98e 100644
--- a/keys.py
+++ b/keys.py
@@ -7,43 +7,82 @@ Key Loader Functions
 @date: May 05, 2010
 """
 
+import os
 from M2Crypto import RSA, DSA
+from M2Crypto.EVP import MessageDigest
+from M2Crypto.RSA import RSAError
+from M2Crypto.DSA import DSAError
 from structutils import unpack_string, get_packed_mp_ints, int_to_bytes
 
 
-def load_public_key(key):
-    """
-    Loads an RFC 4716 formatted public key.
-    """
-    if key.startswith('ssh-'):
-        blob = key.split()[1].decode('base64')
-    else:
-        blob = key.decode('base64')
+class PublicKey(object):
+
+    def __init__(self, hashed=None, instance=None, key_type=None):
+        self.instance = instance
+        self.hashed = hashed
+        self.key_type = key_type
+
+    @property
+    def blob(self):
+        return self.hashed.decode('base64')
+
+    def verify(self, data, signature):
+        try:
+            return bool(self.instance.verify(data, signature))
+        except (RSAError, DSAError):
+            return False
+
+    def sign(self, data):
+        return self.instance.sign(data)
+
+    @property
+    def from_string(cls, key):
+        """
+        Loads an RFC 4716 formatted public key.
+        """
+        pubkey = cls()
 
-    ktype, remainder = unpack_string(blob)
+        if key.startswith('ssh-'):
+            pubkey.hashed = key.split()[1]
+        else:
+            pubkey.hashed = key
 
-    if ktype == 'ssh-rsa':
-        e, n = get_packed_mp_ints(remainder, 2)
-        return RSA.new_pub_key((e, n))
-    elif ktype == 'ssh-dss':
-        p, q, g, y = get_packed_mp_ints(remainder, 4)
-        return DSA.set_params(p, q, g)
+        pubkey.key_type, remainder = unpack_string(pubkey.blob)
 
-    raise ValueError("Invalid key")
+        if pubkey.key_type == 'ssh-rsa':
+            e, n = get_packed_mp_ints(remainder, 2)
+            pubkey.instance = RSA.new_pub_key((e, n))
+        elif pubkey.key_type == 'ssh-dss':
+            p, q, g, y = get_packed_mp_ints(remainder, 4)
+            pubkey.instance = DSA.set_params(p, q, g)
+
+        return pubkey
+
+    @property
+    def from_file(cls, filename):
+        fp = open(filename)
+        try:
+            return cls.from_string(fp.read())
+        finally:
+            fp.close()
 
 
 def load_private_key(filename):
-    first_line = open(filename).readline()
+    fp = open(filename)
+    try:
+        first_line = fp.readline()
+    finally:
+        fp.close()
+
     type = DSA if 'DSA' in first_line else RSA
     return type.load_key(filename)
 
 
-def sign(what, key):
-    pk = load_private_key(key)
-    val = pk.sign(what, None)[0]
-    return int_to_bytes(val)
-
-
-def verify(what, signature, key):
-    signature = int_to_bytes(signature)
-    return bool(key.verify(what, signature))
+def sign_like_agent(data, key):
+    """
+    Emulates the signing behavior of an ssh key agent.
+    """
+    digest = MessageDigest('sha1')
+    digest.update(data)
+    my_data = digest.final()
+    return key.sign(data)
diff --git a/ssh.py b/ssh.py
index b308f5e..0c60cb0 100644
--- a/ssh.py
+++ b/ssh.py
@@ -14,30 +14,137 @@ Ponder this, bitches:
     http://svn.osafoundation.org/m2crypto/trunk/SWIG/_rsa.i
 """
 
-from M2Crypto.RSA import RSAError
 
+import keys
+from keymanifest import KeyManifest
 from structutils import bytes_to_int
 from sshagent import SSHAgent
-from keys import load_private_key, load_public_key
 
-test_data = "Hello world!"
-public_key = "/Users/mcrute/.ssh/id_rsa.ag.pub"
-private_key = "/Users/mcrute/.ssh/id_rsa.ag"
+import os, tempfile, binascii
+from mercurial import util, commands, match
+from mercurial import node as hgnode
+from mercurial.i18n import _
 
-key = open(public_key).read()
-key = key.split()[1].decode('base64')
 
-agent = SSHAgent()
-signature = agent.sign(test_data, key)
-print bytes_to_int(signature)
+def absolute_path(path):
+    path = os.path.expandvars(path)
+    return os.path.expanduser(path)
 
 
-try:
-    pub_key = load_public_key(open(public_key).read())
-    pub_key.verify(test_data, signature)
-    print "Signature matches"
-except RSAError:
-    print "Signature doesn't match"
+class SSHAuthority(object):
+
+    @classmethod
+    def from_ui(cls, ui):
+        public_key = absolute_path(ui.config("sshsign", "public_key"))
+        private_key = absolute_path(ui.config("sshsign", "private_key"))
+        manifest_file = absolute_path(ui.config("sshsign", "manifest_file"))
+
+        manifest = KeyManifest.from_file(manifest_file)
+        public_key = keys.PublicKey.from_file(public_key)
+
+    def __init__(self, public_key, key_manifest=None, private_key=None):
+        self.public_key = public_key
+        self.key_manifest = key_manifest
+        self.private_key = private_key
+
+    def verify(self, data, signature, whom):
+        key = self.key_manifest[whom] # XXX: More elegant error handling.
+        return key.verify(data, signature)
+
+    def sign(self, data):
+        return self.private_key.sign(data)
+
+
+
+def node2txt(repo, node, ver):
+    """map a manifest into some text"""
+    if ver != "0":
+        raise util.Abort(_("unknown signature version"))
+
+    return "%s\n" % hgnode.hex(node)
+
+
+def sign(ui, repo, *revs, **opts):
+    """add a signature for the current or given revision
+
+    If no revision is given, the parent of the working directory is used,
+    or tip if no revision is checked out.
+
+    See 'hg help dates' for a list of formats valid for -d/--date.
+    """
+
+    mygpg = SSHAuthority.from_ui(ui)
+    sigver = "0"
+    sigmessage = ""
+
+    date = opts.get('date')
+    if date:
+        opts['date'] = util.parsedate(date)
+
+    if revs:
+        nodes = [repo.lookup(n) for n in revs]
+    else:
+        nodes = [node for node in repo.dirstate.parents()
+                 if node != hgnode.nullid]
+        if len(nodes) > 1:
+            raise util.Abort(_('uncommitted merge - please provide a '
+                               'specific revision'))
+        if not nodes:
+            nodes = [repo.changelog.tip()]
+
+    for n in nodes:
+        hexnode = hgnode.hex(n)
+        ui.write(_("Signing %d:%s\n") % (repo.changelog.rev(n),
+                                         hgnode.short(n)))
+        # build data
+        data = node2txt(repo, n, sigver)
+        sig = mygpg.sign(data)
+        if not sig:
+            raise util.Abort(_("Error while signing"))
+        sig = binascii.b2a_base64(sig)
+        sig = sig.replace("\n", "")
+        sigmessage += "%s %s %s\n" % (hexnode, sigver, sig)
+
+    # write it
+    if opts['local']:
+        repo.opener("localsigs", "ab").write(sigmessage)
+        return
+
+    msigs = match.exact(repo.root, '', ['.hgsigs'])
+    s = repo.status(match=msigs, unknown=True, ignored=True)[:6]
+    if util.any(s) and not opts["force"]:
+        raise util.Abort(_("working copy of .hgsigs is changed "
+                           "(please commit .hgsigs manually "
+                           "or use --force)"))
+
+    repo.wfile(".hgsigs", "ab").write(sigmessage)
+
+    if '.hgsigs' not in repo.dirstate:
+        repo.add([".hgsigs"])
+
+    if opts["no_commit"]:
+        return
+
+    message = opts['message']
+    if not message:
+        # we don't translate commit messages
+        message = "\n".join(["Added signature for changeset %s"
+                             % hgnode.short(n)
+                             for n in nodes])
+    try:
+        repo.commit(message, opts['user'], opts['date'], match=msigs)
+    except ValueError, inst:
+        raise util.Abort(str(inst))
+
+
+cmdtable = {
+    "sign":
+        (sign,
+         [('l', 'local', None, _('make the signature local')),
+          ('f', 'force', None, _('sign even if the sigfile is modified')),
+          ('', 'no-commit', None, _('do not commit the sigfile after signing')),
+          ('m', 'message', '', _('commit message')),
+         ] + commands.commitopts2,
+         _('hg sign [OPTION]... [REVISION]...')),
+}
 
-priv_key = load_private_key(private_key)
-print bytes_to_int(priv_key.sign(test_data))
diff --git a/sshagent.py b/sshagent.py
index 8c310f4..6803b89 100644
--- a/sshagent.py
+++ b/sshagent.py
@@ -20,11 +20,13 @@ class SSHAgent(object):
     SSH Agent communication protocol for signing only.
     """
 
+    AGENT_SOCK_NAME = 'SSH_AUTH_SOCK'
+
     SSH2_AGENT_SIGN_RESPONSE = 14
     SSH2_AGENTC_SIGN_REQUEST = 13
 
     def __init__(self, socket_path=None):
-        default_path = os.environ.get('SSH_AUTH_SOCK')
+        default_path = os.environ.get(SSHAgent.AGENT_SOCK_NAME)
         socket_path = default_path if not socket_path else socket_path
 
         if not socket_path: