How to use the createPrivateKey function from crypto

rsa-hybrid-encrypt.js

GitHub: PacktPublishing/Essential-Cryptography-for-JavaScript-Developers

54
55
56
57
58
59
60
61
62
63
// Load the public and private keys
// The public one is used for encrypting the message (in this case, to encrypt a symmetric key) and the private one is using for decryption
const publicKeyObject = crypto.createPublicKey(
    await readFile('public.pem')
)
const privateKeyObject = crypto.createPrivateKey(
    await readFile('private.pem')
)

// Encrypt the message using hybrid encryption, and obtain both the ciphertext (encrypted message) and the wrapped key (encrypted key)

10

28

7

index.d.ts

GitHub: mceachen/paseto

153
154
155
156
157
158
159
160
161
162
* Serializes and signs the payload as a PASETO using the provided private key
* @example
* const { createPrivateKey } = require('crypto')
* const { V1 } = require('paseto')
*
* const key = createPrivateKey(privateKey)
*
* const payload = {
*   'urn:example:claim': 'foo'
* }

24

1

1

+ 7 other calls in file

index.js

GitHub: Postcatlab/postcat-extensions

7
8
9
10
11
12
13
14
15
16

const key = HsArr.includes(config.algorithm)
  ? config.isBase64Encoded
    ? Buffer.from(config.Secret).toString('base64')
    : config.Secret
  : createPrivateKey(config.Secret)

const authorizationValue = jwt.sign(
  config.payload ? JSON.parse(config.payload) : {},
  key,

5

8

0

csob.js

GitHub: luckykiet/gastropay

107
108
109
110
111
112
113
114
115
116
117
}


const signMessage = (privateKey, passphrase, message) => {
    try {
        const key = trimPemKey(privateKey);
        const privateKeyToSign = crypto.createPrivateKey({
            key: key,
            passphrase: passphrase
        });
        const sign = crypto.createSign('SHA256');

0

0

1

sign.js

GitHub: ptan159/pinterest

104
105
106
107
108
109
110
111
112
113
  return failure(new Error('secretOrPrivateKey must have a value'));
}

if (secretOrPrivateKey != null && !(secretOrPrivateKey instanceof KeyObject)) {
  try {
    secretOrPrivateKey = createPrivateKey(secretOrPrivateKey)
  } catch (_) {
    try {
      secretOrPrivateKey = createSecretKey(typeof secretOrPrivateKey === 'string' ? Buffer.from(secretOrPrivateKey) : secretOrPrivateKey)
    } catch (_) {

0

0

1

+ 2 other calls in file

PeerGateway.js

GitHub: pestoura/Hyperledger-Caliper

252
253
254
255
256
257
258
259
260
261

//create gRpc client to designated port
const client = await this._createClientForPeer(mspId, peer);

//create signer using the private key of the peer
const privateKey = crypto.createPrivateKey(walletIdentity.privateKey);
const signer = signers.newPrivateKeySigner(privateKey);

//create gateway instance using the grpc client, identity and signer
const gateway = connect({

0

0

1

+ 3 other calls in file

curve.js

GitHub: MR-NIMA-X/signal

78
79
80
81
82
83
84
85
86
87
if (!pubKey || pubKey.byteLength != 32) {
  throw new Error("Invalid public key");
}

if (typeof nodeCrypto.diffieHellman === "function") {
  const nodePrivateKey = nodeCrypto.createPrivateKey({
    key: Buffer.concat([PRIVATE_KEY_DER_PREFIX, privKey]),
    format: "der",
    type: "pkcs8",
  });

0

0

1

test-crypto-dh-stateless.js

GitHub: vladimir-andreevich/node.js-14-windows-7

56
57
58
59
60
61
62
63
64
65
66
       'iBJKZLQMqNdbY14G9rdKmhhTJrQjC+i7Q/wI8JPhOFzHIGA=\n' +
       '-----END PUBLIC KEY-----',
  format: 'pem'
});


const bobPrivateKey = crypto.createPrivateKey({
  key: '-----BEGIN PRIVATE KEY-----\n' +
       'MIIBoQIBADCB1QYJKoZIhvcNAQMBMIHHAoHBAP//////////yQ/aoiFowjTExmKL\n' +
       'gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n' +
       'bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n' +

0

0

0

+ 23 other calls in file

test-crypto-sign-verify.js

GitHub: vladimir-andreevich/node.js-14-windows-7

450
451
452
453
454
455
456
457
458
459
                     true);
}

{
  const data = Buffer.from('Hello world');
  const privKeyObj = crypto.createPrivateKey(pair.private);
  const pubKeyObj = crypto.createPublicKey(pair.public);

  const sig = crypto.sign(algo, data, privKeyObj);
  assert.strictEqual(sig.length, pair.sigLen);

0

0

0

test-webcrypto-export-import-ec.js

GitHub: Mike7323/Mike-s-construction

372
373
374
375
376
377
378
379
380
381
382
383
})().then(common.mustCall());


{
  const rsaPublic = crypto.createPublicKey(
    fixtures.readKey('rsa_public_2048.pem'));
  const rsaPrivate = crypto.createPrivateKey(
    fixtures.readKey('rsa_private_2048.pem'));


  for (const [name, publicUsages, privateUsages] of [
    ['ECDSA', ['verify'], ['sign']],

0

0

0

test-webcrypto-export-import-rsa.js

GitHub: Mike7323/Mike-s-construction

532
533
534
535
536
537
538
539
540
541
542
543
})().then(common.mustCall());


{
  const ecPublic = crypto.createPublicKey(
    fixtures.readKey('ec_p256_public.pem'));
  const ecPrivate = crypto.createPrivateKey(
    fixtures.readKey('ec_p256_private.pem'));


  for (const [name, [publicUsage, privateUsage]] of Object.entries({
    'RSA-PSS': ['verify', 'sign'],

0

0

0

decrypt.js

GitHub: mac2000/cryptography

0
1
2
3
4
5
6
7
8
const crypto = require('crypto')
const fs = require('fs')

const encrypted = Buffer.from(fs.readFileSync('protected.txt', 'utf8'), 'base64')

const privateKey = crypto.createPrivateKey(fs.readFileSync('private.pem', 'utf8'))

const decrypted = crypto.privateDecrypt({key: privateKey, padding: crypto.constants.RSA_PKCS1_PADDING}, Buffer.from(encrypted, 'base64'))
// const decrypted = crypto.privateDecrypt(privateKey, Buffer.from(encrypted, 'base64'))

0

0

1