Initial checkin

5 files changed, 288 insertions, 0 deletions

diff --git a/keymanifest.py b/keymanifest.py
new file mode 100644
index 0000000..df41f1e
--- /dev/null
+++ b/keymanifest.py
@@ -0,0 +1,36 @@
+# vim: set filencoding=utf8
+"""
+Key Manifest
+
+@author: Mike Crute (mcrute@gmail.com)
+@organization: SoftGroup Interactive, Inc.
+@date: May 05, 2010
+"""
+
+from keys import load_public_key
+
+
+class KeyManifest(dict):
+    """
+    KeyManifest stores a list of public keys indexed by their
+    comment field. This object acts like a dictionary and will
+    return public key instances for getitems.
+    """
+
+    @classmethod
+    def from_file(cls, filename):
+        inst = cls()
+        fp = open(filename)
+
+        for line in fp:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+
+            _, key, user = line.split()
+            inst[user.strip()] = key.strip()
+
+        return inst
+
+    def __getitem__(self, key):
+        return load_public_key(dict.__getitem__(self, key))
diff --git a/keys.py b/keys.py
new file mode 100644
index 0000000..9b6b837
--- /dev/null
+++ b/keys.py
@@ -0,0 +1,49 @@
+# vim: set filencoding=utf8
+"""
+Key Loader Functions
+
+@author: Mike Crute (mcrute@gmail.com)
+@organization: SoftGroup Interactive, Inc.
+@date: May 05, 2010
+"""
+
+from M2Crypto import RSA, DSA
+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')
+
+    ktype, remainder = unpack_string(blob)
+
+    if ktype == 'ssh-rsa':
+        e, n = get_packed_mp_ints(remainder, 2)
+        return hawt.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)
+
+    raise ValueError("Invalid key")
+
+
+def load_private_key(filename):
+    first_line = open(filename).readline()
+    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))
diff --git a/ssh.py b/ssh.py
new file mode 100644
index 0000000..a4209dc
--- /dev/null
+++ b/ssh.py
@@ -0,0 +1,20 @@
+# vim: set filencoding=utf8
+"""
+SSH Key Signing
+
+@author: Mike Crute (mcrute@ag.com)
+@organization: American Greetings Interactive
+@date: May 03, 2010
+
+Commands to sign and verify revisions with your
+ssh key.
+"""
+
+
+
+
+
+
+
+if __name__ == '__main__':
+    pass
diff --git a/sshagent.py b/sshagent.py
new file mode 100644
index 0000000..2a43f5f
--- /dev/null
+++ b/sshagent.py
@@ -0,0 +1,75 @@
+# vim: set filencoding=utf8
+"""
+SSH Agent Management
+
+@author: Mike Crute (mcrute@gmail.com)
+@organization: SoftGroup Interactive, Inc.
+@date: May 05, 2010
+"""
+import os
+import socket
+import struct
+
+from structutils import pack_string, pack_int
+from structutils import unpack_int, unpack_string, unpack_mp_int
+
+
+class SSHAgent(object):
+    """
+    SSH Agent communication protocol for signing only.
+    """
+
+    SSH2_AGENT_SIGN_RESPONSE = 14
+    SSH2_AGENTC_SIGN_REQUEST = 13
+
+    def __init__(self, socket_path):
+        default_path = os.environ.get('SSH_AUTH_SOCK')
+        socket_path = default_path if not socket_path else socket_path
+
+        if not socket_path:
+            raise ValueError("Could not find an ssh agent.")
+
+        self.socket = None
+
+    def connect(self):
+        self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.socket.connect(self.socket_path)
+
+    def _build_packet(self, data, key):
+        key = pack_string(key)
+        data = pack_string(data)
+        flags = pack_int(0)
+
+        to_send = ''.join([chr(SSHAgent.SSH2_AGENTC_SIGN_REQUEST),
+                               key, data, flags])
+        pkt_length = len(to_send)
+        packet = pack_int(pkg_length) + to_send
+
+        return packet
+
+    def _parse_response(self):
+        response_length = unpack_int(self.socket.recv(4, socket.MSG_WAITALL))[0]
+        if response_length == 1:
+            raise ValueError("Agent failed")
+
+        response = auth_sock.recv(response_length, socket.MSG_WAITALL)
+
+        status = ord(response[0])
+        if status != SSHAgent.SSH2_AGENT_SIGN_RESPONSE:
+            raise ValueError("Invalid response from agent")
+
+        _, remainder = unpack_int(response[1:])
+        _, remainder = unpack_string(remainder)
+        response, _ = unpack_mp_int(remainder)
+
+        return response
+
+    def sign(self, data, key):
+        packet = self._build_packet(data, key)
+
+        remaining = 0
+        while remaining < len(packet):
+            sent = self.socket.send(packet[remaining:])
+            remaining += sent
+
+        return self._parse_response()
diff --git a/structutils.py b/structutils.py
new file mode 100644
index 0000000..26b0188
--- /dev/null
+++ b/structutils.py
@@ -0,0 +1,108 @@
+# vim: set filencoding=utf8
+"""
+Utilities for Manipulating Byte Streams
+
+@author: Mike Crute (mcrute@gmail.com)
+@organization: SoftGroup Interactive, Inc.
+@date: May 05, 2010
+"""
+
+import struct
+
+
+INT_FORMAT = struct.Struct('>I')
+
+
+def pack_string(string):
+    """
+    Pack a string into a network style byte array.
+    """
+    return pack_int(len(string)) + string
+
+
+def pack_int(integer):
+    """
+    Pack an integer into a byte array.
+    """
+    return INT_FORMAT.pack(integer)
+
+
+def pack_mp_int(mp_int):
+    """
+    Pack a multiple-percision integer into a byte array.
+    """
+    return pack_string(int_to_bytes(mp_int))
+
+
+def unpack_string(buf):
+    """
+    Unpack a string from a byte array buffer returning
+    the string and the remainder of the buffer.
+    """
+    length, = INT_FORMAT.unpack(buf[:4])
+    string = buf[4:4+length]
+    remainder = buf[4+length:]
+    return string, remainder
+
+
+def unpack_mp_int(buf):
+    """
+    Unpack a multiple-percision integer from a byte array
+    buffer returning the string and the remainder of the
+    buffer.
+    """
+    length, = INT_FORMAT.unpack(buf[:4])
+    remainder = buf[4+length:]
+
+    return bytes_to_int(buf[4:4+length]), remainder
+
+
+def unpack_int(buf):
+    """
+    Unpack an integer from a byte array buffer returning the
+    string and the remainder of the buffer.
+    """
+    integer, = INT_FORMAT.unpack(buf[:4])
+    remainder = buf[4:]
+    return integer, remainder
+
+
+def get_packed_mp_ints(buf, count=1):
+    """
+    Get a number of multiple-percision integers from a byte
+    array buffer but leaves them as network style mpints.
+    """
+    ints = []
+    for _ in range(count):
+        length, = INT_FORMAT.unpack(buf[:4])
+        ints.append(buf[:4+length]
+        buf = buf[4+length:]
+
+    return ints
+
+
+def int_to_bytes(integer):
+    """
+    Convert an integer or a long integer to an array of
+    bytes.
+    """
+    bytes = []
+
+    while integer > 0:
+        integer, chunk = divmod(integer, 256)
+        bytes.insert(0, chr(chunk))
+
+    return ''.join(bytes)
+
+
+def bytes_to_int(buf):
+    """
+    Convert an array of bytes into an integer or long
+    integer.
+    """
+    integer = 0
+    for byte in buf:
+        integer <<= 8
+        integer += ord(byte)
+
+    return integer