Added signature verification for a post

boards/models/post/sync.py

@@ -1,129 +1,160 b''
 import xml.etree.ElementTree as et
 from django.db import transaction
 from boards.models import KeyPair, GlobalId, Signature, Post
 
 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'
 
 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()
 
             if not post.is_opening():
                 thread = et.SubElement(content_tag, TAG_THREAD)
                 thread_id = et.SubElement(thread, TAG_ID)
                 post.get_thread().get_opening_post().global_id.to_xml_element(thread_id)
             else:
                 # TODO Output tags here
                 pass
 
             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.signature.all()
             if post_signatures:
                 signatures = post.signatures
             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(model, ENCODING_UNICODE)),
+                    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')
+
                 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()
 
                     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)
                     if thread:
                         opening_post = Post.objects.get(
                             id=thread.find(TAG_ID).text)
                     else:
                         opening_post = None
                         # TODO Get tags here
 
                     # TODO Check that the replied posts are already present
                     # before adding new ones
 
                     post = Post.objects.import_post(
                         title=title, text=text, pub_time=pub_time,
                         opening_post=opening_post)
                     post.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
+
+        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)
+
+            if not KeyPair.objects.verify(
+                    signature_key,
+                    et.tostring(tag_content, ENCODING_UNICODE),
+                    signature_value, signature_type):
+                valid = False
+                break
+
+        return valid

docs/dip-1.markdown

@@ -1,205 +1,205 b''
 # 0 Title #
 
 DIP-1 Common protocol description
 
 # 1 Intro #
 
 This document describes the Data Interchange Protocol (DIP), designed to
 exchange filtered data that can be stored as a graph structure between
 network nodes.
 
 # 2 Purpose #
 
 This protocol will be used to share the models (originally imageboard posts)
 across multiple servers. The main differnce of this protocol is that the node
 can specify what models it wants to get and from whom. The nodes can get
 models from a specific server, or from all except some specific servers. Also
 the models can be filtered by timestamps or tags.
 
 # 3 Protocol description #
 
 The node requests other node's changes list since some time (since epoch if
 this is the start). The other node sends a list of post ids or posts in the
 XML format.
 
 Protocol version is the version of the sync api. Model version is the version
 of data models. If at least one of them is different, the sync cannot be
 performed.
 
 The node signs the data with its keys. The receiving node saves the key at the
 first sync and checks it every time. If the key has changed, the info won't be
 saved from the node (or the node id must be changed). A model can be signed 
 with several keys but at least one of them must be the same as in the global 
 ID to verify the sender.
 
 Each node can have several keys. Nodes can have shared keys to serve as a pool
 (several nodes with the same key).
 
 Each post has an ID in the unique format: key-type::key::local-id
 
 All requests pass a request type, protocol and model versions, and a list of
 optional arguments used for filtering.
 
 Each request has its own version. Version consists of 2 numbers: first is
 incompatible version (1.3 and 2.0 are not compatible and must not be in sync)
 and the second one is minor and compatible (for example, new optional field
 is added which will be igroned by those who don't support it yet).
 
 Post edits and reflinks are not saved to the sync model. The replied post ID 
 can be got from the post text, and reflinks can be computed when loading 
 posts. The edit time is not saved because a foreign post can be 'edited' (new
 replies are added) but the signature must not change (so we can't update the
 content). The inner posts can be edited, and the signature will change then
 but the local-id won't, so the other node can detect that and replace the post
 instead of adding a new one.
 
 ## 3.1 Requests ##
 
 There is no constraint on how the server should calculate the request. The
 server can return any information by any filter and the requesting node is
 responsible for validating it.
 
 The server is required to return the status of request. See 3.2 for details.
 
 ### 3.1.1 pull ###
 
 "pull" request gets the desired model id list by the given filter (e.g. thread, tags,
 author)
 
 Sample request is as follows:
 
-<?xml version="1.1" encoding="UTF-8" ?>
-<request version="1.0" type="pull">
-    <model version="1.0" name="post">
-        <timestamp_from>0</timestamp_from>
-        <timestamp_to>0</timestamp_to>
-        <tags>
-            <tag>tag1</tag>
-        </tags>
-        <sender>
-            <allow>
-                <key>abcehy3h9t</key>
-                <key>ehoehyoe</key>
-            </allow>
-            <!-- There can be only allow block (all other are denied) or deny block (all other are allowed) -->
-        </sender>
-    </model>
-</request>
+    <?xml version="1.1" encoding="UTF-8" ?>
+    <request version="1.0" type="pull">
+        <model version="1.0" name="post">
+            <timestamp_from>0</timestamp_from>
+            <timestamp_to>0</timestamp_to>
+            <tags>
+                <tag>tag1</tag>
+            </tags>
+            <sender>
+                <allow>
+                    <key>abcehy3h9t</key>
+                    <key>ehoehyoe</key>
+                </allow>
+                <!-- There can be only allow block (all other are denied) or deny block (all other are allowed) -->
+            </sender>
+        </model>
+    </request>
 
 Under the <model> tag there are filters. Filters for the "post" model can
 be found in DIP-2.
 
 Sample response:
 
     <?xml version="1.1" encoding="UTF-8" ?>
     <response>
         <status>success</status>
         <models>
             <id key="id1" type="ecdsa" local-id="1" />
             <id key="id1" type="ecdsa" local-id="2" />
             <id key="id2" type="ecdsa" local-id="1" />
             <id key="id2" type="ecdsa" local-id="5" />
         </models>
     </response>
 
 ### 3.1.2 get ###
 
 "get" gets models by id list.
 
 Sample request:
 
     <?xml version="1.1" encoding="UTF-8" ?>
     <request version="1.0" type="get">
         <model version="1.0" name="post">
             <id key="id1" type="ecdsa" local-id="1" />
             <id key="id1" type="ecdsa" local-id="2" />
         </model>
     </request>
 
 Id consists of a key, key type and local id. This key is used for signing and
 validating of data in the model content.
 
 Sample response:
 
     <?xml version="1.1" encoding="UTF-8" ?>
     <response>
         <!--
              Valid statuses are 'success' and 'error'.
         -->
         <status>success</status>
         <models>
             <model name="post">
                 <!--
                     Content tag is the data that is signed by signatures and must
                     not be changed for the post from other node.
                 -->
                 <content>
                     <id key="id1" type="ecdsa" local-id="1" />
                     <title>13</title>
                     <text>Thirteen</text>
                     <thread><id key="id1" type="ecdsa" local-id="2" /></thread>
                     <pub-time>12</pub-time>
                     <!--
                         Images are saved as attachments and included in the
                         signature.
                     -->
                     <attachments>
                         <attachment mimetype="image/png" name="12345.png">
                             TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0
                             aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1
                             c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0
                             aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdl
                             LCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=
                         </attachment>
                     </attachments>
                 </content>
                 <!--
                     There can be several signatures for one model. At least one
                     signature must be made with the key used in global ID.
                  -->
                 <signatures>
                     <signature key="id1" type="ecdsa" value="dhefhtreh" />
                     <signature key="id45" type="ecdsa" value="dsgfgdhefhtreh" />
                 </signatures>
             </model>
             <model name="post">
                 <content>
                     <id key="id1" type="ecdsa" local-id="id2" />
                     <title>13</title>
                     <text>Thirteen</text>
                     <pub-time>12</pub-time>
                     <edit-time>13</edit-time>
                     <tags>
                         <tag>tag1</tag>
                     </tags>
                 </content>
                 <signatures>
                     <signature key="id2" type="ecdsa" value="dehdfh" />
                 </signatures>
             </model>
         </models>
     </response>
 
 ### 3.1.3 put ###
 
 "put" gives a model to the given node (you have no guarantee the node takes
 it, consider you are just advising the node to take your post). This request
 type is useful in pool where all the nodes try to duplicate all of their data
 across the pool.
 
 ## 3.2 Responses ##
 
 ### 3.2.1 "not supported" ###
 
 If the request if completely not supported, a "not supported" status will be
 returned.
 
 ### 3.2.2 "success" ###
 
 "success" status means the request was processed and the result is returned.
 
 ### 3.2.3 "error" ###
 
 If the server knows for sure that the operation cannot be processed, it sends
 the "error" status. Additional tags describing the error may be <description>
 and <stack>.