How to use the randomFillSync function from crypto

Find comprehensive JavaScript crypto.randomFillSync code examples handpicked from public code repositorys.

crypto.randomFillSync is a function in the Node.js crypto module that fills a buffer with cryptographically secure pseudo-random bytes synchronously.

32
33
34
35
36
37
38
39
40
41
 * @param {Number} [off=0]
 * @param {Number} [size=buf.length-off]
 * @returns {Buffer}
 */

exports.randomFill = crypto.randomFillSync;

/**
 * Generate pseudo-random bytes.
 * @param {Number} size
fork icon42
star icon0
watch icon2

351
352
353
354
355
356
357
358
359
                array[i] = (Math.random()*4294967296)>>>0;
            }
        }
    }
    else { // NodeJS
        crypto.randomFillSync(array);
    }
    return array;
}
fork icon7
star icon41
watch icon6

How does crypto.randomFillSync work?

crypto.randomFillSync works by filling a buffer with cryptographically secure pseudo-random bytes synchronously.

The function takes two arguments: a buffer to fill with random bytes, and an optional offset within the buffer where the filling should start.

The function then fills the buffer with random bytes, replacing any existing data that may be in the buffer.

The generated bytes are cryptographically secure, which means they are suitable for use in security-sensitive applications such as encryption and authentication.

By using crypto.randomFillSync, developers can easily fill a buffer with random bytes with a high degree of entropy, which is essential for security-sensitive applications.

26
27
28
29
30
31
32
33
34
35
36
37


Token.sync();


const generateRandomBytes = () => {
    let buf = Buffer.alloc(8);
    randomFillSync(buf);
    //buf = Buffer.from([0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF]);
    logger.info("Generated randomBytes :" + buf.toString('hex'));
    return buf;
}
fork icon4
star icon8
watch icon3

78
79
80
81
82
83
84
85
86
87
  target.writeUInt32BE(data.length, 6);
}

if (!options.mask) return [target, data];

randomFillSync(mask, 0, 4);

target[1] |= 0x80;
target[offset - 4] = mask[0];
target[offset - 3] = mask[1];
fork icon0
star icon0
watch icon0

+ 2 other calls in file

Ai Example

1
2
3
4
5
const crypto = require("crypto");

const buffer = Buffer.alloc(16);
crypto.randomFillSync(buffer);
console.log(buffer.toString("hex"));

In this example, we use crypto.randomFillSync to fill a buffer with 16 random bytes. We first create a new buffer with Buffer.alloc(16) and store it in a variable called buffer. We then call crypto.randomFillSync(buffer) to fill the buffer with random bytes. Finally, we convert the bytes to a hexadecimal string using the toString() method with the 'hex' encoding, and log the resulting string to the console. By using crypto.randomFillSync in this way, we can easily fill a buffer with cryptographically secure random bytes for use in security-sensitive applications.

71
72
73
74
75
76
77
78
79
80
81
82
}


{
  const buf = Buffer.alloc(10);
  const before = buf.toString('hex');
  const after = crypto.randomFillSync(buf).toString('hex');
  assert.notStrictEqual(before, after);
}


{
fork icon0
star icon0
watch icon0

+ 35 other calls in file

16
17
18
19
20
21
22
23
24
};


const cryptoPackage = require("crypto");
globalThis.crypto = {
    getRandomValues(b) {
        cryptoPackage.randomFillSync(b);
    },
};
fork icon0
star icon0
watch icon0

-2
-1
  module.exports = require('./browser')
}
fork icon0
star icon0
watch icon0

31
32
33
34
35
36
37
38
39
40
        `getRandomValues() cannot generate more than 65536 bytes of random values; ` +
        `${array.byteLength} bytes were requested`,
        "QuotaExceededError"
      ]);
    }
    nodeCrypto.randomFillSync(array);
    return array;
  }
}

fork icon0
star icon0
watch icon0