Added GET request handler, command for key generation. Changed KeyPair format for ecdsa (use to_string instead of to_pem because it's shorter)

boards/management/commands/generate_keypair.py

@@ -0,0 +1,17 b''
+__author__ = 'neko259'
+
+
+from django.core.management import BaseCommand
+from django.db import transaction
+
+from boards.models import KeyPair
+
+
+class Command(BaseCommand):
+    help = 'Generates the new keypair. The first one will be primary.'
+
+    @transaction.atomic
+    def handle(self, *args, **options):
+        key = KeyPair.objects.generate_key(
+            primary=not KeyPair.objects.has_primary())
+        print(key)
  No newline at end of file

boards/tests/test_sync.py

@@ -0,0 +1,55 b''
+from boards.models import KeyPair, Post
+from boards.tests.mocks import MockRequest
+from boards.views.sync import respond_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.
+        """
+
+        key = KeyPair(public_key='pubkey', private_key='privkey',
+                      key_type='test_key_type', primary=True)
+        key.save()
+
+        post = Post.objects.create_post(title='test_title', text='test_text')
+
+        request = MockRequest()
+        request.POST['xml'] = (
+            '<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)
+        )
+
+        self.assertTrue(
+            '<response>'
+            '<status>success</status>'
+            '<models>'
+            '<model name="post" ref-id="1">'
+            '<id key="%s" local-id="%d" type="%s" />'
+            '<title>%s</title>'
+            '<text>%s</text>'
+            '<pub-time>%d</pub-time>'
+            '<edit-time>%d</edit-time>'
+            '</model>'
+            '</models>'
+            '</response>' % (
+                post.global_id.key,
+                post.id,
+                post.global_id.key_type,
+                post.title,
+                post.text.raw,
+                post.get_pub_time_epoch(),
+                post.get_edit_time_epoch(),
+            ) in respond_get(request).content.decode(),
+            'Wrong response generated for the GET request.')
  No newline at end of file

boards/models/signature.py

@@ -1,45 +1,67 b''
 import xml.etree.ElementTree as et
 from django.db import models
 
 
 ATTR_KEY = 'key'
 ATTR_KEY_TYPE = 'type'
 ATTR_LOCAL_ID = 'local-id'
 
 
 class GlobalId(models.Model):
     class Meta:
         app_label = 'boards'
 
     def __init__(self, *args, **kwargs):
         models.Model.__init__(self, *args, **kwargs)
 
         if 'key' in kwargs and 'key_type' in kwargs and 'local_id' in kwargs:
             self.key = kwargs['key']
             self.key_type = kwargs['key_type']
             self.local_id = kwargs['local_id']
 
     key = models.TextField()
     key_type = models.TextField()
     local_id = models.IntegerField()
 
     def __str__(self):
-        return '%s / %s / %d' % (self.key_type, self.key, self.local_id)
+        return '%s | %s | %d' % (self.key_type, self.key, self.local_id)
 
-    def to_xml_element(self, element: et.SubElement):
+    def to_xml_element(self, element: et.Element):
         """
         Exports global id to an XML element.
         """
 
         element.set(ATTR_KEY, self.key)
         element.set(ATTR_KEY_TYPE, self.key_type)
         element.set(ATTR_LOCAL_ID, str(self.local_id))
 
+    @staticmethod
+    def from_xml_element(element: et.Element, existing=False):
+        """
+        Parses XML id tag and gets global id from it.
+
+        Arguments:
+        element -- the XML 'id' element
+        existing -- if this is False, a new instance of GlobalId will be
+         created. Otherwise, we will search for an existing GlobalId instance
+         and throw DoesNotExist if there isn't one.
+        """
+
+        if existing:
+            return GlobalId.objects.get(key=element.get(ATTR_KEY),
+                                        key_type=element.get(ATTR_KEY_TYPE),
+                                        local_id=int(element.get(
+                                            ATTR_LOCAL_ID)))
+        else:
+            return GlobalId(key=element.get(ATTR_KEY),
+                            key_type=element.get(ATTR_KEY_TYPE),
+                            local_id=int(element.get(ATTR_LOCAL_ID)))
+
 
 class Signature(models.Model):
     class Meta:
         app_label = 'boards'
 
     key_type = models.TextField()
     key = models.TextField()
     signature = models.TextField()

boards/models/sync_key.py

@@ -1,57 +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 = private.to_pem().decode()
-            public_key_str = public.to_pem().decode()
+            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_pem(public_key_str)
+            public = VerifyingKey.from_string(base64.b64decode(public_key_str))
             signature_byte = base64.b64decode(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)
+        return '%s | %s' % (self.key_type, self.public_key)
 
     def sign(self, string):
-        private = SigningKey.from_pem(self.private_key)
+        private = SigningKey.from_string(base64.b64decode(
+            self.private_key.encode()))
         signature_byte = private.sign(string.encode())
         return base64.b64encode(signature_byte)

boards/templates/boards/post.html

@@ -1,103 +1,103 b''
 {% load i18n %}
 {% load board %}
 {% load cache %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
 {% spaceless %}
     {% cache 600 post post.id post.last_edit_time thread.archived bumpable truncated moderator LANGUAGE_CODE need_open_link %}
         {% if thread.archived %}
             <div class="post archive_post" id="{{ post.id }}">
         {% elif bumpable %}
             <div class="post" id="{{ post.id }}">
         {% else %}
             <div class="post dead_post" id="{{ post.id }}">
         {% endif %}
 
         <div class="post-info">
             <a class="post_id" href="{% post_object_url post thread=thread %}"
                 {% if not truncated and not thread.archived %}
                     onclick="javascript:addQuickReply('{{ post.id }}'); return false;"
                     title="{% trans 'Quote' %}"
                 {% endif %}
                 >({{ post.id }}) </a>
             <span class="title">{{ post.title }} </span>
             <span class="pub_time">{{ post.pub_time }}</span>
             {% if thread.archived %}
                 — {{ thread.bump_time }}
             {% endif %}
             {% if is_opening and need_open_link %}
                 {% if thread.archived %}
                     [<a class="link" href="{% url 'thread' post.id %}">{% trans "Open" %}</a>]
                 {% else %}
                     [<a class="link" href="{% url 'thread' post.id %}#form">{% trans "Reply" %}</a>]
                 {% endif %}
             {% endif %}
 
             {% if post.global_id %}
-                <span class="global-id">{{ post.global_id.key_type }} / {{ post.global_id.key }} / {{ post.global_id.local_id }}</span>
+                <span class="global-id"> {{ post.global_id }} </span>
             {% endif %}
 
             {% if moderator %}
                 <span class="moderator_info">
                     [<a href="{% url 'post_admin' post_id=post.id %}"
                         >{% trans 'Edit' %}</a>]
                     [<a href="{% url 'delete' post_id=post.id %}"
                         >{% trans 'Delete' %}</a>]
                     ({{ post.poster_ip }})
                     [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
                         >{% trans 'Ban IP' %}</a>]
                 </span>
             {% endif %}
         </div>
         {% if post.images.exists %}
             {% with post.images.all.0 as image %}
             <div class="image">
                 <a
                         class="thumb"
                         href="{{ image.image.url }}"><img
                         src="{{ image.image.url_200x150 }}"
                         alt="{{ post.id }}"
                         width="{{ image.pre_width }}"
                         height="{{ image.pre_height }}"
                         data-width="{{ image.width }}"
                         data-height="{{ image.height }}"/>
                 </a>
             </div>
             {% endwith %}
         {% endif %}
         <div class="message">
             {% autoescape off %}
                 {% if truncated %}
                     {{ post.text.rendered|truncatewords_html:50 }}
                 {% else %}
                     {{ post.text.rendered }}
                 {% endif %}
             {% endautoescape %}
             {% if post.is_referenced %}
                 <div class="refmap">
                     {% autoescape off %}
                         {% trans "Replies" %}: {{ post.refmap }}
                     {% endautoescape %}
                 </div>
             {% endif %}
         </div>
     {% endcache %}
         {% if is_opening %}
         {% cache 600 post_thread thread.id thread.last_edit_time LANGUAGE_CODE need_open_link %}
             <div class="metadata">
                 {% if is_opening and need_open_link %}
                     {{ thread.get_reply_count }} {% trans 'messages' %},
                     {{ thread.get_images_count }} {% trans 'images' %}.
                 {% endif %}
                 <span class="tags">
                     {% for tag in thread.get_tags %}
                         <a class="tag" href="{% url 'tag' tag.name %}">
                             #{{ tag.name }}</a>{% if not forloop.last %},{% endif %}
                     {% endfor %}
                 </span>
             </div>
         {% endcache %}
         {% endif %}
         </div>
 {% endspaceless %}

boards/views/sync.py

@@ -1,6 +1,33 b''
+import xml.etree.ElementTree as et
+from django.http import HttpResponse
+from boards.models import GlobalId, Post
+
+
 def respond_pull(request):
     pass
 
 
 def respond_get(request):
+    """
+    Processes a GET request with post ID list and returns the posts XML list.
+    Request should contain an 'xml' post attribute with the actual request XML.
+    """
+
+    request_xml = request.POST['xml']
+
+    posts = []
+
+    root_tag = et.fromstring(request_xml)
+    model_tag = root_tag[0]
+    for id_tag in model_tag:
+        try:
+            global_id = GlobalId.from_xml_element(id_tag, existing=True)
+            posts += Post.objects.filter(global_id=global_id)
+        except GlobalId.DoesNotExist:
+            # This is normal. If we don't have such GlobalId in the system,
+            # just ignore this ID and proceed to the next one.
     pass
+
+    response_xml = Post.objects.generate_response_get(posts)
+
+    return HttpResponse(content=response_xml)
  No newline at end of file