vacp2p/nim-libp2p
1
0
Fork 0
mirror of https://github.com/vacp2p/nim-libp2p.git synced 2025-03-01 08:30:29 +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],
connmanager, upgrademngrs/muxedupgrade, observedaddrmanager,
nameresolving/nameresolver,
errors, utility
errors, utility, utils/random/securerng
export
switch, peerid, peerinfo, connection, multiaddress, crypto, errors
@ -44,7 +44,7 @@ type
secureManagers: seq[SecureProtocol]
muxers: seq[MuxerProvider]
transports: seq[TransportProvider]
rng: ref HmacDrbgContext
rng: Rng
maxConnections: int
maxIn: int
sendSignedPeerRecord: bool
@ -149,7 +149,7 @@ proc withTransport*(b: SwitchBuilder, prov: TransportProvider): SwitchBuilder {.
proc withTcpTransport*(b: SwitchBuilder, flags: set[ServerFlags] = {}): SwitchBuilder {.public.} =
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
@ -215,7 +215,7 @@ proc build*(b: SwitchBuilder): Switch
if b.rng == nil: # newRng could fail
raise newException(Defect, "Cannot initialize RNG")
let pkRes = PrivateKey.random(b.rng[])
let pkRes = PrivateKey.random(b.rng)
let
seckey = b.privKey.get(otherwise = pkRes.expect("Expected default Private Key"))
@ -253,7 +253,7 @@ proc build*(b: SwitchBuilder): Switch
b.secureManagers &= SecureProtocol.Noise
if isNil(b.rng):
b.rng = newRng()
b.rng = SecureRng.new()
let peerStore = block:
b.peerStoreCapacity.withValue(capacity):
@ -297,7 +297,7 @@ proc newStandardSwitch*(
SecureProtocol.Noise,
],
transportFlags: set[ServerFlags] = {},
rng = newRng(),
rng: Rng = SecureRng.new(),
inTimeout: Duration = 5.minutes,
outTimeout: Duration = 5.minutes,
maxConnections = MaxConnections,

8
libp2p/crypto/crypto.nim
View File

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

8
libp2p/crypto/curve25519.nim
View File

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

11
libp2p/crypto/ecnist.nim
View File

@ -23,6 +23,7 @@ import minasn1
export minasn1.Asn1Error
import stew/[results, ctops]
import ../utils/random/rng
import ../utility
export results
@ -233,7 +234,7 @@ proc clear*[T: EcPKI|EcKeyPair](pki: var T) =
proc random*(
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
## algorithm.
##
@ -241,7 +242,7 @@ proc random*(
## secp521r1).
var ecimp = ecGetDefault()
var res = new EcPrivateKey
if ecKeygen(addr rng.vtable, ecimp,
if ecKeygen(rng.vtable, ecimp,
addr res.key, addr res.buffer[0],
safeConvert[cint](kind)) == 0:
err(EcKeyGenError)
@ -267,7 +268,7 @@ proc getPublicKey*(seckey: EcPrivateKey): EcResult[EcPublicKey] =
proc random*(
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
## HMAC-SHA256-DRBG algorithm.
##
@ -999,7 +1000,7 @@ type ECDHEScheme* = EcCurveKind
proc ephemeral*(
scheme: ECDHEScheme,
rng: var HmacDrbgContext): EcResult[EcKeyPair] =
rng: Rng): EcResult[EcKeyPair] =
## Generate ephemeral keys used to perform ECDHE.
var keypair: EcKeyPair
if scheme == Secp256r1:
@ -1011,7 +1012,7 @@ proc ephemeral*(
ok(keypair)
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.
##
## 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 ../../utility
import ../../utils/random/rng
export results
export results, rng
# This workaround needed because of some bugs in Nim Static[T].
export hash, sha2, rand
@ -1648,14 +1649,14 @@ proc checkScalar*(scalar: openArray[byte]): uint32 =
c = -1
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
var
point: GeP3
pk: array[EdPublicKeySize, byte]
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))
hh.data[0] = hh.data[0] and 0xF8'u8
@ -1667,14 +1668,14 @@ proc random*(t: typedesc[EdPrivateKey], rng: var HmacDrbgContext): EdPrivateKey
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
## CSPRNG.
var
point: GeP3
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))
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]
# We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
import nimcrypto/utils as ncrutils
import ../utils/random/rng
export Asn1Error, results
@ -115,7 +116,7 @@ template trimZeroes(b: seq[byte], pt, ptlen: untyped) =
pt = cast[ptr byte](cast[uint](pt) + 1)
ptlen -= 1
proc random*[T: RsaKP](t: typedesc[T], rng: var HmacDrbgContext,
proc random*[T: RsaKP](t: typedesc[T], rng: Rng,
bits = DefaultKeySize,
pubexp = DefaultPublicExponent): RsaResult[T] =
## 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()
if keygen(addr rng.vtable,
if keygen(rng.vtable,
addr res.seck, addr res.buffer[sko],
addr res.pubk, addr res.buffer[pko],
cuint(bits), pubexp) == 0:

12
libp2p/crypto/secp.nim
View File

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

5
libp2p/peerid.nim
View File

@ -20,6 +20,7 @@ import
utility,
./crypto/crypto, ./multicodec, ./multihash, ./vbuffer,
./protobuf/minprotobuf
import utils/random/securerng
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``.
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.
let randomKey = PrivateKey.random(Secp256k1, rng[])[]
let randomKey = PrivateKey.random(Secp256k1, rng)[]
PeerId.init(randomKey).orError(cstring("failed to generate random key"))
func match*(pid: PeerId, pubkey: PublicKey): bool =

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

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

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

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

7
libp2p/services/autorelayservice.nim
View File

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

5
libp2p/transports/tortransport.nim
View File

@ -21,7 +21,8 @@ import transport,
../builders,
../stream/[lpstream, connection, chronosstream],
../multiaddress,
../upgrademngrs/upgrade
../upgrademngrs/upgrade,
../utils/random/rng
const
IPTcp = mapAnd(IP, mapEq("tcp"))
@ -252,7 +253,7 @@ type
proc new*(
T: typedesc[TorSwitch],
torServer: TransportAddress,
rng: ref HmacDrbgContext,
rng: Rng,
addresses: seq[MultiAddress] = @[],
flags: set[ServerFlags] = {}): TorSwitch
{.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/switch
import ../libp2p/nameresolving/[nameresolver, mockresolver]
import ../libp2p/utils/random/testrng
import "."/[asyncunit, errorhelpers]
export asyncunit, errorhelpers, mockresolver
@ -72,8 +73,8 @@ proc getRng(): ref HmacDrbgContext =
rngVar.rng = newRng()
rngVar.rng
template rng*(): ref HmacDrbgContext =
getRng()
template rng*(): Rng =
TestRng.new()
type
WriteHandler* = proc(
@ -221,3 +222,6 @@ proc setDNSAddr*(switch: Switch) {.async.} =
return @[MultiAddress.init("/dns4/localhost/").tryGet() & listenAddrs[0][1].tryGet()]
switch.peerInfo.addressMappers.add(addressMapper)
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()
proc randomPeerId(): PeerId =
PeerId.init(PrivateKey.random(ECDSA, rng[]).get()).get()
const MsgIdGenSuccess = "msg id generation success"

2
tests/testautonat.nim
View File

@ -25,7 +25,7 @@ import
proc createAutonatSwitch(nameResolver: NameResolver = nil): Switch =
var builder = SwitchBuilder.new()
.withRng(newRng())
.withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport()
.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 =
var builder = SwitchBuilder.new()
.withRng(newRng())
.withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport()
.withMaxConnsPerPeer(maxConnsPerPeer)
@ -50,7 +50,7 @@ suite "Autonat Service":
let autonatClientStub = AutonatClientStub.new(expectedDials = 3)
autonatClientStub.answer = NotReachable
let autonatService = AutonatService.new(autonatClientStub, newRng())
let autonatService = AutonatService.new(autonatClientStub, rng())
let switch1 = createSwitch(autonatService)
let switch2 = createSwitch()
@ -78,7 +78,7 @@ suite "Autonat Service":
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 switch2 = createSwitch()
@ -122,7 +122,7 @@ suite "Autonat Service":
let autonatClientStub = AutonatClientStub.new(expectedDials = 6)
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 switch2 = createSwitch()
@ -164,7 +164,7 @@ suite "Autonat Service":
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 switch2 = createSwitch(withAutonat = false)
@ -204,7 +204,7 @@ suite "Autonat Service":
let autonatClientStub = AutonatClientStub.new(expectedDials = 6)
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 switch2 = createSwitch()
@ -247,7 +247,7 @@ suite "Autonat Service":
asyncTest "Calling setup and stop twice must work":
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)) == false
@ -258,7 +258,7 @@ suite "Autonat Service":
await allFuturesThrowing(switch.stop())
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)
await switch1.setDNSAddr()
@ -290,9 +290,9 @@ suite "Autonat Service":
switch1.stop(), switch2.stop())
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 autonatService2 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3)
let autonatService3 = 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(), rng(), 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 switch2 = createSwitch(autonatService2, maxConnsPerPeer = 0)
@ -337,8 +337,8 @@ suite "Autonat Service":
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":
let autonatService1 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3)
let autonatService2 = 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(), rng(), Opt.some(500.millis), maxQueueSize = 3)
let switch1 = createSwitch(autonatService1, maxConnsPerPeer = 0)
let switch2 = createSwitch(autonatService2, maxConnsPerPeer = 0)
@ -378,7 +378,7 @@ suite "Autonat Service":
switch1.stop(), switch2.stop())
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 switch2 = createSwitch()
@ -423,7 +423,7 @@ suite "Autonat Service":
switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop(), switch5.stop())
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 switch2 = createSwitch()

8
tests/testautorelay.nim
View File

@ -19,7 +19,7 @@ import ./helpers
proc createSwitch(r: Relay, autorelay: Service = nil): Switch =
var builder = SwitchBuilder.new()
.withRng(newRng())
.withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport()
.withMplex()
@ -52,7 +52,7 @@ suite "Autorelay":
check: addresses[0] == buildRelayMA(switchRelay, switchClient)
check: addresses.len() == 1
fut.complete()
autorelay = AutoRelayService.new(3, relayClient, checkMA, newRng())
autorelay = AutoRelayService.new(3, relayClient, checkMA, rng())
switchClient = createSwitch(relayClient, autorelay)
await allFutures(switchClient.start(), switchRelay.start())
await switchClient.connect(switchRelay.peerInfo.peerId, switchRelay.peerInfo.addrs)
@ -70,7 +70,7 @@ suite "Autorelay":
proc checkMA(address: seq[MultiAddress]) =
check: address[0] == buildRelayMA(switchRelay, switchClient)
fut.complete()
let autorelay = AutoRelayService.new(3, relayClient, checkMA, newRng())
let autorelay = AutoRelayService.new(3, relayClient, checkMA, rng())
switchClient = createSwitch(relayClient, autorelay)
await allFutures(switchClient.start(), switchRelay.start())
await sleepAsync(500.millis)
@ -112,7 +112,7 @@ suite "Autorelay":
addresses.len() == 2
state += 1
fut.complete()
let autorelay = AutoRelayService.new(2, relayClient, checkMA, newRng())
let autorelay = AutoRelayService.new(2, relayClient, checkMA, rng())
switchClient = createSwitch(relayClient, autorelay)
await allFutures(switchClient.start(), rel1.start(), rel2.start(), rel3.start())
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":
let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
let mux = getMuxer(peerId)
connMngr.storeMuxer(mux)
@ -69,7 +69,7 @@ suite "Connection Manager":
asyncTest "shouldn't allow a closed connection":
let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
let mux = getMuxer(peerId)
await mux.connection.close()
@ -80,7 +80,7 @@ suite "Connection Manager":
asyncTest "shouldn't allow an EOFed connection":
let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
let mux = getMuxer(peerId)
mux.connection.isEof = true
@ -92,7 +92,7 @@ suite "Connection Manager":
asyncTest "shouldn't allow a muxer with no connection":
let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
let muxer = getMuxer(peerId)
let conn = muxer.connection
muxer.connection = nil
@ -107,7 +107,7 @@ suite "Connection Manager":
asyncTest "get conn with direction":
# 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 peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
let mux1 = getMuxer(peerId, Direction.Out)
let mux2 = getMuxer(peerId)
@ -129,7 +129,7 @@ suite "Connection Manager":
asyncTest "get muxed stream for peer":
let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
let muxer = new TestMuxer
let connection = Connection.new(peerId, Direction.In, Opt.none(MultiAddress))
@ -149,7 +149,7 @@ suite "Connection Manager":
asyncTest "get stream from directed connection":
let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
let muxer = new TestMuxer
let connection = Connection.new(peerId, Direction.In, Opt.none(MultiAddress))
@ -170,7 +170,7 @@ suite "Connection Manager":
asyncTest "should raise on too many connections":
let connMngr = ConnManager.new(maxConnsPerPeer = 0)
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
connMngr.storeMuxer(getMuxer(peerId))
@ -187,7 +187,7 @@ suite "Connection Manager":
asyncTest "expect connection from peer":
# FIXME This should be 1 instead of 0, it will get fixed soon
let connMngr = ConnManager.new(maxConnsPerPeer = 0)
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
connMngr.storeMuxer(getMuxer(peerId))
@ -206,7 +206,7 @@ suite "Connection Manager":
await waitedConn1.cancelAndWait()
let
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)
connMngr.storeMuxer(conn)
check (await waitedConn2) == conn
@ -223,7 +223,7 @@ suite "Connection Manager":
asyncTest "cleanup on connection close":
let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
let muxer = getMuxer(peerId)
connMngr.storeMuxer(muxer)
@ -238,7 +238,7 @@ suite "Connection Manager":
asyncTest "drop connections for peer":
let connMngr = ConnManager.new()
let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
let peerId = randomPeerId()
for i in 0..<2:
let dir = if i mod 2 == 0:
@ -373,7 +373,7 @@ suite "Connection Manager":
let muxer =
getMuxer(
PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet(),
randomPeerId(),
Direction.In)
slot.trackMuxer(muxer)

15
tests/testcrypto.nim
View File

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

2
tests/testdiscovery.nim
View File

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

34
tests/testecnist.nim
View File

@ -14,6 +14,8 @@ import nimcrypto/utils
import ../libp2p/crypto/[crypto, ecnist]
import stew/results
import ../libp2p/utils/random/securerng
const
TestsCount = 10 # number of random tests
@ -295,14 +297,14 @@ const
35ab"""
]
let rng = newRng()
let rng = SecureRng.new()
suite "EC NIST-P256/384/521 test suite":
test "[secp256r1] Private key serialize/deserialize test":
for i in 0..<TestsCount:
var rkey1, rkey2: EcPrivateKey
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")
check:
key.toBytes(skey2).expect("bytes") > 0
@ -324,7 +326,7 @@ suite "EC NIST-P256/384/521 test suite":
for i in 0..<TestsCount:
var rkey1, rkey2: EcPublicKey
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")
check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -343,8 +345,8 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp256r1] ECDHE test":
for i in 0..<TestsCount:
var kp1 = EcKeyPair.random(Secp256r1, rng[]).expect("random key")
var kp2 = 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 shared1 = kp2.pubkey.scalarMul(kp1.seckey)
var shared2 = kp1.pubkey.scalarMul(kp2.seckey)
check:
@ -398,7 +400,7 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp256r1] Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign"
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 sersk = kp.seckey.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:
var rkey1, rkey2: EcPrivateKey
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")
check:
key.toBytes(skey2).expect("bytes") > 0
@ -437,7 +439,7 @@ suite "EC NIST-P256/384/521 test suite":
for i in 0..<TestsCount:
var rkey1, rkey2: EcPublicKey
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")
check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -456,8 +458,8 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp384r1] ECDHE test":
for i in 0..<TestsCount:
var kp1 = EcKeyPair.random(Secp384r1, rng[]).expect("random key")
var kp2 = 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 shared1 = kp2.pubkey.scalarMul(kp1.seckey)
var shared2 = kp1.pubkey.scalarMul(kp2.seckey)
check:
@ -511,7 +513,7 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp384r1] Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign"
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 sersk = kp.seckey.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:
var rkey1, rkey2: EcPrivateKey
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")
check:
key.toBytes(skey2).expect("bytes") > 0
@ -550,7 +552,7 @@ suite "EC NIST-P256/384/521 test suite":
for i in 0..<TestsCount:
var rkey1, rkey2: EcPublicKey
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")
check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -569,8 +571,8 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp521r1] ECDHE test":
for i in 0..<TestsCount:
var kp1 = EcKeyPair.random(Secp521r1, rng[]).expect("random key")
var kp2 = 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 shared1 = kp2.pubkey.scalarMul(kp1.seckey)
var shared2 = kp1.pubkey.scalarMul(kp2.seckey)
check:
@ -624,7 +626,7 @@ suite "EC NIST-P256/384/521 test suite":
test "[secp521r1] Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign"
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 sersk = kp.seckey.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 ../libp2p/crypto/crypto
import ../libp2p/crypto/ed25519/ed25519
import ../libp2p/utils/random/testrng
const TestsCount = 20
@ -101,7 +102,7 @@ const GoodScalars = [
"ECD3F55C1A631258D69CF7A2DEF9DE1400000000000000000000000000000010",
]
let rng = newRng()
let rng = TestRng.new()
suite "Ed25519 test suite":
test "Scalar check edge cases test":
@ -114,7 +115,7 @@ suite "Ed25519 test suite":
for i in 0..<TestsCount:
var rkey1, rkey2: EdPrivateKey
var skey2 = newSeq[byte](256)
var key = EdPrivateKey.random(rng[])
var key = EdPrivateKey.random(rng)
var skey1 = key.getBytes()
check:
key.toBytes(skey2) > 0
@ -138,7 +139,7 @@ suite "Ed25519 test suite":
for i in 0..<TestsCount:
var rkey1, rkey2: EdPublicKey
var skey2 = newSeq[byte](256)
var pair = EdKeyPair.random(rng[])
var pair = EdKeyPair.random(rng)
var skey1 = pair.pubkey.getBytes()
check:
pair.pubkey.toBytes(skey2) > 0
@ -174,7 +175,7 @@ suite "Ed25519 test suite":
test "Generate/Sign/Serialize/Deserialize/Verify test":
var message = "message to sign"
for i in 0..<TestsCount:
var kp = EdKeyPair.random(rng[])
var kp = EdKeyPair.random(rng)
var sig = kp.seckey.sign(message)
var sersk = kp.seckey.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].} =
var builder = SwitchBuilder.new()
.withRng(newRng())
.withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport()
.withMplex()
@ -58,7 +58,7 @@ suite "Hole Punching":
asyncTest "Direct connection must work when peer address is public":
let autonatClientStub = AutonatClientStub.new(expectedDials = 1)
autonatClientStub.answer = NotReachable
let autonatService = AutonatService.new(autonatClientStub, newRng(), maxQueueSize = 1)
let autonatService = AutonatService.new(autonatClientStub, rng(), maxQueueSize = 1)
let relayClient = RelayClient.new()
let privatePeerRelayAddr = newFuture[seq[MultiAddress]]()
@ -74,7 +74,7 @@ suite "Hole Punching":
if not privatePeerRelayAddr.completed():
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)
@ -100,7 +100,7 @@ suite "Hole Punching":
let autonatClientStub = AutonatClientStub.new(expectedDials = 1)
autonatClientStub.answer = NotReachable
let autonatService = AutonatService.new(autonatClientStub, newRng(), maxQueueSize = 1)
let autonatService = AutonatService.new(autonatClientStub, rng(), maxQueueSize = 1)
let relayClient = RelayClient.new()
let privatePeerRelayAddr = newFuture[seq[MultiAddress]]()
@ -112,7 +112,7 @@ suite "Hole Punching":
if not privatePeerRelayAddr.completed():
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)
@ -140,11 +140,11 @@ suite "Hole Punching":
let autonatClientStub1 = AutonatClientStub.new(expectedDials = 1)
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)
autonatClientStub2.answer = answer
let autonatService2 = AutonatService.new(autonatClientStub2, newRng(), maxQueueSize = 1)
let autonatService2 = AutonatService.new(autonatClientStub2, rng(), maxQueueSize = 1)
let relayClient1 = RelayClient.new()
let relayClient2 = RelayClient.new()
@ -154,8 +154,8 @@ suite "Hole Punching":
if not privatePeerRelayAddr1.completed():
privatePeerRelayAddr1.complete(address)
let autoRelayService1 = AutoRelayService.new(1, relayClient1, checkMA, newRng())
let autoRelayService2 = AutoRelayService.new(1, relayClient2, nil, newRng())
let autoRelayService1 = AutoRelayService.new(1, relayClient1, checkMA, rng())
let autoRelayService2 = AutoRelayService.new(1, relayClient2, nil, rng())
let hpservice1 = HPService.new(autonatService1, autoRelayService1)
let hpservice2 = HPService.new(autonatService2, autoRelayService2)

6
tests/testidentify.nim
View File

@ -46,7 +46,7 @@ suite "Identify":
asyncSetup:
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(
remoteSecKey,
ma,
@ -129,7 +129,7 @@ suite "Identify":
conn = await transport2.dial(transport1.addrs[0])
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 identifyProto2.identify(conn, pi2.peerId)
@ -240,7 +240,7 @@ suite "Identify":
switch1.peerStore[ProtoBook][switch2.peerInfo.peerId] != switch2.peerInfo.protocols
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)

4
tests/testinterop.nim
View File

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

41
tests/testnoise.nim
View File

@ -29,7 +29,8 @@ import ../libp2p/[switch,
protocols/secure/plaintext,
protocols/secure/secure,
upgrademngrs/muxedupgrade,
connmanager]
connmanager,
utils/random/rng]
import ./helpers
const
@ -55,7 +56,7 @@ method init(p: TestProto) {.gcsafe.} =
proc createSwitch(ma: MultiAddress; outgoing: bool, plaintext: bool = false): (Switch, PeerInfo) =
var
privateKey = PrivateKey.random(ECDSA, rng[]).get()
privateKey = PrivateKey.random(ECDSA, rng()).get()
peerInfo = PeerInfo.new(privateKey, @[ma])
proc createMplex(conn: Connection): Muxer =
@ -69,7 +70,7 @@ proc createSwitch(ma: MultiAddress; outgoing: bool, plaintext: bool = false): (S
secureManagers = if plaintext:
[Secure(PlainText.new())]
else:
[Secure(Noise.new(rng, privateKey, outgoing = outgoing))]
[Secure(Noise.new(rng(), privateKey, outgoing = outgoing))]
connManager = ConnManager.new()
ms = MultistreamSelect.new()
muxedUpgrade = MuxedUpgrade.new(muxers, secureManagers, ms)
@ -91,9 +92,9 @@ suite "Noise":
asyncTest "e2e: handle write + noise":
let
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)
serverNoise = Noise.new(rng, serverPrivKey, outgoing = false)
serverNoise = Noise.new(rng(), serverPrivKey, outgoing = false)
let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
asyncSpawn transport1.start(server)
@ -110,9 +111,9 @@ suite "Noise":
let
acceptFut = acceptHandler()
transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
clientPrivKey = PrivateKey.random(ECDSA, rng[]).get()
clientPrivKey = PrivateKey.random(ECDSA, rng()).get()
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])
let sconn = await clientNoise.secure(conn, Opt.some(serverInfo.peerId))
@ -131,9 +132,9 @@ suite "Noise":
asyncTest "e2e: handle write + noise (wrong prologue)":
let
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)
serverNoise = Noise.new(rng, serverPrivKey, outgoing = false)
serverNoise = Noise.new(rng(), serverPrivKey, outgoing = false)
let
transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
@ -153,9 +154,9 @@ suite "Noise":
let
handlerWait = acceptHandler()
transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
clientPrivKey = PrivateKey.random(ECDSA, rng[]).get()
clientPrivKey = PrivateKey.random(ECDSA, rng()).get()
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])
var sconn: Connection = nil
@ -170,9 +171,9 @@ suite "Noise":
asyncTest "e2e: handle read + noise":
let
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)
serverNoise = Noise.new(rng, serverPrivKey, outgoing = false)
serverNoise = Noise.new(rng(), serverPrivKey, outgoing = false)
readTask = newFuture[void]()
let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
@ -192,9 +193,9 @@ suite "Noise":
let
acceptFut = acceptHandler()
transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
clientPrivKey = PrivateKey.random(ECDSA, rng[]).get()
clientPrivKey = PrivateKey.random(ECDSA, rng()).get()
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])
let sconn = await clientNoise.secure(conn, Opt.some(serverInfo.peerId))
@ -208,13 +209,13 @@ suite "Noise":
asyncTest "e2e: handle read + noise fragmented":
let
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)
serverNoise = Noise.new(rng, serverPrivKey, outgoing = false)
serverNoise = Noise.new(rng(), serverPrivKey, outgoing = false)
readTask = newFuture[void]()
var hugePayload = newSeq[byte](0xFFFFF)
hmacDrbgGenerate(rng[], hugePayload)
rng().generate(hugePayload)
trace "Sending huge payload", size = hugePayload.len
let
@ -233,9 +234,9 @@ suite "Noise":
let
acceptFut = acceptHandler()
transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
clientPrivKey = PrivateKey.random(ECDSA, rng[]).get()
clientPrivKey = PrivateKey.random(ECDSA, rng()).get()
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])
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
import unittest2
import nimcrypto/utils, stew/base58
import ../libp2p/crypto/crypto, ../libp2p/peerid
import ../libp2p/crypto/crypto, ../libp2p/peerid, ../libp2p/utils/random/testrng
import bearssl/hash
const
@ -237,15 +237,15 @@ suite "Peer testing suite":
ekey2 == pubkey
ekey3 == pubkey
ekey4 == pubkey
test "Test PeerId.random() proc":
# generate a random peer with a deterministic ssed
var rng = (ref HmacDrbgContext)()
hmacDrbgInit(rng[], addr sha256Vtable, nil, 0)
var randomPeer1 = PeerId.random(rng)
check:
$randomPeer1.get() == "16Uiu2HAmCxpSTFDNdWiu1MLScu7inPhcbbGfPvuvRPD1e51gw1Xr"
# generate a random peer with a new random seed
var randomPeer2 = PeerId.random()
check:
randomPeer2.isErr() != true
# test "Test PeerId.random() proc":
# # generate a random peer with a deterministic ssed
# var rng = (ref HmacDrbgContext)()
# hmacDrbgInit(rng[], addr sha256Vtable, nil, 0)
# var randomPeer1 = PeerId.random(TestRng.new())
# check:
# $randomPeer1.get() == "16Uiu2HAmCxpSTFDNdWiu1MLScu7inPhcbbGfPvuvRPD1e51gw1Xr"
#
# # generate a random peer with a new random seed
# var randomPeer2 = PeerId.random()
# check:
# randomPeer2.isErr() != true

6
tests/testpeerinfo.nim
View File

@ -21,7 +21,7 @@ import ./helpers
suite "PeerInfo":
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 peerId = PeerId.init(seckey).get()
@ -34,7 +34,7 @@ suite "PeerInfo":
ExpectedPayloadType = @[(byte) 0x03, (byte) 0x01]
let
seckey = PrivateKey.random(rng[]).tryGet()
seckey = PrivateKey.random(rng).tryGet()
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()]
peerInfo = PeerInfo.new(seckey, multiAddresses)
@ -61,7 +61,7 @@ suite "PeerInfo":
test "Public address mapping":
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()]
multiAddresses2 = @[MultiAddress.init("/ip4/8.8.8.8/tcp/33").tryGet()]

8
tests/testpeerstore.nim
View File

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

6
tests/testrelayv1.nim
View File

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

2
tests/testrelayv2.nim
View File

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

2
tests/testrendezvous.nim
View File

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

6
tests/testrendezvousinterface.nim
View File

@ -19,7 +19,7 @@ import ./helpers
proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch =
SwitchBuilder.new()
.withRng(newRng())
.withRng(rng())
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
.withTcpTransport()
.withMplex()
@ -67,7 +67,7 @@ suite "RendezVous Interface":
await client.stop()
asyncTest "Check timeToAdvertise interval":
await baseTimeToAdvertiseTest(MockRendezVous.new(newRng()))
await baseTimeToAdvertiseTest(MockRendezVous.new(rng()))
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 ../libp2p/[routing_record, crypto/crypto]
import ../libp2p/utils/random/testrng
let rng = TestRng.new()
suite "Routing record":
test "Encode -> decode test":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).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()]
routingRecord = PeerRecord.init(peerId, multiAddresses, 42)
@ -50,8 +53,7 @@ suite "Routing record":
suite "Signed Routing Record":
test "Encode -> decode test":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).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()]
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":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey2 = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).tryGet()
privKey2 = PrivateKey.random(rng).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()]
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":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).tryGet()
peerId = PeerId.init(privKey).tryGet()
multiAddresses = @[MultiAddress(), MultiAddress.init("/ip4/0.0.0.0/tcp/25").tryGet()]
routingRecord = PeerRecord.init(peerId, multiAddresses, 42)
@ -93,8 +93,7 @@ suite "Signed Routing Record":
test "Decode doesn't fail if there are no addresses":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).tryGet()
peerId = PeerId.init(privKey).tryGet()
multiAddresses = newSeq[MultiAddress]()
routingRecord = PeerRecord.init(peerId, multiAddresses, 42)
@ -106,8 +105,7 @@ suite "Signed Routing Record":
test "Decode fails if all addresses are invalid":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).tryGet()
peerId = PeerId.init(privKey).tryGet()
multiAddresses = @[MultiAddress(), MultiAddress()]
routingRecord = PeerRecord.init(peerId, multiAddresses, 42)

25
tests/testrsa.nim
View File

@ -12,6 +12,7 @@
import unittest2
import nimcrypto/utils
import ../libp2p/crypto/[crypto, rsa]
import ../libp2p/utils/random/testrng
const
NotAllowedPrivateKeys = [
@ -354,7 +355,7 @@ const
ACB51807206B8332127E3692269013B96F0CABD95D7431805E48176ADC5D1366"""
]
let rng = newRng()
let rng = TestRng.new()
type
RsaPrivateKey = rsa.RsaPrivateKey
@ -364,7 +365,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa2048] Private key serialize/deserialize test":
var rkey1, rkey2: RsaPrivateKey
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")
check key.toBytes(skey2).expect("bytes") > 0
check:
@ -381,7 +382,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa3072] Private key serialize/deserialize test":
var rkey1, rkey2: RsaPrivateKey
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")
check key.toBytes(skey2).expect("bytes") > 0
check:
@ -400,7 +401,7 @@ suite "RSA 2048/3072/4096 test suite":
when defined(release):
var rkey1, rkey2: RsaPrivateKey
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")
check key.toBytes(skey2).expect("bytes") > 0
check:
@ -419,7 +420,7 @@ suite "RSA 2048/3072/4096 test suite":
test "[rsa2048] Public key serialize/deserialize test":
var rkey1, rkey2: RsaPublicKey
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")
check:
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":
var rkey1, rkey2: RsaPublicKey
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")
check:
pair.pubkey.toBytes(skey2).expect("bytes") > 0
@ -454,7 +455,7 @@ suite "RSA 2048/3072/4096 test suite":
when defined(release):
var rkey1, rkey2: RsaPublicKey
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")
check:
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":
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 sersk = kp.seckey.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":
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 sersk = kp.seckey.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":
when defined(release):
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 sersk = kp.seckey.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
test "[rsa512] not allowed test":
var key1 = RsaPrivateKey.random(rng[], 512)
var key1 = RsaPrivateKey.random(rng, 512)
let prvser = fromHex(stripSpaces(NotAllowedPrivateKeys[0]))
let pubser = fromHex(stripSpaces(NotAllowedPublicKeys[0]))
var key2 = RsaPrivateKey.init(prvser)
@ -602,7 +603,7 @@ suite "RSA 2048/3072/4096 test suite":
key3.error == RsaKeyIncorrectError
test "[rsa1024] not allowed test":
var key1 = RsaPrivateKey.random(rng[], 1024)
var key1 = RsaPrivateKey.random(rng, 1024)
let prvser = fromHex(stripSpaces(NotAllowedPrivateKeys[1]))
let pubser = fromHex(stripSpaces(NotAllowedPublicKeys[1]))
var key2 = RsaPrivateKey.init(prvser)

10
tests/testsecp256k1.nim
View File

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

16
tests/testsigned_envelope.nim
View File

@ -13,11 +13,14 @@ import unittest2
import stew/byteutils
import ../libp2p/[signed_envelope]
import ../libp2p/utils/random/testrng
let rng = TestRng.new()
suite "Signed envelope":
test "Encode -> decode -> encode -> decode test":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).tryGet()
envelope = Envelope.init(privKey, @[byte 12, 0], "payload".toBytes(), "domain").tryGet()
buffer = envelope.encode().tryGet()
decodedEnvelope = Envelope.decode(buffer, "domain").tryGet()
@ -67,8 +70,7 @@ proc payloadType*(T: typedesc[DummyPayload]): seq[byte] = @[(byte) 0x00, (byte)
suite "Signed payload":
test "Simple encode -> decode":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).tryGet()
dummyPayload = DummyPayload(awesome: 12.byte)
signed = SignedDummy.init(privKey, dummyPayload).tryGet()
@ -81,8 +83,7 @@ suite "Signed payload":
test "Invalid payload":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).tryGet()
dummyPayload = DummyPayload(awesome: 30.byte)
signed = SignedDummy.init(privKey, dummyPayload).tryGet()
@ -91,8 +92,7 @@ suite "Signed payload":
test "Invalid payload type":
let
rng = newRng()
privKey = PrivateKey.random(rng[]).tryGet()
privKey = PrivateKey.random(rng).tryGet()
dummyPayload = DummyPayload(awesome: 30.byte)
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":
let switch1 = newStandardSwitch()
let rng = crypto.newRng()
# 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(
privKey = some(privKey),
rng = rng)
@ -572,10 +571,9 @@ suite "Switch":
switch3.stop())
asyncTest "e2e should allow dropping peer from connection events":
let rng = crypto.newRng()
# use same private keys to emulate two connection from same peer
let
privateKey = PrivateKey.random(rng[]).tryGet()
privateKey = PrivateKey.random(rng).tryGet()
peerInfo = PeerInfo.new(privateKey)
var switches: seq[Switch]
@ -609,10 +607,9 @@ suite "Switch":
switches.mapIt( it.stop() ))
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
let
privateKey = PrivateKey.random(rng[]).tryGet()
privateKey = PrivateKey.random(rng).tryGet()
peerInfo = PeerInfo.new(privateKey)
var conns = 1
@ -671,7 +668,7 @@ suite "Switch":
await switch.start()
var peerId = PeerId.init(PrivateKey.random(ECDSA, rng[]).get()).get()
var peerId = randomPeerId()
expect DialFailedError:
await switch.connect(peerId, transport.addrs)
@ -723,7 +720,7 @@ suite "Switch":
let switch2 = newStandardSwitch(secureManagers = [SecureProtocol.Noise])
await switch2.start()
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])
expect(DialFailedError):
discard await switch2.dial(somePeer.peerId, somePeer.addrs, TestCodec)
@ -980,7 +977,7 @@ suite "Switch":
srcWsSwitch =
SwitchBuilder.new()
.withAddress(wsAddress)
.withRng(crypto.newRng())
.withRng(rng)
.withMplex()
.withTransport(proc (upgr: Upgrade): Transport = WsTransport.new(upgr))
.withNameResolver(resolver)
@ -990,7 +987,7 @@ suite "Switch":
destSwitch =
SwitchBuilder.new()
.withAddresses(@[tcpAddress, wsAddress])
.withRng(crypto.newRng())
.withRng(rng)
.withMplex()
.withTransport(proc (upgr: Upgrade): Transport = WsTransport.new(upgr))
.withTcpTransport()

5
tests/testtortransport.nim
View File

@ -18,7 +18,8 @@ import ../libp2p/[stream/connection,
transports/tortransport,
upgrademngrs/upgrade,
multiaddress,
builders]
builders,
utils/random/testrng]
import ./helpers, ./stubs/torstub, ./commontransport
@ -98,7 +99,7 @@ suite "Tor transport":
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()