Implementing get routes

Database.md

@@ -97,16 +97,20 @@ A Law Document looks like this:
 ```
 
 # users
-For every Registered user there is a
-Public and Private PGP Key (GnuPG):
+For every Registered user there is a private and public key.
+The private key is encrypted with each of the users three passwords.
+This makes it possible to use private keys with each of them
 ```json
 { "public_key" : "<RSA Public Key>"
-, "private_key" : "<Encrypted RSA Private Key>"
+, "private_keys" : ["<Encrypted RSA Private Key>"]
+, "passwords" : ["<passwords>"]
 , "username" : "<unique username>"
 , "first_name" : "<first real name>"
 , "last_name" : "<last real name>"
 , "expiration" : "<date of expiration of key pair>"
 , "feed" : ["<hash of message where this user is either in the to or from part>"]
+, "readings" : ["<hash of messages, that the user is reading>"]
+, "writings" : ["<hash of messages, that the user is writing>"]
 , "old_keys" : [{ "expiration" : "<unix timestamp of their expiration>"
                 , "public_key" :"<old public key until the expiration>"
                 , "private_key" : "<old, encrypted private key>"
@@ -115,24 +119,17 @@ Public and Private PGP Key (GnuPG):
 ```
 
 # messages
-Anybody can send end-to-end encypted messages to anyone.
-A message, that is addressed to `all` is a post.
-The process of encrypting and decrypting a message
-from Alice to Bob is like this:
-
-    Alice's Message -> Alice's Private Key -> Bob's Public Key -> Send -> Bob's Private Key -> Alice's Public Key
-
-A post is just signed by the author
-
-    Alice's Message -> Alice's Private Key -> Published
-
+For now, there can be only one kind of messages:
+Public posts.
+These messages can be read and are addressed to anyone.
 ```json
 { "from" : "<username of the author>"
-, "to" : [ "<username's of the recipients or 'all', when the message is a post>" ]
-, "body" : [{ "recipient_name" : "<username of the recipient>"
-  , "ciphertext" : "<encrypted text of the message, D(D(body, recipient_private_key), author_public_key) == message>"
-  }]
+, "to" : "all"
+, "body" : { "title" : "<title of the post"
+           , "content" : "<markdown content of the post."
+         }
 , "hash" : "<SHA256 of a dict of all the other fields in the message, used as unique and secure identifier>"
+, "draft" : <true if message is a draft and not yet ready to be send.>
 }
 ```
 If in "to" there is `"all"` then the body isn't encrypted

Server/Patches.py

@@ -2,70 +2,27 @@
 import subprocess, os, json
 from Crypto.Hash import SHA256
 from pymongo import MongoClient
-
-"""
-Env Variables:
-$PATCHES : Folder with the Git Repositories of the Patches (format: patcher-patch/)
-$ORIGIN_REPOSITORY : Location of the Original Git Repository, from which patches are cloned from
-and to whom patches are pushed after being approved.
-
-create a patch:
-- clone the origin_repository, as stored in the $ORIGIN_REPOSITORY envvar.
-- create an entry in the collection patches on the demnet database.
-
-This patch needs the following options:
-
-- The name of the patcher, that can either be the username in demnet
-or a pseudonyme chosen by a non-user, which will then be noted in a separate
-variable called "is_user".
-
-- The name of the patch, that should be descriptive (hopefully)
-
-- The simple_description of the patcher's intent.
-This is useful for users, if the patcher wants to hold an election before
-starting development. These users won't often be interested in the technical
-details, for whom this description should suffice.
-
-- The technical_description is for all developers trying to understand
-the patcher's intent on a deeper level.
-
-- As part of the technical_description, the patcher can also reference issues,
-bug reports and generally link to ressources, detailing his intention.
-This is separatly done in the "references" field.
-The Patcher should put a most conclusive list here
-and reference only some of it in the descriptions.
-
-- The Patcher may not want to start developing, waste hours and hours of time,
-and see that the users don't even have an interest their patch.
-All patches have to pass an election eventually, but if the patcher wants to,
-they can hold an election before starting to develop, just to see if there
-is any interest. If the election is lost, the patcher will either have to delete
-the patch or modify it substantially. If they want to hold such an election,
-"hold_pre_election" must be set to True.
-
-- After the Patch has been closed and the Patch Repository deleted, the
-patch entry "closed" = True
-
-After creating the patch,
-a SHA256 of all the data is created and
-returned as the reference to the patch.
-This is also put into one field called "sha256".
-(That this isn't included in the calculation of the hash is self-evident.)
-"""
-def create(patcher,patch_name, options):
+from typing import List
+
+def create  ( patcher                   : str
+            , patch_name                : str
+            , is_user                   : bool
+            , simple_description        : str
+            , technical_description     : str
+            , references                : List[str]
+            ):
     client = MongoClient()
     db = client.demnet
     patches = db.patches
     patch = { "patcher" : patcher
-            , "is_user" : options['is_user']
+            , "is_user" : is_user
             , "name" : patch_name
-            , "simple_description" : options['simple_description']
-            , "technical_description" : options['technical_description']
-            , "hold_pre_election" : options['hold_pre_election']
-            , "references" : options['references']
+            , "simple_description" : simple_description
+            , "technical_description" : technical_description
+            , "references" : references
             , "closed" : False
             }
-    patch['hash'] = SHA256.new(data=json.dumps(patch).encode('utf-8')).hexdigest()
+    patch['hash'] = SHA256.new().update(json.dumps(patch)).encode('utf-8')).hexdigest()
     patch_id = patches.insert_one(patch).inserted_id
 
     subprocess.run(['bash', 'patch.sh', 'create', os.environ["ORIGIN_REPOSITORY"], patcher, patch_name])
@@ -75,6 +32,14 @@ def create(patcher,patch_name, options):
 def merge(patcher, patch_name):
     subprocess.run(['bash', 'patch.sh', 'merge', patcher, patch_name])
 
+def lock(patcher, patch_name):
+    path_of_patch   = path_of_patch(patcher,patch_name)
+    if not path_of_patch:
+        return False
+    else:
+        os.chmod(path_of_patch, 0444) # readonly to all
+        return True
+
 """
 Closing a patch means:
 Deleting the Git Repo.
@@ -90,7 +55,7 @@ def close(patcher, patch_name, id, merge=False):
                               , "closed"    : False
                               } )
 
-    repo_path = f"{os.environ['PATCHES']}/{patcher}-{patch_name}"
+    repo_path = path_of_patch(patcher, patch_name, check_existence=False)
     if patch and os.path.isdir(repo_path):
         if merge:
             merge(patcher, patch_name)
@@ -101,3 +66,10 @@ def close(patcher, patch_name, id, merge=False):
         return True
     else:
         return False
+
+def path_of_patch(patcher, patch_name, check_existence=True):
+    path    = f"{os.environ["PATCHES"]}/{patcher}-{patch_name}"
+    if check_existence:
+        return path if os.path.isdir(path) else False
+    else:
+        return path

Server/Type_checks.py

@@ -0,0 +1,49 @@
+from typing import Dict, TypeVar
+class Type_Check_Error (Exception):
+    def __init__(self,data_name, msg):
+        self.data_name  = data_name
+        self.msg        = msg
+
+Dict_Values = TypeVar("Dict_Values")
+def check_for_type(dictionary_name : str, dictionary : Dict[str, Dict_Values]):
+    try:
+        if dictionary_name == "additions":
+            for addition in dictionary:
+                assert check_for_type(addition,     { "title"       : ""
+                                                    , "book"        : ""
+                                                    , "articles"    : []
+                                                    }
+                        )
+        elif dictionary == "amendments":
+            for amendment in dictionary:
+                assert check_for_type(amendment,    { "book"        : ""
+                                                    , "law"         : ""
+                                                    , "articles"    : []
+                                                    }
+                            )
+        elif dictionary == "repeals":
+            for repeal in repeals:
+                assert check_for_type(repael,       { "books"       : []
+                                                    , "laws"        : []
+                                                    })
+            else:
+            raise Type_Check_Error(dictionary_name, "unknown dictionary name")
+    except AssertionError as assertion_error:
+        raise Type_Check_Error(dictionary_name, assertion_error.args[0])
+    except Exception as e:
+        raise e
+    else:
+        return True
+
+def check_dictionary_for_type   (   dictionary  : Dict[str, Dict_Values]
+                                ,   types       : Dict[str, Dict_Values]
+                                ):
+    try:
+        tests           = [(type(types[key]) == type(dictionary[key]), key) for key in types]
+        test_failed     = False in filter(lambda t: t[0], tests)
+        assert not test_failed, f"Type Check Failed: {list(map(lambda t: t[1], filter(lambda t: t[0] == False, tests)))}"
+
+    except Exception as e:
+        raise e
+    else:
+        return True

Server/Users.py

@@ -12,6 +12,7 @@
 from Crypto.Hash import SHA256
 from Crypto.Cipher import AES
 from pymongo import MongoClient
+import pymongo
 import datetime, sys, json
 
 client = MongoClient()
@@ -31,7 +32,7 @@ def login(username, passphrase):
         if keys.publickey().export_key(format="PEM") != user["public_key"]:
             users.update_one({ "username" : username }, { "$set" : { "public_key"  : keys.publickey().export_key(format="PEM") } } )
 
-        if datetime.datetime.strptime(user["expiration"], "%m/%d/%Y") > datetime.datetime.now():
+        if datetime.date.fromisoformat(user["expiration"]) > datetime.datetime.now():
 
             new_keys = RSA.generate(2048)
             new_expiration = datetime.timedelta (weeks=104
@@ -43,8 +44,9 @@ def login(username, passphrase):
                                                 ,microseconds=0
                                                 ) + datetime.datetime.now()
 
-            private_key = new_keys.export_key(format="PEM", passphrase=passphrase)
-            public_key  = new_keys.publickey().export_key(format="PEM")
+            new_expiration  = new_expiration.isoformat()
+            private_key     = new_keys.export_key(format="PEM", passphrase=passphrase)
+            public_key      = new_keys.publickey().export_key(format="PEM")
 
 
             users.update_one(   { "username" : username }
@@ -129,30 +131,21 @@ def encrypt(message,keys):
 
 """
 Publishing a message works in these steps:
-1. Encrypt/Sign the message
-2. Publish it in demnet.messages
-3. Add a notification to the recipient's feed.
+1. Publish it in demnet.messages
 Parameters:
 - *message* message document with unencrypted body
 - *keys* private and public keys of the author
 Returns:
 True if successfull
 False if not
 """
-def publish(message, keys):
-    # 1. Encrypt/Sign the message
-    body = encrypt(message, keys)
-    if body != False:
+def publish(message):
+    if message['body'] != False:
         # 2. Publish it in demnet.messages
-        message['body'] = body
-        message['hash'] = SHA256.new(json.dumps(body).encode('utf-8')).hexdigest()
         messages = db.messages
+        message['hash'] = SHA256.new(json.dumps(message['body']).encode('utf-8')).hexdigest()
+        message['upload_time'] = messages.find().sort("upload_time", pymongo.DESCENDING).limit(1)[0]["upload_time"] + 1 # Some inconsistent (race condition) is possible, but not critical.
         messages.insert_one(message)
 
-        # 3. Add a notification to the recipient's feed
-        for recipient_name in message['to']:
-            users.update_one({ "username" : recipient_name }
-                             , { "$push" : { "feed" : message["hash"] } }
-                            )
         return True
     return False