From 0ce3852e4fe413dffe1b7c852a64ea5446126795 Mon Sep 17 00:00:00 2001
From: Csaba Kiraly <csaba.kiraly@gmail.com>
Date: Wed, 1 Sep 2021 14:57:42 +0200
Subject: [PATCH] using normal file io instead of memfiles

mmap has serveral potential issues and we do not really need it, so
changing to use the normal system file interface is better.

Signed-off-by: Csaba Kiraly <csaba.kiraly@gmail.com>
---
 dagger/storageproofs/pos.nim | 39 ++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/dagger/storageproofs/pos.nim b/dagger/storageproofs/pos.nim
index eb1b3f6f..000fcd53 100644
--- a/dagger/storageproofs/pos.nim
+++ b/dagger/storageproofs/pos.nim
@@ -9,8 +9,6 @@
 
 import libp2p/crypto/crypto # for RSA
 import bearssl
-import memfiles
-import math
 import nimcrypto # for SHA512
 import random
 
@@ -18,7 +16,7 @@ import ./bigint/stint2
 #import ./bigint/bigints2
 
 const keysize = 2048
-const sectorsperblock = 4
+const sectorsperblock = 4.int64
 const bytespersector = 128
 const querylen = 22
 assert bytespersector < keysize div 8 # TODO: not strict
@@ -29,8 +27,9 @@ proc fromBytesBE(nptr: ptr cuchar, nlen: int): BigInt =
   let nptra = cast[ptr array[0xffffffff,byte]](nptr)
   result = fromBytesBE(nptra[], nlen)
 
-proc getSector(filep: ptr ZChar, blockid: int64, sectorid: int64, spb: int64): Zchar =
-  result = cast[ptr array[0xffffffff, ZChar]](filep)[blockid * spb + sectorid]
+proc getSector(f: File, blockid: int64, sectorid: int64, spb: int64): ZChar =
+  f.setFilePos(blockid * spb + sectorid)
+  let r = f.readBytes(result, 0, sizeof(result))
 
 proc fromBytesBE(sector: ZChar): BigInt =
   result = fromBytesBE(sector, sizeof(ZChar))
@@ -88,32 +87,31 @@ proc rsaKeygen*(): (PublicKey, PrivateKey) =
   var pubkey = seckey.getKey().get()
   return (pubkey, seckey)
 
-proc openFile(file: string, s = sectorsperblock, c = sizeof(ZChar)): (ptr ZChar, int64, int64) =
-  let mm = memfiles.open(file)
-  
-  let size = mm.size
-  let n = int64(ceil(float64(size / (s * c))))
+proc split(f: File): (int64, int64) =
+  let size = f.getFileSize()
+  let n = ((size - 1) div (sectorsperblock * sizeof(ZChar))) + 1
  
-  return (cast[ptr ZChar](mm.mem), int64(s), n)
+  return (sectorsperblock, n)
 
 proc hashNameI(name: openArray[byte], i: int64): BigInt =
   let hashString = $sha512.digest($name & $i)
   return fromBytesBE(cast[seq[byte]](hashString), hashString.len()) # TODO: use better way to convert
 
-proc generateAuthenticator(i: int64, s: int64, t: TauZero, filep: ptr ZChar, ssk: PrivateKey): BigInt =
+proc generateAuthenticator(i: int64, s: int64, t: TauZero, f: File, ssk: PrivateKey): BigInt =
   let N = ssk.getModulus()
 
   var productory = BigInt.one
   for j in 0 ..< s:
     productory = mulmod(productory,
-                        powmod(t.u[j], fromBytesBE(getSector(filep, i, j, s)), N),
+                        powmod(t.u[j], fromBytesBE(getSector(f, i, j, s)), N),
                         N)
 
   # result = (hashNameI(t.name, i) * productory).powmod(getPrivex(ssk), N)
   result = rsaDecode((hashNameI(t.name, i) * productory) mod N, ssk)
 
-proc st*(ssk: PrivateKey, file: string): (Tau, seq[BigInt]) =
-  let (filep, s, n) = openFile(file)
+proc st*(ssk: PrivateKey, filename: string): (Tau, seq[BigInt]) =
+  let file = open(filename)
+  let (s, n) = split(file)
   var t = TauZero(n: n)
 
   # generate a random name
@@ -130,8 +128,9 @@ proc st*(ssk: PrivateKey, file: string): (Tau, seq[BigInt]) =
   #generate sigmas
   var sigmas: seq[BigInt]
   for i in 0 ..< n :
-    sigmas.add(generateAuthenticator(i, s, t, filep, ssk)) #TODO: int64 sizes?
+    sigmas.add(generateAuthenticator(i, s, t, file, ssk)) #TODO: int64 sizes?
 
+  file.close()
   result = (tau, sigmas)
 
 type QElement = object
@@ -153,15 +152,16 @@ proc generateQuery*(
     q.V = initBigInt(rand(uint64)) #TODO: fix range
     result.add(q)
 
-proc generateProof*(q: openArray[QElement], authenticators: openArray[BigInt], spk: PublicKey, file: string): (seq[BigInt], BigInt) =
-  let (filep, s, _) = openFile(file)
+proc generateProof*(q: openArray[QElement], authenticators: openArray[BigInt], spk: PublicKey, filename: string): (seq[BigInt], BigInt) =
+  let file = open(filename)
   let N = spk.getModulus()
+  let s = sectorsperblock
 
   var mu: seq[BigInt]
   for j in 0 ..< s :
     var muj = BigInt.zero
     for qelem in q :
-      let sector = fromBytesBE(getSector(filep, qelem.I, j, s))
+      let sector = fromBytesBE(getSector(file, qelem.I, j, s))
       muj += qelem.V * sector
       #muj = addmod(muj, mulmod(qelem.V, sector, N), N)
     mu.add(muj)
@@ -172,6 +172,7 @@ proc generateProof*(q: openArray[QElement], authenticators: openArray[BigInt], s
                    powmod(authenticators[qelem.I], qelem.V, N),
                    N)
 
+  file.close()
   return (mu, sigma)
 
 proc verifyProof*(tau: Tau, q: openArray[QElement], mus: openArray[BigInt], sigma: BigInt, spk: PublicKey): bool =