vacp2p/nim-libp2p
1
0
Fork 0
mirror of https://github.com/vacp2p/nim-libp2p.git synced 2025-03-01 16:40:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

use a mock rng in tests

Browse Source
This commit is contained in:
Diego 2024-04-18 17:30:31 +02:00
parent b30b2656d5
commit ffe80dc24b
No known key found for this signature in database
GPG Key ID: C9DAC9BF68D1F806
42 changed files with 378 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
libp2p/builders.nim
View File

@ -27,7 +27,7 @@ import
protocols/connectivity/[autonat/server, relay/relay, relay/client, relay/rtransport], protocols/connectivity/[autonat/server, relay/relay, relay/client, relay/rtransport],
connmanager, upgrademngrs/muxedupgrade, observedaddrmanager, connmanager, upgrademngrs/muxedupgrade, observedaddrmanager,
nameresolving/nameresolver, nameresolving/nameresolver,
errors, utility errors, utility, utils/random/securerng
export export
switch, peerid, peerinfo, connection, multiaddress, crypto, errors switch, peerid, peerinfo, connection, multiaddress, crypto, errors
@ -44,7 +44,7 @@ type
secureManagers: seq[SecureProtocol] secureManagers: seq[SecureProtocol]
muxers: seq[MuxerProvider] muxers: seq[MuxerProvider]
transports: seq[TransportProvider] transports: seq[TransportProvider]
rng: ref HmacDrbgContext rng: Rng
maxConnections: int maxConnections: int
maxIn: int maxIn: int
sendSignedPeerRecord: bool sendSignedPeerRecord: bool
@ -149,7 +149,7 @@ proc withTransport*(b: SwitchBuilder, prov: TransportProvider): SwitchBuilder {.
proc withTcpTransport*(b: SwitchBuilder, flags: set[ServerFlags] = {}): SwitchBuilder {.public.} = proc withTcpTransport*(b: SwitchBuilder, flags: set[ServerFlags] = {}): SwitchBuilder {.public.} =
b.withTransport(proc(upgr: Upgrade): Transport = TcpTransport.new(flags, upgr)) b.withTransport(proc(upgr: Upgrade): Transport = TcpTransport.new(flags, upgr))
proc withRng*(b: SwitchBuilder, rng: ref HmacDrbgContext): SwitchBuilder {.public.} = proc withRng*(b: SwitchBuilder, rng: Rng): SwitchBuilder {.public.} =
b.rng = rng b.rng = rng
b b
@ -215,7 +215,7 @@ proc build*(b: SwitchBuilder): Switch
if b.rng == nil: # newRng could fail if b.rng == nil: # newRng could fail
raise newException(Defect, "Cannot initialize RNG") raise newException(Defect, "Cannot initialize RNG")
let pkRes = PrivateKey.random(b.rng[]) let pkRes = PrivateKey.random(b.rng)
let let
seckey = b.privKey.get(otherwise = pkRes.expect("Expected default Private Key")) seckey = b.privKey.get(otherwise = pkRes.expect("Expected default Private Key"))
@ -253,7 +253,7 @@ proc build*(b: SwitchBuilder): Switch
b.secureManagers &= SecureProtocol.Noise b.secureManagers &= SecureProtocol.Noise
if isNil(b.rng): if isNil(b.rng):
b.rng = newRng() b.rng = SecureRng.new()
let peerStore = block: let peerStore = block:
b.peerStoreCapacity.withValue(capacity): b.peerStoreCapacity.withValue(capacity):
@ -297,7 +297,7 @@ proc newStandardSwitch*(
SecureProtocol.Noise, SecureProtocol.Noise,
], ],
transportFlags: set[ServerFlags] = {}, transportFlags: set[ServerFlags] = {},
rng = newRng(), rng: Rng = SecureRng.new(),
inTimeout: Duration = 5.minutes, inTimeout: Duration = 5.minutes,
outTimeout: Duration = 5.minutes, outTimeout: Duration = 5.minutes,
maxConnections = MaxConnections, maxConnections = MaxConnections,

8
libp2p/crypto/crypto.nim
View File

@ -188,7 +188,7 @@ proc shuffle*[T](
swap(x[i], x[y]) swap(x[i], x[y])
proc random*(T: typedesc[PrivateKey], scheme: PKScheme, proc random*(T: typedesc[PrivateKey], scheme: PKScheme,
rng: var HmacDrbgContext, rng: Rng,
bits = RsaDefaultKeySize): CryptoResult[PrivateKey] = bits = RsaDefaultKeySize): CryptoResult[PrivateKey] =
## Generate random private key for scheme ``scheme``. ## Generate random private key for scheme ``scheme``.
## ##
@ -220,7 +220,7 @@ proc random*(T: typedesc[PrivateKey], scheme: PKScheme,
else: else:
err(SchemeError) err(SchemeError)
proc random*(T: typedesc[PrivateKey], rng: var HmacDrbgContext, proc random*(T: typedesc[PrivateKey], rng: Rng,
bits = RsaDefaultKeySize): CryptoResult[PrivateKey] = bits = RsaDefaultKeySize): CryptoResult[PrivateKey] =
## Generate random private key using default public-key cryptography scheme. ## Generate random private key using default public-key cryptography scheme.
## ##
@ -244,7 +244,7 @@ proc random*(T: typedesc[PrivateKey], rng: var HmacDrbgContext,
err(SchemeError) err(SchemeError)
proc random*(T: typedesc[KeyPair], scheme: PKScheme, proc random*(T: typedesc[KeyPair], scheme: PKScheme,
rng: var HmacDrbgContext, rng: Rng,
bits = RsaDefaultKeySize): CryptoResult[KeyPair] = bits = RsaDefaultKeySize): CryptoResult[KeyPair] =
## Generate random key pair for scheme ``scheme``. ## Generate random key pair for scheme ``scheme``.
## ##
@ -284,7 +284,7 @@ proc random*(T: typedesc[KeyPair], scheme: PKScheme,
else: else:
err(SchemeError) err(SchemeError)
proc random*(T: typedesc[KeyPair], rng: var HmacDrbgContext, proc random*(T: typedesc[KeyPair], rng: Rng,
bits = RsaDefaultKeySize): CryptoResult[KeyPair] = bits = RsaDefaultKeySize): CryptoResult[KeyPair] =
## Generate random private pair of keys using default public-key cryptography ## Generate random private pair of keys using default public-key cryptography
## scheme. ## scheme.

8
libp2p/crypto/curve25519.nim
View File

@ -20,6 +20,9 @@
import bearssl/[ec, rand] import bearssl/[ec, rand]
import stew/results import stew/results
from stew/assign2 import assign from stew/assign2 import assign
import ../utils/random/rng
export results export results
const const
@ -79,11 +82,10 @@ proc mulgen(_: type[Curve25519], dst: var Curve25519Key, point: Curve25519Key) =
proc public*(private: Curve25519Key): Curve25519Key = proc public*(private: Curve25519Key): Curve25519Key =
Curve25519.mulgen(result, private) Curve25519.mulgen(result, private)
proc random*(_: type[Curve25519Key], rng: var HmacDrbgContext): Curve25519Key = proc random*(_: type[Curve25519Key], rng: Rng): Curve25519Key =
var res: Curve25519Key var res: Curve25519Key
let defaultBrEc = ecGetDefault() let defaultBrEc = ecGetDefault()
let len = ecKeygen( let len = ecKeygen(addr rng.vtable, defaultBrEc, nil, addr res[0], EC_curve25519)
addr rng.vtable, defaultBrEc, nil, addr res[0], EC_curve25519)
# Per bearssl documentation, the keygen only fails if the curve is # Per bearssl documentation, the keygen only fails if the curve is
# unrecognised - # unrecognised -
doAssert len == Curve25519KeySize, "Could not generate curve" doAssert len == Curve25519KeySize, "Could not generate curve"

11
libp2p/crypto/ecnist.nim
View File

@ -23,6 +23,7 @@ import minasn1
export minasn1.Asn1Error export minasn1.Asn1Error
import stew/[results, ctops] import stew/[results, ctops]
import ../utils/random/rng
import ../utility import ../utility
export results export results
@ -233,7 +234,7 @@ proc clear*[T: EcPKI|EcKeyPair](pki: var T) =
proc random*( proc random*(
T: typedesc[EcPrivateKey], kind: EcCurveKind, T: typedesc[EcPrivateKey], kind: EcCurveKind,
rng: var HmacDrbgContext): EcResult[EcPrivateKey] = rng: Rng): EcResult[EcPrivateKey] =
## Generate new random EC private key using BearSSL's HMAC-SHA256-DRBG ## Generate new random EC private key using BearSSL's HMAC-SHA256-DRBG
## algorithm. ## algorithm.
## ##
@ -241,7 +242,7 @@ proc random*(
## secp521r1). ## secp521r1).
var ecimp = ecGetDefault() var ecimp = ecGetDefault()
var res = new EcPrivateKey var res = new EcPrivateKey
if ecKeygen(addr rng.vtable, ecimp, if ecKeygen(rng.vtable, ecimp,
addr res.key, addr res.buffer[0], addr res.key, addr res.buffer[0],
safeConvert[cint](kind)) == 0: safeConvert[cint](kind)) == 0:
err(EcKeyGenError) err(EcKeyGenError)
@ -267,7 +268,7 @@ proc getPublicKey*(seckey: EcPrivateKey): EcResult[EcPublicKey] =
proc random*( proc random*(
T: typedesc[EcKeyPair], kind: EcCurveKind, T: typedesc[EcKeyPair], kind: EcCurveKind,
rng: var HmacDrbgContext): EcResult[T] = rng: Rng): EcResult[T] =
## Generate new random EC private and public keypair using BearSSL's ## Generate new random EC private and public keypair using BearSSL's
## HMAC-SHA256-DRBG algorithm. ## HMAC-SHA256-DRBG algorithm.
## ##
@ -999,7 +1000,7 @@ type ECDHEScheme* = EcCurveKind
proc ephemeral*( proc ephemeral*(
scheme: ECDHEScheme, scheme: ECDHEScheme,
rng: var HmacDrbgContext): EcResult[EcKeyPair] = rng: Rng): EcResult[EcKeyPair] =
## Generate ephemeral keys used to perform ECDHE. ## Generate ephemeral keys used to perform ECDHE.
var keypair: EcKeyPair var keypair: EcKeyPair
if scheme == Secp256r1: if scheme == Secp256r1:
@ -1011,7 +1012,7 @@ proc ephemeral*(
ok(keypair) ok(keypair)
proc ephemeral*( proc ephemeral*(
scheme: string, rng: var HmacDrbgContext): EcResult[EcKeyPair] = scheme: string, rng: Rng): EcResult[EcKeyPair] =
## Generate ephemeral keys used to perform ECDHE using string encoding. ## Generate ephemeral keys used to perform ECDHE using string encoding.
## ##
## Currently supported encoding strings are P-256, P-384, P-521, if encoding ## Currently supported encoding strings are P-256, P-384, P-521, if encoding

11
libp2p/crypto/ed25519/ed25519.nim
View File

@ -21,8 +21,9 @@ import nimcrypto/utils as ncrutils
import stew/[results, ctops] import stew/[results, ctops]
import ../../utility import ../../utility
import ../../utils/random/rng
export results export results, rng
# This workaround needed because of some bugs in Nim Static[T]. # This workaround needed because of some bugs in Nim Static[T].
export hash, sha2, rand export hash, sha2, rand
@ -1648,14 +1649,14 @@ proc checkScalar*(scalar: openArray[byte]): uint32 =
c = -1 c = -1
result = NEQ(z, 0'u32) and LT0(c) result = NEQ(z, 0'u32) and LT0(c)
proc random*(t: typedesc[EdPrivateKey], rng: var HmacDrbgContext): EdPrivateKey = proc random*(t: typedesc[EdPrivateKey], rng: Rng): EdPrivateKey =
## Generate new random ED25519 private key using the given random number generator ## Generate new random ED25519 private key using the given random number generator
var var
point: GeP3 point: GeP3
pk: array[EdPublicKeySize, byte] pk: array[EdPublicKeySize, byte]
res: EdPrivateKey res: EdPrivateKey
hmacDrbgGenerate(rng, res.data.toOpenArray(0, 31)) rng.generate(res.data.toOpenArray(0, 31))
var hh = sha512.digest(res.data.toOpenArray(0, 31)) var hh = sha512.digest(res.data.toOpenArray(0, 31))
hh.data[0] = hh.data[0] and 0xF8'u8 hh.data[0] = hh.data[0] and 0xF8'u8
@ -1667,14 +1668,14 @@ proc random*(t: typedesc[EdPrivateKey], rng: var HmacDrbgContext): EdPrivateKey
res res
proc random*(t: typedesc[EdKeyPair], rng: var HmacDrbgContext): EdKeyPair = proc random*(t: typedesc[EdKeyPair], rng: Rng): EdKeyPair =
## Generate new random ED25519 private and public keypair using OS specific ## Generate new random ED25519 private and public keypair using OS specific
## CSPRNG. ## CSPRNG.
var var
point: GeP3 point: GeP3
res: EdKeyPair res: EdKeyPair
hmacDrbgGenerate(rng, res.seckey.data.toOpenArray(0, 31)) rng.generate(res.seckey.data.toOpenArray(0, 31))
var hh = sha512.digest(res.seckey.data.toOpenArray(0, 31)) var hh = sha512.digest(res.seckey.data.toOpenArray(0, 31))
hh.data[0] = hh.data[0] and 0xF8'u8 hh.data[0] = hh.data[0] and 0xF8'u8

5
libp2p/crypto/rsa.nim
View File

@ -20,6 +20,7 @@ import minasn1
import stew/[results, ctops] import stew/[results, ctops]
# We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures. # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
import nimcrypto/utils as ncrutils import nimcrypto/utils as ncrutils
import ../utils/random/rng
export Asn1Error, results export Asn1Error, results
@ -115,7 +116,7 @@ template trimZeroes(b: seq[byte], pt, ptlen: untyped) =
pt = cast[ptr byte](cast[uint](pt) + 1) pt = cast[ptr byte](cast[uint](pt) + 1)
ptlen -= 1 ptlen -= 1
proc random*[T: RsaKP](t: typedesc[T], rng: var HmacDrbgContext, proc random*[T: RsaKP](t: typedesc[T], rng: Rng,
bits = DefaultKeySize, bits = DefaultKeySize,
pubexp = DefaultPublicExponent): RsaResult[T] = pubexp = DefaultPublicExponent): RsaResult[T] =
## Generate new random RSA private key using BearSSL's HMAC-SHA256-DRBG ## Generate new random RSA private key using BearSSL's HMAC-SHA256-DRBG
@ -139,7 +140,7 @@ proc random*[T: RsaKP](t: typedesc[T], rng: var HmacDrbgContext,
var keygen = rsaKeygenGetDefault() var keygen = rsaKeygenGetDefault()
if keygen(addr rng.vtable, if keygen(rng.vtable,
addr res.seck, addr res.buffer[sko], addr res.seck, addr res.buffer[sko],
addr res.pubk, addr res.buffer[pko], addr res.pubk, addr res.buffer[pko],
cuint(bits), pubexp) == 0: cuint(bits), pubexp) == 0:

12
libp2p/crypto/secp.nim
View File

@ -15,6 +15,8 @@ import
stew/[byteutils, results], stew/[byteutils, results],
nimcrypto/[hash, sha2] nimcrypto/[hash, sha2]
import ../utils/random/rng
export sha2, results, rand export sha2, results, rand
const const
@ -32,18 +34,16 @@ type
SkSignature* = distinct secp256k1.SkSignature SkSignature* = distinct secp256k1.SkSignature
SkKeyPair* = distinct secp256k1.SkKeyPair SkKeyPair* = distinct secp256k1.SkKeyPair
proc random*(t: typedesc[SkPrivateKey], rng: var HmacDrbgContext): SkPrivateKey = proc random*(t: typedesc[SkPrivateKey], rng: rng.Rng): SkPrivateKey =
#TODO is there a better way? #TODO is there a better way?
var rngPtr = addr rng
proc callRng(data: var openArray[byte]) = proc callRng(data: var openArray[byte]) =
hmacDrbgGenerate(rngPtr[], data) rng.generate(data)
SkPrivateKey(SkSecretKey.random(callRng)) SkPrivateKey(SkSecretKey.random(callRng))
proc random*(t: typedesc[SkKeyPair], rng: var HmacDrbgContext): SkKeyPair = proc random*(t: typedesc[SkKeyPair], rng: rng.Rng): SkKeyPair =
let rngPtr = addr rng
proc callRng(data: var openArray[byte]) = proc callRng(data: var openArray[byte]) =
hmacDrbgGenerate(rngPtr[], data) rng.generate(data)
SkKeyPair(secp256k1.SkKeyPair.random(callRng)) SkKeyPair(secp256k1.SkKeyPair.random(callRng))

5
libp2p/peerid.nim
View File

@ -20,6 +20,7 @@ import
utility, utility,
./crypto/crypto, ./multicodec, ./multihash, ./vbuffer, ./crypto/crypto, ./multicodec, ./multihash, ./vbuffer,
./protobuf/minprotobuf ./protobuf/minprotobuf
import utils/random/securerng
export results, utility export results, utility
@ -178,9 +179,9 @@ func init*(t: typedesc[PeerId], seckey: PrivateKey): Result[PeerId, cstring] =
## Create new peer id from private key ``seckey``. ## Create new peer id from private key ``seckey``.
PeerId.init(? seckey.getPublicKey().orError(cstring("invalid private key"))) PeerId.init(? seckey.getPublicKey().orError(cstring("invalid private key")))
proc random*(t: typedesc[PeerId], rng = newRng()): Result[PeerId, cstring] = proc random*(t: typedesc[PeerId], rng: Rng = SecureRng.new()): Result[PeerId, cstring] =
## Create new peer id with random public key. ## Create new peer id with random public key.
let randomKey = PrivateKey.random(Secp256k1, rng[])[] let randomKey = PrivateKey.random(Secp256k1, rng)[]
PeerId.init(randomKey).orError(cstring("failed to generate random key")) PeerId.init(randomKey).orError(cstring("failed to generate random key"))
func match*(pid: PeerId, pubkey: PublicKey): bool = func match*(pid: PeerId, pubkey: PublicKey): bool =

5
libp2p/protocols/connectivity/autonat/service.nim
View File

@ -16,6 +16,7 @@ import ../../../wire
import client import client
from core import NetworkReachability, AutonatUnreachableError from core import NetworkReachability, AutonatUnreachableError
import ../../../utils/heartbeat import ../../../utils/heartbeat
import ../../../utils/random/rng
import ../../../crypto/crypto import ../../../crypto/crypto
export core.NetworkReachability export core.NetworkReachability
@ -35,7 +36,7 @@ type
answers: Deque[NetworkReachability] answers: Deque[NetworkReachability]
autonatClient: AutonatClient autonatClient: AutonatClient
statusAndConfidenceHandler: StatusAndConfidenceHandler statusAndConfidenceHandler: StatusAndConfidenceHandler
rng: ref HmacDrbgContext rng: Rng
scheduleInterval: Opt[Duration] scheduleInterval: Opt[Duration]
askNewConnectedPeers: bool askNewConnectedPeers: bool
numPeersToAsk: int numPeersToAsk: int
@ -49,7 +50,7 @@ type
proc new*( proc new*(
T: typedesc[AutonatService], T: typedesc[AutonatService],
autonatClient: AutonatClient, autonatClient: AutonatClient,
rng: ref HmacDrbgContext, rng: Rng,
scheduleInterval: Opt[Duration] = Opt.none(Duration), scheduleInterval: Opt[Duration] = Opt.none(Duration),
askNewConnectedPeers = true, askNewConnectedPeers = true,
numPeersToAsk: int = 5, numPeersToAsk: int = 5,

11
libp2p/protocols/secure/noise.nim
View File

@ -21,6 +21,7 @@ import ../../peerinfo
import ../../protobuf/minprotobuf import ../../protobuf/minprotobuf
import ../../utility import ../../utility
import ../../errors import ../../errors
import ../../utils/random/rng
import secure, import secure,
../../crypto/[crypto, chacha20poly1305, curve25519, hkdf] ../../crypto/[crypto, chacha20poly1305, curve25519, hkdf]
@ -78,7 +79,7 @@ type
rs: Curve25519Key rs: Curve25519Key
Noise* = ref object of Secure Noise* = ref object of Secure
rng: ref HmacDrbgContext rng: Rng
localPrivateKey: PrivateKey localPrivateKey: PrivateKey
localPublicKey: seq[byte] localPublicKey: seq[byte]
noiseKeys: KeyPair noiseKeys: KeyPair
@ -106,7 +107,7 @@ func shortLog*(conn: NoiseConnection): auto =
chronicles.formatIt(NoiseConnection): shortLog(it) chronicles.formatIt(NoiseConnection): shortLog(it)
proc genKeyPair(rng: var HmacDrbgContext): KeyPair = proc genKeyPair(rng: Rng): KeyPair =
result.privateKey = Curve25519Key.random(rng) result.privateKey = Curve25519Key.random(rng)
result.publicKey = result.privateKey.public() result.publicKey = result.privateKey.public()
@ -235,7 +236,7 @@ template write_e: untyped =
trace "noise write e" trace "noise write e"
# Sets e (which must be empty) to GENERATE_KEYPAIR(). # Sets e (which must be empty) to GENERATE_KEYPAIR().
# Appends e.public_key to the buffer. Calls MixHash(e.public_key). # Appends e.public_key to the buffer. Calls MixHash(e.public_key).
hs.e = genKeyPair(p.rng[]) hs.e = genKeyPair(p.rng)
msg.add hs.e.publicKey msg.add hs.e.publicKey
hs.ss.mixHash(hs.e.publicKey) hs.ss.mixHash(hs.e.publicKey)
@ -645,7 +646,7 @@ method init*(p: Noise) {.gcsafe.} =
proc new*( proc new*(
T: typedesc[Noise], T: typedesc[Noise],
rng: ref HmacDrbgContext, rng: Rng,
privateKey: PrivateKey, privateKey: PrivateKey,
outgoing: bool = true, outgoing: bool = true,
commonPrologue: seq[byte] = @[]): T = commonPrologue: seq[byte] = @[]): T =
@ -658,7 +659,7 @@ proc new*(
outgoing: outgoing, outgoing: outgoing,
localPrivateKey: privateKey, localPrivateKey: privateKey,
localPublicKey: pkBytes, localPublicKey: pkBytes,
noiseKeys: genKeyPair(rng[]), noiseKeys: genKeyPair(rng),
commonPrologue: commonPrologue, commonPrologue: commonPrologue,
) )

7
libp2p/services/autorelayservice.nim
View File

@ -11,7 +11,8 @@
import chronos, chronicles, times, tables, sequtils import chronos, chronicles, times, tables, sequtils
import ../switch, import ../switch,
../protocols/connectivity/relay/[client, utils] ../protocols/connectivity/relay/[client, utils],
../utils/random/rng
logScope: logScope:
topics = "libp2p autorelay" topics = "libp2p autorelay"
@ -30,7 +31,7 @@ type
peerAvailable: AsyncEvent peerAvailable: AsyncEvent
onReservation: OnReservationHandler onReservation: OnReservationHandler
addressMapper: AddressMapper addressMapper: AddressMapper
rng: ref HmacDrbgContext rng: Rng
proc isRunning*(self: AutoRelayService): bool = proc isRunning*(self: AutoRelayService): bool =
return self.running return self.running
@ -139,7 +140,7 @@ proc new*(T: typedesc[AutoRelayService],
numRelays: int, numRelays: int,
client: RelayClient, client: RelayClient,
onReservation: OnReservationHandler, onReservation: OnReservationHandler,
rng: ref HmacDrbgContext): T = rng: Rng): T =
T(numRelays: numRelays, T(numRelays: numRelays,
client: client, client: client,
onReservation: onReservation, onReservation: onReservation,

5
libp2p/transports/tortransport.nim
View File

@ -21,7 +21,8 @@ import transport,
../builders, ../builders,
../stream/[lpstream, connection, chronosstream], ../stream/[lpstream, connection, chronosstream],
../multiaddress, ../multiaddress,
../upgrademngrs/upgrade ../upgrademngrs/upgrade,
../utils/random/rng
const const
IPTcp = mapAnd(IP, mapEq("tcp")) IPTcp = mapAnd(IP, mapEq("tcp"))
@ -252,7 +253,7 @@ type
proc new*( proc new*(
T: typedesc[TorSwitch], T: typedesc[TorSwitch],
torServer: TransportAddress, torServer: TransportAddress,
rng: ref HmacDrbgContext, rng: Rng,
addresses: seq[MultiAddress] = @[], addresses: seq[MultiAddress] = @[],
flags: set[ServerFlags] = {}): TorSwitch flags: set[ServerFlags] = {}): TorSwitch
{.raises: [LPError], public.} = {.raises: [LPError], public.} =

25
libp2p/utils/random/rng.nim Normal file
View File

@ -0,0 +1,25 @@
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
{.push raises: [].}
import bearssl/rand
export PrngClass
type
Rng* = ref object of RootObj
vtable*: ptr ptr PrngClass
method shuffle*[T](
rng: Rng,
x: var openArray[T]) {.base.} =
raiseAssert("Not implemented!")
method generate*(rng: Rng, v: var openArray[byte]) {.base.} =
raiseAssert("Not implemented!")

33
libp2p/utils/random/securerng.nim Normal file
View File

@ -0,0 +1,33 @@
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
{.push raises: [].}
import rng
import bearssl/rand
import ../../crypto/crypto
export Rng
type
SecureRng* = ref object of Rng
hmacDrbgContext: ref HmacDrbgContext
method shuffle*[T](
rng: SecureRng,
x: var openArray[T]) =
rng.hmacDrbgContext[].shuffle(x)
method generate*(rng: SecureRng, v: var openArray[byte]) =
generate(rng.hmacDrbgContext[], v)
proc new*(
T: typedesc[SecureRng]): T =
var hmacDrbgContext = newRng()
return T(hmacDrbgContext: hmacDrbgContext, vtable: addr hmacDrbgContext.vtable)

82
libp2p/utils/random/testrng.nim Normal file
View File

@ -0,0 +1,82 @@
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
{.push raises: [].}
import rng
import bearssl/rand
import bearssl/hash
import std/random
export Rng
type
TestRng* = ref object of Rng
hmacDrbgContext: ref HmacDrbgContextMock
prngClass: PrngClass
HmacDrbgContextMock* = object
vtable: ptr PrngClass # Mock VTable
K: array[64, byte] # Mock cryptographic key
V: array[64, byte] # Mock cryptographic state
digestClass: ptr HashClass # Point to a mock or dummy hash class
# Helper to easily cast to correct type
proc toMock(ctx: ptr ptr PrngClass): ptr HmacDrbgContextMock =
return cast[ptr HmacDrbgContextMock](ctx[])
proc mockInit(ctx: ptr ptr PrngClass, params: pointer, seed: pointer, seedLen: uint) {.cdecl, noSideEffect, gcsafe.} =
let mockCtx = toMock(ctx)
# Initialize V with a simple pattern or seed data if available
for i in 0..<len(mockCtx.V):
mockCtx.V[i] = byte(i) # or derive from `seed` if applicable
proc mockGenerate(ctx: ptr ptr PrngClass, `out`: pointer, len: uint) {.cdecl, noSideEffect, gcsafe.} =
let mockCtx = toMock(ctx)
if `out` != nil:
let output = cast[ptr array[0..high(int), byte]](`out`)
for i in 0..<int(len):
# Use current state of V to compute next byte
output[i] = byte((mockCtx.V[i mod len(mockCtx.V)] * 1664525'u32 + 1013904223'u32) shr 24)
# Update V to ensure it changes for the next call
mockCtx.V[i mod len(mockCtx.V)] = output[i]
proc mockUpdate(ctx: ptr ptr PrngClass, seed: pointer, seedLen: uint) {.cdecl, noSideEffect, gcsafe.} =
# Update V based on seed
let mockCtx = toMock(ctx)
if seed != nil and seedLen > 0:
let seedBytes = cast[ptr array[0..high(int), byte]](seed)
for i in 0..<min(int(seedLen), len(mockCtx.V)):
# Correctly dereference the byte at index i from seedBytes
let currentSeedByte = seedBytes[i] # Access ith byte from seedBytes
mockCtx.V[i] = byte((mockCtx.V[i] + currentSeedByte) mod 256)
method shuffle*[T](
rng: TestRng,
x: var openArray[T]) =
x
method generate*(rng: TestRng, v: var openArray[byte]) =
for i in 0..<len(v):
v[i] = rand(0..255).uint8
proc new*(
T: typedesc[TestRng]): T =
let t = T(
hmacDrbgContext: HmacDrbgContextMock.new(),
prngClass:
PrngClass(
contextSize: uint(sizeof(HmacDrbgContextMock)),
init: mockInit,
generate: mockGenerate,
update: mockUpdate)
)
t.hmacDrbgContext.vtable = addr t.prngClass
t.vtable = addr t.hmacDrbgContext.vtable
t

8
tests/helpers.nim
View File

@ -13,6 +13,7 @@ import ../libp2p/muxers/mplex/lpchannel
import ../libp2p/protocols/secure/secure import ../libp2p/protocols/secure/secure
import ../libp2p/switch import ../libp2p/switch
import ../libp2p/nameresolving/[nameresolver, mockresolver] import ../libp2p/nameresolving/[nameresolver, mockresolver]
import ../libp2p/utils/random/testrng
import "."/[asyncunit, errorhelpers] import "."/[asyncunit, errorhelpers]
export asyncunit, errorhelpers, mockresolver export asyncunit, errorhelpers, mockresolver
@ -72,8 +73,8 @@ proc getRng(): ref HmacDrbgContext =
rngVar.rng = newRng() rngVar.rng = newRng()
rngVar.rng rngVar.rng
template rng*(): ref HmacDrbgContext = template rng*(): Rng =
getRng() TestRng.new()
type type
WriteHandler* = proc( WriteHandler* = proc(
@ -221,3 +222,6 @@ proc setDNSAddr*(switch: Switch) {.async.} =
return @[MultiAddress.init("/dns4/localhost/").tryGet() & listenAddrs[0][1].tryGet()] return @[MultiAddress.init("/dns4/localhost/").tryGet() & listenAddrs[0][1].tryGet()]
switch.peerInfo.addressMappers.add(addressMapper) switch.peerInfo.addressMappers.add(addressMapper)
await switch.peerInfo.update() await switch.peerInfo.update()
proc randomPeerId*(): PeerId =
PeerId.init(PrivateKey.random(ECDSA, rng).get()).get()

3
tests/pubsub/testmcache.nim
View File

@ -10,8 +10,7 @@ import ./utils
var rng = newRng() var rng = newRng()
proc randomPeerId(): PeerId =
PeerId.init(PrivateKey.random(ECDSA, rng[]).get()).get()
const MsgIdGenSuccess = "msg id generation success" const MsgIdGenSuccess = "msg id generation success"

2
tests/testautonat.nim
View File

@ -25,7 +25,7 @@ import
proc createAutonatSwitch(nameResolver: NameResolver = nil): Switch = proc createAutonatSwitch(nameResolver: NameResolver = nil): Switch =
var builder = SwitchBuilder.new() var builder = SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()

30
tests/testautonatservice.nim
View File

@ -22,7 +22,7 @@ import stubs/autonatclientstub
proc createSwitch(autonatSvc: Service = nil, withAutonat = true, maxConnsPerPeer = 1, maxConns = 100, nameResolver: NameResolver = nil): Switch = proc createSwitch(autonatSvc: Service = nil, withAutonat = true, maxConnsPerPeer = 1, maxConns = 100, nameResolver: NameResolver = nil): Switch =
var builder = SwitchBuilder.new() var builder = SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMaxConnsPerPeer(maxConnsPerPeer) .withMaxConnsPerPeer(maxConnsPerPeer)
@ -50,7 +50,7 @@ suite "Autonat Service":
let autonatClientStub = AutonatClientStub.new(expectedDials = 3) let autonatClientStub = AutonatClientStub.new(expectedDials = 3)
autonatClientStub.answer = NotReachable autonatClientStub.answer = NotReachable
let autonatService = AutonatService.new(autonatClientStub, newRng()) let autonatService = AutonatService.new(autonatClientStub, rng())
let switch1 = createSwitch(autonatService) let switch1 = createSwitch(autonatService)
let switch2 = createSwitch() let switch2 = createSwitch()
@ -78,7 +78,7 @@ suite "Autonat Service":
asyncTest "Peer must be reachable": asyncTest "Peer must be reachable":
let autonatService = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(1.seconds)) let autonatService = AutonatService.new(AutonatClient.new(), rng(), Opt.some(1.seconds))
let switch1 = createSwitch(autonatService) let switch1 = createSwitch(autonatService)
let switch2 = createSwitch() let switch2 = createSwitch()
@ -122,7 +122,7 @@ suite "Autonat Service":
let autonatClientStub = AutonatClientStub.new(expectedDials = 6) let autonatClientStub = AutonatClientStub.new(expectedDials = 6)
autonatClientStub.answer = NotReachable autonatClientStub.answer = NotReachable
let autonatService = AutonatService.new(autonatClientStub, newRng(), Opt.some(1.seconds)) let autonatService = AutonatService.new(autonatClientStub, rng(), Opt.some(1.seconds))
let switch1 = createSwitch(autonatService) let switch1 = createSwitch(autonatService)
let switch2 = createSwitch() let switch2 = createSwitch()
@ -164,7 +164,7 @@ suite "Autonat Service":
asyncTest "Peer must be reachable when one connected peer has autonat disabled": asyncTest "Peer must be reachable when one connected peer has autonat disabled":
let autonatService = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(1.seconds), maxQueueSize = 2) let autonatService = AutonatService.new(AutonatClient.new(), rng(), Opt.some(1.seconds), maxQueueSize = 2)
let switch1 = createSwitch(autonatService) let switch1 = createSwitch(autonatService)
let switch2 = createSwitch(withAutonat = false) let switch2 = createSwitch(withAutonat = false)
@ -204,7 +204,7 @@ suite "Autonat Service":
let autonatClientStub = AutonatClientStub.new(expectedDials = 6) let autonatClientStub = AutonatClientStub.new(expectedDials = 6)
autonatClientStub.answer = NotReachable autonatClientStub.answer = NotReachable
let autonatService = AutonatService.new(autonatClientStub, newRng(), Opt.some(1.seconds), maxQueueSize = 3) let autonatService = AutonatService.new(autonatClientStub, rng(), Opt.some(1.seconds), maxQueueSize = 3)
let switch1 = createSwitch(autonatService) let switch1 = createSwitch(autonatService)
let switch2 = createSwitch() let switch2 = createSwitch()
@ -247,7 +247,7 @@ suite "Autonat Service":
asyncTest "Calling setup and stop twice must work": asyncTest "Calling setup and stop twice must work":
let switch = createSwitch() let switch = createSwitch()
let autonatService = AutonatService.new(AutonatClientStub.new(expectedDials = 0), newRng(), Opt.some(1.seconds)) let autonatService = AutonatService.new(AutonatClientStub.new(expectedDials = 0), rng(), Opt.some(1.seconds))
check (await autonatService.setup(switch)) == true check (await autonatService.setup(switch)) == true
check (await autonatService.setup(switch)) == false check (await autonatService.setup(switch)) == false
@ -258,7 +258,7 @@ suite "Autonat Service":
await allFuturesThrowing(switch.stop()) await allFuturesThrowing(switch.stop())
asyncTest "Must bypass maxConnectionsPerPeer limit": asyncTest "Must bypass maxConnectionsPerPeer limit":
let autonatService = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(1.seconds), maxQueueSize = 1) let autonatService = AutonatService.new(AutonatClient.new(), rng(), Opt.some(1.seconds), maxQueueSize = 1)
let switch1 = createSwitch(autonatService, maxConnsPerPeer = 0) let switch1 = createSwitch(autonatService, maxConnsPerPeer = 0)
await switch1.setDNSAddr() await switch1.setDNSAddr()
@ -290,9 +290,9 @@ suite "Autonat Service":
switch1.stop(), switch2.stop()) switch1.stop(), switch2.stop())
asyncTest "Must work when peers ask each other at the same time with max 1 conn per peer": asyncTest "Must work when peers ask each other at the same time with max 1 conn per peer":
let autonatService1 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3) let autonatService1 = AutonatService.new(AutonatClient.new(), rng(), Opt.some(500.millis), maxQueueSize = 3)
let autonatService2 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3) let autonatService2 = AutonatService.new(AutonatClient.new(), rng(), Opt.some(500.millis), maxQueueSize = 3)
let autonatService3 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3) let autonatService3 = AutonatService.new(AutonatClient.new(), rng(), Opt.some(500.millis), maxQueueSize = 3)
let switch1 = createSwitch(autonatService1, maxConnsPerPeer = 0) let switch1 = createSwitch(autonatService1, maxConnsPerPeer = 0)
let switch2 = createSwitch(autonatService2, maxConnsPerPeer = 0) let switch2 = createSwitch(autonatService2, maxConnsPerPeer = 0)
@ -337,8 +337,8 @@ suite "Autonat Service":
switch1.stop(), switch2.stop(), switch3.stop()) switch1.stop(), switch2.stop(), switch3.stop())
asyncTest "Must work for one peer when two peers ask each other at the same time with max 1 conn per peer": asyncTest "Must work for one peer when two peers ask each other at the same time with max 1 conn per peer":
let autonatService1 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3) let autonatService1 = AutonatService.new(AutonatClient.new(), rng(), Opt.some(500.millis), maxQueueSize = 3)
let autonatService2 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3) let autonatService2 = AutonatService.new(AutonatClient.new(), rng(), Opt.some(500.millis), maxQueueSize = 3)
let switch1 = createSwitch(autonatService1, maxConnsPerPeer = 0) let switch1 = createSwitch(autonatService1, maxConnsPerPeer = 0)
let switch2 = createSwitch(autonatService2, maxConnsPerPeer = 0) let switch2 = createSwitch(autonatService2, maxConnsPerPeer = 0)
@ -378,7 +378,7 @@ suite "Autonat Service":
switch1.stop(), switch2.stop()) switch1.stop(), switch2.stop())
asyncTest "Must work with low maxConnections": asyncTest "Must work with low maxConnections":
let autonatService = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(1.seconds), maxQueueSize = 1) let autonatService = AutonatService.new(AutonatClient.new(), rng(), Opt.some(1.seconds), maxQueueSize = 1)
let switch1 = createSwitch(autonatService, maxConns = 4) let switch1 = createSwitch(autonatService, maxConns = 4)
let switch2 = createSwitch() let switch2 = createSwitch()
@ -423,7 +423,7 @@ suite "Autonat Service":
switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop(), switch5.stop()) switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop(), switch5.stop())
asyncTest "Peer must not ask an incoming peer": asyncTest "Peer must not ask an incoming peer":
let autonatService = AutonatService.new(AutonatClient.new(), newRng()) let autonatService = AutonatService.new(AutonatClient.new(), rng())
let switch1 = createSwitch(autonatService) let switch1 = createSwitch(autonatService)
let switch2 = createSwitch() let switch2 = createSwitch()

8
tests/testautorelay.nim
View File

@ -19,7 +19,7 @@ import ./helpers
proc createSwitch(r: Relay, autorelay: Service = nil): Switch = proc createSwitch(r: Relay, autorelay: Service = nil): Switch =
var builder = SwitchBuilder.new() var builder = SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()
@ -52,7 +52,7 @@ suite "Autorelay":
check: addresses[0] == buildRelayMA(switchRelay, switchClient) check: addresses[0] == buildRelayMA(switchRelay, switchClient)
check: addresses.len() == 1 check: addresses.len() == 1
fut.complete() fut.complete()
autorelay = AutoRelayService.new(3, relayClient, checkMA, newRng()) autorelay = AutoRelayService.new(3, relayClient, checkMA, rng())
switchClient = createSwitch(relayClient, autorelay) switchClient = createSwitch(relayClient, autorelay)
await allFutures(switchClient.start(), switchRelay.start()) await allFutures(switchClient.start(), switchRelay.start())
await switchClient.connect(switchRelay.peerInfo.peerId, switchRelay.peerInfo.addrs) await switchClient.connect(switchRelay.peerInfo.peerId, switchRelay.peerInfo.addrs)
@ -70,7 +70,7 @@ suite "Autorelay":
proc checkMA(address: seq[MultiAddress]) = proc checkMA(address: seq[MultiAddress]) =
check: address[0] == buildRelayMA(switchRelay, switchClient) check: address[0] == buildRelayMA(switchRelay, switchClient)
fut.complete() fut.complete()
let autorelay = AutoRelayService.new(3, relayClient, checkMA, newRng()) let autorelay = AutoRelayService.new(3, relayClient, checkMA, rng())
switchClient = createSwitch(relayClient, autorelay) switchClient = createSwitch(relayClient, autorelay)
await allFutures(switchClient.start(), switchRelay.start()) await allFutures(switchClient.start(), switchRelay.start())
await sleepAsync(500.millis) await sleepAsync(500.millis)
@ -112,7 +112,7 @@ suite "Autorelay":
addresses.len() == 2 addresses.len() == 2
state += 1 state += 1
fut.complete() fut.complete()
let autorelay = AutoRelayService.new(2, relayClient, checkMA, newRng()) let autorelay = AutoRelayService.new(2, relayClient, checkMA, rng())
switchClient = createSwitch(relayClient, autorelay) switchClient = createSwitch(relayClient, autorelay)
await allFutures(switchClient.start(), rel1.start(), rel2.start(), rel3.start()) await allFutures(switchClient.start(), rel1.start(), rel2.start(), rel3.start())
await switchClient.connect(rel1.peerInfo.peerId, rel1.peerInfo.addrs) await switchClient.connect(rel1.peerInfo.peerId, rel1.peerInfo.addrs)

26
tests/testconnmngr.nim
View File

@ -42,7 +42,7 @@ suite "Connection Manager":
asyncTest "add and retrieve a muxer": asyncTest "add and retrieve a muxer":
let connMngr = ConnManager.new() let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
let mux = getMuxer(peerId) let mux = getMuxer(peerId)
connMngr.storeMuxer(mux) connMngr.storeMuxer(mux)
@ -69,7 +69,7 @@ suite "Connection Manager":
asyncTest "shouldn't allow a closed connection": asyncTest "shouldn't allow a closed connection":
let connMngr = ConnManager.new() let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
let mux = getMuxer(peerId) let mux = getMuxer(peerId)
await mux.connection.close() await mux.connection.close()
@ -80,7 +80,7 @@ suite "Connection Manager":
asyncTest "shouldn't allow an EOFed connection": asyncTest "shouldn't allow an EOFed connection":
let connMngr = ConnManager.new() let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
let mux = getMuxer(peerId) let mux = getMuxer(peerId)
mux.connection.isEof = true mux.connection.isEof = true
@ -92,7 +92,7 @@ suite "Connection Manager":
asyncTest "shouldn't allow a muxer with no connection": asyncTest "shouldn't allow a muxer with no connection":
let connMngr = ConnManager.new() let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
let muxer = getMuxer(peerId) let muxer = getMuxer(peerId)
let conn = muxer.connection let conn = muxer.connection
muxer.connection = nil muxer.connection = nil
@ -107,7 +107,7 @@ suite "Connection Manager":
asyncTest "get conn with direction": asyncTest "get conn with direction":
# This would work with 1 as well cause of a bug in connmanager that will get fixed soon # This would work with 1 as well cause of a bug in connmanager that will get fixed soon
let connMngr = ConnManager.new(maxConnsPerPeer = 2) let connMngr = ConnManager.new(maxConnsPerPeer = 2)
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
let mux1 = getMuxer(peerId, Direction.Out) let mux1 = getMuxer(peerId, Direction.Out)
let mux2 = getMuxer(peerId) let mux2 = getMuxer(peerId)
@ -129,7 +129,7 @@ suite "Connection Manager":
asyncTest "get muxed stream for peer": asyncTest "get muxed stream for peer":
let connMngr = ConnManager.new() let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
let muxer = new TestMuxer let muxer = new TestMuxer
let connection = Connection.new(peerId, Direction.In, Opt.none(MultiAddress)) let connection = Connection.new(peerId, Direction.In, Opt.none(MultiAddress))
@ -149,7 +149,7 @@ suite "Connection Manager":
asyncTest "get stream from directed connection": asyncTest "get stream from directed connection":
let connMngr = ConnManager.new() let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
let muxer = new TestMuxer let muxer = new TestMuxer
let connection = Connection.new(peerId, Direction.In, Opt.none(MultiAddress)) let connection = Connection.new(peerId, Direction.In, Opt.none(MultiAddress))
@ -170,7 +170,7 @@ suite "Connection Manager":
asyncTest "should raise on too many connections": asyncTest "should raise on too many connections":
let connMngr = ConnManager.new(maxConnsPerPeer = 0) let connMngr = ConnManager.new(maxConnsPerPeer = 0)
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
connMngr.storeMuxer(getMuxer(peerId)) connMngr.storeMuxer(getMuxer(peerId))
@ -187,7 +187,7 @@ suite "Connection Manager":
asyncTest "expect connection from peer": asyncTest "expect connection from peer":
# FIXME This should be 1 instead of 0, it will get fixed soon # FIXME This should be 1 instead of 0, it will get fixed soon
let connMngr = ConnManager.new(maxConnsPerPeer = 0) let connMngr = ConnManager.new(maxConnsPerPeer = 0)
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
connMngr.storeMuxer(getMuxer(peerId)) connMngr.storeMuxer(getMuxer(peerId))
@ -206,7 +206,7 @@ suite "Connection Manager":
await waitedConn1.cancelAndWait() await waitedConn1.cancelAndWait()
let let
waitedConn2 = connMngr.expectConnection(peerId, In) waitedConn2 = connMngr.expectConnection(peerId, In)
waitedConn3 = connMngr.expectConnection(PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet(), In) waitedConn3 = connMngr.expectConnection(randomPeerId(), In)
conn = getMuxer(peerId) conn = getMuxer(peerId)
connMngr.storeMuxer(conn) connMngr.storeMuxer(conn)
check (await waitedConn2) == conn check (await waitedConn2) == conn
@ -223,7 +223,7 @@ suite "Connection Manager":
asyncTest "cleanup on connection close": asyncTest "cleanup on connection close":
let connMngr = ConnManager.new() let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
let muxer = getMuxer(peerId) let muxer = getMuxer(peerId)
connMngr.storeMuxer(muxer) connMngr.storeMuxer(muxer)
@ -238,7 +238,7 @@ suite "Connection Manager":
asyncTest "drop connections for peer": asyncTest "drop connections for peer":
let connMngr = ConnManager.new() let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet() let peerId = randomPeerId()
for i in 0..<2: for i in 0..<2:
let dir = if i mod 2 == 0: let dir = if i mod 2 == 0:
@ -373,7 +373,7 @@ suite "Connection Manager":
let muxer = let muxer =
getMuxer( getMuxer(
PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet(), randomPeerId(),
Direction.In) Direction.In)
slot.trackMuxer(muxer) slot.trackMuxer(muxer)

15
tests/testcrypto.nim
View File

@ -16,6 +16,7 @@ import unittest2
import bearssl/hash import bearssl/hash
import nimcrypto/utils import nimcrypto/utils
import ../libp2p/crypto/[crypto, chacha20poly1305, curve25519, hkdf] import ../libp2p/crypto/[crypto, chacha20poly1305, curve25519, hkdf]
import ../libp2p/utils/random/securerng
const const
PrivateKeys = [ PrivateKeys = [
@ -366,7 +367,7 @@ proc testStretcher(s, e: int, cs: string, ds: string): bool =
if not result: if not result:
break break
let rng = newRng() let rng = SecureRng.new()
suite "Key interface test suite": suite "Key interface test suite":
@ -413,9 +414,9 @@ suite "Key interface test suite":
var bmsg = cast[seq[byte]](msg) var bmsg = cast[seq[byte]](msg)
for i in 0..<5: for i in 0..<5:
var seckey = PrivateKey.random(ECDSA, rng[]).get() var seckey = PrivateKey.random(ECDSA, rng).get()
var pubkey = seckey.getPublicKey().get() var pubkey = seckey.getPublicKey().get()
var pair = KeyPair.random(ECDSA, rng[]).get() var pair = KeyPair.random(ECDSA, rng).get()
var sig1 = pair.seckey.sign(bmsg).get() var sig1 = pair.seckey.sign(bmsg).get()
var sig2 = seckey.sign(bmsg).get() var sig2 = seckey.sign(bmsg).get()
var sersig1 = sig1.getBytes() var sersig1 = sig1.getBytes()
@ -433,9 +434,9 @@ suite "Key interface test suite":
recsig2.verify(bmsg, recpub2) == true recsig2.verify(bmsg, recpub2) == true
for i in 0..<5: for i in 0..<5:
var seckey = PrivateKey.random(Ed25519, rng[]).get() var seckey = PrivateKey.random(Ed25519, rng).get()
var pubkey = seckey.getPublicKey().get() var pubkey = seckey.getPublicKey().get()
var pair = KeyPair.random(Ed25519, rng[]).get() var pair = KeyPair.random(Ed25519, rng).get()
var sig1 = pair.seckey.sign(bmsg).get() var sig1 = pair.seckey.sign(bmsg).get()
var sig2 = seckey.sign(bmsg).get() var sig2 = seckey.sign(bmsg).get()
var sersig1 = sig1.getBytes() var sersig1 = sig1.getBytes()
@ -453,9 +454,9 @@ suite "Key interface test suite":
recsig2.verify(bmsg, recpub2) == true recsig2.verify(bmsg, recpub2) == true
for i in 0 ..< 2: for i in 0 ..< 2:
var seckey = PrivateKey.random(RSA, rng[], 2048).get() var seckey = PrivateKey.random(RSA, rng, 2048).get()
var pubkey = seckey.getPublicKey().get() var pubkey = seckey.getPublicKey().get()
var pair = KeyPair.random(RSA, rng[], 2048).get() var pair = KeyPair.random(RSA, rng, 2048).get()
var sig1 = pair.seckey.sign(bmsg).get() var sig1 = pair.seckey.sign(bmsg).get()
var sig2 = seckey.sign(bmsg).get() var sig2 = seckey.sign(bmsg).get()
var sersig1 = sig1.getBytes() var sersig1 = sig1.getBytes()

2
tests/testdiscovery.nim
View File

@ -19,7 +19,7 @@ import ./helpers
proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch = proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch =
SwitchBuilder.new() SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()

34
tests/testecnist.nim
View File

@ -14,6 +14,8 @@ import nimcrypto/utils
import ../libp2p/crypto/[crypto, ecnist] import ../libp2p/crypto/[crypto, ecnist]
import stew/results import stew/results
import ../libp2p/utils/random/securerng
const const
TestsCount = 10 # number of random tests TestsCount = 10 # number of random tests
@ -295,14 +297,14 @@ const
35ab""" 35ab"""
] ]
let rng = newRng() let rng = SecureRng.new()
suite "EC NIST-P256/384/521 test suite": suite "EC NIST-P256/384/521 test suite":
test "[secp256r1] Private key serialize/deserialize test": test "[secp256r1] Private key serialize/deserialize test":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: EcPrivateKey var rkey1, rkey2: EcPrivateKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var key = EcPrivateKey.random(Secp256r1, rng[]).expect("random key") var key = EcPrivateKey.random(Secp256r1, rng).expect("random key")
var skey1 = key.getBytes().expect("bytes") var skey1 = key.getBytes().expect("bytes")
check: check:
key.toBytes(skey2).expect("bytes") > 0 key.toBytes(skey2).expect("bytes") > 0
@ -324,7 +326,7 @@ suite "EC NIST-P256/384/521 test suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: EcPublicKey var rkey1, rkey2: EcPublicKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var pair = EcKeyPair.random(Secp256r1, rng[]).expect("random key") var pair = EcKeyPair.random(Secp256r1, rng).expect("random key")
var skey1 = pair.pubkey.getBytes().expect("bytes") var skey1 = pair.pubkey.getBytes().expect("bytes")
check: check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0 pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -343,8 +345,8 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp256r1] ECDHE test": test "[secp256r1] ECDHE test":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var kp1 = EcKeyPair.random(Secp256r1, rng[]).expect("random key") var kp1 = EcKeyPair.random(Secp256r1, rng).expect("random key")
var kp2 = EcKeyPair.random(Secp256r1, rng[]).expect("random key") var kp2 = EcKeyPair.random(Secp256r1, rng).expect("random key")
var shared1 = kp2.pubkey.scalarMul(kp1.seckey) var shared1 = kp2.pubkey.scalarMul(kp1.seckey)
var shared2 = kp1.pubkey.scalarMul(kp2.seckey) var shared2 = kp1.pubkey.scalarMul(kp2.seckey)
check: check:
@ -398,7 +400,7 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp256r1] Generate/Sign/Serialize/Deserialize/Verify test": test "[secp256r1] Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign" var message = "message to sign"
for i in 0..<TestsCount: for i in 0..<TestsCount:
var kp = EcKeyPair.random(Secp256r1, rng[]).expect("random key") var kp = EcKeyPair.random(Secp256r1, rng).expect("random key")
var sig = kp.seckey.sign(message).expect("signature") var sig = kp.seckey.sign(message).expect("signature")
var sersk = kp.seckey.getBytes().expect("bytes") var sersk = kp.seckey.getBytes().expect("bytes")
var serpk = kp.pubkey.getBytes().expect("bytes") var serpk = kp.pubkey.getBytes().expect("bytes")
@ -415,7 +417,7 @@ suite "EC NIST-P256/384/521 test suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: EcPrivateKey var rkey1, rkey2: EcPrivateKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var key = EcPrivateKey.random(Secp384r1, rng[]).expect("random key") var key = EcPrivateKey.random(Secp384r1, rng).expect("random key")
var skey1 = key.getBytes().expect("bytes") var skey1 = key.getBytes().expect("bytes")
check: check:
key.toBytes(skey2).expect("bytes") > 0 key.toBytes(skey2).expect("bytes") > 0
@ -437,7 +439,7 @@ suite "EC NIST-P256/384/521 test suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: EcPublicKey var rkey1, rkey2: EcPublicKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var pair = EcKeyPair.random(Secp384r1, rng[]).expect("random key") var pair = EcKeyPair.random(Secp384r1, rng).expect("random key")
var skey1 = pair.pubkey.getBytes().expect("bytes") var skey1 = pair.pubkey.getBytes().expect("bytes")
check: check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0 pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -456,8 +458,8 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp384r1] ECDHE test": test "[secp384r1] ECDHE test":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var kp1 = EcKeyPair.random(Secp384r1, rng[]).expect("random key") var kp1 = EcKeyPair.random(Secp384r1, rng).expect("random key")
var kp2 = EcKeyPair.random(Secp384r1, rng[]).expect("random key") var kp2 = EcKeyPair.random(Secp384r1, rng).expect("random key")
var shared1 = kp2.pubkey.scalarMul(kp1.seckey) var shared1 = kp2.pubkey.scalarMul(kp1.seckey)
var shared2 = kp1.pubkey.scalarMul(kp2.seckey) var shared2 = kp1.pubkey.scalarMul(kp2.seckey)
check: check:
@ -511,7 +513,7 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp384r1] Generate/Sign/Serialize/Deserialize/Verify test": test "[secp384r1] Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign" var message = "message to sign"
for i in 0..<TestsCount: for i in 0..<TestsCount:
var kp = EcKeyPair.random(Secp384r1, rng[]).expect("random key") var kp = EcKeyPair.random(Secp384r1, rng).expect("random key")
var sig = kp.seckey.sign(message).expect("signature") var sig = kp.seckey.sign(message).expect("signature")
var sersk = kp.seckey.getBytes().expect("bytes") var sersk = kp.seckey.getBytes().expect("bytes")
var serpk = kp.pubkey.getBytes().expect("bytes") var serpk = kp.pubkey.getBytes().expect("bytes")
@ -528,7 +530,7 @@ suite "EC NIST-P256/384/521 test suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: EcPrivateKey var rkey1, rkey2: EcPrivateKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var key = EcPrivateKey.random(Secp521r1, rng[]).expect("random key") var key = EcPrivateKey.random(Secp521r1, rng).expect("random key")
var skey1 = key.getBytes().expect("bytes") var skey1 = key.getBytes().expect("bytes")
check: check:
key.toBytes(skey2).expect("bytes") > 0 key.toBytes(skey2).expect("bytes") > 0
@ -550,7 +552,7 @@ suite "EC NIST-P256/384/521 test suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: EcPublicKey var rkey1, rkey2: EcPublicKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var pair = EcKeyPair.random(Secp521r1, rng[]).expect("random key") var pair = EcKeyPair.random(Secp521r1, rng).expect("random key")
var skey1 = pair.pubkey.getBytes().expect("bytes") var skey1 = pair.pubkey.getBytes().expect("bytes")
check: check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0 pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -569,8 +571,8 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp521r1] ECDHE test": test "[secp521r1] ECDHE test":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var kp1 = EcKeyPair.random(Secp521r1, rng[]).expect("random key") var kp1 = EcKeyPair.random(Secp521r1, rng).expect("random key")
var kp2 = EcKeyPair.random(Secp521r1, rng[]).expect("random key") var kp2 = EcKeyPair.random(Secp521r1, rng).expect("random key")
var shared1 = kp2.pubkey.scalarMul(kp1.seckey) var shared1 = kp2.pubkey.scalarMul(kp1.seckey)
var shared2 = kp1.pubkey.scalarMul(kp2.seckey) var shared2 = kp1.pubkey.scalarMul(kp2.seckey)
check: check:
@ -624,7 +626,7 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp521r1] Generate/Sign/Serialize/Deserialize/Verify test": test "[secp521r1] Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign" var message = "message to sign"
for i in 0..<TestsCount: for i in 0..<TestsCount:
var kp = EcKeyPair.random(Secp521r1, rng[]).expect("random key") var kp = EcKeyPair.random(Secp521r1, rng).expect("random key")
var sig = kp.seckey.sign(message).expect("signature") var sig = kp.seckey.sign(message).expect("signature")
var sersk = kp.seckey.getBytes().expect("bytes") var sersk = kp.seckey.getBytes().expect("bytes")
var serpk = kp.pubkey.getBytes().expect("bytes") var serpk = kp.pubkey.getBytes().expect("bytes")

9
tests/tested25519.nim
View File

@ -14,6 +14,7 @@ import unittest2
import nimcrypto/utils import nimcrypto/utils
import ../libp2p/crypto/crypto import ../libp2p/crypto/crypto
import ../libp2p/crypto/ed25519/ed25519 import ../libp2p/crypto/ed25519/ed25519
import ../libp2p/utils/random/testrng
const TestsCount = 20 const TestsCount = 20
@ -101,7 +102,7 @@ const GoodScalars = [
"ECD3F55C1A631258D69CF7A2DEF9DE1400000000000000000000000000000010", "ECD3F55C1A631258D69CF7A2DEF9DE1400000000000000000000000000000010",
] ]
let rng = newRng() let rng = TestRng.new()
suite "Ed25519 test suite": suite "Ed25519 test suite":
test "Scalar check edge cases test": test "Scalar check edge cases test":
@ -114,7 +115,7 @@ suite "Ed25519 test suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: EdPrivateKey var rkey1, rkey2: EdPrivateKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var key = EdPrivateKey.random(rng[]) var key = EdPrivateKey.random(rng)
var skey1 = key.getBytes() var skey1 = key.getBytes()
check: check:
key.toBytes(skey2) > 0 key.toBytes(skey2) > 0
@ -138,7 +139,7 @@ suite "Ed25519 test suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: EdPublicKey var rkey1, rkey2: EdPublicKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var pair = EdKeyPair.random(rng[]) var pair = EdKeyPair.random(rng)
var skey1 = pair.pubkey.getBytes() var skey1 = pair.pubkey.getBytes()
check: check:
pair.pubkey.toBytes(skey2) > 0 pair.pubkey.toBytes(skey2) > 0
@ -174,7 +175,7 @@ suite "Ed25519 test suite":
test "Generate/Sign/Serialize/Deserialize/Verify test": test "Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign" var message = "message to sign"
for i in 0..<TestsCount: for i in 0..<TestsCount:
var kp = EdKeyPair.random(rng[]) var kp = EdKeyPair.random(rng)
var sig = kp.seckey.sign(message) var sig = kp.seckey.sign(message)
var sersk = kp.seckey.getBytes() var sersk = kp.seckey.getBytes()
var serpk = kp.pubkey.getBytes() var serpk = kp.pubkey.getBytes()

18
tests/testhpservice.nim
View File

@ -28,7 +28,7 @@ import stubs/autonatclientstub
proc createSwitch(r: Relay = nil, hpService: Service = nil, nameResolver: NameResolver = nil): Switch {.raises: [LPError].} = proc createSwitch(r: Relay = nil, hpService: Service = nil, nameResolver: NameResolver = nil): Switch {.raises: [LPError].} =
var builder = SwitchBuilder.new() var builder = SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()
@ -58,7 +58,7 @@ suite "Hole Punching":
asyncTest "Direct connection must work when peer address is public": asyncTest "Direct connection must work when peer address is public":
let autonatClientStub = AutonatClientStub.new(expectedDials = 1) let autonatClientStub = AutonatClientStub.new(expectedDials = 1)
autonatClientStub.answer = NotReachable autonatClientStub.answer = NotReachable
let autonatService = AutonatService.new(autonatClientStub, newRng(), maxQueueSize = 1) let autonatService = AutonatService.new(autonatClientStub, rng(), maxQueueSize = 1)
let relayClient = RelayClient.new() let relayClient = RelayClient.new()
let privatePeerRelayAddr = newFuture[seq[MultiAddress]]() let privatePeerRelayAddr = newFuture[seq[MultiAddress]]()
@ -74,7 +74,7 @@ suite "Hole Punching":
if not privatePeerRelayAddr.completed(): if not privatePeerRelayAddr.completed():
privatePeerRelayAddr.complete(address) privatePeerRelayAddr.complete(address)
let autoRelayService = AutoRelayService.new(1, relayClient, checkMA, newRng()) let autoRelayService = AutoRelayService.new(1, relayClient, checkMA, rng())
let hpservice = HPService.new(autonatService, autoRelayService) let hpservice = HPService.new(autonatService, autoRelayService)
@ -100,7 +100,7 @@ suite "Hole Punching":
let autonatClientStub = AutonatClientStub.new(expectedDials = 1) let autonatClientStub = AutonatClientStub.new(expectedDials = 1)
autonatClientStub.answer = NotReachable autonatClientStub.answer = NotReachable
let autonatService = AutonatService.new(autonatClientStub, newRng(), maxQueueSize = 1) let autonatService = AutonatService.new(autonatClientStub, rng(), maxQueueSize = 1)
let relayClient = RelayClient.new() let relayClient = RelayClient.new()
let privatePeerRelayAddr = newFuture[seq[MultiAddress]]() let privatePeerRelayAddr = newFuture[seq[MultiAddress]]()
@ -112,7 +112,7 @@ suite "Hole Punching":
if not privatePeerRelayAddr.completed(): if not privatePeerRelayAddr.completed():
privatePeerRelayAddr.complete(address) privatePeerRelayAddr.complete(address)
let autoRelayService = AutoRelayService.new(1, relayClient, checkMA, newRng()) let autoRelayService = AutoRelayService.new(1, relayClient, checkMA, rng())
let hpservice = HPService.new(autonatService, autoRelayService) let hpservice = HPService.new(autonatService, autoRelayService)
@ -140,11 +140,11 @@ suite "Hole Punching":
let autonatClientStub1 = AutonatClientStub.new(expectedDials = 1) let autonatClientStub1 = AutonatClientStub.new(expectedDials = 1)
autonatClientStub1.answer = NotReachable autonatClientStub1.answer = NotReachable
let autonatService1 = AutonatService.new(autonatClientStub1, newRng(), maxQueueSize = 1) let autonatService1 = AutonatService.new(autonatClientStub1, rng(), maxQueueSize = 1)
let autonatClientStub2 = AutonatClientStub.new(expectedDials = 1) let autonatClientStub2 = AutonatClientStub.new(expectedDials = 1)
autonatClientStub2.answer = answer autonatClientStub2.answer = answer
let autonatService2 = AutonatService.new(autonatClientStub2, newRng(), maxQueueSize = 1) let autonatService2 = AutonatService.new(autonatClientStub2, rng(), maxQueueSize = 1)
let relayClient1 = RelayClient.new() let relayClient1 = RelayClient.new()
let relayClient2 = RelayClient.new() let relayClient2 = RelayClient.new()
@ -154,8 +154,8 @@ suite "Hole Punching":
if not privatePeerRelayAddr1.completed(): if not privatePeerRelayAddr1.completed():
privatePeerRelayAddr1.complete(address) privatePeerRelayAddr1.complete(address)
let autoRelayService1 = AutoRelayService.new(1, relayClient1, checkMA, newRng()) let autoRelayService1 = AutoRelayService.new(1, relayClient1, checkMA, rng())
let autoRelayService2 = AutoRelayService.new(1, relayClient2, nil, newRng()) let autoRelayService2 = AutoRelayService.new(1, relayClient2, nil, rng())
let hpservice1 = HPService.new(autonatService1, autoRelayService1) let hpservice1 = HPService.new(autonatService1, autoRelayService1)
let hpservice2 = HPService.new(autonatService2, autoRelayService2) let hpservice2 = HPService.new(autonatService2, autoRelayService2)

6
tests/testidentify.nim
View File

@ -46,7 +46,7 @@ suite "Identify":
asyncSetup: asyncSetup:
ma = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()] ma = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
remoteSecKey = PrivateKey.random(ECDSA, rng[]).get() remoteSecKey = PrivateKey.random(ECDSA, rng).get()
remotePeerInfo = PeerInfo.new( remotePeerInfo = PeerInfo.new(
remoteSecKey, remoteSecKey,
ma, ma,
@ -129,7 +129,7 @@ suite "Identify":
conn = await transport2.dial(transport1.addrs[0]) conn = await transport2.dial(transport1.addrs[0])
expect IdentityNoMatchError: expect IdentityNoMatchError:
let pi2 = PeerInfo.new(PrivateKey.random(ECDSA, rng[]).get()) let pi2 = PeerInfo.new(PrivateKey.random(ECDSA, rng).get())
discard await msDial.select(conn, IdentifyCodec) discard await msDial.select(conn, IdentifyCodec)
discard await identifyProto2.identify(conn, pi2.peerId) discard await identifyProto2.identify(conn, pi2.peerId)
@ -240,7 +240,7 @@ suite "Identify":
switch1.peerStore[ProtoBook][switch2.peerInfo.peerId] != switch2.peerInfo.protocols switch1.peerStore[ProtoBook][switch2.peerInfo.peerId] != switch2.peerInfo.protocols
let oldPeerId = switch2.peerInfo.peerId let oldPeerId = switch2.peerInfo.peerId
switch2.peerInfo = PeerInfo.new(PrivateKey.random(newRng()[]).get()) switch2.peerInfo = PeerInfo.new(PrivateKey.random(rng).get())
await identifyPush2.push(switch2.peerInfo, conn) await identifyPush2.push(switch2.peerInfo, conn)

4
tests/testinterop.nim
View File

@ -11,7 +11,7 @@ proc switchMplexCreator(
SwitchBuilder.new() SwitchBuilder.new()
.withSignedPeerRecord(false) .withSignedPeerRecord(false)
.withMaxConnections(MaxConnections) .withMaxConnections(MaxConnections)
.withRng(crypto.newRng()) .withRng(rng())
.withAddresses(@[ ma ]) .withAddresses(@[ ma ])
.withMaxIn(-1) .withMaxIn(-1)
.withMaxOut(-1) .withMaxOut(-1)
@ -33,7 +33,7 @@ proc switchYamuxCreator(
SwitchBuilder.new() SwitchBuilder.new()
.withSignedPeerRecord(false) .withSignedPeerRecord(false)
.withMaxConnections(MaxConnections) .withMaxConnections(MaxConnections)
.withRng(crypto.newRng()) .withRng(rng())
.withAddresses(@[ ma ]) .withAddresses(@[ ma ])
.withMaxIn(-1) .withMaxIn(-1)
.withMaxOut(-1) .withMaxOut(-1)

41
tests/testnoise.nim
View File

@ -29,7 +29,8 @@ import ../libp2p/[switch,
protocols/secure/plaintext, protocols/secure/plaintext,
protocols/secure/secure, protocols/secure/secure,
upgrademngrs/muxedupgrade, upgrademngrs/muxedupgrade,
connmanager] connmanager,
utils/random/rng]
import ./helpers import ./helpers
const const
@ -55,7 +56,7 @@ method init(p: TestProto) {.gcsafe.} =
proc createSwitch(ma: MultiAddress; outgoing: bool, plaintext: bool = false): (Switch, PeerInfo) = proc createSwitch(ma: MultiAddress; outgoing: bool, plaintext: bool = false): (Switch, PeerInfo) =
var var
privateKey = PrivateKey.random(ECDSA, rng[]).get() privateKey = PrivateKey.random(ECDSA, rng()).get()
peerInfo = PeerInfo.new(privateKey, @[ma]) peerInfo = PeerInfo.new(privateKey, @[ma])
proc createMplex(conn: Connection): Muxer = proc createMplex(conn: Connection): Muxer =
@ -69,7 +70,7 @@ proc createSwitch(ma: MultiAddress; outgoing: bool, plaintext: bool = false): (S
secureManagers = if plaintext: secureManagers = if plaintext:
[Secure(PlainText.new())] [Secure(PlainText.new())]
else: else:
[Secure(Noise.new(rng, privateKey, outgoing = outgoing))] [Secure(Noise.new(rng(), privateKey, outgoing = outgoing))]
connManager = ConnManager.new() connManager = ConnManager.new()
ms = MultistreamSelect.new() ms = MultistreamSelect.new()
muxedUpgrade = MuxedUpgrade.new(muxers, secureManagers, ms) muxedUpgrade = MuxedUpgrade.new(muxers, secureManagers, ms)
@ -91,9 +92,9 @@ suite "Noise":
asyncTest "e2e: handle write + noise": asyncTest "e2e: handle write + noise":
let let
server = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()] server = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
serverPrivKey = PrivateKey.random(ECDSA, rng[]).get() serverPrivKey = PrivateKey.random(ECDSA, rng()).get()
serverInfo = PeerInfo.new(serverPrivKey, server) serverInfo = PeerInfo.new(serverPrivKey, server)
serverNoise = Noise.new(rng, serverPrivKey, outgoing = false) serverNoise = Noise.new(rng(), serverPrivKey, outgoing = false)
let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade()) let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
asyncSpawn transport1.start(server) asyncSpawn transport1.start(server)
@ -110,9 +111,9 @@ suite "Noise":
let let
acceptFut = acceptHandler() acceptFut = acceptHandler()
transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade()) transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
clientPrivKey = PrivateKey.random(ECDSA, rng[]).get() clientPrivKey = PrivateKey.random(ECDSA, rng()).get()
clientInfo = PeerInfo.new(clientPrivKey, transport1.addrs) clientInfo = PeerInfo.new(clientPrivKey, transport1.addrs)
clientNoise = Noise.new(rng, clientPrivKey, outgoing = true) clientNoise = Noise.new(rng(), clientPrivKey, outgoing = true)
conn = await transport2.dial(transport1.addrs[0]) conn = await transport2.dial(transport1.addrs[0])
let sconn = await clientNoise.secure(conn, Opt.some(serverInfo.peerId)) let sconn = await clientNoise.secure(conn, Opt.some(serverInfo.peerId))
@ -131,9 +132,9 @@ suite "Noise":
asyncTest "e2e: handle write + noise (wrong prologue)": asyncTest "e2e: handle write + noise (wrong prologue)":
let let
server = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()] server = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
serverPrivKey = PrivateKey.random(ECDSA, rng[]).get() serverPrivKey = PrivateKey.random(ECDSA, rng()).get()
serverInfo = PeerInfo.new(serverPrivKey, server) serverInfo = PeerInfo.new(serverPrivKey, server)
serverNoise = Noise.new(rng, serverPrivKey, outgoing = false) serverNoise = Noise.new(rng(), serverPrivKey, outgoing = false)
let let
transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade()) transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
@ -153,9 +154,9 @@ suite "Noise":
let let
handlerWait = acceptHandler() handlerWait = acceptHandler()
transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade()) transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
clientPrivKey = PrivateKey.random(ECDSA, rng[]).get() clientPrivKey = PrivateKey.random(ECDSA, rng()).get()
clientInfo = PeerInfo.new(clientPrivKey, transport1.addrs) clientInfo = PeerInfo.new(clientPrivKey, transport1.addrs)
clientNoise = Noise.new(rng, clientPrivKey, outgoing = true, commonPrologue = @[1'u8, 2'u8, 3'u8]) clientNoise = Noise.new(rng(), clientPrivKey, outgoing = true, commonPrologue = @[1'u8, 2'u8, 3'u8])
conn = await transport2.dial(transport1.addrs[0]) conn = await transport2.dial(transport1.addrs[0])
var sconn: Connection = nil var sconn: Connection = nil
@ -170,9 +171,9 @@ suite "Noise":
asyncTest "e2e: handle read + noise": asyncTest "e2e: handle read + noise":
let let
server = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()] server = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
serverPrivKey = PrivateKey.random(ECDSA, rng[]).get() serverPrivKey = PrivateKey.random(ECDSA, rng()).get()
serverInfo = PeerInfo.new(serverPrivKey, server) serverInfo = PeerInfo.new(serverPrivKey, server)
serverNoise = Noise.new(rng, serverPrivKey, outgoing = false) serverNoise = Noise.new(rng(), serverPrivKey, outgoing = false)
readTask = newFuture[void]() readTask = newFuture[void]()
let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade()) let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
@ -192,9 +193,9 @@ suite "Noise":
let let
acceptFut = acceptHandler() acceptFut = acceptHandler()
transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade()) transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
clientPrivKey = PrivateKey.random(ECDSA, rng[]).get() clientPrivKey = PrivateKey.random(ECDSA, rng()).get()
clientInfo = PeerInfo.new(clientPrivKey, transport1.addrs) clientInfo = PeerInfo.new(clientPrivKey, transport1.addrs)
clientNoise = Noise.new(rng, clientPrivKey, outgoing = true) clientNoise = Noise.new(rng(), clientPrivKey, outgoing = true)
conn = await transport2.dial(transport1.addrs[0]) conn = await transport2.dial(transport1.addrs[0])
let sconn = await clientNoise.secure(conn, Opt.some(serverInfo.peerId)) let sconn = await clientNoise.secure(conn, Opt.some(serverInfo.peerId))
@ -208,13 +209,13 @@ suite "Noise":
asyncTest "e2e: handle read + noise fragmented": asyncTest "e2e: handle read + noise fragmented":
let let
server = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()] server = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
serverPrivKey = PrivateKey.random(ECDSA, rng[]).get() serverPrivKey = PrivateKey.random(ECDSA, rng()).get()
serverInfo = PeerInfo.new(serverPrivKey, server) serverInfo = PeerInfo.new(serverPrivKey, server)
serverNoise = Noise.new(rng, serverPrivKey, outgoing = false) serverNoise = Noise.new(rng(), serverPrivKey, outgoing = false)
readTask = newFuture[void]() readTask = newFuture[void]()
var hugePayload = newSeq[byte](0xFFFFF) var hugePayload = newSeq[byte](0xFFFFF)
hmacDrbgGenerate(rng[], hugePayload) rng().generate(hugePayload)
trace "Sending huge payload", size = hugePayload.len trace "Sending huge payload", size = hugePayload.len
let let
@ -233,9 +234,9 @@ suite "Noise":
let let
acceptFut = acceptHandler() acceptFut = acceptHandler()
transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade()) transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
clientPrivKey = PrivateKey.random(ECDSA, rng[]).get() clientPrivKey = PrivateKey.random(ECDSA, rng()).get()
clientInfo = PeerInfo.new(clientPrivKey, transport1.addrs) clientInfo = PeerInfo.new(clientPrivKey, transport1.addrs)
clientNoise = Noise.new(rng, clientPrivKey, outgoing = true) clientNoise = Noise.new(rng(), clientPrivKey, outgoing = true)
conn = await transport2.dial(transport1.addrs[0]) conn = await transport2.dial(transport1.addrs[0])
let sconn = await clientNoise.secure(conn, Opt.some(serverInfo.peerId)) let sconn = await clientNoise.secure(conn, Opt.some(serverInfo.peerId))

26
tests/testpeerid.nim
View File

@ -13,7 +13,7 @@
## https://github.com/libp2p/go-libp2p-peer ## https://github.com/libp2p/go-libp2p-peer
import unittest2 import unittest2
import nimcrypto/utils, stew/base58 import nimcrypto/utils, stew/base58
import ../libp2p/crypto/crypto, ../libp2p/peerid import ../libp2p/crypto/crypto, ../libp2p/peerid, ../libp2p/utils/random/testrng
import bearssl/hash import bearssl/hash
const const
@ -237,15 +237,15 @@ suite "Peer testing suite":
ekey2 == pubkey ekey2 == pubkey
ekey3 == pubkey ekey3 == pubkey
ekey4 == pubkey ekey4 == pubkey
test "Test PeerId.random() proc": # test "Test PeerId.random() proc":
# generate a random peer with a deterministic ssed # # generate a random peer with a deterministic ssed
var rng = (ref HmacDrbgContext)() # var rng = (ref HmacDrbgContext)()
hmacDrbgInit(rng[], addr sha256Vtable, nil, 0) # hmacDrbgInit(rng[], addr sha256Vtable, nil, 0)
var randomPeer1 = PeerId.random(rng) # var randomPeer1 = PeerId.random(TestRng.new())
check: # check:
$randomPeer1.get() == "16Uiu2HAmCxpSTFDNdWiu1MLScu7inPhcbbGfPvuvRPD1e51gw1Xr" # $randomPeer1.get() == "16Uiu2HAmCxpSTFDNdWiu1MLScu7inPhcbbGfPvuvRPD1e51gw1Xr"
#
# generate a random peer with a new random seed # # generate a random peer with a new random seed
var randomPeer2 = PeerId.random() # var randomPeer2 = PeerId.random()
check: # check:
randomPeer2.isErr() != true # randomPeer2.isErr() != true

6
tests/testpeerinfo.nim
View File

@ -21,7 +21,7 @@ import ./helpers
suite "PeerInfo": suite "PeerInfo":
test "Should init with private key": test "Should init with private key":
let seckey = PrivateKey.random(ECDSA, rng[]).get() let seckey = PrivateKey.random(ECDSA, rng).get()
var peerInfo = PeerInfo.new(seckey) var peerInfo = PeerInfo.new(seckey)
var peerId = PeerId.init(seckey).get() var peerId = PeerId.init(seckey).get()
@ -34,7 +34,7 @@ suite "PeerInfo":
ExpectedPayloadType = @[(byte) 0x03, (byte) 0x01] ExpectedPayloadType = @[(byte) 0x03, (byte) 0x01]
let let
seckey = PrivateKey.random(rng[]).tryGet() seckey = PrivateKey.random(rng).tryGet()
peerId = PeerId.init(seckey).get() peerId = PeerId.init(seckey).get()
multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()] multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()]
peerInfo = PeerInfo.new(seckey, multiAddresses) peerInfo = PeerInfo.new(seckey, multiAddresses)
@ -61,7 +61,7 @@ suite "PeerInfo":
test "Public address mapping": test "Public address mapping":
let let
seckey = PrivateKey.random(ECDSA, rng[]).get() seckey = PrivateKey.random(ECDSA, rng).get()
multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()] multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()]
multiAddresses2 = @[MultiAddress.init("/ip4/8.8.8.8/tcp/33").tryGet()] multiAddresses2 = @[MultiAddress.init("/ip4/8.8.8.8/tcp/33").tryGet()]

8
tests/testpeerstore.nim
View File

@ -22,13 +22,13 @@ suite "PeerStore":
# Testvars # Testvars
let let
# Peer 1 # Peer 1
keyPair1 = KeyPair.random(ECDSA, rng[]).get() keyPair1 = KeyPair.random(ECDSA, rng).get()
peerId1 = PeerId.init(keyPair1.seckey).get() peerId1 = PeerId.init(keyPair1.seckey).get()
multiaddrStr1 = "/ip4/127.0.0.1/udp/1234/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC" multiaddrStr1 = "/ip4/127.0.0.1/udp/1234/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC"
multiaddr1 = MultiAddress.init(multiaddrStr1).get() multiaddr1 = MultiAddress.init(multiaddrStr1).get()
testcodec1 = "/nim/libp2p/test/0.0.1-beta1" testcodec1 = "/nim/libp2p/test/0.0.1-beta1"
# Peer 2 # Peer 2
keyPair2 = KeyPair.random(ECDSA, rng[]).get() keyPair2 = KeyPair.random(ECDSA, rng).get()
peerId2 = PeerId.init(keyPair2.seckey).get() peerId2 = PeerId.init(keyPair2.seckey).get()
multiaddrStr2 = "/ip4/0.0.0.0/tcp/1234/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC" multiaddrStr2 = "/ip4/0.0.0.0/tcp/1234/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC"
multiaddr2 = MultiAddress.init(multiaddrStr2).get() multiaddr2 = MultiAddress.init(multiaddrStr2).get()
@ -128,7 +128,7 @@ suite "PeerStore":
var peerStore = PeerStore.new(nil, capacity = 20) var peerStore = PeerStore.new(nil, capacity = 20)
for i in 0..<30: for i in 0..<30:
let randomPeerId = PeerId.init(KeyPair.random(ECDSA, rng[]).get().pubkey).get() let randomPeerId = PeerId.init(KeyPair.random(ECDSA, rng).get().pubkey).get()
peerStore[AgentBook][randomPeerId] = "gds" peerStore[AgentBook][randomPeerId] = "gds"
peerStore.cleanup(randomPeerId) peerStore.cleanup(randomPeerId)
@ -138,7 +138,7 @@ suite "PeerStore":
var peerStore = PeerStore.new(nil, capacity = -1) var peerStore = PeerStore.new(nil, capacity = -1)
for i in 0..<30: for i in 0..<30:
let randomPeerId = PeerId.init(KeyPair.random(ECDSA, rng[]).get().pubkey).get() let randomPeerId = PeerId.init(KeyPair.random(ECDSA, rng).get().pubkey).get()
peerStore[AgentBook][randomPeerId] = "gds" peerStore[AgentBook][randomPeerId] = "gds"
peerStore.cleanup(randomPeerId) peerStore.cleanup(randomPeerId)

6
tests/testrelayv1.nim
View File

@ -88,7 +88,7 @@ suite "Circuit Relay":
clDst = RelayClient.new() clDst = RelayClient.new()
r = Relay.new(circuitRelayV1=true) r = Relay.new(circuitRelayV1=true)
src = SwitchBuilder.new() src = SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()
@ -96,7 +96,7 @@ suite "Circuit Relay":
.withCircuitRelay(clSrc) .withCircuitRelay(clSrc)
.build() .build()
dst = SwitchBuilder.new() dst = SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()
@ -104,7 +104,7 @@ suite "Circuit Relay":
.withCircuitRelay(clDst) .withCircuitRelay(clDst)
.build() .build()
srelay = SwitchBuilder.new() srelay = SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()

2
tests/testrelayv2.nim
View File

@ -21,7 +21,7 @@ import stew/byteutils
proc createSwitch(r: Relay = nil, useYamux: bool = false): Switch = proc createSwitch(r: Relay = nil, useYamux: bool = false): Switch =
var builder = SwitchBuilder.new() var builder = SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()

2
tests/testrendezvous.nim
View File

@ -19,7 +19,7 @@ import ./helpers
proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch = proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch =
SwitchBuilder.new() SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()

6
tests/testrendezvousinterface.nim
View File

@ -19,7 +19,7 @@ import ./helpers
proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch = proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch =
SwitchBuilder.new() SwitchBuilder.new()
.withRng(newRng()) .withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ]) .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport() .withTcpTransport()
.withMplex() .withMplex()
@ -67,7 +67,7 @@ suite "RendezVous Interface":
await client.stop() await client.stop()
asyncTest "Check timeToAdvertise interval": asyncTest "Check timeToAdvertise interval":
await baseTimeToAdvertiseTest(MockRendezVous.new(newRng())) await baseTimeToAdvertiseTest(MockRendezVous.new(rng()))
asyncTest "Check timeToAdvertise interval when there is an error": asyncTest "Check timeToAdvertise interval when there is an error":
await baseTimeToAdvertiseTest(MockErrorRendezVous.new(newRng())) await baseTimeToAdvertiseTest(MockErrorRendezVous.new(rng()))

24
tests/testrouting_record.nim
View File

@ -13,11 +13,14 @@ import unittest2
import stew/byteutils import stew/byteutils
import ../libp2p/[routing_record, crypto/crypto] import ../libp2p/[routing_record, crypto/crypto]
import ../libp2p/utils/random/testrng
let rng = TestRng.new()
suite "Routing record": suite "Routing record":
test "Encode -> decode test": test "Encode -> decode test":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
peerId = PeerId.init(privKey).tryGet() peerId = PeerId.init(privKey).tryGet()
multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()] multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()]
routingRecord = PeerRecord.init(peerId, multiAddresses, 42) routingRecord = PeerRecord.init(peerId, multiAddresses, 42)
@ -50,8 +53,7 @@ suite "Routing record":
suite "Signed Routing Record": suite "Signed Routing Record":
test "Encode -> decode test": test "Encode -> decode test":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
peerId = PeerId.init(privKey).tryGet() peerId = PeerId.init(privKey).tryGet()
multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()] multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()]
routingRecord = SignedPeerRecord.init(privKey, PeerRecord.init(peerId, multiAddresses, 42)).tryGet() routingRecord = SignedPeerRecord.init(privKey, PeerRecord.init(peerId, multiAddresses, 42)).tryGet()
@ -68,9 +70,8 @@ suite "Signed Routing Record":
test "Can't use mismatched public key": test "Can't use mismatched public key":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet() privKey2 = PrivateKey.random(rng).tryGet()
privKey2 = PrivateKey.random(rng[]).tryGet()
peerId = PeerId.init(privKey).tryGet() peerId = PeerId.init(privKey).tryGet()
multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()] multiAddresses = @[MultiAddress.init("/ip4/0.0.0.0/tcp/24").tryGet(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()]
routingRecord = SignedPeerRecord.init(privKey2, PeerRecord.init(peerId, multiAddresses, 42)).tryGet() routingRecord = SignedPeerRecord.init(privKey2, PeerRecord.init(peerId, multiAddresses, 42)).tryGet()
@ -80,8 +81,7 @@ suite "Signed Routing Record":
test "Decode doesn't fail if some addresses are invalid": test "Decode doesn't fail if some addresses are invalid":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
peerId = PeerId.init(privKey).tryGet() peerId = PeerId.init(privKey).tryGet()
multiAddresses = @[MultiAddress(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()] multiAddresses = @[MultiAddress(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()]
routingRecord = PeerRecord.init(peerId, multiAddresses, 42) routingRecord = PeerRecord.init(peerId, multiAddresses, 42)
@ -93,8 +93,7 @@ suite "Signed Routing Record":
test "Decode doesn't fail if there are no addresses": test "Decode doesn't fail if there are no addresses":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
peerId = PeerId.init(privKey).tryGet() peerId = PeerId.init(privKey).tryGet()
multiAddresses = newSeq[MultiAddress]() multiAddresses = newSeq[MultiAddress]()
routingRecord = PeerRecord.init(peerId, multiAddresses, 42) routingRecord = PeerRecord.init(peerId, multiAddresses, 42)
@ -106,8 +105,7 @@ suite "Signed Routing Record":
test "Decode fails if all addresses are invalid": test "Decode fails if all addresses are invalid":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
peerId = PeerId.init(privKey).tryGet() peerId = PeerId.init(privKey).tryGet()
multiAddresses = @[MultiAddress(), MultiAddress()] multiAddresses = @[MultiAddress(), MultiAddress()]
routingRecord = PeerRecord.init(peerId, multiAddresses, 42) routingRecord = PeerRecord.init(peerId, multiAddresses, 42)

25
tests/testrsa.nim
View File

@ -12,6 +12,7 @@
import unittest2 import unittest2
import nimcrypto/utils import nimcrypto/utils
import ../libp2p/crypto/[crypto, rsa] import ../libp2p/crypto/[crypto, rsa]
import ../libp2p/utils/random/testrng
const const
NotAllowedPrivateKeys = [ NotAllowedPrivateKeys = [
@ -354,7 +355,7 @@ const
ACB51807206B8332127E3692269013B96F0CABD95D7431805E48176ADC5D1366""" ACB51807206B8332127E3692269013B96F0CABD95D7431805E48176ADC5D1366"""
] ]
let rng = newRng() let rng = TestRng.new()
type type
RsaPrivateKey = rsa.RsaPrivateKey RsaPrivateKey = rsa.RsaPrivateKey
@ -364,7 +365,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa2048] Private key serialize/deserialize test": test "[rsa2048] Private key serialize/deserialize test":
var rkey1, rkey2: RsaPrivateKey var rkey1, rkey2: RsaPrivateKey
var skey2 = newSeq[byte](4096) var skey2 = newSeq[byte](4096)
var key = RsaPrivateKey.random(rng[], 2048).expect("random failed") var key = RsaPrivateKey.random(rng, 2048).expect("random failed")
var skey1 = key.getBytes().expect("bytes") var skey1 = key.getBytes().expect("bytes")
check key.toBytes(skey2).expect("bytes") > 0 check key.toBytes(skey2).expect("bytes") > 0
check: check:
@ -381,7 +382,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa3072] Private key serialize/deserialize test": test "[rsa3072] Private key serialize/deserialize test":
var rkey1, rkey2: RsaPrivateKey var rkey1, rkey2: RsaPrivateKey
var skey2 = newSeq[byte](4096) var skey2 = newSeq[byte](4096)
var key = RsaPrivateKey.random(rng[], 3072).expect("random failed") var key = RsaPrivateKey.random(rng, 3072).expect("random failed")
var skey1 = key.getBytes().expect("bytes") var skey1 = key.getBytes().expect("bytes")
check key.toBytes(skey2).expect("bytes") > 0 check key.toBytes(skey2).expect("bytes") > 0
check: check:
@ -400,7 +401,7 @@ suite "RSA 2048/3072/4096 test suite":
when defined(release): when defined(release):
var rkey1, rkey2: RsaPrivateKey var rkey1, rkey2: RsaPrivateKey
var skey2 = newSeq[byte](4096) var skey2 = newSeq[byte](4096)
var key = RsaPrivateKey.random(rng[], 4096).expect("random failed") var key = RsaPrivateKey.random(rng, 4096).expect("random failed")
var skey1 = key.getBytes().expect("bytes") var skey1 = key.getBytes().expect("bytes")
check key.toBytes(skey2).expect("bytes") > 0 check key.toBytes(skey2).expect("bytes") > 0
check: check:
@ -419,7 +420,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa2048] Public key serialize/deserialize test": test "[rsa2048] Public key serialize/deserialize test":
var rkey1, rkey2: RsaPublicKey var rkey1, rkey2: RsaPublicKey
var skey2 = newSeq[byte](4096) var skey2 = newSeq[byte](4096)
var pair = RsaKeyPair.random(rng[], 2048).expect("random failed") var pair = RsaKeyPair.random(rng, 2048).expect("random failed")
var skey1 = pair.pubkey.getBytes().expect("bytes") var skey1 = pair.pubkey.getBytes().expect("bytes")
check: check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0 pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -436,7 +437,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa3072] Public key serialize/deserialize test": test "[rsa3072] Public key serialize/deserialize test":
var rkey1, rkey2: RsaPublicKey var rkey1, rkey2: RsaPublicKey
var skey2 = newSeq[byte](4096) var skey2 = newSeq[byte](4096)
var pair = RsaKeyPair.random(rng[], 3072).expect("random failed") var pair = RsaKeyPair.random(rng, 3072).expect("random failed")
var skey1 = pair.pubkey.getBytes().expect("bytes") var skey1 = pair.pubkey.getBytes().expect("bytes")
check: check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0 pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -454,7 +455,7 @@ suite "RSA 2048/3072/4096 test suite":
when defined(release): when defined(release):
var rkey1, rkey2: RsaPublicKey var rkey1, rkey2: RsaPublicKey
var skey2 = newSeq[byte](4096) var skey2 = newSeq[byte](4096)
var pair = RsaKeyPair.random(rng[], 4096).expect("random failed") var pair = RsaKeyPair.random(rng, 4096).expect("random failed")
var skey1 = pair.pubkey.getBytes().expect("bytes") var skey1 = pair.pubkey.getBytes().expect("bytes")
check: check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0 pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -472,7 +473,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa2048] Generate/Sign/Serialize/Deserialize/Verify test": test "[rsa2048] Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign" var message = "message to sign"
var kp = RsaKeyPair.random(rng[], 2048).expect("RsaPrivateKey.random failed") var kp = RsaKeyPair.random(rng, 2048).expect("RsaPrivateKey.random failed")
var sig = kp.seckey.sign(message).expect("signature") var sig = kp.seckey.sign(message).expect("signature")
var sersk = kp.seckey.getBytes().expect("bytes") var sersk = kp.seckey.getBytes().expect("bytes")
var serpk = kp.pubkey.getBytes().expect("bytes") var serpk = kp.pubkey.getBytes().expect("bytes")
@ -487,7 +488,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa3072] Generate/Sign/Serialize/Deserialize/Verify test": test "[rsa3072] Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign" var message = "message to sign"
var kp = RsaKeyPair.random(rng[], 3072).expect("RsaPrivateKey.random failed") var kp = RsaKeyPair.random(rng, 3072).expect("RsaPrivateKey.random failed")
var sig = kp.seckey.sign(message).expect("signature") var sig = kp.seckey.sign(message).expect("signature")
var sersk = kp.seckey.getBytes().expect("bytes") var sersk = kp.seckey.getBytes().expect("bytes")
var serpk = kp.pubkey.getBytes().expect("bytes") var serpk = kp.pubkey.getBytes().expect("bytes")
@ -503,7 +504,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa4096] Generate/Sign/Serialize/Deserialize/Verify test": test "[rsa4096] Generate/Sign/Serialize/Deserialize/Verify test":
when defined(release): when defined(release):
var message = "message to sign" var message = "message to sign"
var kp = RsaKeyPair.random(rng[], 4096).expect("RsaPrivateKey.random failed") var kp = RsaKeyPair.random(rng, 4096).expect("RsaPrivateKey.random failed")
var sig = kp.seckey.sign(message).expect("signature") var sig = kp.seckey.sign(message).expect("signature")
var sersk = kp.seckey.getBytes().expect("bytes") var sersk = kp.seckey.getBytes().expect("bytes")
var serpk = kp.pubkey.getBytes().expect("bytes") var serpk = kp.pubkey.getBytes().expect("bytes")
@ -588,7 +589,7 @@ suite "RSA 2048/3072/4096 test suite":
csig.verify(Messages[4 + (i + 1) mod 2], pubkey) == false csig.verify(Messages[4 + (i + 1) mod 2], pubkey) == false
test "[rsa512] not allowed test": test "[rsa512] not allowed test":
var key1 = RsaPrivateKey.random(rng[], 512) var key1 = RsaPrivateKey.random(rng, 512)
let prvser = fromHex(stripSpaces(NotAllowedPrivateKeys[0])) let prvser = fromHex(stripSpaces(NotAllowedPrivateKeys[0]))
let pubser = fromHex(stripSpaces(NotAllowedPublicKeys[0])) let pubser = fromHex(stripSpaces(NotAllowedPublicKeys[0]))
var key2 = RsaPrivateKey.init(prvser) var key2 = RsaPrivateKey.init(prvser)
@ -602,7 +603,7 @@ suite "RSA 2048/3072/4096 test suite":
key3.error == RsaKeyIncorrectError key3.error == RsaKeyIncorrectError
test "[rsa1024] not allowed test": test "[rsa1024] not allowed test":
var key1 = RsaPrivateKey.random(rng[], 1024) var key1 = RsaPrivateKey.random(rng, 1024)
let prvser = fromHex(stripSpaces(NotAllowedPrivateKeys[1])) let prvser = fromHex(stripSpaces(NotAllowedPrivateKeys[1]))
let pubser = fromHex(stripSpaces(NotAllowedPublicKeys[1])) let pubser = fromHex(stripSpaces(NotAllowedPublicKeys[1]))
var key2 = RsaPrivateKey.init(prvser) var key2 = RsaPrivateKey.init(prvser)

10
tests/testsecp256k1.nim
View File

@ -12,7 +12,9 @@
import unittest2 import unittest2
import ../libp2p/crypto/[crypto, secp] import ../libp2p/crypto/[crypto, secp]
let rng = newRng() import ../libp2p/utils/random/testrng
let rng = TestRng.new()
suite "Secp256k1 testing suite": suite "Secp256k1 testing suite":
const TestsCount = 20 const TestsCount = 20
@ -21,7 +23,7 @@ suite "Secp256k1 testing suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: SkPrivateKey var rkey1, rkey2: SkPrivateKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var key = SkPrivateKey.random(rng[]) var key = SkPrivateKey.random(rng)
var skey1 = key.getBytes() var skey1 = key.getBytes()
check: check:
key.toBytes(skey2).expect("bytes len") > 0 key.toBytes(skey2).expect("bytes len") > 0
@ -39,7 +41,7 @@ suite "Secp256k1 testing suite":
for i in 0..<TestsCount: for i in 0..<TestsCount:
var rkey1, rkey2: SkPublicKey var rkey1, rkey2: SkPublicKey
var skey2 = newSeq[byte](256) var skey2 = newSeq[byte](256)
var pair = SkKeyPair.random(rng[]) var pair = SkKeyPair.random(rng)
var skey1 = pair.pubkey.getBytes() var skey1 = pair.pubkey.getBytes()
check: check:
pair.pubkey.toBytes(skey2).expect("bytes len") > 0 pair.pubkey.toBytes(skey2).expect("bytes len") > 0
@ -55,7 +57,7 @@ suite "Secp256k1 testing suite":
test "Generate/Sign/Serialize/Deserialize/Verify test": test "Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign" var message = "message to sign"
for i in 0..<TestsCount: for i in 0..<TestsCount:
var kp = SkKeyPair.random(rng[]) var kp = SkKeyPair.random(rng)
var sig = kp.seckey.sign(message) var sig = kp.seckey.sign(message)
var sersk = kp.seckey.getBytes() var sersk = kp.seckey.getBytes()
var serpk = kp.pubkey.getBytes() var serpk = kp.pubkey.getBytes()

16
tests/testsigned_envelope.nim
View File

@ -13,11 +13,14 @@ import unittest2
import stew/byteutils import stew/byteutils
import ../libp2p/[signed_envelope] import ../libp2p/[signed_envelope]
import ../libp2p/utils/random/testrng
let rng = TestRng.new()
suite "Signed envelope": suite "Signed envelope":
test "Encode -> decode -> encode -> decode test": test "Encode -> decode -> encode -> decode test":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
envelope = Envelope.init(privKey, @[byte 12, 0], "payload".toBytes(), "domain").tryGet() envelope = Envelope.init(privKey, @[byte 12, 0], "payload".toBytes(), "domain").tryGet()
buffer = envelope.encode().tryGet() buffer = envelope.encode().tryGet()
decodedEnvelope = Envelope.decode(buffer, "domain").tryGet() decodedEnvelope = Envelope.decode(buffer, "domain").tryGet()
@ -67,8 +70,7 @@ proc payloadType*(T: typedesc[DummyPayload]): seq[byte] = @[(byte) 0x00, (byte)
suite "Signed payload": suite "Signed payload":
test "Simple encode -> decode": test "Simple encode -> decode":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
dummyPayload = DummyPayload(awesome: 12.byte) dummyPayload = DummyPayload(awesome: 12.byte)
signed = SignedDummy.init(privKey, dummyPayload).tryGet() signed = SignedDummy.init(privKey, dummyPayload).tryGet()
@ -81,8 +83,7 @@ suite "Signed payload":
test "Invalid payload": test "Invalid payload":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
dummyPayload = DummyPayload(awesome: 30.byte) dummyPayload = DummyPayload(awesome: 30.byte)
signed = SignedDummy.init(privKey, dummyPayload).tryGet() signed = SignedDummy.init(privKey, dummyPayload).tryGet()
@ -91,8 +92,7 @@ suite "Signed payload":
test "Invalid payload type": test "Invalid payload type":
let let
rng = newRng() privKey = PrivateKey.random(rng).tryGet()
privKey = PrivateKey.random(rng[]).tryGet()
dummyPayload = DummyPayload(awesome: 30.byte) dummyPayload = DummyPayload(awesome: 30.byte)
signed = Envelope.init(privKey, @[55.byte], dummyPayload.encode(), DummyPayload.payloadDomain).tryGet() signed = Envelope.init(privKey, @[55.byte], dummyPayload.encode(), DummyPayload.payloadDomain).tryGet()

17
tests/testswitch.nim
View File

@ -508,9 +508,8 @@ suite "Switch":
asyncTest "e2e should trigger peer events only once per peer": asyncTest "e2e should trigger peer events only once per peer":
let switch1 = newStandardSwitch() let switch1 = newStandardSwitch()
let rng = crypto.newRng()
# use same private keys to emulate two connection from same peer # use same private keys to emulate two connection from same peer
let privKey = PrivateKey.random(rng[]).tryGet() let privKey = PrivateKey.random(rng).tryGet()
let switch2 = newStandardSwitch( let switch2 = newStandardSwitch(
privKey = some(privKey), privKey = some(privKey),
rng = rng) rng = rng)
@ -572,10 +571,9 @@ suite "Switch":
switch3.stop()) switch3.stop())
asyncTest "e2e should allow dropping peer from connection events": asyncTest "e2e should allow dropping peer from connection events":
let rng = crypto.newRng()
# use same private keys to emulate two connection from same peer # use same private keys to emulate two connection from same peer
let let
privateKey = PrivateKey.random(rng[]).tryGet() privateKey = PrivateKey.random(rng).tryGet()
peerInfo = PeerInfo.new(privateKey) peerInfo = PeerInfo.new(privateKey)
var switches: seq[Switch] var switches: seq[Switch]
@ -609,10 +607,9 @@ suite "Switch":
switches.mapIt( it.stop() )) switches.mapIt( it.stop() ))
asyncTest "e2e should allow dropping multiple connections for peer from connection events": asyncTest "e2e should allow dropping multiple connections for peer from connection events":
let rng = crypto.newRng()
# use same private keys to emulate two connection from same peer # use same private keys to emulate two connection from same peer
let let
privateKey = PrivateKey.random(rng[]).tryGet() privateKey = PrivateKey.random(rng).tryGet()
peerInfo = PeerInfo.new(privateKey) peerInfo = PeerInfo.new(privateKey)
var conns = 1 var conns = 1
@ -671,7 +668,7 @@ suite "Switch":
await switch.start() await switch.start()
var peerId = PeerId.init(PrivateKey.random(ECDSA, rng[]).get()).get() var peerId = randomPeerId()
expect DialFailedError: expect DialFailedError:
await switch.connect(peerId, transport.addrs) await switch.connect(peerId, transport.addrs)
@ -723,7 +720,7 @@ suite "Switch":
let switch2 = newStandardSwitch(secureManagers = [SecureProtocol.Noise]) let switch2 = newStandardSwitch(secureManagers = [SecureProtocol.Noise])
await switch2.start() await switch2.start()
let someAddr = MultiAddress.init("/ip4/127.128.0.99").get() let someAddr = MultiAddress.init("/ip4/127.128.0.99").get()
let seckey = PrivateKey.random(ECDSA, rng[]).get() let seckey = PrivateKey.random(ECDSA, rng).get()
let somePeer = PeerInfo.new(seckey, [someAddr]) let somePeer = PeerInfo.new(seckey, [someAddr])
expect(DialFailedError): expect(DialFailedError):
discard await switch2.dial(somePeer.peerId, somePeer.addrs, TestCodec) discard await switch2.dial(somePeer.peerId, somePeer.addrs, TestCodec)
@ -980,7 +977,7 @@ suite "Switch":
srcWsSwitch = srcWsSwitch =
SwitchBuilder.new() SwitchBuilder.new()
.withAddress(wsAddress) .withAddress(wsAddress)
.withRng(crypto.newRng()) .withRng(rng)
.withMplex() .withMplex()
.withTransport(proc (upgr: Upgrade): Transport = WsTransport.new(upgr)) .withTransport(proc (upgr: Upgrade): Transport = WsTransport.new(upgr))
.withNameResolver(resolver) .withNameResolver(resolver)
@ -990,7 +987,7 @@ suite "Switch":
destSwitch = destSwitch =
SwitchBuilder.new() SwitchBuilder.new()
.withAddresses(@[tcpAddress, wsAddress]) .withAddresses(@[tcpAddress, wsAddress])
.withRng(crypto.newRng()) .withRng(rng)
.withMplex() .withMplex()
.withTransport(proc (upgr: Upgrade): Transport = WsTransport.new(upgr)) .withTransport(proc (upgr: Upgrade): Transport = WsTransport.new(upgr))
.withTcpTransport() .withTcpTransport()

5
tests/testtortransport.nim
View File

@ -18,7 +18,8 @@ import ../libp2p/[stream/connection,
transports/tortransport, transports/tortransport,
upgrademngrs/upgrade, upgrademngrs/upgrade,
multiaddress, multiaddress,
builders] builders,
utils/random/testrng]
import ./helpers, ./stubs/torstub, ./commontransport import ./helpers, ./stubs/torstub, ./commontransport
@ -98,7 +99,7 @@ suite "Tor transport":
return T.new(codecs = @[TestCodec], handler = handle) return T.new(codecs = @[TestCodec], handler = handle)
let rng = newRng() let rng = TestRng.new()
let ma = MultiAddress.init("/ip4/127.0.0.1/tcp/8080/onion3/a2mncbqsbullu7thgm4e6zxda2xccmcgzmaq44oayhdtm6rav5vovcad:80").tryGet() let ma = MultiAddress.init("/ip4/127.0.0.1/tcp/8080/onion3/a2mncbqsbullu7thgm4e6zxda2xccmcgzmaq44oayhdtm6rav5vovcad:80").tryGet()