feat: add keyfile support for RLN credentials secure storage

apps/chat2/config_chat2.nim

@@ -290,6 +290,11 @@ type
       desc: "Address of membership contract on an Ethereum testnet", 
       defaultValue: ""
       name: "rln-relay-eth-contract-address" }: string
+
+    rlnRelayCredentialsPassword* {.
+      desc: "Password for encrypting RLN credentials", 
+      defaultValue: ""
+      name: "rln-relay-cred-password" }: string
 
 # NOTE: Keys are different in nim-libp2p
 proc parseCmdArg*(T: type crypto.PrivateKey, p: TaintedString): T =

apps/wakunode2/config.nim

@@ -174,7 +174,12 @@ type
       desc: "Address of membership contract on an Ethereum testnet", 
       defaultValue: ""
       name: "rln-relay-eth-contract-address" }: string
-
+
+    rlnRelayCredentialsPassword* {.
+      desc: "Password for encrypting RLN credentials", 
+      defaultValue: ""
+      name: "rln-relay-cred-password" }: string
+
     staticnodes* {.
       desc: "Peer multiaddr to directly connect with. Argument may be repeated."
       name: "staticnode" }: seq[string]

tests/all_tests_v2.nim

@@ -43,7 +43,9 @@ import
   ./v2/test_enr_utils,
   ./v2/test_peer_exchange,
   ./v2/test_waku_noise,
-  ./v2/test_waku_noise_sessions
+  ./v2/test_waku_noise_sessions,
+  # Utils
+  ./v2/test_keyfile
 
 when defined(rln) or defined(rlnzerokit):
   import 

tests/v2/test_keyfile.nim

@@ -0,0 +1,119 @@
+{.used.}
+
+import
+  std/[json, os],
+  testutils/unittests, chronos, chronicles,
+  eth/keys,
+  ../../waku/v2/utils/keyfile,
+  ../test_helpers
+
+from ../../waku/v2/protocol/waku_noise/noise_utils import randomSeqByte
+
+suite "KeyFile test suite":
+
+  let rng = newRng()
+
+  test "Create/Save/Load single keyfile":
+
+    let password = "randompassword"
+    let filepath = "./test.keyfile"
+
+    var secret = randomSeqByte(rng[], 300)
+    let keyfile = createKeyFileJson(secret, password)
+
+    check:
+      keyfile.isOk()
+      saveKeyFile(filepath, keyfile.get()).isOk()
+
+    var decodedSecret = loadKeyFile("test.keyfile", password)
+
+    check:
+      decodedSecret.isOk()
+      secret == decodedSecret.get()
+
+    removeFile(filepath)
+
+  test "Create/Save/Load multiple keyfiles in same file":
+
+    let password1 = "password1"
+    let password2 = "password2"
+    let password3 = "password3"
+    let filepath = "./test.keyfile"
+    var keyfile: KfResult[JsonNode] 
+
+    let secret1 = randomSeqByte(rng[], 300)
+    keyfile = createKeyFileJson(secret1, password1)
+    check:
+      keyfile.isOk()
+      saveKeyFile(filepath, keyfile.get()).isOk()
+
+    let secret2 = randomSeqByte(rng[], 300)
+    keyfile = createKeyFileJson(secret2, password2)
+    check:
+      keyfile.isOk()
+      saveKeyFile(filepath, keyfile.get()).isOk()
+
+    let secret3 = randomSeqByte(rng[], 300)
+    keyfile = createKeyFileJson(secret3, password3)
+    check:
+      keyfile.isOk()
+      saveKeyFile(filepath, keyfile.get()).isOk()
+
+    # We encrypt secret4 with password3
+    let secret4 = randomSeqByte(rng[], 300)
+    keyfile = createKeyFileJson(secret4, password3)
+    check:
+      keyfile.isOk()
+      saveKeyFile(filepath, keyfile.get()).isOk()
+
+    # We encrypt secret5 with password1
+    let secret5 = randomSeqByte(rng[], 300)
+    keyfile = createKeyFileJson(secret5, password1)
+    check:
+      keyfile.isOk()
+      saveKeyFile(filepath, keyfile.get()).isOk()
+
+    # We encrypt secret5 with password1
+    let secret6 = randomSeqByte(rng[], 300)
+    keyfile = createKeyFileJson(secret6, password1)
+    check:
+      keyfile.isOk()
+      saveKeyFile(filepath, keyfile.get()).isOk()
+
+    # Now there are 5 keyfiles stored in filepath encrypted with 3 different passwords
+    # We decode with the respective passwords
+
+    var decodedSecret1 = loadKeyFile("test.keyfile", password1)
+    check:
+      decodedSecret1.isOk()
+      secret1 == decodedSecret1.get()
+
+    var decodedSecret2 = loadKeyFile("test.keyfile", password2)
+    check:
+      decodedSecret2.isOk()
+      secret2 == decodedSecret2.get()
+
+    var decodedSecret3 = loadKeyFile("test.keyfile", password3)
+    check:
+      decodedSecret3.isOk()
+      secret3 == decodedSecret3.get()
+
+    # Since we have 2 keyfiles encrypted with same password3, to obtain the secret we skip the first successful decryption, i.e. the keyfile for secret3
+    var decodedSecret4 = loadKeyFile("test.keyfile", password3, skip = 1)
+    check:
+      decodedSecret4.isOk()
+      secret4 == decodedSecret4.get()
+
+    # Since we have 3 keyfiles encrypted with same password1, to obtain the secret we skip the first successful decryption, i.e. the keyfile for secret1
+    var decodedSecret5 = loadKeyFile("test.keyfile", password1, skip = 1)
+    check:
+      decodedSecret5.isOk()
+      secret5 == decodedSecret5.get()
+
+    # Since we have 3 keyfiles encrypted with same password1, to obtain the secret we skip the first 2 successful decryptions, i.e. the keyfile for secret1 and secret5
+    var decodedSecret6 = loadKeyFile("test.keyfile", password1, skip = 2)
+    check:
+      decodedSecret6.isOk()
+      secret6 == decodedSecret6.get()
+
+    removeFile(filepath)

tests/v2/test_waku_rln_relay.nim

@@ -2,7 +2,7 @@
 {.used.}
 
 import
-  std/options, sequtils, times, deques,
+  std/[options,os], sequtils, times, deques,
   testutils/unittests, chronos, chronicles, stint,
   stew/byteutils, stew/shims/net as stewNet,
   libp2p/crypto/crypto,
@@ -980,7 +980,7 @@ suite "Waku rln relay":
     check:
       keypair.get().idCommitment == idCommitment
 
-  test "Read Persistent RLN credentials":
+  test "Read/Write RLN credentials":
     # create an RLN instance
     var rlnInstance = createRLNInstance()
     check:
@@ -1003,16 +1003,21 @@ suite "Waku rln relay":
 
     var rlnMembershipCredentials = RlnMembershipCredentials(membershipKeyPair: k, rlnIndex: index)
 
-    let path = "testPath.txt"
+    let filepath = "./testRLNCredentials.txt"
+    let password = "%m0um0ucoW%"
 
     # Write RLN credentials
-    writeFile(path, pretty(%rlnMembershipCredentials))
+    check:
+      writeRlnCredentials(filepath, rlnMembershipCredentials, password).isOk()
 
-    var credentials = readPersistentRlnCredentials(path)
+    var credentials = readRlnCredentials(filepath, password)
 
     check:
-      credentials.membershipKeyPair == k
-      credentials.rlnIndex == index
+      credentials.isSome()
+      credentials.get().membershipKeyPair == k
+      credentials.get().rlnIndex == index
+
+    removeFile(filepath)
 
   test "histogram static bucket generation":
     let buckets = generateBucketsForHistogram(10)

waku/v2/protocol/waku_rln_relay/waku_rln_relay_utils.nim

@@ -15,7 +15,7 @@ import
   waku_rln_relay_constants,
   waku_rln_relay_types,
   waku_rln_relay_metrics,
-  ../../utils/time,
+  ../../utils/[time, keyfile],
   ../../node/waku_node, 
   ../../../../../apps/wakunode2/config,  ## TODO: Decouple the protocol code from the app configuration
   ../../../../../apps/chat2/config_chat2,  ## TODO: Decouple the protocol code from the app configuration
@@ -38,6 +38,18 @@ contract(MembershipContract):
   # proc withdraw(secret: Uint256, pubkeyIndex: Uint256, receiver: Address)
   # proc withdrawBatch( secrets: seq[Uint256], pubkeyIndex: seq[Uint256], receiver: seq[Address])
 
+# Note: works only for non empty input
+proc toString(bytes: openArray[byte]): string =
+  var output = newString(bytes.len)
+  copyMem(output[0].addr, bytes[0].unsafeAddr, bytes.len)
+  return output
+
+# Note: works only for non empty input
+proc toSeqByte(str: string): seq[byte] =
+  var output = newSeq[byte](str.len)
+  copyMem(output[0].addr, str[0].unsafeAddr, str.len)
+  return output
+
 proc toBuffer*(x: openArray[byte]): Buffer =
   ## converts the input to a Buffer object
   ## the Buffer object is used to communicate data with the rln lib
@@ -1145,19 +1157,31 @@ proc mountRlnRelayDynamic*(node: WakuNode,
   node.wakuRlnRelay = rlnPeer
   return ok(true)
 
-proc readPersistentRlnCredentials*(path: string) : RlnMembershipCredentials {.raises: [Defect, OSError, IOError, Exception].} =
-  info "Rln credentials exist in file"
+proc writeRlnCredentials*(path: string, credentials: RlnMembershipCredentials, password: string) : KfResult[void] {.raises: [Defect, OSError, IOError, Exception].} =
+  info "Storing RLN credentials"
+  var jsonString: string
+  jsonString.toUgly(%credentials)
+  let keyfile = createKeyFileJson(toSeqByte(jsonString), password)
+  if keyfile.isErr():
+    return err(keyfile.error)
+  return saveKeyFile(path, keyfile.get())
+
+proc readRlnCredentials*(path: string, password: string) : Option[RlnMembershipCredentials] {.raises: [Defect, OSError, IOError, Exception].} =
+  info "Reading RLN credentials"
   # With regards to printing the keys, it is purely for debugging purposes so that the user becomes explicitly aware of the current keys in use when nwaku is started.
   # Note that this is only until the RLN contract being used is the one deployed on Goerli testnet.
   # These prints need to omitted once RLN contract is deployed on Ethereum mainnet and using valuable funds for staking.
   waku_rln_membership_credentials_import_duration_seconds.nanosecondTime:
-    let entireRlnCredentialsFile = readFile(path)
-
-    let jsonObject = parseJson(entireRlnCredentialsFile)
-    let deserializedRlnCredentials = to(jsonObject, RlnMembershipCredentials)
-
-  debug "Deserialized Rln credentials", rlnCredentials=deserializedRlnCredentials
-  return deserializedRlnCredentials
+    let entireRlnCredentialsFile = loadKeyFile(path, password)
+    if entireRlnCredentialsFile.isOk():
+      let jsonObject = parseJson(toString(entireRlnCredentialsFile.get()))
+      let deserializedRlnCredentials = to(jsonObject, RlnMembershipCredentials)   
+      debug "Deserialized RLN credentials", rlnCredentials=deserializedRlnCredentials
+      return some(deserializedRlnCredentials)
+    else:
+      debug "Unable to decrypt RLN credentials with provided password. ", error=entireRlnCredentialsFile.error
+      echo "Unable to decrypt RLN credentials with provided password. ", entireRlnCredentialsFile.error
+      return none(RlnMembershipCredentials)
 
 proc mount(node: WakuNode,
            conf: WakuNodeConf|Chat2Conf,
@@ -1220,9 +1244,10 @@ proc mount(node: WakuNode,
       let rlnRelayCredPath = joinPath(conf.rlnRelayCredPath, RlnCredentialsFilename)
       debug "rln-relay credential path", rlnRelayCredPath
       # check if there is an rln-relay credential file in the supplied path
-      if fileExists(rlnRelayCredPath): 
+      if fileExists(rlnRelayCredPath):
+        info "A RLN credential file exists in provided path"
         # retrieve rln-relay credential
-        credentials = some(readPersistentRlnCredentials(rlnRelayCredPath))
+        credentials = readRlnCredentials(rlnRelayCredPath, conf.rlnRelayCredentialsPassword)
 
       else: # there is no credential file available in the supplied path
         # mount the rln-relay protocol leaving rln-relay credentials arguments unassigned 
@@ -1256,8 +1281,8 @@ proc mount(node: WakuNode,
         # persist rln credential
         credentials = some(RlnMembershipCredentials(rlnIndex: node.wakuRlnRelay.membershipIndex, 
                                                     membershipKeyPair: node.wakuRlnRelay.membershipKeyPair))
-        writeFile(rlnRelayCredPath, pretty(%credentials.get()))
-
+        if writeRlnCredentials(rlnRelayCredPath, credentials.get(), conf.rlnRelayCredentialsPassword).isErr():
+          return err("error in storing rln credentials")
 
     else:
       # do not persist or use a persisted rln-relay credential