Home

Index

How to use the randomBytes function from crypto

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

crypto.randomBytes is a function in the Node.js crypto module that generates cryptographically secure pseudo-random bytes.

crypto.js

73
74
75
76
77
78
79
80
81
82
  : fs.createReadStream(origpath)
// create data and creds file
const dataDest = fs.createWriteStream(dataDestPath)
const credsDest = fs.createWriteStream(credsDestPath)
// generate a cryptographically secure random iv
const iv = scrypto.randomBytes(CRYPTO.DEFAULTS.IVLENGTH)
// create the AES-256-GCM cipher with iv and derive encryption key
const cipher = scrypto.createCipheriv(
  CRYPTO.DEFAULTS.ALGORITHM,
  dcreds.key,

450

utils.js

GitHub: baddate/trilium

15
16
17
18
19
20
21
22
23
24
function randomString(length) {
    return randtoken.generate(length);
}

function randomSecureToken(bytes = 32) {
    return crypto.randomBytes(bytes).toString('base64');
}

function md5(content) {
    return crypto.createHash('md5').update(content).digest('hex');

190

+ 13 other calls in file

How does crypto.randomBytes work?

crypto.randomBytes works by generating a set of random bytes using a secure pseudo-random number generator.

The function takes an integer argument that specifies the number of bytes to generate, and returns a Buffer object containing the generated bytes.

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.randomBytes, developers can easily generate a set of random bytes with a high degree of entropy, which is essential for security-sensitive applications.

xmlenc.js

GitHub: auth0/node-xml-encryption

79
80
81
82
83
84
85
86
87
88
switch (options.encryptionAlgorithm) {
  case 'http://www.w3.org/2001/04/xmlenc#aes128-cbc':
    crypto.randomBytes(16, cb); // generate a symmetric random key 16 bytes length
    break;
  case 'http://www.w3.org/2001/04/xmlenc#aes256-cbc':
    crypto.randomBytes(32, cb); // generate a symmetric random key 32 bytes length
    break;
  case 'http://www.w3.org/2009/xmlenc11#aes128-gcm':
    crypto.randomBytes(16, cb); // generate a symmetric random key 16 bytes length
    break;

+ 23 other calls in file

index.js

GitHub: lpinca/shopify-token

83
84
85
86
87
88
89
90
91
92
 *
 * @return {String} The random nonce
 * @public
 */
generateNonce() {
  return crypto.randomBytes(16).toString('hex');
}

/**
 * Build the authorization URL.

129

Ai Example

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

const bytes = crypto.randomBytes(16);
console.log(bytes.toString("hex"));

In this example, we use crypto.randomBytes to generate a set of 16 random bytes. We call crypto.randomBytes(16) to generate the bytes and store them in a variable called bytes. We then convert the bytes to a hexadecimal string using the toString() method with the 'hex' encoding. The resulting string is then logged to the console. By using crypto.randomBytes in this way, we can easily generate cryptographically secure random bytes for use in security-sensitive applications.

main.js

GitHub: FilenCloudDienste/filen-mobile

134
135
136
137
138
139
140
141
142
143
144
145
}


const randomString = (length) => {
    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    const charsLength = chars.length
    const randomBytes = crypto.randomBytes(length)
    let result = new Array(length)
    let cursor = 0


    for(let i = 0; i < length; i++){

118

AES-256-CBC.js

GitHub: alladdin/node-lox-ws-api

9
10
11
12
13
14
15
16
17
18
this._connection = connection;
this._api = api;
this._hmac_hash = '';

this._public_key = '';
this._iv = crypto.randomBytes(16);
this._key = crypto.createHash('sha256').update(crypto.randomBytes(16).toString('hex')).digest();
this._session_key;

this._salt_bytes = 16;

+ 3 other calls in file

session.js

GitHub: Eyevinn/channel-engine

26
27
28
29
30
31
32
33
34
35
 * }
 *
 */
constructor(assetManager, config, sessionStore) {
  this._assetManager = assetManager;
  this._sessionId = crypto.randomBytes(20).toString('hex');

  this._sessionStateStore = sessionStore.sessionStateStore;
  this._playheadStateStore = sessionStore.playheadStateStore;
  this._instanceId = sessionStore.instanceId;

server.js

GitHub: nai-degen/TavernAIScale

71
72
73
74
75
76
77
78
79
80
81
82
83
const urlencodedParser = express.urlencoded({extended: true, limit: '100mb'});


// CSRF Protection //
const doubleCsrf = require('csrf-csrf').doubleCsrf;


const CSRF_SECRET = crypto.randomBytes(8).toString('hex');
const COOKIES_SECRET = crypto.randomBytes(8).toString('hex');


const { invalidCsrfTokenError, generateToken, doubleCsrfProtection } = doubleCsrf({
	getSecret: () => CSRF_SECRET,

+ 5 other calls in file

api.js

GitHub: hakatashi/esolang-battle

9
10
11
12
13
14
15
16
17
18
19
20
const Language = require('../models/Language');
const Submission = require('../models/Submission');
const {Mutex} = require('async-mutex');


const executionMutex = new Mutex();
const apiKey = process.env.API_KEY || crypto.randomBytes(64).toString('hex');


/*
 * Middleware for all /api/contest/:contest routes
 */

index.js

GitHub: maulvialf/CTF-Challs-Archive

9
10
11
12
13
14
15
16
17
18
19
20
21


app.use('/', express.static(path.join(__dirname, 'public')))
app.use(express.urlencoded({extended: false}))
app.use(cookieParser())


function rand() { return crypto.randomBytes(20).toString('hex') }


app.use((req, res, next) => {
  const { id } = req.cookies;
  req.user = (id && db.cookies[id] && db.cookies[id].username) ? db.cookies[id].username : undefined;

+ 2 other calls in file

config.js

GitHub: ministryofjustice/prepare-a-case

233
234
235
236
237
238
239
240
241
242
  }
},
appVersion: get('APP_VERSION', 'dev-build'),
domain: `${get('INGRESS_URL', `http://localhost:${port}`)}`,
https: production,
nonce: crypto.randomBytes(16).toString('base64'),
googleAnalyticsKey: get('GOOGLE_ANALYTICS_KEY', null),
instrumentationKey: get('APPINSIGHTS_INSTRUMENTATIONKEY', null),
notification: {
  username: get('NOTIFICATION_USERNAME', null, requiredInProduction),

softball-server.js

GitHub: thbrown/softball-scorer

1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
  sessData.nonHttpOnlyToken = token;
}

async function generateToken(length = 30) {
  return new Promise((resolve, reject) => {
    crypto.randomBytes(length, (err, buf) => {
      if (err) {
        reject(err);
      } else {
        // Make sure the token is url safe

apiroute.js

GitHub: jiiihpeeh/project-untamo

337
338
339
340
341
342
343
344
345
346
347
router.post("/qrToken",function(req,res) {
	console.log('checking out new qrpost');
	if(!req.body) {
		return res.status(400).json({message:"Bad request"});
	}
	let qrToken = crypto.randomBytes(96).toString("hex");


	let now=Date.now();
	let qrKey = new qrModel({
		qrToken: qrToken,

+ 8 other calls in file

userModel.js

GitHub: phucnguyn-203/MonaFresh

101
102
103
104
105
106
107
108
109
110
111
    }
    return false;
};


userSchema.methods.createPasswordResetToken = function () {
    const resetToken = crypto.randomBytes(32).toString("hex");
    this.passwordResetToken = crypto.createHash("sha256").update(resetToken).digest("hex");
    this.passwordResetExpires = Date.now() + 10 * 60 * 1000;
    return resetToken;
};

+ 2 other calls in file

user.js

GitHub: Leotheprodu/flproductions-server

45
46
47
48
49
50
51
52
53
54
55
56


router.put('/actualizar-usuarios/:id', (req, res) => {


  const id = parseInt(req.params.id);
  const { username, email, password } = req.body;
  const token = crypto.randomBytes(32).toString('hex');// Genera un token aleatorio de 32 caracteres
  const link = `${process.env.NODE_ENV === 'production' ? 'https://flproductionscr.com/' : 'http://localhost:5000/'}api/verificar-correo/${token}`;
  const newTempToken = {
    token: token,
    user_email: email

userModel.js

GitHub: RajithaThilanka/Project-Iris

189
190
191
192
193
194
195
196
197
198
199
200
  }
  return false;
};


userSchema.methods.createPasswordResetToken = function () {
  const resetToken = crypto.randomBytes(32).toString('hex');


  this.passwordResetToken = crypto
    .createHash('sha256')
    .update(resetToken)

auth.controller.js

GitHub: nghiapham17-22/be-mt247

43
44
45
46
47
48
49
50
51
52
if (err) {
  return res.status(500).json({ message: err.message });
}
const token = new Token({
  userId: user._id,
  token: crypto.randomBytes(16).toString('hex'),
});
await token.save(async (err) => {
  if (err) {
    return res.status(500).json({ message: err.message });

+ 3 other calls in file

UserController.js

GitHub: jmartinacu/DeliverUS-Backend

128
129
130
131
132
133
134
135
136
137
138
}


async function register (req, res, userType) {
  const newUser = User.build(req.body)
  newUser.userType = userType
  newUser.token = crypto.randomBytes(20).toString('hex')
  const expirationDate = new Date()
  expirationDate.setHours(expirationDate.getHours() + 1)
  newUser.tokenExpiration = expirationDate
  if (typeof req.file !== 'undefined') {

auth.js

GitHub: saiabhiram1928/ss23-backend

201
202
203
204
205
206
207
208
209
210
if (!user)
  return res.status(403).send("User does not exist");

// let token = await Token.findOne({ userId: user._id });
// if (token) await token.deleteOne();
// let resetToken = crypto.randomBytes(10).toString("hex");
// const hash = crypto
//             .createHmac("sha256", user.salt)
//             .update(resetToken)
//             .digest("hex");

routes.js

GitHub: ministryofjustice/hmpps-activity-management-prototype

85
86
87
88
89
90
91
92
93
94
// Get the ID for the payrate or generate a random one
let payIncentiveId;
if (req.session.data["id"]) {
  payIncentiveId = req.session.data["id"];
} else {
  payIncentiveId = crypto.randomBytes(4).toString("hex");
}

// Create the payrate data object
const payrateData = {

+ 3 other calls in file

Other functions in crypto

Sorted by popularity

crypto.createHash is the most popular function in crypto (882 examples)

Other popular packages:

Home

About