diff --git a/packages/crypto/benchmark/ed25519/compat.cjs b/packages/crypto/benchmark/ed25519/compat.cjs
index e8e31e4a47..1cee912180 100644
--- a/packages/crypto/benchmark/ed25519/compat.cjs
+++ b/packages/crypto/benchmark/ed25519/compat.cjs
@@ -21,7 +21,6 @@ const { fromString } = require('uint8arrays/from-string')
 
 const native = require('ed25519')
 const noble = require('@noble/ed25519')
-const { randomBytes } = noble.utils
 const { subtle } = require('crypto').webcrypto
 require('node-forge/lib/ed25519')
 const stable = require('@stablelib/ed25519')
@@ -61,7 +60,7 @@ const implementations = [{
   name: 'node-forge/ed25519',
   before: () => {},
   generateKeyPair: async () => {
-    const seed = randomBytes(32)
+    const seed = crypto.getRandomValues(new Uint8Array(32))
     const key = await forge.pki.ed25519.generateKeyPair({ seed })
 
     return {
@@ -100,7 +99,7 @@ const implementations = [{
 }, {
   name: 'native Ed25519',
   generateKeyPair: async () => {
-    const seed = randomBytes(32)
+    const seed = crypto.getRandomValues(new Uint8Array(32))
     const key = native.MakeKeypair(seed)
 
     return {
diff --git a/packages/crypto/benchmark/ed25519/index.js b/packages/crypto/benchmark/ed25519/index.js
index c0f554e8a8..c0eb4746b9 100644
--- a/packages/crypto/benchmark/ed25519/index.js
+++ b/packages/crypto/benchmark/ed25519/index.js
@@ -10,8 +10,6 @@ import supercopWasm from 'supercop.wasm'
 import ed25519WasmPro from 'ed25519-wasm-pro'
 import * as libp2pCrypto from '../../dist/src/index.js'
 
-const { randomBytes } = noble.utils
-
 const suite = new Benchmark.Suite('ed25519 implementations')
 
 suite.add('@libp2p/crypto', async (d) => {
@@ -58,7 +56,7 @@ suite.add('@stablelib/ed25519', async (d) => {
 
 suite.add('node-forge/ed25519', async (d) => {
   const message = Buffer.from('hello world ' + Math.random())
-  const seed = randomBytes(32)
+  const seed = crypto.getRandomValues(new Uint8Array(32))
   const key = await forge.pki.ed25519.generateKeyPair({ seed })
   const signature = await forge.pki.ed25519.sign({ message, privateKey: key.privateKey })
   const res = await forge.pki.ed25519.verify({ signature, message, publicKey: key.publicKey })
@@ -100,7 +98,7 @@ suite.add('ed25519-wasm-pro', async (d) => {
 
 suite.add('ed25519 (native module)', async (d) => {
   const message = Buffer.from('hello world ' + Math.random())
-  const seed = randomBytes(32)
+  const seed = crypto.getRandomValues(new Uint8Array(32))
   const key = native.MakeKeypair(seed)
   const signature = native.Sign(message, key)
   const res = native.Verify(message, signature, key.publicKey)
diff --git a/packages/crypto/src/random-bytes.ts b/packages/crypto/src/random-bytes.ts
index f74c11c248..d1d3817f00 100644
--- a/packages/crypto/src/random-bytes.ts
+++ b/packages/crypto/src/random-bytes.ts
@@ -1,12 +1,13 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import { randomBytes as randB } from '@noble/hashes/utils.js'
 
 /**
  * Generates a Uint8Array with length `number` populated by random bytes
+ *
+ * @deprecated use `crypto.getRandomValues()` instead
  */
 export default function randomBytes (length: number): Uint8Array {
   if (isNaN(length) || length <= 0) {
     throw new InvalidParametersError('random bytes length must be a Number bigger than 0')
   }
-  return randB(length)
+  return crypto.getRandomValues(new Uint8Array(length))
 }
diff --git a/packages/crypto/test/crypto.spec.ts b/packages/crypto/test/crypto.spec.ts
index f23ebcf8bf..07f252594b 100644
--- a/packages/crypto/test/crypto.spec.ts
+++ b/packages/crypto/test/crypto.spec.ts
@@ -5,7 +5,6 @@ import { base58btc } from 'multiformats/bases/base58'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { generateKeyPair, generateKeyPairFromSeed, privateKeyFromProtobuf, privateKeyToProtobuf, publicKeyFromProtobuf, publicKeyToProtobuf } from '../src/keys/index.ts'
 import pbkdf2 from '../src/pbkdf2.ts'
-import randomBytes from '../src/random-bytes.ts'
 import fixtures from './fixtures/go-key-rsa.ts'
 import type { RSAPrivateKey } from '@libp2p/interface'
 
@@ -39,7 +38,7 @@ describe('libp2p-crypto', function () {
   })
 
   it('generateKeyPairFromSeed', () => {
-    const seed = randomBytes(32)
+    const seed = crypto.getRandomValues(new Uint8Array(32))
 
     // @ts-expect-error key type is invalid
     return expect(generateKeyPairFromSeed('invalid-key-type', seed, 512)).to.eventually.be.rejected
@@ -131,14 +130,14 @@ describe('libp2p-crypto', function () {
   describe('randomBytes', () => {
     it('throws with invalid number passed', () => {
       expect(() => {
-        randomBytes(-1)
+        crypto.getRandomValues(new Uint8Array(-1))
       }).to.throw()
     })
 
     it('generates different random things', () => {
-      const buf1 = randomBytes(10)
+      const buf1 = crypto.getRandomValues(new Uint8Array(10))
       expect(buf1.length).to.equal(10)
-      const buf2 = randomBytes(10)
+      const buf2 = crypto.getRandomValues(new Uint8Array(10))
       expect(buf1).to.not.eql(buf2)
     })
   })
diff --git a/packages/crypto/test/keys/ecdsa.spec.ts b/packages/crypto/test/keys/ecdsa.spec.ts
index 1ebe5ed792..b512e5d2dd 100644
--- a/packages/crypto/test/keys/ecdsa.spec.ts
+++ b/packages/crypto/test/keys/ecdsa.spec.ts
@@ -4,7 +4,6 @@ import { expect } from 'aegir/chai'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { randomBytes } from '../../src/index.ts'
 import { unmarshalECDSAPrivateKey, unmarshalECDSAPublicKey } from '../../src/keys/ecdsa/utils.ts'
 import { privateKeyToCryptoKeyPair, generateKeyPair, privateKeyFromProtobuf, privateKeyFromRaw, publicKeyFromProtobuf, publicKeyFromRaw, privateKeyFromCryptoKeyPair } from '../../src/keys/index.ts'
 import { PrivateKey, PublicKey } from '../../src/keys/keys.ts'
@@ -33,7 +32,7 @@ describe('ECDSA', function () {
   })
 
   it('signs', async () => {
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = await key.sign(text)
     const res = await key.publicKey.verify(text, sig)
     expect(res).to.be.be.true()
@@ -42,7 +41,7 @@ describe('ECDSA', function () {
   it('should abort signing', async () => {
     const controller = new AbortController()
     controller.abort()
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     await expect((async () => {
       return key.sign(text, {
         signal: controller.signal
@@ -54,7 +53,7 @@ describe('ECDSA', function () {
   it('should abort verifying', async () => {
     const controller = new AbortController()
     controller.abort()
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = await key.sign(text)
 
     await expect((async () => {
@@ -67,8 +66,8 @@ describe('ECDSA', function () {
 
   it('signs a list', async () => {
     const text = new Uint8ArrayList(
-      randomBytes(512),
-      randomBytes(512)
+      crypto.getRandomValues(new Uint8Array(512)),
+      crypto.getRandomValues(new Uint8Array(512))
     )
     const sig = await key.sign(text)
     const sig2 = await key.sign(text.subarray())
diff --git a/packages/crypto/test/keys/ed25519.spec.ts b/packages/crypto/test/keys/ed25519.spec.ts
index c7624d5fad..7206e5e42f 100644
--- a/packages/crypto/test/keys/ed25519.spec.ts
+++ b/packages/crypto/test/keys/ed25519.spec.ts
@@ -3,7 +3,6 @@ import { isPrivateKey, isPublicKey } from '@libp2p/interface'
 import { expect } from 'aegir/chai'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { randomBytes } from '../../src/index.ts'
 import { hashAndSignNoble, hashAndVerifyNoble } from '../../src/keys/ed25519/index.browser.ts'
 import { unmarshalEd25519PrivateKey, unmarshalEd25519PublicKey } from '../../src/keys/ed25519/utils.ts'
 import { generateKeyPair, generateKeyPairFromSeed, privateKeyFromProtobuf, privateKeyFromRaw, publicKeyFromProtobuf, publicKeyFromRaw, privateKeyToCryptoKeyPair } from '../../src/keys/index.ts'
@@ -31,7 +30,7 @@ describe('ed25519', function () {
   })
 
   it('generates a valid key from seed', async () => {
-    const seed = randomBytes(32)
+    const seed = crypto.getRandomValues(new Uint8Array(32))
     const seededKey = await generateKeyPairFromSeed('Ed25519', seed)
     expect(seededKey).to.have.property('type', 'Ed25519')
     expect(key.raw).to.have.length(64)
@@ -39,7 +38,7 @@ describe('ed25519', function () {
   })
 
   it('generates the same key from the same seed', async () => {
-    const seed = randomBytes(32)
+    const seed = crypto.getRandomValues(new Uint8Array(32))
     const seededKey1 = await generateKeyPairFromSeed('Ed25519', seed)
     const seededKey2 = await generateKeyPairFromSeed('Ed25519', seed)
     expect(seededKey1.equals(seededKey2)).to.be.true()
@@ -47,30 +46,30 @@ describe('ed25519', function () {
   })
 
   it('generates different keys for different seeds', async () => {
-    const seed1 = randomBytes(32)
+    const seed1 = crypto.getRandomValues(new Uint8Array(32))
     const seededKey1 = await generateKeyPairFromSeed('Ed25519', seed1)
-    const seed2 = randomBytes(32)
+    const seed2 = crypto.getRandomValues(new Uint8Array(32))
     const seededKey2 = await generateKeyPairFromSeed('Ed25519', seed2)
     expect(seededKey1.equals(seededKey2)).to.be.false()
     expect(seededKey1.publicKey.equals(seededKey2.publicKey)).to.be.false()
   })
 
   it('signs', async () => {
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = await key.sign(text)
     const res = await key.publicKey.verify(text, sig)
     expect(res).to.be.be.true()
   })
 
   it('signs using noble', async () => {
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = await key.sign(text)
     const res = hashAndVerifyNoble(key.publicKey.raw, sig, text)
     expect(res).to.be.be.true()
   })
 
   it('verifies using noble', async () => {
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = hashAndSignNoble(key.raw, text)
     const res = await key.publicKey.verify(text, sig)
     expect(res).to.be.be.true()
@@ -78,8 +77,8 @@ describe('ed25519', function () {
 
   it('signs a list', async () => {
     const text = new Uint8ArrayList(
-      randomBytes(512),
-      randomBytes(512)
+      crypto.getRandomValues(new Uint8Array(512)),
+      crypto.getRandomValues(new Uint8Array(512))
     )
     const sig = await key.sign(text)
 
@@ -95,7 +94,7 @@ describe('ed25519', function () {
   it('should abort signing', async () => {
     const controller = new AbortController()
     controller.abort()
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     await expect((async () => {
       return key.sign(text, {
         signal: controller.signal
@@ -107,7 +106,7 @@ describe('ed25519', function () {
   it('should abort verifying', async () => {
     const controller = new AbortController()
     controller.abort()
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = await key.sign(text)
 
     await expect((async () => {
diff --git a/packages/crypto/test/keys/rsa.spec.ts b/packages/crypto/test/keys/rsa.spec.ts
index ade913bd15..a0d4297562 100644
--- a/packages/crypto/test/keys/rsa.spec.ts
+++ b/packages/crypto/test/keys/rsa.spec.ts
@@ -7,7 +7,6 @@ import * as asn1js from 'asn1js'
 import { create } from 'multiformats/hashes/digest'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { randomBytes } from '../../src/index.ts'
 import { privateKeyFromCryptoKeyPair, generateKeyPair, privateKeyFromProtobuf, privateKeyFromRaw, privateKeyToProtobuf, publicKeyFromProtobuf, publicKeyFromRaw, publicKeyToProtobuf, privateKeyToCryptoKeyPair } from '../../src/keys/index.ts'
 import * as pb from '../../src/keys/keys.ts'
 import { RSAPrivateKey as RSAPrivateKeyClass, RSAPublicKey as RSAPublicKeyClass } from '../../src/keys/rsa/rsa.ts'
@@ -67,8 +66,8 @@ describe('RSA', function () {
 
   it('signs a list', async () => {
     const text = new Uint8ArrayList(
-      randomBytes(512),
-      randomBytes(512)
+      crypto.getRandomValues(new Uint8Array(512)),
+      crypto.getRandomValues(new Uint8Array(512))
     )
     const sig = await key.sign(text)
 
@@ -90,7 +89,7 @@ describe('RSA', function () {
   it('should abort signing', async () => {
     const controller = new AbortController()
     controller.abort()
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     await expect((async () => {
       return key.sign(text, {
         signal: controller.signal
@@ -102,7 +101,7 @@ describe('RSA', function () {
   it('should abort verifying', async () => {
     const controller = new AbortController()
     controller.abort()
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = await key.sign(text)
 
     await expect((async () => {
diff --git a/packages/crypto/test/keys/secp256k1.spec.ts b/packages/crypto/test/keys/secp256k1.spec.ts
index 2b16c4d896..3024f50409 100644
--- a/packages/crypto/test/keys/secp256k1.spec.ts
+++ b/packages/crypto/test/keys/secp256k1.spec.ts
@@ -4,7 +4,6 @@ import { isPrivateKey, isPublicKey } from '@libp2p/interface'
 import { expect } from 'aegir/chai'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { randomBytes } from '../../src/index.ts'
 import { generateKeyPair, privateKeyFromRaw, privateKeyToProtobuf, publicKeyFromRaw, publicKeyToProtobuf, privateKeyToCryptoKeyPair } from '../../src/keys/index.ts'
 import { KeyType, PrivateKey, PublicKey } from '../../src/keys/keys.ts'
 import { hashAndSign, hashAndVerify } from '../../src/keys/secp256k1/index.ts'
@@ -26,7 +25,7 @@ describe('secp256k1 keys', () => {
   })
 
   it('signs', async () => {
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = await key.sign(text)
     const res = await key.publicKey.verify(text, sig)
     expect(res).to.equal(true)
@@ -34,8 +33,8 @@ describe('secp256k1 keys', () => {
 
   it('signs a list', async () => {
     const text = new Uint8ArrayList(
-      randomBytes(512),
-      randomBytes(512)
+      crypto.getRandomValues(new Uint8Array(512)),
+      crypto.getRandomValues(new Uint8Array(512))
     )
     const sig = await key.sign(text)
 
@@ -51,7 +50,7 @@ describe('secp256k1 keys', () => {
   it('should abort signing', async () => {
     const controller = new AbortController()
     controller.abort()
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     await expect((async () => {
       return key.sign(text, {
         signal: controller.signal
@@ -63,7 +62,7 @@ describe('secp256k1 keys', () => {
   it('should abort verifying', async () => {
     const controller = new AbortController()
     controller.abort()
-    const text = randomBytes(512)
+    const text = crypto.getRandomValues(new Uint8Array(512))
     const sig = await key.sign(text)
 
     await expect((async () => {
diff --git a/packages/floodsub/src/utils.ts b/packages/floodsub/src/utils.ts
index ca8e8993f0..4985b800bd 100644
--- a/packages/floodsub/src/utils.ts
+++ b/packages/floodsub/src/utils.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
 import { InvalidMessageError } from '@libp2p/interface'
 import { peerIdFromMultihash, peerIdFromPublicKey } from '@libp2p/peer-id'
@@ -14,7 +13,7 @@ import type { PublicKey } from '@libp2p/interface'
  * Generate a random sequence number
  */
 export function randomSeqno (): bigint {
-  return BigInt(`0x${uint8ArrayToString(randomBytes(8), 'base16')}`)
+  return BigInt(`0x${uint8ArrayToString(crypto.getRandomValues(new Uint8Array(8)), 'base16')}`)
 }
 
 /**
diff --git a/packages/gossipsub/test/message-cache.spec.ts b/packages/gossipsub/test/message-cache.spec.ts
index 9b65768cb8..143acb582a 100644
--- a/packages/gossipsub/test/message-cache.spec.ts
+++ b/packages/gossipsub/test/message-cache.spec.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { expect } from 'aegir/chai'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
@@ -9,7 +8,7 @@ import type { RPC } from '../src/message/rpc.ts'
 import type { MessageId } from '../src/types.ts'
 
 function randomSeqno (): bigint {
-  return BigInt(`0x${uint8ArrayToString(randomBytes(8), 'base16')}`)
+  return BigInt(`0x${uint8ArrayToString(crypto.getRandomValues(new Uint8Array(8)), 'base16')}`)
 }
 
 const toMessageId = (msgId: Uint8Array): MessageId => {
diff --git a/packages/integration-tests/test/mdns.node.ts b/packages/integration-tests/test/mdns.node.ts
index be9cd3dbc3..9f741cd053 100644
--- a/packages/integration-tests/test/mdns.node.ts
+++ b/packages/integration-tests/test/mdns.node.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { start, stop } from '@libp2p/interface'
 import { mdns } from '@libp2p/mdns'
 import { tcp } from '@libp2p/tcp'
@@ -29,7 +28,7 @@ describe('mdns', () => {
     const deferred = defer()
 
     // use a random tag to prevent CI collision
-    const serviceTag = `libp2p-test-${uint8ArrayToString(randomBytes(4), 'base16')}.local`
+    const serviceTag = `libp2p-test-${uint8ArrayToString(crypto.getRandomValues(new Uint8Array(4)), 'base16')}.local`
 
     const getConfig = (): Libp2pOptions => ({
       start: false,
diff --git a/packages/interface-compliance-tests/src/transport/index.ts b/packages/interface-compliance-tests/src/transport/index.ts
index 45b0256331..e940456e35 100644
--- a/packages/interface-compliance-tests/src/transport/index.ts
+++ b/packages/interface-compliance-tests/src/transport/index.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { stop, TimeoutError } from '@libp2p/interface'
 import { prefixLogger } from '@libp2p/logger'
 import { expect } from 'aegir/chai'
@@ -335,7 +334,7 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
 
       const connection = await dialer.dial(dialAddrs[0])
 
-      const input = randomBytes(1024)
+      const input = crypto.getRandomValues(new Uint8Array(1024))
       const output = await dialer.services.echo.echo(connection.remotePeer, input, {
         signal: AbortSignal.timeout(timeout)
       })
@@ -351,7 +350,7 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
 
       const connection = await dialer.dial(dialAddrs[0])
 
-      const input = uint8ArrayConcat(new Array(160).fill(0).map(() => randomBytes(65536)))
+      const input = uint8ArrayConcat(new Array(160).fill(0).map(() => crypto.getRandomValues(new Uint8Array(65536))))
       const output = await dialer.services.echo.echo(connection.remotePeer, input, {
         signal: AbortSignal.timeout(timeout)
       })
@@ -369,7 +368,7 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
       const echoProtocol = dialer.services.echo.protocol
 
       for (let i = 0; i < 2_000; i++) {
-        const input = randomBytes(1024)
+        const input = crypto.getRandomValues(new Uint8Array(1024))
         const output = await dialer.services.echo.echo(connection.remotePeer, input, {
           signal: AbortSignal.timeout(timeout)
         })
diff --git a/packages/kad-dht/benchmarks/add-with-kad-id.js b/packages/kad-dht/benchmarks/add-with-kad-id.js
index c6f868d52c..e377cf9cec 100644
--- a/packages/kad-dht/benchmarks/add-with-kad-id.js
+++ b/packages/kad-dht/benchmarks/add-with-kad-id.js
@@ -1,5 +1,4 @@
 /* eslint-disable no-console */
-import { randomBytes } from 'node:crypto'
 import { generateKeyPair } from '@libp2p/crypto/keys'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
 import Benchmark from 'benchmark'
@@ -16,7 +15,7 @@ import { convertPeerId } from '../dist/src/utils.js'
 // simulate roughly full routing table
 const peers = 6_000
 const capacity = 20
-const originDhtKey = (await sha256.digest(randomBytes(32))).digest
+const originDhtKey = (await sha256.digest(crypto.getRandomValues(new Uint8Array(32)))).digest
 const toAdd = await Promise.all(
   new Array(peers).fill(0).map(async () => {
     const privateKey = await generateKeyPair('Ed25519')
diff --git a/packages/kad-dht/src/routing-table/refresh.ts b/packages/kad-dht/src/routing-table/refresh.ts
index 387c03d6d7..ca5a1bd828 100644
--- a/packages/kad-dht/src/routing-table/refresh.ts
+++ b/packages/kad-dht/src/routing-table/refresh.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { peerIdFromMultihash } from '@libp2p/peer-id'
 import { anySignal } from 'any-signal'
 import length from 'it-length'
@@ -178,7 +177,7 @@ export class RoutingTableRefresh {
       throw new Error('Local peer not set')
     }
 
-    const randomData = randomBytes(2)
+    const randomData = crypto.getRandomValues(new Uint8Array(2))
     const randomUint16 = (randomData[1] << 8) + randomData[0]
 
     const key = this._makePeerId(this.routingTable.kb.localPeer.kadId, randomUint16, targetCommonPrefixLength)
diff --git a/packages/kad-dht/test/utils/create-values.ts b/packages/kad-dht/test/utils/create-values.ts
index b4e2e75611..af93426a54 100644
--- a/packages/kad-dht/test/utils/create-values.ts
+++ b/packages/kad-dht/test/utils/create-values.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
 import { sha256 } from 'multiformats/hashes/sha2'
@@ -11,7 +10,7 @@ export interface Value {
 export async function createValues (length: number): Promise<Value[]> {
   return Promise.all(
     Array.from({ length }).map(async () => {
-      const bytes = randomBytes(32)
+      const bytes = crypto.getRandomValues(new Uint8Array(32))
       const h = await sha256.digest(bytes)
       return {
         cid: CID.createV1(raw.code, h),
diff --git a/packages/keychain/src/keychain.ts b/packages/keychain/src/keychain.ts
index e208d75e2d..a8fd5c72d0 100644
--- a/packages/keychain/src/keychain.ts
+++ b/packages/keychain/src/keychain.ts
@@ -1,6 +1,6 @@
 /* eslint max-nested-callbacks: ["error", 5] */
 
-import { pbkdf2, randomBytes } from '@libp2p/crypto'
+import { pbkdf2 } from '@libp2p/crypto'
 import { privateKeyToProtobuf } from '@libp2p/crypto/keys'
 import { InvalidParametersError, NotFoundError, serviceCapabilities } from '@libp2p/interface'
 import { Key } from 'interface-datastore/key'
@@ -142,7 +142,7 @@ export class Keychain implements KeychainInterface {
     const saltLength = Math.ceil(NIST.minSaltLength / 3) * 3 // no base64 padding
 
     if (options.dek != null) {
-      options.dek.salt = uint8ArrayToString(randomBytes(saltLength), 'base64')
+      options.dek.salt = uint8ArrayToString(crypto.getRandomValues(new Uint8Array(saltLength)), 'base64')
     }
 
     return options
diff --git a/packages/keychain/src/utils/export.ts b/packages/keychain/src/utils/export.ts
index 8f3cc4a267..649a591a3c 100644
--- a/packages/keychain/src/utils/export.ts
+++ b/packages/keychain/src/utils/export.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { AES_GCM } from '@libp2p/crypto/ciphers'
 import { privateKeyToProtobuf } from '@libp2p/crypto/keys'
 import webcrypto from '@libp2p/crypto/webcrypto'
@@ -130,7 +129,7 @@ export async function exportToPem (privateKey: RSAPrivateKey, password: string):
 
   const keyBuf = keyWrapper.toBER()
   const keyArr = new Uint8Array(keyBuf, 0, keyBuf.byteLength)
-  const salt = randomBytes(SALT_LENGTH)
+  const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH))
 
   const encryptionKey = await pbkdf2Async(
     sha512,
@@ -141,7 +140,7 @@ export async function exportToPem (privateKey: RSAPrivateKey, password: string):
     }
   )
 
-  const iv = randomBytes(16)
+  const iv = crypto.getRandomValues(new Uint8Array(16))
   const cryptoKey = await crypto.subtle.importKey('raw', withArrayBuffer(encryptionKey), 'AES-CBC', false, ['encrypt'])
   const encrypted = await crypto.subtle.encrypt({
     name: 'AES-CBC',
diff --git a/packages/libp2p/src/connection-monitor.ts b/packages/libp2p/src/connection-monitor.ts
index d3980f1e17..6505b4b789 100644
--- a/packages/libp2p/src/connection-monitor.ts
+++ b/packages/libp2p/src/connection-monitor.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { serviceCapabilities } from '@libp2p/interface'
 import { AdaptiveTimeout, byteStream } from '@libp2p/utils'
 import { setMaxListeners } from 'main-event'
@@ -110,7 +109,7 @@ export class ConnectionMonitor implements Startable {
             start = Date.now()
 
             await Promise.all([
-              bs.write(randomBytes(PING_LENGTH), {
+              bs.write(crypto.getRandomValues(new Uint8Array(PING_LENGTH)), {
                 signal
               }),
               bs.read({
diff --git a/packages/libp2p/src/random-walk.ts b/packages/libp2p/src/random-walk.ts
index 40777776f6..c92c36d820 100644
--- a/packages/libp2p/src/random-walk.ts
+++ b/packages/libp2p/src/random-walk.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { anySignal } from 'any-signal'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import pDefer from 'p-defer'
@@ -116,7 +115,7 @@ export class RandomWalk extends TypedEventEmitter<RandomWalkEvents> implements R
       // find peers until no more consumers are interested
       while (this.walkers > 0) {
         try {
-          const data = randomBytes(32)
+          const data = crypto.getRandomValues(new Uint8Array(32))
           let s = Date.now()
 
           for await (const peer of this.peerRouting.getClosestPeers(data, { signal })) {
diff --git a/packages/multistream-select/package.json b/packages/multistream-select/package.json
index 5dd314e3ec..18b6631751 100644
--- a/packages/multistream-select/package.json
+++ b/packages/multistream-select/package.json
@@ -60,7 +60,6 @@
   },
   "devDependencies": {
     "aegir": "^48.0.11",
-    "iso-random-stream": "^2.0.2",
     "it-all": "^3.0.9",
     "it-drain": "^3.0.10",
     "it-pipe": "^3.0.1",
diff --git a/packages/multistream-select/test/dialer.spec.ts b/packages/multistream-select/test/dialer.spec.ts
index db2f0f3ad9..17fa1f4fdf 100644
--- a/packages/multistream-select/test/dialer.spec.ts
+++ b/packages/multistream-select/test/dialer.spec.ts
@@ -3,7 +3,6 @@
 
 import { streamPair } from '@libp2p/utils'
 import { expect } from 'aegir/chai'
-import randomBytes from 'iso-random-stream/src/random.js'
 import all from 'it-all'
 import { pEvent } from 'p-event'
 import pTimeout from 'p-timeout'
@@ -23,7 +22,7 @@ describe('Dialer', () => {
       expect(selection).to.equal(protocol)
 
       // Ensure stream is usable after selection - send data outgoing -> incoming
-      const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+      const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
 
       for (const buf of input) {
         if (!outgoingStream.send(buf)) {
@@ -48,9 +47,9 @@ describe('Dialer', () => {
       const protocol = '/foo/1.0.0'
       const [outgoingStream, incomingStream] = await streamPair()
       const input = new Uint8ArrayList(
-        randomBytes(10),
-        randomBytes(64),
-        randomBytes(3)
+        crypto.getRandomValues(new Uint8Array(10)),
+        crypto.getRandomValues(new Uint8Array(64)),
+        crypto.getRandomValues(new Uint8Array(3))
       )
       const receivedAllData = Promise.withResolvers<void>()
 
@@ -122,7 +121,7 @@ describe('Dialer', () => {
       const output = all(incomingStream)
 
       // Ensure stream is usable after selection
-      const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+      const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
       for (const buf of input) {
         if (!outgoingStream.send(buf)) {
           await pEvent(outgoingStream, 'drain')
@@ -159,7 +158,7 @@ describe('Dialer', () => {
       expect(selection).to.equal(protocol)
 
       // Ensure stream is usable after selection
-      const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+      const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
       const output = all(incomingStream)
 
       for (const buf of input) {
@@ -190,7 +189,7 @@ describe('Dialer', () => {
       expect(selection).to.equal(selectedProtocol)
 
       // Ensure stream is usable after selection
-      const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+      const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
       const output = all(incomingStream)
 
       for (const buf of input) {
diff --git a/packages/multistream-select/test/integration.spec.ts b/packages/multistream-select/test/integration.spec.ts
index eacc765deb..8a97ef97af 100644
--- a/packages/multistream-select/test/integration.spec.ts
+++ b/packages/multistream-select/test/integration.spec.ts
@@ -1,6 +1,5 @@
 import { streamPair } from '@libp2p/utils'
 import { expect } from 'aegir/chai'
-import randomBytes from 'iso-random-stream/src/random.js'
 import all from 'it-all'
 import { pipe } from 'it-pipe'
 import { pEvent } from 'p-event'
@@ -22,7 +21,7 @@ describe('Dialer and Listener integration', () => {
     expect(listenerSelection).to.equal(selectedProtocol)
 
     // Ensure stream is usable after selection
-    const input = [new Uint8ArrayList(randomBytes(10), randomBytes(64), randomBytes(3))]
+    const input = [new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3)))]
     const output = await Promise.all([
       (async function () {
         for (const buf of input) {
@@ -63,7 +62,7 @@ describe('Dialer and Listener integration', () => {
     expect(listenerSelection).to.equal(selectedProtocol)
 
     // Ensure stream is usable after selection
-    const input = [new Uint8ArrayList(randomBytes(10), randomBytes(64), randomBytes(3))]
+    const input = [new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3)))]
     const output = await Promise.all([
       (async function () {
         for (const buf of input) {
@@ -99,7 +98,7 @@ describe('Dialer and Listener integration', () => {
     expect(listenerSelection).to.equal(selectedProtocol)
 
     // Ensure stream is usable after selection
-    const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+    const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
     const output = await Promise.all([
       (async function () {
         for (const buf of input) {
@@ -131,7 +130,7 @@ describe('Dialer and Listener integration', () => {
     expect(dialerSelection).to.equal(protocol)
 
     // Ensure stream is usable after selection
-    const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+    const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
     // Since the stream is lazy, we need to write to it before handling
     const dialerOutPromise = (async function () {
       for (const buf of input) {
@@ -172,7 +171,7 @@ describe('Dialer and Listener integration', () => {
     void mss.handle(incomingStream, otherProtocol).catch(() => {})
 
     // should fail when we interact with the stream
-    const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+    const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
     await expect(async function () {
       for (const buf of input) {
         outgoingStream.send(buf)
@@ -195,7 +194,7 @@ describe('Dialer and Listener integration', () => {
     expect(dialerSelection).to.equal(protocol)
 
     // ensure stream is usable after selection
-    const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+    const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
 
     const [, dialerOut] = await Promise.all([
       // the listener handles the incoming stream
@@ -223,7 +222,7 @@ describe('Dialer and Listener integration', () => {
     expect(dialerSelection).to.equal(protocol)
 
     // ensure stream is usable after selection
-    const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+    const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
 
     const [listenerOut] = await Promise.all([
       // the listener handles the incoming stream
@@ -271,7 +270,7 @@ describe('Dialer and Listener integration', () => {
     expect(dialerSelection).to.equal(protocol)
 
     // Ensure stream is usable after selection
-    const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+    const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
 
     // Since the stream is lazy, we need to write to it before handling
     const dialerResultPromise = (async function () {
diff --git a/packages/multistream-select/test/listener.spec.ts b/packages/multistream-select/test/listener.spec.ts
index 248b016f2d..15cc1e17dc 100644
--- a/packages/multistream-select/test/listener.spec.ts
+++ b/packages/multistream-select/test/listener.spec.ts
@@ -1,6 +1,5 @@
 import { lpStream, streamPair } from '@libp2p/utils'
 import { expect } from 'aegir/chai'
-import randomBytes from 'iso-random-stream/src/random.js'
 import drain from 'it-drain'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
@@ -10,7 +9,7 @@ describe('Listener', () => {
   describe('listener.handle', () => {
     it('should handle a protocol', async () => {
       const protocol = '/echo/1.0.0'
-      const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+      const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
 
       const [outgoingStream, incomingStream] = await streamPair()
       const outputStream = lpStream(incomingStream)
@@ -32,7 +31,7 @@ describe('Listener', () => {
 
     it('should reject unhandled protocols', async () => {
       const protocol = '/echo/1.0.0'
-      const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+      const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
 
       const [outgoingStream, incomingStream] = await streamPair()
       const outputStream = lpStream(incomingStream)
@@ -57,7 +56,7 @@ describe('Listener', () => {
 
     it('should reject when unsupported protocols are ignored', async () => {
       const protocol = '/echo/1.0.0'
-      const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+      const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
 
       const [outgoingStream, incomingStream] = await streamPair()
       const outputStream = lpStream(incomingStream)
@@ -73,7 +72,7 @@ describe('Listener', () => {
 
     it('should handle ls', async () => {
       const protocol = '/echo/1.0.0'
-      const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
+      const input = [crypto.getRandomValues(new Uint8Array(10)), crypto.getRandomValues(new Uint8Array(64)), crypto.getRandomValues(new Uint8Array(3))]
 
       const [outgoingStream, incomingStream] = await streamPair()
       const outputStream = lpStream(incomingStream)
diff --git a/packages/pnet/package.json b/packages/pnet/package.json
index 75924f9044..f71cd72fb5 100644
--- a/packages/pnet/package.json
+++ b/packages/pnet/package.json
@@ -44,7 +44,6 @@
     "doc-check": "aegir doc-check"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.1.19",
     "@libp2p/interface": "^3.2.3",
     "@libp2p/utils": "^7.2.2",
     "uint8arraylist": "^3.0.2",
diff --git a/packages/pnet/src/index.ts b/packages/pnet/src/index.ts
index 4402076129..9853bde1b3 100644
--- a/packages/pnet/src/index.ts
+++ b/packages/pnet/src/index.ts
@@ -56,7 +56,6 @@
  * ```
  */
 
-import { randomBytes } from '@libp2p/crypto'
 import { InvalidParametersError } from '@libp2p/interface'
 import { byteStream } from '@libp2p/utils'
 import { BoxMessageStream, decodeV1PSK } from './crypto.ts'
@@ -115,7 +114,7 @@ class PreSharedKeyConnectionProtector implements ConnectionProtector {
     // Exchange nonces
     const log = connection.log.newScope('pnet')
     log('protecting the connection')
-    const localNonce = randomBytes(NONCE_LENGTH)
+    const localNonce = crypto.getRandomValues(new Uint8Array(NONCE_LENGTH))
 
     if (options == null) {
       options = {
diff --git a/packages/pnet/src/key-generator.ts b/packages/pnet/src/key-generator.ts
index 579250e38c..8aae15e1ba 100644
--- a/packages/pnet/src/key-generator.ts
+++ b/packages/pnet/src/key-generator.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 
@@ -9,7 +8,7 @@ import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
  * @returns {void}
  */
 export function generateKey (bytes: Uint8Array | NodeJS.WriteStream): void {
-  const psk = uint8ArrayToString(randomBytes(KEY_LENGTH), 'base16')
+  const psk = uint8ArrayToString(crypto.getRandomValues(new Uint8Array(KEY_LENGTH)), 'base16')
   const key = uint8ArrayFromString('/key/swarm/psk/1.0.0/\n/base16/\n' + psk)
 
   if (bytes instanceof Uint8Array) {
diff --git a/packages/protocol-ping/package.json b/packages/protocol-ping/package.json
index c9628fb05d..cc46065b32 100644
--- a/packages/protocol-ping/package.json
+++ b/packages/protocol-ping/package.json
@@ -44,7 +44,6 @@
     "doc-check": "aegir doc-check"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.1.19",
     "@libp2p/interface": "^3.2.3",
     "@libp2p/interface-internal": "^3.1.6",
     "p-event": "^7.0.0",
@@ -53,6 +52,7 @@
     "uint8arrays": "^6.1.1"
   },
   "devDependencies": {
+    "@libp2p/crypto": "^5.1.19",
     "@libp2p/peer-id": "^6.0.10",
     "@libp2p/utils": "^7.2.2",
     "aegir": "^48.0.11",
diff --git a/packages/protocol-ping/src/ping.ts b/packages/protocol-ping/src/ping.ts
index 0560d23e2b..23efca22fc 100644
--- a/packages/protocol-ping/src/ping.ts
+++ b/packages/protocol-ping/src/ping.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { ProtocolError, serviceCapabilities, setMaxListeners, TimeoutError } from '@libp2p/interface'
 import { pEvent } from 'p-event'
 import { raceSignal } from 'race-signal'
@@ -95,7 +94,7 @@ export class Ping implements Startable, PingInterface {
    * Ping a given peer and wait for its response, getting the operation latency.
    */
   async ping (peer: DialTarget, options: DialProtocolOptions = {}): Promise<number> {
-    const data = randomBytes(PING_LENGTH)
+    const data = crypto.getRandomValues(new Uint8Array(PING_LENGTH))
     const stream = await this.components.connectionManager.openStream(peer, this.protocol, {
       runOnLimitedConnection: this.runOnLimitedConnection,
       ...options
diff --git a/packages/stream-multiplexer-mplex/package.json b/packages/stream-multiplexer-mplex/package.json
index 7291f13498..8951f2270f 100644
--- a/packages/stream-multiplexer-mplex/package.json
+++ b/packages/stream-multiplexer-mplex/package.json
@@ -68,7 +68,6 @@
     "@libp2p/logger": "^6.2.8",
     "aegir": "^48.0.11",
     "benchmark": "^2.1.4",
-    "iso-random-stream": "^2.0.2",
     "it-all": "^3.0.9",
     "it-drain": "^3.0.10",
     "it-foreach": "^2.1.4",
diff --git a/packages/stream-multiplexer-mplex/test/restrict-size.spec.ts b/packages/stream-multiplexer-mplex/test/restrict-size.spec.ts
index 72b02e0d29..c205bfb3ca 100644
--- a/packages/stream-multiplexer-mplex/test/restrict-size.spec.ts
+++ b/packages/stream-multiplexer-mplex/test/restrict-size.spec.ts
@@ -1,5 +1,4 @@
 import { expect } from 'aegir/chai'
-import randomBytes from 'iso-random-stream/src/random.js'
 import all from 'it-all'
 import drain from 'it-drain'
 import each from 'it-foreach'
@@ -15,10 +14,10 @@ describe('restrict size', () => {
     const maxSize = 32
 
     const input: Message[] = [
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(8)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(16)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(maxSize)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(64)) }
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(8))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(16))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(maxSize))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(64))) }
     ]
 
     const output: Message[] = []
@@ -65,13 +64,13 @@ describe('restrict size', () => {
     const maxUnprocessedMessageQueueSize = 64
 
     const input: Message[] = [
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(16)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(16)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(16)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(16)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(16)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(16)) },
-      { id: 0, type: 1, data: new Uint8ArrayList(randomBytes(16)) }
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(16))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(16))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(16))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(16))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(16))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(16))) },
+      { id: 0, type: 1, data: new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(16))) }
     ]
 
     const output: Message[] = []
@@ -101,7 +100,7 @@ describe('restrict size', () => {
   it('should throw when unprocessed message queue size is too big because of garbage', async () => {
     const maxMessageSize = 32
     const maxUnprocessedMessageQueueSize = 64
-    const input = randomBytes(maxUnprocessedMessageQueueSize + 1)
+    const input = crypto.getRandomValues(new Uint8Array(maxUnprocessedMessageQueueSize + 1))
     const output: Message[] = []
 
     try {
diff --git a/packages/stream-multiplexer-mplex/test/stream.spec.ts b/packages/stream-multiplexer-mplex/test/stream.spec.ts
index bd1ea52ee6..391905126d 100644
--- a/packages/stream-multiplexer-mplex/test/stream.spec.ts
+++ b/packages/stream-multiplexer-mplex/test/stream.spec.ts
@@ -1,7 +1,6 @@
 import { StreamCloseEvent } from '@libp2p/interface'
 import { echo, multiaddrConnectionPair } from '@libp2p/utils'
 import { expect } from 'aegir/chai'
-import randomBytes from 'iso-random-stream/src/random.js'
 import { pushable } from 'it-pushable'
 import { pEvent } from 'p-event'
 import randomInt from 'random-int'
@@ -17,7 +16,7 @@ import type { MplexStream } from '../src/stream.ts'
 import type { MessageStream } from '@libp2p/interface'
 
 function randomInput (min = 1, max = 100): Uint8ArrayList[] {
-  return Array.from(Array(randomInt(min, max)), () => new Uint8ArrayList(randomBytes(randomInt(1, 128))))
+  return Array.from(Array(randomInt(min, max)), () => new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(randomInt(1, 128)))))
 }
 
 function expectMsgType (actual: keyof typeof MessageTypeNames, expected: keyof typeof MessageTypeNames): void {
diff --git a/packages/transport-webtransport/package.json b/packages/transport-webtransport/package.json
index 87790eb1c5..fa58c569dd 100644
--- a/packages/transport-webtransport/package.json
+++ b/packages/transport-webtransport/package.json
@@ -62,7 +62,6 @@
     "@libp2p/daemon-client": "^10.0.29",
     "@libp2p/logger": "^6.2.8",
     "@libp2p/ping": "^3.1.6",
-    "@noble/hashes": "^2.0.1",
     "aegir": "^48.0.11",
     "execa": "^9.6.0",
     "go-libp2p": "^1.6.0",
diff --git a/packages/transport-webtransport/test/fixtures/random-bytes.ts b/packages/transport-webtransport/test/fixtures/random-bytes.ts
index 315e05d103..77e9bc2ed7 100644
--- a/packages/transport-webtransport/test/fixtures/random-bytes.ts
+++ b/packages/transport-webtransport/test/fixtures/random-bytes.ts
@@ -1,5 +1,4 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import { randomBytes as randB } from '@noble/hashes/utils.js'
 
 /**
  * Generates a Uint8Array with length `number` populated by random bytes
@@ -9,5 +8,5 @@ export function randomBytes (length: number): Uint8Array {
     throw new InvalidParametersError('random bytes length must be a Number bigger than 0')
   }
 
-  return randB(length)
+  return crypto.getRandomValues(new Uint8Array(length))
 }
diff --git a/packages/utils/package.json b/packages/utils/package.json
index 7078960f57..9189990003 100644
--- a/packages/utils/package.json
+++ b/packages/utils/package.json
@@ -47,7 +47,6 @@
   "dependencies": {
     "@chainsafe/is-ip": "^2.1.0",
     "@chainsafe/netmask": "^2.0.0",
-    "@libp2p/crypto": "^5.1.19",
     "@libp2p/interface": "^3.2.3",
     "@libp2p/logger": "^6.2.8",
     "@multiformats/multiaddr": "^13.0.3",
@@ -72,6 +71,7 @@
     "uint8arrays": "^6.1.1"
   },
   "devDependencies": {
+    "@libp2p/crypto": "^5.1.19",
     "@libp2p/peer-id": "^6.0.10",
     "@types/netmask": "^2.0.5",
     "aegir": "^48.0.11",
diff --git a/packages/utils/src/filters/bloom-filter.ts b/packages/utils/src/filters/bloom-filter.ts
index 720d0cc29c..7e0e7320d5 100644
--- a/packages/utils/src/filters/bloom-filter.ts
+++ b/packages/utils/src/filters/bloom-filter.ts
@@ -1,5 +1,4 @@
 // ported from xxbloom - https://github.com/ceejbot/xxbloom/blob/master/LICENSE
-import { randomBytes } from '@libp2p/crypto'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { alloc } from 'uint8arrays/alloc'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
@@ -117,7 +116,7 @@ function generateSeeds (count: number): number[] {
   const seeds = []
 
   for (let i = 0; i < count; i++) {
-    buf = new Uint8ArrayList(randomBytes(4))
+    buf = new Uint8ArrayList(crypto.getRandomValues(new Uint8Array(4)))
     seeds[i] = buf.getUint32(0, true)
 
     // Make sure we don't end up with two identical seeds,
diff --git a/packages/utils/test/filters/cuckoo-filter.spec.ts b/packages/utils/test/filters/cuckoo-filter.spec.ts
index 83c5786d49..dd3c4b427e 100644
--- a/packages/utils/test/filters/cuckoo-filter.spec.ts
+++ b/packages/utils/test/filters/cuckoo-filter.spec.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { expect } from 'aegir/chai'
 import { CuckooFilter } from '../../src/filters/cuckoo-filter.ts'
 
@@ -17,7 +16,7 @@ describe('cuckoo-filter', () => {
 
   it('add 1500 keys', () => {
     for (let i = 0; i < 1500; i++) {
-      const rand = randomBytes(36)
+      const rand = crypto.getRandomValues(new Uint8Array(36))
       keys.push(rand)
 
       expect(cuckoo.add(rand)).to.be.true()
@@ -43,7 +42,7 @@ describe('cuckoo-filter', () => {
 
   it('becomes unreliable', () => {
     while (true) {
-      cuckoo.add(randomBytes(36))
+      cuckoo.add(crypto.getRandomValues(new Uint8Array(36)))
 
       if (!cuckoo.reliable) {
         break
diff --git a/packages/utils/test/filters/scalable-cuckoo-filter.spec.ts b/packages/utils/test/filters/scalable-cuckoo-filter.spec.ts
index c9933e12ed..c33022064f 100644
--- a/packages/utils/test/filters/scalable-cuckoo-filter.spec.ts
+++ b/packages/utils/test/filters/scalable-cuckoo-filter.spec.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { expect } from 'aegir/chai'
 import { ScalableCuckooFilter, createScalableCuckooFilter } from '../../src/filters/scalable-cuckoo-filter.ts'
 
@@ -17,7 +16,7 @@ describe('scalable-cuckoo-filter', () => {
 
   it('add 150k keys', () => {
     for (let i = 0; i < 150000; i++) {
-      const rand = randomBytes(36)
+      const rand = crypto.getRandomValues(new Uint8Array(36))
       keys.push(rand)
 
       expect(cuckoo.add(rand)).to.be.true()
@@ -46,7 +45,7 @@ describe('scalable-cuckoo-filter', () => {
 
   it('optimizes input', () => {
     const filter = createScalableCuckooFilter(100000, 0.001)
-    const key = randomBytes(32)
+    const key = crypto.getRandomValues(new Uint8Array(32))
 
     filter.add(key)