Added a nicer wrapper interface around the CFFI functions

python/BSSpeke.py

+#import base64
+
+from _bsspeke_cffi import ffi, lib
+
+class Client:
+    
+    def __init__(self, user_id, server_id, password):
+        uid_utf8 = user_id.encode('utf-8')
+        print("uid_utf8:", uid_utf8.decode('utf-8'), len(uid_utf8))
+        sid_utf8 = server_id.encode('utf-8')
+        print("sid_utf8:", sid_utf8.decode('utf-8'), len(sid_utf8))
+        pwd_utf8 = password.encode('utf-8')
+        print("pwd_utf8:", pwd_utf8.decode('utf-8'), len(pwd_utf8))
+
+        from _bsspeke_cffi import ffi, lib
+        self.ffi = ffi
+        self.lib = lib
+
+        self.ctx = self.ffi.new("bsspeke_client_ctx *")
+        self.lib.bsspeke_client_init(self.ctx,
+                                     uid_utf8, len(uid_utf8),
+                                     sid_utf8, len(sid_utf8),
+                                     pwd_utf8, len(pwd_utf8))
+
+    def generate_blind(self):
+        blind = bytes(32)
+        self.lib.bsspeke_client_generate_blind(blind, self.ctx)
+        return blind
+
+
+    def get_client_id(self):
+        clientid_len = self.ctx.client_id_len
+        client_id_bytes = bytes(ffi.buffer(self.ctx.client_id, self.ctx.client_id_len))
+        client_id = client_id_bytes.decode('utf-8')
+        #print("ClientId string = [%s]" % client_id)
+        return client_id
+
+
+    def generate_P_and_V(self, blind_salt, phf_params):
+        P = bytes(32)
+        V = bytes(32)
+        phf_blocks = phf_params["blocks"]
+        phf_iterations = phf_params["iterations"]
+        self.lib.bsspeke_client_generate_P_and_V(P, V,
+                                                 blind_salt,
+                                                 phf_blocks, phf_iterations,
+                                                 self.ctx)
+        return P,V
+#        request = {}
+#        request["P"] = base64.b64encode(P)
+#        request["V"] = base64.b64encode(V)
+#        request["phf"] = {}
+#        request["phf"]["name"] = "argon2i"
+#        request["phf"]["blocks"] = phf_blocks
+#        request["phf"]["iterations"] = phf_iterations
+#
+#        return request
+
+    def generate_A(self, blind_salt, phf_params):
+        phf_blocks = phf_params["blocks"]
+        phf_iterations = phf_params["iterations"]
+        self.lib.bsspeke_client_generate_A(blind_salt,
+                                           phf_blocks,
+                                           phf_iterations,
+                                           self.ctx)
+        A = bytes(ffi.buffer(self.ctx.A, 32))
+        return A
+
+    def generate_shared_key(self, B):
+        self.lib.bsspeke_client_generate_shared_key(B, self.ctx)
+
+    def verify_server(self, server_verifier):
+        rc = self.lib.bsspeke_client_verify_server(server_verifier, self.ctx)
+        if rc != 0:
+            return False
+        else:
+            return True
+
+
+class Server:
+    def __init__(self, server_id, user_id):
+        sid_utf8 = server_id.encode('utf-8')
+        print("sid_utf8:", sid_utf8.decode('utf-8'), len(sid_utf8))
+        uid_utf8 = user_id.encode('utf-8')
+        print("uid_utf8:", uid_utf8.decode('utf-8'), len(uid_utf8))
+
+        from _bsspeke_cffi import ffi, lib
+        self.ffi = ffi
+        self.lib = lib
+        
+        self.ctx = self.ffi.new("bsspeke_server_ctx *")
+        self.lib.bsspeke_server_init(self.ctx,
+                                     sid_utf8, len(sid_utf8),
+                                     uid_utf8, len(uid_utf8))
+
+    def blind_salt(self, blind, salt):
+        blind_salt = bytes(32)
+        self.lib.bsspeke_server_blind_salt(blind_salt, blind, salt, len(salt))
+        return blind_salt
+
+    def generate_B(self, P):
+        self.lib.bsspeke_server_generate_B(P, self.ctx)
+        B = bytes(self.ffi.buffer(self.ctx.B, 32))
+        return B
+
+    def derive_shared_key(self, A, V):
+        self.lib.bsspeke_server_derive_shared_key(A, V, self.ctx)
+        
+    def verify_client(self, client_verifier):
+        rc = self.lib.bsspeke_server_verify_client(client_verifier, self.ctx)
+        if rc != 0:
+            return False
+        else:
+            return True
+
+    def generate_verifier(self):
+        server_verifier = bytes(32)
+        self.lib.bsspeke_server_generate_verifier(server_verifier, self.ctx)
+        return server_verifier
+