diff --git a/django/contrib/comments/forms.py b/django/contrib/comments/forms.py
index 713269f..40cc24b 100644
--- a/django/contrib/comments/forms.py
+++ b/django/contrib/comments/forms.py
@@ -15,26 +15,82 @@ from django.utils.translation import ungettext, ugettext_lazy as _
 
 COMMENT_MAX_LENGTH = getattr(settings,'COMMENT_MAX_LENGTH', 3000)
 
-class CommentForm(forms.Form):
-    name          = forms.CharField(label=_("Name"), max_length=50)
-    email         = forms.EmailField(label=_("Email address"))
-    url           = forms.URLField(label=_("URL"), required=False)
-    comment       = forms.CharField(label=_('Comment'), widget=forms.Textarea,
-                                    max_length=COMMENT_MAX_LENGTH)
-    honeypot      = forms.CharField(required=False,
-                                    label=_('If you enter anything in this field '\
-                                            'your comment will be treated as spam'))
+class BaseCommentForm(forms.Form):
     content_type  = forms.CharField(widget=forms.HiddenInput)
     object_pk     = forms.CharField(widget=forms.HiddenInput)
     timestamp     = forms.IntegerField(widget=forms.HiddenInput)
     security_hash = forms.CharField(min_length=40, max_length=40, widget=forms.HiddenInput)
-
+    
     def __init__(self, target_object, data=None, initial=None):
         self.target_object = target_object
         if initial is None:
             initial = {}
         initial.update(self.generate_security_data())
-        super(CommentForm, self).__init__(data=data, initial=initial)
+        super(BaseCommentForm, self).__init__(data=data, initial=initial)
+
+    def generate_security_data(self):
+        """Generate a dict of security data for "initial" data."""
+        timestamp = int(time.time())
+        security_dict =   {
+            'content_type'  : str(self.target_object._meta),
+            'object_pk'     : str(self.target_object._get_pk_val()),
+            'timestamp'     : str(timestamp),
+            'security_hash' : self.initial_security_hash(timestamp),
+        }
+        return security_dict
+
+    def initial_security_hash(self, timestamp):
+        """
+        Generate the initial security hash from self.content_object
+        and a (unix) timestamp.
+        """
+
+        initial_security_dict = {
+            'content_type' : str(self.target_object._meta),
+            'object_pk' : str(self.target_object._get_pk_val()),
+            'timestamp' : str(timestamp),
+          }
+        return self.generate_security_hash(**initial_security_dict)
+
+    def generate_security_hash(self, content_type, object_pk, timestamp):
+        """Generate a (SHA1) security hash from the provided info."""
+        info = (content_type, object_pk, timestamp, settings.SECRET_KEY)
+        return sha_constructor("".join(info)).hexdigest()
+
+    def security_errors(self):
+        """Return just those errors associated with security"""
+        errors = ErrorDict()
+        for f in ["timestamp", "security_hash"]:
+            if f in self.errors:
+                errors[f] = self.errors[f]
+        return errors
+
+    def clean_security_hash(self):
+        """Check the security hash."""
+        security_hash_dict = {
+            'content_type' : self.data.get("content_type", ""),
+            'object_pk' : self.data.get("object_pk", ""),
+            'timestamp' : self.data.get("timestamp", ""),
+        }
+        expected_hash = self.generate_security_hash(**security_hash_dict)
+        actual_hash = self.cleaned_data["security_hash"]
+        if expected_hash != actual_hash:
+            raise forms.ValidationError("Security hash check failed.")
+        return actual_hash
+
+    def clean_timestamp(self):
+        """Make sure the timestamp isn't too far (> 2 hours) in the past."""
+        ts = self.cleaned_data["timestamp"]
+        if time.time() - ts > (2 * 60 * 60):
+            raise forms.ValidationError("Timestamp check failed")
+        return ts
+
+class MetaCommentForm(BaseCommentForm):
+    name          = forms.CharField(label=_("Name"), max_length=50)
+    email         = forms.EmailField(label=_("Email address"))
+    url           = forms.URLField(label=_("URL"), required=False)
+    comment       = forms.CharField(label=_('Comment'), widget=forms.Textarea,
+                                    max_length=COMMENT_MAX_LENGTH)
 
     def get_comment_object(self):
         """
@@ -76,41 +132,6 @@ class CommentForm(forms.Form):
 
         return new
 
-    def security_errors(self):
-        """Return just those errors associated with security"""
-        errors = ErrorDict()
-        for f in ["honeypot", "timestamp", "security_hash"]:
-            if f in self.errors:
-                errors[f] = self.errors[f]
-        return errors
-
-    def clean_honeypot(self):
-        """Check that nothing's been entered into the honeypot."""
-        value = self.cleaned_data["honeypot"]
-        if value:
-            raise forms.ValidationError(self.fields["honeypot"].label)
-        return value
-
-    def clean_security_hash(self):
-        """Check the security hash."""
-        security_hash_dict = {
-            'content_type' : self.data.get("content_type", ""),
-            'object_pk' : self.data.get("object_pk", ""),
-            'timestamp' : self.data.get("timestamp", ""),
-        }
-        expected_hash = self.generate_security_hash(**security_hash_dict)
-        actual_hash = self.cleaned_data["security_hash"]
-        if expected_hash != actual_hash:
-            raise forms.ValidationError("Security hash check failed.")
-        return actual_hash
-
-    def clean_timestamp(self):
-        """Make sure the timestamp isn't too far (> 2 hours) in the past."""
-        ts = self.cleaned_data["timestamp"]
-        if time.time() - ts > (2 * 60 * 60):
-            raise forms.ValidationError("Timestamp check failed")
-        return ts
-
     def clean_comment(self):
         """
         If COMMENTS_ALLOW_PROFANITIES is False, check that the comment doesn't
@@ -127,31 +148,22 @@ class CommentForm(forms.Form):
                     get_text_list(['"%s%s%s"' % (i[0], '-'*(len(i)-2), i[-1]) for i in bad_words], 'and'))
         return comment
 
-    def generate_security_data(self):
-        """Generate a dict of security data for "initial" data."""
-        timestamp = int(time.time())
-        security_dict =   {
-            'content_type'  : str(self.target_object._meta),
-            'object_pk'     : str(self.target_object._get_pk_val()),
-            'timestamp'     : str(timestamp),
-            'security_hash' : self.initial_security_hash(timestamp),
-        }
-        return security_dict
 
-    def initial_security_hash(self, timestamp):
-        """
-        Generate the initial security hash from self.content_object
-        and a (unix) timestamp.
-        """
+class CommentForm(MetaCommentForm):
+    honeypot      = forms.CharField(required=False,
+                                    label=_('If you enter anything in this field '
+                                            'your comment will be treated as spam'))
 
-        initial_security_dict = {
-            'content_type' : str(self.target_object._meta),
-            'object_pk' : str(self.target_object._get_pk_val()),
-            'timestamp' : str(timestamp),
-          }
-        return self.generate_security_hash(**initial_security_dict)
+    def security_errors(self):
+        errors = super(CommentForm, self).security_errors()
+        if 'honeypot' in self.errors:
+            errors['honeypot'] = self.errors['honeypot']
+        return errors
+
+    def clean_honeypot(self):
+        """Check that nothing's been entered into the honeypot."""
+        value = self.cleaned_data["honeypot"]
+        if value:
+            raise forms.ValidationError(self.fields["honeypot"].label)
+        return value
 
-    def generate_security_hash(self, content_type, object_pk, timestamp):
-        """Generate a (SHA1) security hash from the provided info."""
-        info = (content_type, object_pk, timestamp, settings.SECRET_KEY)
-        return sha_constructor("".join(info)).hexdigest()
