diff --git a/git/objects/commit.py b/git/objects/commit.py
index cbfd5097b..f4ef80548 100644
--- a/git/objects/commit.py
+++ b/git/objects/commit.py
@@ -26,7 +26,7 @@
                         parse_actor_and_date
                     )
 from time import (
-                    time, 
+                    time,
                     altzone
                 )
 import os
@@ -36,52 +36,52 @@
 
 class Commit(base.Object, Iterable, Diffable, Traversable, Serializable):
     """Wraps a git Commit object.
-    
-    This class will act lazily on some of its attributes and will query the 
+
+    This class will act lazily on some of its attributes and will query the
     value on demand only if it involves calling the git binary."""
-    
+
     # ENVIRONMENT VARIABLES
     # read when creating new commits
     env_author_date = "GIT_AUTHOR_DATE"
     env_committer_date = "GIT_COMMITTER_DATE"
-    
+
     # CONFIGURATION KEYS
     conf_encoding = 'i18n.commitencoding'
-    
+
     # INVARIANTS
     default_encoding = "UTF-8"
-    
-    
-    # object configuration 
+
+
+    # object configuration
     type = "commit"
     __slots__ = ("tree",
                  "author", "authored_date", "author_tz_offset",
                  "committer", "committed_date", "committer_tz_offset",
-                 "message", "parents", "encoding")
+                 "message", "parents", "encoding", "gpgsig")
     _id_attribute_ = "binsha"
-    
+
     def __init__(self, repo, binsha, tree=None, author=None, authored_date=None, author_tz_offset=None,
-                 committer=None, committed_date=None, committer_tz_offset=None, 
-                 message=None,  parents=None, encoding=None):
-        """Instantiate a new Commit. All keyword arguments taking None as default will 
-        be implicitly set on first query. 
-        
+                 committer=None, committed_date=None, committer_tz_offset=None,
+                 message=None,  parents=None, encoding=None, gpgsig=None):
+        """Instantiate a new Commit. All keyword arguments taking None as default will
+        be implicitly set on first query.
+
         :param binsha: 20 byte sha1
-        :param parents: tuple( Commit, ... ) 
+        :param parents: tuple( Commit, ... )
             is a tuple of commit ids or actual Commits
         :param tree: Tree
             Tree object
         :param author: Actor
             is the author string ( will be implicitly converted into an Actor object )
         :param authored_date: int_seconds_since_epoch
-            is the authored DateTime - use time.gmtime() to convert it into a 
+            is the authored DateTime - use time.gmtime() to convert it into a
             different format
         :param author_tz_offset: int_seconds_west_of_utc
             is the timezone that the authored_date is in
         :param committer: Actor
             is the committer string
         :param committed_date: int_seconds_since_epoch
-            is the committed DateTime - use time.gmtime() to convert it into a 
+            is the committed DateTime - use time.gmtime() to convert it into a
             different format
         :param committer_tz_offset: int_seconds_west_of_utc
             is the timezone that the authored_date is in
@@ -90,12 +90,12 @@ def __init__(self, repo, binsha, tree=None, author=None, authored_date=None, aut
         :param encoding: string
             encoding of the message, defaults to UTF-8
         :param parents:
-            List or tuple of Commit objects which are our parent(s) in the commit 
+            List or tuple of Commit objects which are our parent(s) in the commit
             dependency graph
         :return: git.Commit
-        
-        :note: Timezone information is in the same format and in the same sign 
-            as what time.altzone returns. The sign is inverted compared to git's 
+
+        :note: Timezone information is in the same format and in the same sign
+            as what time.altzone returns. The sign is inverted compared to git's
             UTC timezone."""
         super(Commit,self).__init__(repo, binsha)
         if tree is not None:
@@ -120,7 +120,10 @@ def __init__(self, repo, binsha, tree=None, author=None, authored_date=None, aut
             self.parents = parents
         if encoding is not None:
             self.encoding = encoding
-        
+        self.gpgsig = None
+        if gpgsig is not None:
+          self.gpgsig = gpgsig
+
     @classmethod
     def _get_intermediate_items(cls, commit):
         return commit.parents
@@ -138,12 +141,12 @@ def _set_cache_(self, attr):
     def summary(self):
         """:return: First line of the commit message"""
         return self.message.split('\n', 1)[0]
-        
+
     def count(self, paths='', **kwargs):
         """Count the number of commits reachable from this commit
 
         :param paths:
-            is an optinal path or a list of paths restricting the return value 
+            is an optinal path or a list of paths restricting the return value
             to commits actually containing the paths
 
         :param kwargs:
@@ -156,7 +159,7 @@ def count(self, paths='', **kwargs):
             return len(self.repo.git.rev_list(self.hexsha, '--', paths, **kwargs).splitlines())
         else:
             return len(self.repo.git.rev_list(self.hexsha, **kwargs).splitlines())
-        
+
 
     @property
     def name_rev(self):
@@ -173,7 +176,7 @@ def iter_items(cls, repo, rev, paths='', **kwargs):
         :param repo: is the Repo
         :param rev: revision specifier, see git-rev-parse for viable options
         :param paths:
-            is an optinal path or list of paths, if set only Commits that include the path 
+            is an optinal path or list of paths, if set only Commits that include the path
             or paths will be considered
         :param kwargs:
             optional keyword arguments to git rev-list where
@@ -191,28 +194,28 @@ def iter_items(cls, repo, rev, paths='', **kwargs):
 
         proc = repo.git.rev_list(rev, args, as_process=True, **kwargs)
         return cls._iter_from_process_or_stream(repo, proc)
-        
+
     def iter_parents(self, paths='', **kwargs):
         """Iterate _all_ parents of this commit.
-        
+
         :param paths:
-            Optional path or list of paths limiting the Commits to those that 
+            Optional path or list of paths limiting the Commits to those that
             contain at least one of the paths
         :param kwargs: All arguments allowed by git-rev-list
         :return: Iterator yielding Commit objects which are parents of self """
         # skip ourselves
         skip = kwargs.get("skip", 1)
-        if skip == 0:   # skip ourselves 
+        if skip == 0:   # skip ourselves
             skip = 1
         kwargs['skip'] = skip
-        
+
         return self.iter_items(self.repo, self, paths, **kwargs)
 
     @property
     def stats(self):
-        """Create a git stat from changes between this commit and its first parent 
+        """Create a git stat from changes between this commit and its first parent
         or from all changes done if this is the very first commit.
-        
+
         :return: git.Stats"""
         if not self.parents:
             text = self.repo.git.diff_tree(self.hexsha, '--', numstat=True, root=True)
@@ -236,7 +239,7 @@ def _iter_from_process_or_stream(cls, repo, proc_or_stream):
         stream = proc_or_stream
         if not hasattr(stream,'readline'):
             stream = proc_or_stream.stdout
-            
+
         readline = stream.readline
         while True:
             line = readline()
@@ -247,37 +250,37 @@ def _iter_from_process_or_stream(cls, repo, proc_or_stream):
                 # split additional information, as returned by bisect for instance
                 hexsha, rest = line.split(None, 1)
             # END handle extra info
-            
+
             assert len(hexsha) == 40, "Invalid line: %s" % hexsha
             yield Commit(repo, hex_to_bin(hexsha))
         # END for each line in stream
-        
-        
+
+
     @classmethod
     def create_from_tree(cls, repo, tree, message, parent_commits=None, head=False):
         """Commit the given tree, creating a commit object.
-        
-        :param repo: Repo object the commit should be part of 
-        :param tree: Tree object or hex or bin sha 
+
+        :param repo: Repo object the commit should be part of
+        :param tree: Tree object or hex or bin sha
             the tree of the new commit
         :param message: Commit message. It may be an empty string if no message is provided.
             It will be converted to a string in any case.
         :param parent_commits:
             Optional Commit objects to use as parents for the new commit.
-            If empty list, the commit will have no parents at all and become 
+            If empty list, the commit will have no parents at all and become
             a root commit.
-            If None , the current head commit will be the parent of the 
+            If None , the current head commit will be the parent of the
             new commit object
         :param head:
             If True, the HEAD will be advanced to the new commit automatically.
-            Else the HEAD will remain pointing on the previous commit. This could 
+            Else the HEAD will remain pointing on the previous commit. This could
             lead to undesired results when diffing files.
-            
+
         :return: Commit object representing the new commit
-            
+
         :note:
             Additional information about the committer and Author are taken from the
-            environment or from the git configuration, see git-commit-tree for 
+            environment or from the git configuration, see git-commit-tree for
             more information"""
         parents = parent_commits
         if parent_commits is None:
@@ -288,66 +291,66 @@ def create_from_tree(cls, repo, tree, message, parent_commits=None, head=False):
                 parent_commits = list()
             # END handle parent commits
         # END if parent commits are unset
-        
-        # retrieve all additional information, create a commit object, and 
+
+        # retrieve all additional information, create a commit object, and
         # serialize it
-        # Generally: 
+        # Generally:
         # * Environment variables override configuration values
         # * Sensible defaults are set according to the git documentation
-        
+
         # COMMITER AND AUTHOR INFO
         cr = repo.config_reader()
         env = os.environ
-        
+
         committer = Actor.committer(cr)
         author = Actor.author(cr)
-        
+
         # PARSE THE DATES
         unix_time = int(time())
         offset = altzone
-        
+
         author_date_str = env.get(cls.env_author_date, '')
         if author_date_str:
             author_time, author_offset = parse_date(author_date_str)
         else:
             author_time, author_offset = unix_time, offset
         # END set author time
-        
+
         committer_date_str = env.get(cls.env_committer_date, '')
-        if committer_date_str: 
+        if committer_date_str:
             committer_time, committer_offset = parse_date(committer_date_str)
         else:
             committer_time, committer_offset = unix_time, offset
         # END set committer time
-        
+
         # assume utf8 encoding
         enc_section, enc_option = cls.conf_encoding.split('.')
         conf_encoding = cr.get_value(enc_section, enc_option, cls.default_encoding)
-        
-        
+
+
         # if the tree is no object, make sure we create one - otherwise
         # the created commit object is invalid
         if isinstance(tree, str):
             tree = repo.tree(tree)
         # END tree conversion
-        
+
         # CREATE NEW COMMIT
-        new_commit = cls(repo, cls.NULL_BIN_SHA, tree, 
-                        author, author_time, author_offset, 
+        new_commit = cls(repo, cls.NULL_BIN_SHA, tree,
+                        author, author_time, author_offset,
                         committer, committer_time, committer_offset,
                         message, parent_commits, conf_encoding)
-        
+
         stream = StringIO()
         new_commit._serialize(stream)
         streamlen = stream.tell()
         stream.seek(0)
-        
+
         istream = repo.odb.store(IStream(cls.type, streamlen, stream))
         new_commit.binsha = istream.binsha
-        
+
         if head:
             # need late import here, importing git at the very beginning throws
-            # as well ... 
+            # as well ...
             import git.refs
             try:
                 repo.head.set_commit(new_commit, logmsg="commit: %s" % message)
@@ -358,44 +361,47 @@ def create_from_tree(cls, repo, tree, message, parent_commits=None, head=False):
                 master = git.refs.Head.create(repo, repo.head.ref, new_commit, logmsg="commit (initial): %s" % message)
                 repo.head.set_reference(master, logmsg='commit: Switching to %s' % master)
             # END handle empty repositories
-        # END advance head handling 
-        
+        # END advance head handling
+
         return new_commit
-    
+
     #{ Serializable Implementation
-    
+
     def _serialize(self, stream):
         write = stream.write
         write("tree %s\n" % self.tree)
         for p in self.parents:
             write("parent %s\n" % p)
-            
+
         a = self.author
         aname = a.name
         if isinstance(aname, unicode):
             aname = aname.encode(self.encoding)
         # END handle unicode in name
-        
+
         c = self.committer
         fmt = "%s %s <%s> %s %s\n"
-        write(fmt % ("author", aname, a.email, 
-                        self.authored_date, 
+        write(fmt % ("author", aname, a.email,
+                        self.authored_date,
                         altz_to_utctz_str(self.author_tz_offset)))
-            
+
         # encode committer
         aname = c.name
         if isinstance(aname, unicode):
             aname = aname.encode(self.encoding)
         # END handle unicode in name
-        write(fmt % ("committer", aname, c.email, 
+        write(fmt % ("committer", aname, c.email,
                         self.committed_date,
                         altz_to_utctz_str(self.committer_tz_offset)))
-        
+
         if self.encoding != self.default_encoding:
             write("encoding %s\n" % self.encoding)
-        
+
+        if self.gpgsig:
+            write("gpgsig %s" % self.gpgsig)
+
         write("\n")
-        
+
         # write plain bytes, be sure its encoded according to our encoding
         if isinstance(self.message, unicode):
             write(self.message.encode(self.encoding))
@@ -403,7 +409,7 @@ def _serialize(self, stream):
             write(self.message)
         # END handle encoding
         return self
-    
+
     def _deserialize(self, stream):
         """:param from_rev_list: if true, the stream format is coming from the rev-list command
         Otherwise it is assumed to be a plain data stream from our object"""
@@ -421,37 +427,42 @@ def _deserialize(self, stream):
             self.parents.append(type(self)(self.repo, hex_to_bin(parent_line.split()[-1])))
         # END for each parent line
         self.parents = tuple(self.parents)
-        
+
         self.author, self.authored_date, self.author_tz_offset = parse_actor_and_date(next_line)
         self.committer, self.committed_date, self.committer_tz_offset = parse_actor_and_date(readline())
-        
-        
+
+
         # now we can have the encoding line, or an empty line followed by the optional
         # message.
         self.encoding = self.default_encoding
-        # read encoding or empty line to separate message
-        enc = readline()
-        enc = enc.strip()
-        if enc:
-            self.encoding = enc[enc.find(' ')+1:]
-            # now comes the message separator 
-            readline()
-        # END handle encoding
-        
+
+        # read headers
+        buf = readline().strip()
+        while buf != "":
+          if buf[0:10] == "encoding ":
+            self.encoding = buf[buf.find(' ')+1:]
+          elif buf[0:7] == "gpgsig ":
+            sig = buf[buf.find(' ')+1:] + "\n"
+            while True:
+              sig += readline()
+              if sig.find("END PGP SIGNATURE") > -1: break
+            self.gpgsig = sig
+          buf = readline().strip()
+
         # decode the authors name
         try:
-            self.author.name = self.author.name.decode(self.encoding) 
+            self.author.name = self.author.name.decode(self.encoding)
         except UnicodeDecodeError:
             print >> sys.stderr, "Failed to decode author name '%s' using encoding %s" % (self.author.name, self.encoding)
         # END handle author's encoding
-        
+
         # decode committer name
         try:
-            self.committer.name = self.committer.name.decode(self.encoding) 
+            self.committer.name = self.committer.name.decode(self.encoding)
         except UnicodeDecodeError:
             print >> sys.stderr, "Failed to decode committer name '%s' using encoding %s" % (self.committer.name, self.encoding)
         # END handle author's encoding
-        
+
         # a stream from our data simply gives us the plain message
         # The end of our message stream is marked with a newline that we strip
         self.message = stream.read()
@@ -459,7 +470,7 @@ def _deserialize(self, stream):
             self.message = self.message.decode(self.encoding)
         except UnicodeDecodeError:
             print >> sys.stderr, "Failed to decode message '%s' using encoding %s" % (self.message, self.encoding)
-        # END exception handling 
+        # END exception handling
         return self
-        
+
     #} END serializable implementation
