Save signatures when the post is parsed for the later use

boards/models/post/manager.py

@@ -1,128 +1,128 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 from django.db import models, transaction
 from django.utils import timezone
 from boards import utils
 from boards.mdx_neboard import Parser
 from boards.models import PostImage
 import boards.models
 
 __author__ = 'vurdalak'
 
 
 NO_IP = '0.0.0.0'
 POSTS_PER_DAY_RANGE = 7
 
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, image=None, thread=None,
                     ip=NO_IP, tags: list=None, opening_posts: list=None):
         """
         Creates new post
         """
 
         is_banned = boards.models.Ban.objects.filter(ip=ip).exists()
 
         # TODO Raise specific exception and catch it in the views
         if is_banned:
             raise Exception("This user is banned")
 
         if not tags:
             tags = []
         if not opening_posts:
             opening_posts = []
 
         posting_time = timezone.now()
         new_thread = False
         if not thread:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=posting_time, last_edit_time=posting_time)
             list(map(thread.tags.add, tags))
             boards.models.thread.Thread.objects.process_oldest_threads()
             new_thread = True
 
         pre_text = Parser().preparse(text)
 
         post = self.create(title=title,
                            text=pre_text,
                            pub_time=posting_time,
                            poster_ip=ip,
                            thread=thread,
                            last_edit_time=posting_time)
         post.threads.add(thread)
 
         post.set_global_id()
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post {} by {}'.format(post, post.poster_ip))
 
         if image:
             post.images.add(PostImage.objects.create_with_hash(image))
 
         if not new_thread:
             thread.last_edit_time = posting_time
             thread.bump()
             thread.save()
 
         post.build_url()
         post.connect_replies()
         post.connect_threads(opening_posts)
         post.connect_notifications()
 
         return post
 
     @transaction.atomic
-    def import_post(self, title: str, text: str, pub_time: str,
+    def import_post(self, title: str, text: str, pub_time: str, global_id,
                     opening_post=None, tags=list()):
         if opening_post is None:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=pub_time, last_edit_time=pub_time)
             list(map(thread.tags.add, tags))
         else:
             thread = opening_post.get_thread()
 
         post = self.create(title=title, text=text,
                            pub_time=pub_time,
                            poster_ip=NO_IP,
                            last_edit_time=pub_time,
-                           thread_id=thread.id)
+                           thread_id=thread.id, global_id=global_id)
 
         post.build_url()
         post.connect_replies()
         post.connect_notifications()
 
         return post
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         for post in posts:
             post.delete()
 
     @utils.cached_result()
     def get_posts_per_day(self) -> float:
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         day_time_start = timezone.make_aware(datetime.combine(
             day_start, dtime()), timezone.get_current_timezone())
         day_time_end = timezone.make_aware(datetime.combine(
             day_end, dtime()), timezone.get_current_timezone())
 
         posts_per_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         return ppd

boards/models/post/sync.py

@@ -1,173 +1,175 b''
 import xml.etree.ElementTree as et
 from django.db import transaction
 from boards.models import KeyPair, GlobalId, Signature, Post, Tag
 
 ENCODING_UNICODE = 'unicode'
 
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_RESPONSE = 'response'
 TAG_ID = 'id'
 TAG_STATUS = 'status'
 TAG_MODELS = 'models'
 TAG_TITLE = 'title'
 TAG_TEXT = 'text'
 TAG_THREAD = 'thread'
 TAG_PUB_TIME = 'pub-time'
 TAG_SIGNATURES = 'signatures'
 TAG_SIGNATURE = 'signature'
 TAG_CONTENT = 'content'
 TAG_ATTACHMENTS = 'attachments'
 TAG_ATTACHMENT = 'attachment'
 TAG_TAGS = 'tags'
 TAG_TAG = 'tag'
 
 TYPE_GET = 'get'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 ATTR_VALUE = 'value'
 ATTR_MIMETYPE = 'mimetype'
 ATTR_KEY = 'key'
 
 STATUS_SUCCESS = 'success'
 
 
 class SyncManager:
     @staticmethod
     def generate_response_get(model_list: list):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         for post in model_list:
             model = et.SubElement(models, TAG_MODEL)
             model.set(ATTR_NAME, 'post')
 
             content_tag = et.SubElement(model, TAG_CONTENT)
 
             tag_id = et.SubElement(content_tag, TAG_ID)
             post.global_id.to_xml_element(tag_id)
 
             title = et.SubElement(content_tag, TAG_TITLE)
             title.text = post.title
 
             text = et.SubElement(content_tag, TAG_TEXT)
             text.text = post.get_sync_text()
 
             thread = post.get_thread()
             if post.is_opening():
                 tag_tags = et.SubElement(content_tag, TAG_TAGS)
                 for tag in thread.get_tags():
                     tag_tag = et.SubElement(tag_tags, TAG_TAG)
                     tag_tag.text = tag.name
             else:
                 tag_thread = et.SubElement(content_tag, TAG_THREAD)
                 thread_id = et.SubElement(tag_thread, TAG_ID)
                 thread.get_opening_post().global_id.to_xml_element(thread_id)
 
             pub_time = et.SubElement(content_tag, TAG_PUB_TIME)
             pub_time.text = str(post.get_pub_time_str())
 
             signatures_tag = et.SubElement(model, TAG_SIGNATURES)
             post_signatures = post.global_id.signature_set.all()
             if post_signatures:
                 signatures = post_signatures
                 # TODO Adding signature to a post is not yet added. For now this
                 # block is useless
             else:
                 # TODO Maybe the signature can be computed only once after
                 # the post is added? Need to add some on_save signal queue
                 # and add this there.
                 key = KeyPair.objects.get(public_key=post.global_id.key)
                 signatures = [Signature(
                     key_type=key.key_type,
                     key=key.public_key,
                     signature=key.sign(et.tostring(content_tag, ENCODING_UNICODE)),
                 )]
             for signature in signatures:
                 signature_tag = et.SubElement(signatures_tag, TAG_SIGNATURE)
                 signature_tag.set(ATTR_TYPE, signature.key_type)
                 signature_tag.set(ATTR_VALUE, signature.signature)
                 signature_tag.set(ATTR_KEY, signature.key)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     @transaction.atomic
     def parse_response_get(response_xml):
         tag_root = et.fromstring(response_xml)
         tag_status = tag_root.find(TAG_STATUS)
         if STATUS_SUCCESS == tag_status.text:
             tag_models = tag_root.find(TAG_MODELS)
             for tag_model in tag_models:
                 tag_content = tag_model.find(TAG_CONTENT)
 
-                valid = SyncManager._verify_model(tag_content, tag_model)
-
-                if not valid:
-                    raise Exception('Invalid model signature')
+                signatures = SyncManager._verify_model(tag_content, tag_model)
 
                 tag_id = tag_content.find(TAG_ID)
                 global_id, exists = GlobalId.from_xml_element(tag_id)
 
                 if exists:
                     print('Post with same ID already exists')
                 else:
                     global_id.save()
+                    for signature in signatures:
+                        signature.global_id = global_id
+                        signature.save()
 
                     title = tag_content.find(TAG_TITLE).text
                     text = tag_content.find(TAG_TEXT).text
                     pub_time = tag_content.find(TAG_PUB_TIME).text
 
                     thread = tag_content.find(TAG_THREAD)
                     tags = []
                     if thread:
                         opening_post = Post.objects.get(
                             id=thread.find(TAG_ID).text)
                     else:
                         opening_post = None
                         tag_tags = tag_content.find(TAG_TAGS)
                         for tag_tag in tag_tags:
                             tag, created = Tag.objects.get_or_create(name=tag_tag.text)
                             tags.append(tag)
 
                     # TODO Check that the replied posts are already present
                     # before adding new ones
 
                     # TODO Get images
 
                     post = Post.objects.import_post(
                         title=title, text=text, pub_time=pub_time,
-                        opening_post=opening_post, tags=tags)
-                    post.global_id = global_id
+                        opening_post=opening_post, tags=tags,
+                        global_id=global_id)
         else:
             # TODO Throw an exception?
             pass
 
     @staticmethod
     def _verify_model(tag_content, tag_model):
         """
         Verifies all signatures for a single model.
         """
 
-        valid = True
+        signatures = []
 
         tag_signatures = tag_model.find(TAG_SIGNATURES)
         for tag_signature in tag_signatures:
             signature_type = tag_signature.get(ATTR_TYPE)
             signature_value = tag_signature.get(ATTR_VALUE)
             signature_key = tag_signature.get(ATTR_KEY)
 
+            signature = Signature(key_type=signature_type,
+                                  key=signature_key,
+                                  signature=signature_value)
+            signatures.append(signature)
+
             if not KeyPair.objects.verify(
-                    signature_key,
-                    et.tostring(tag_content, ENCODING_UNICODE),
-                    signature_value, signature_type):
-                valid = False
-                break
+                    signature, et.tostring(tag_content, ENCODING_UNICODE)):
+                raise Exception('Invalid model signature')
 
-        return valid
+        return signatures

boards/models/sync_key.py

@@ -1,61 +1,61 b''
 import base64
 from ecdsa import SigningKey, VerifyingKey, BadSignatureError
 from django.db import models
 
 TYPE_ECDSA = 'ecdsa'
 
 APP_LABEL_BOARDS = 'boards'
 
 
 class KeyPairManager(models.Manager):
     def generate_key(self, key_type=TYPE_ECDSA, primary=False):
         if primary and self.filter(primary=True).exists():
             raise Exception('There can be only one primary key')
 
         if key_type == TYPE_ECDSA:
             private = SigningKey.generate()
             public = private.get_verifying_key()
 
             private_key_str = base64.b64encode(private.to_string()).decode()
             public_key_str = base64.b64encode(public.to_string()).decode()
 
             return self.create(public_key=public_key_str,
                                private_key=private_key_str,
                                key_type=TYPE_ECDSA, primary=primary)
         else:
             raise Exception('Key type not supported')
 
-    def verify(self, public_key_str, string, signature, key_type=TYPE_ECDSA):
-        if key_type == TYPE_ECDSA:
-            public = VerifyingKey.from_string(base64.b64decode(public_key_str))
-            signature_byte = base64.b64decode(signature)
+    def verify(self, signature, string):
+        if signature.key_type == TYPE_ECDSA:
+            public = VerifyingKey.from_string(base64.b64decode(signature.key))
+            signature_byte = base64.b64decode(signature.signature)
             try:
                 return public.verify(signature_byte, string.encode())
             except BadSignatureError:
                 return False
         else:
             raise Exception('Key type not supported')
 
     def has_primary(self):
         return self.filter(primary=True).exists()
 
 
 class KeyPair(models.Model):
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     objects = KeyPairManager()
 
     public_key = models.TextField()
     private_key = models.TextField()
     key_type = models.TextField()
     primary = models.BooleanField(default=False)
 
     def __str__(self):
         return '%s::%s' % (self.key_type, self.public_key)
 
     def sign(self, string):
         private = SigningKey.from_string(base64.b64decode(
             self.private_key.encode()))
         signature_byte = private.sign_deterministic(string.encode())
         return base64.b64encode(signature_byte).decode()

boards/tests/test_keys.py

@@ -1,87 +1,89 b''
 from base64 import b64encode
 import logging
 
 from django.test import TestCase
-from boards.models import KeyPair, GlobalId, Post
+from boards.models import KeyPair, GlobalId, Post, Signature
 from boards.models.post.sync import SyncManager
 
 logger = logging.getLogger(__name__)
 
 
 class KeyTest(TestCase):
     def test_create_key(self):
         key = KeyPair.objects.generate_key('ecdsa')
 
         self.assertIsNotNone(key, 'The key was not created.')
 
     def test_validation(self):
         key = KeyPair.objects.generate_key(key_type='ecdsa')
         message = 'msg'
-        signature = key.sign(message)
-        valid = KeyPair.objects.verify(key.public_key, message, signature,
-                                       key_type='ecdsa')
+        signature_value = key.sign(message)
+
+        signature = Signature(key_type='ecdsa', key=key.public_key,
+                              signature=signature_value)
+        valid = KeyPair.objects.verify(signature, message)
 
         self.assertTrue(valid, 'Message verification failed.')
 
     def test_primary_constraint(self):
         KeyPair.objects.generate_key(key_type='ecdsa', primary=True)
 
         with self.assertRaises(Exception):
             KeyPair.objects.generate_key(key_type='ecdsa', primary=True)
 
     def test_model_id_save(self):
         model_id = GlobalId(key_type='test', key='test key', local_id='1')
         model_id.save()
 
     def test_request_get(self):
         post = self._create_post_with_key()
 
         request = GlobalId.objects.generate_request_get([post.global_id])
         logger.debug(request)
 
         key = KeyPair.objects.get(primary=True)
         self.assertTrue('<request type="get" version="1.0">'
                         '<model name="post" version="1.0">'
                         '<id key="%s" local-id="1" type="%s" />'
                         '</model>'
                         '</request>' % (
                             key.public_key,
                             key.key_type,
                         ) in request,
                         'Wrong XML generated for the GET request.')
 
     def test_response_get(self):
         post = self._create_post_with_key()
         reply_post = Post.objects.create_post(title='test_title',
                                               text='[post]%d[/post]' % post.id,
                                               thread=post.get_thread())
 
         response = SyncManager.generate_response_get([reply_post])
         logger.debug(response)
 
         key = KeyPair.objects.get(primary=True)
         self.assertTrue('<status>success</status>'
                         '<models>'
                         '<model name="post">'
                         '<content>'
                         '<id key="%s" local-id="%d" type="%s" />'
                         '<title>test_title</title>'
                         '<text>[post]%s[/post]</text>'
                         '<thread><id key="%s" local-id="%d" type="%s" /></thread>'
                         '<pub-time>%s</pub-time>'
                         '</content>' % (
                             key.public_key,
                             reply_post.id,
                             key.key_type,
                             str(post.global_id),
                             key.public_key,
                             post.id,
                             key.key_type,
                             str(reply_post.get_pub_time_str()),
                         ) in response,
                         'Wrong XML generated for the GET response.')
 
     def _create_post_with_key(self):
         KeyPair.objects.generate_key(primary=True)
 
         return Post.objects.create_post(title='test_title', text='test_text')

boards/tests/test_sync.py

@@ -1,69 +1,72 b''
 from boards.models import KeyPair, Post, Tag
 from boards.models.post.sync import SyncManager
 from boards.tests.mocks import MockRequest
 from boards.views.sync import response_get
 
 __author__ = 'neko259'
 
 
 from django.test import TestCase
 
 
 class SyncTest(TestCase):
     def test_get(self):
         """
         Forms a GET request of a post and checks the response.
         """
 
         KeyPair.objects.generate_key(primary=True)
         tag = Tag.objects.create(name='tag1')
         post = Post.objects.create_post(title='test_title', text='test_text',
                                         tags=[tag])
 
         request = MockRequest()
         request.body = (
             '<request type="get" version="1.0">'
             '<model name="post" version="1.0">'
             '<id key="%s" local-id="%d" type="%s" />'
             '</model>'
             '</request>' % (post.global_id.key,
                             post.id,
                             post.global_id.key_type)
         )
 
         response = response_get(request).content.decode()
         self.assertTrue(
             '<status>success</status>'
             '<models>'
             '<model name="post">'
             '<content>'
             '<id key="%s" local-id="%d" type="%s" />'
             '<title>%s</title>'
             '<text>%s</text>'
             '<tags><tag>%s</tag></tags>'
             '<pub-time>%s</pub-time>'
             '</content>' % (
                 post.global_id.key,
                 post.id,
                 post.global_id.key_type,
                 post.title,
                 post.get_raw_text(),
                 post.get_thread().get_tags().first().name,
                 post.get_pub_time_str(),
             ) in response_get(request).content.decode(),
             'Wrong response generated for the GET request.')
 
         post.delete()
 
         SyncManager.parse_response_get(response)
         self.assertEqual(1, Post.objects.count(),
                          'Post was not created from XML response.')
 
         parsed_post = Post.objects.first()
         self.assertEqual('tag1',
                          parsed_post.get_thread().get_tags().first().name,
                          'Invalid tag was parsed.')
 
         SyncManager.parse_response_get(response)
         self.assertEqual(1, Post.objects.count(),
                          'The same post was imported twice.')
+
+        self.assertEqual(1, parsed_post.global_id.signature_set.count(),
+                         'Signature was not saved.')