crypto: add raw key formats support to the KeyObject APIs

Add raw key format support (raw-public, raw-private, raw-seed) to
KeyObject.prototype.export(), crypto.createPrivateKey(),
and crypto.createPublicKey() for applicable asymmetric keys (EC,
CFRG curves, ML-DSA, ML-KEM, and SLH-DSA).
Also wire these to the Web Cryptography APIs and remove the unnecessary
KeyExportJob. The KeyExportJob classes were removed because the export
operations they performed are not computationally expensive. They're
just serialization of already-available key data (SPKI, PKCS8, raw
bytes). Running them as async CryptoJobs on the libuv thread pool added
unnecessary overhead and complexity for operations that complete
instantly.
PR-URL: #62240
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: panva

benchmark/crypto/create-keyobject.js

@@ -30,8 +30,22 @@ if (hasOpenSSL(3, 5)) {
 
 constbench=common.createBenchmark(main,{
 keyType: Object.keys(keyFixtures),
-keyFormat: ['pkcs8','spki','der-pkcs8','der-spki','jwk-public','jwk-private'],
+keyFormat: ['pkcs8','spki','der-pkcs8','der-spki','jwk-public','jwk-private',
+'raw-public','raw-private','raw-seed'],
 n: [1e3],
+},{
+combinationFilter(p){
+// raw-private is not supported for rsa and ml-dsa
+if(p.keyFormat==='raw-private')
+returnp.keyType!=='rsa'&&!p.keyType.startsWith('ml-');
+// raw-public is not supported by rsa
+if(p.keyFormat==='raw-public')
+returnp.keyType!=='rsa';
+// raw-seed is only supported for ml-dsa
+if(p.keyFormat==='raw-seed')
+returnp.keyType.startsWith('ml-');
+returntrue;
+},
 });
 
 functionmeasure(n,fn,input){
@@ -82,6 +96,29 @@ function main({ n, keyFormat, keyType }) {
 fn=crypto.createPrivateKey;
 break;
 }
+case'raw-public': {
+constexportedKey=keyPair.publicKey.export({format: 'raw-public'});
+key={key: exportedKey,format: 'raw-public',asymmetricKeyType: keyType};
+if(keyType==='ec')key.namedCurve=keyPair.publicKey.asymmetricKeyDetails.namedCurve;
+fn=crypto.createPublicKey;
+break;
+}
+case'raw-private': {
+constexportedKey=keyPair.privateKey.export({format: 'raw-private'});
+key={key: exportedKey,format: 'raw-private',asymmetricKeyType: keyType};
+if(keyType==='ec')key.namedCurve=keyPair.privateKey.asymmetricKeyDetails.namedCurve;
+fn=crypto.createPrivateKey;
+break;
+}
+case'raw-seed': {
+key={
+key: keyPair.privateKey.export({format: 'raw-seed'}),
+format: 'raw-seed',
+asymmetricKeyType: keyType,
+};
+fn=crypto.createPrivateKey;
+break;
+}
 default:
 thrownewError('not implemented');
 }

benchmark/crypto/kem.js

@@ -11,22 +11,29 @@ function readKey(name) {
 returnfs.readFileSync(`${fixtures_keydir}/${name}.pem`,'utf8');
 }
 
+functionreadKeyPair(publicKeyName,privateKeyName){
+return{
+publicKey: readKey(publicKeyName),
+privateKey: readKey(privateKeyName),
+};
+}
+
 constkeyFixtures={};
 
 if(hasOpenSSL(3,5)){
-keyFixtures['ml-kem-512']=readKey('ml_kem_512_private');
-keyFixtures['ml-kem-768']=readKey('ml_kem_768_private');
-keyFixtures['ml-kem-1024']=readKey('ml_kem_1024_private');
+keyFixtures['ml-kem-512']=readKeyPair('ml_kem_512_public','ml_kem_512_private');
+keyFixtures['ml-kem-768']=readKeyPair('ml_kem_768_public','ml_kem_768_private');
+keyFixtures['ml-kem-1024']=readKeyPair('ml_kem_1024_public','ml_kem_1024_private');
 }
 if(hasOpenSSL(3,2)){
-keyFixtures['p-256']=readKey('ec_p256_private');
-keyFixtures['p-384']=readKey('ec_p384_private');
-keyFixtures['p-521']=readKey('ec_p521_private');
-keyFixtures.x25519=readKey('x25519_private');
-keyFixtures.x448=readKey('x448_private');
+keyFixtures['p-256']=readKeyPair('ec_p256_public','ec_p256_private');
+keyFixtures['p-384']=readKeyPair('ec_p384_public','ec_p384_private');
+keyFixtures['p-521']=readKeyPair('ec_p521_public','ec_p521_private');
+keyFixtures.x25519=readKeyPair('x25519_public','x25519_private');
+keyFixtures.x448=readKeyPair('x448_public','x448_private');
 }
 if(hasOpenSSL(3,0)){
-keyFixtures.rsa=readKey('rsa_private_2048');
+keyFixtures.rsa=readKeyPair('rsa_public_2048','rsa_private_2048');
 }
 
 if(Object.keys(keyFixtures).length===0){
@@ -37,32 +44,46 @@ if (Object.keys(keyFixtures).length === 0) {
 constbench=common.createBenchmark(main,{
 keyType: Object.keys(keyFixtures),
 mode: ['sync','async','async-parallel'],
-keyFormat: ['keyObject','keyObject.unique'],
+keyFormat: ['keyObject','keyObject.unique','pem','der','jwk',
+'raw-public','raw-private','raw-seed'],
 op: ['encapsulate','decapsulate'],
 n: [1e3],
 },{
 combinationFilter(p){
 // "keyObject.unique" allows to compare the result with "keyObject" to
 // assess whether mutexes over the key material impact the operation
-returnp.keyFormat!=='keyObject.unique'||
-(p.keyFormat==='keyObject.unique'&&p.mode==='async-parallel');
+if(p.keyFormat==='keyObject.unique')
+returnp.mode==='async-parallel';
+// JWK is not supported for ml-kem for now
+if(p.keyFormat==='jwk')
+return!p.keyType.startsWith('ml-');
+// raw-public is only supported for encapsulate, not rsa
+if(p.keyFormat==='raw-public')
+returnp.keyType!=='rsa'&&p.op==='encapsulate';
+// raw-private is not supported for rsa and ml-kem, only for decapsulate
+if(p.keyFormat==='raw-private')
+returnp.keyType!=='rsa'&&!p.keyType.startsWith('ml-')&&p.op==='decapsulate';
+// raw-seed is only supported for ml-kem
+if(p.keyFormat==='raw-seed')
+returnp.keyType.startsWith('ml-');
+returntrue;
 },
 });
 
-functionmeasureSync(n,op,privateKey,keys,ciphertexts){
+functionmeasureSync(n,op,key,keys,ciphertexts){
 bench.start();
 for(leti=0;i<n;++i){
-constkey=privateKey||keys[i];
+constk=key||keys[i];
 if(op==='encapsulate'){
-crypto.encapsulate(key);
+crypto.encapsulate(k);
 }else{
-crypto.decapsulate(key,ciphertexts[i]);
+crypto.decapsulate(k,ciphertexts[i]);
 }
 }
 bench.end(n);
 }
 
-functionmeasureAsync(n,op,privateKey,keys,ciphertexts){
+functionmeasureAsync(n,op,key,keys,ciphertexts){
 letremaining=n;
 functiondone(){
 if(--remaining===0)
@@ -72,44 +93,98 @@ function measureAsync(n, op, privateKey, keys, ciphertexts) {
 }
 
 functionone(){
-constkey=privateKey||keys[n-remaining];
+constk=key||keys[n-remaining];
 if(op==='encapsulate'){
-crypto.encapsulate(key,done);
+crypto.encapsulate(k,done);
 }else{
-crypto.decapsulate(key,ciphertexts[n-remaining],done);
+crypto.decapsulate(k,ciphertexts[n-remaining],done);
 }
 }
 bench.start();
 one();
 }
 
-functionmeasureAsyncParallel(n,op,privateKey,keys,ciphertexts){
+functionmeasureAsyncParallel(n,op,key,keys,ciphertexts){
 letremaining=n;
 functiondone(){
 if(--remaining===0)
 bench.end(n);
 }
 bench.start();
 for(leti=0;i<n;++i){
-constkey=privateKey||keys[i];
+constk=key||keys[i];
 if(op==='encapsulate'){
-crypto.encapsulate(key,done);
+crypto.encapsulate(k,done);
 }else{
-crypto.decapsulate(key,ciphertexts[i],done);
+crypto.decapsulate(k,ciphertexts[i],done);
 }
 }
 }
 
 functionmain({ n, mode, keyFormat, keyType, op }){
-constpems=[...Buffer.alloc(n)].map(()=>keyFixtures[keyType]);
-constkeyObjects=pems.map(crypto.createPrivateKey);
+constisEncapsulate=op==='encapsulate';
+constpemSource=isEncapsulate ?
+keyFixtures[keyType].publicKey :
+keyFixtures[keyType].privateKey;
+constcreateKeyFn=isEncapsulate ? crypto.createPublicKey : crypto.createPrivateKey;
+constpems=[...Buffer.alloc(n)].map(()=>pemSource);
+constkeyObjects=pems.map(createKeyFn);
 
-letprivateKey,keys,ciphertexts;
+// Warm up OpenSSL's provider operation cache for each key object
+if(isEncapsulate){
+for(constkeyObjectofkeyObjects){
+crypto.encapsulate(keyObject);
+}
+}else{
+constwarmupCiphertext=crypto.encapsulate(keyObjects[0]).ciphertext;
+for(constkeyObjectofkeyObjects){
+crypto.decapsulate(keyObject,warmupCiphertext);
+}
+}
+
+constasymmetricKeyType=keyObjects[0].asymmetricKeyType;
+letkey,keys,ciphertexts;
 
 switch(keyFormat){
 case'keyObject':
-privateKey=keyObjects[0];
+key=keyObjects[0];
+break;
+case'pem':
+key=pems[0];
 break;
+case'jwk': {
+key={key: keyObjects[0].export({format: 'jwk'}),format: 'jwk'};
+break;
+}
+case'der': {
+consttype=isEncapsulate ? 'spki' : 'pkcs8';
+key={key: keyObjects[0].export({format: 'der', type }),format: 'der', type };
+break;
+}
+case'raw-public': {
+constexportedKey=keyObjects[0].export({format: 'raw-public'});
+constkeyOpts={key: exportedKey,format: 'raw-public', asymmetricKeyType };
+if(asymmetricKeyType==='ec')keyOpts.namedCurve=keyObjects[0].asymmetricKeyDetails.namedCurve;
+key=keyOpts;
+break;
+}
+case'raw-private': {
+constexportedKey=keyObjects[0].export({format: 'raw-private'});
+constkeyOpts={key: exportedKey,format: 'raw-private', asymmetricKeyType };
+if(asymmetricKeyType==='ec')keyOpts.namedCurve=keyObjects[0].asymmetricKeyDetails.namedCurve;
+key=keyOpts;
+break;
+}
+case'raw-seed': {
+// raw-seed requires a private key to export from
+constprivateKeyObject=crypto.createPrivateKey(keyFixtures[keyType].privateKey);
+key={
+key: privateKeyObject.export({format: 'raw-seed'}),
+format: 'raw-seed',
+ asymmetricKeyType,
+};
+break;
+}
 case'keyObject.unique':
 keys=keyObjects;
 break;
@@ -118,23 +193,25 @@ function main({ n, mode, keyFormat, keyType, op }) {
 }
 
 // Pre-generate ciphertexts for decapsulate operations
-if(op==='decapsulate'){
-if(privateKey){
-ciphertexts=[...Buffer.alloc(n)].map(()=>crypto.encapsulate(privateKey).ciphertext);
+if(!isEncapsulate){
+constencapKey=crypto.createPublicKey(
+crypto.createPrivateKey(keyFixtures[keyType].privateKey));
+if(key){
+ciphertexts=[...Buffer.alloc(n)].map(()=>crypto.encapsulate(encapKey).ciphertext);
 }else{
-ciphertexts=keys.map((key)=>crypto.encapsulate(key).ciphertext);
+ciphertexts=keys.map(()=>crypto.encapsulate(encapKey).ciphertext);
 }
 }
 
 switch(mode){
 case'sync':
-measureSync(n,op,privateKey,keys,ciphertexts);
+measureSync(n,op,key,keys,ciphertexts);
 break;
 case'async':
-measureAsync(n,op,privateKey,keys,ciphertexts);
+measureAsync(n,op,key,keys,ciphertexts);
 break;
 case'async-parallel':
-measureAsyncParallel(n,op,privateKey,keys,ciphertexts);
+measureAsyncParallel(n,op,key,keys,ciphertexts);
 break;
 }
 }

benchmark/crypto/oneshot-sign.js

@@ -29,14 +29,21 @@ let keyObjects;
 constbench=common.createBenchmark(main,{
 keyType: Object.keys(keyFixtures),
 mode: ['sync','async','async-parallel'],
-keyFormat: ['pem','der','jwk','keyObject','keyObject.unique'],
+keyFormat: ['pem','der','jwk','keyObject','keyObject.unique','raw-private','raw-seed'],
 n: [1e3],
 },{
 combinationFilter(p){
 // "keyObject.unique" allows to compare the result with "keyObject" to
 // assess whether mutexes over the key material impact the operation
-returnp.keyFormat!=='keyObject.unique'||
-(p.keyFormat==='keyObject.unique'&&p.mode==='async-parallel');
+if(p.keyFormat==='keyObject.unique')
+returnp.mode==='async-parallel';
+// raw-private is not supported for rsa and ml-dsa
+if(p.keyFormat==='raw-private')
+returnp.keyType!=='rsa'&&!p.keyType.startsWith('ml-');
+// raw-seed is only supported for ml-dsa
+if(p.keyFormat==='raw-seed')
+returnp.keyType.startsWith('ml-');
+returntrue;
 },
 });
 
@@ -91,6 +98,12 @@ function main({ n, mode, keyFormat, keyType }) {
 pems||=[...Buffer.alloc(n)].map(()=>keyFixtures[keyType]);
 keyObjects||=pems.map(crypto.createPrivateKey);
 
+// Warm up OpenSSL's provider operation cache for each key object
+for(constkeyObjectofkeyObjects){
+crypto.sign(keyType==='rsa'||keyType==='ec' ? 'sha256' : null,
+data,keyObject);
+}
+
 letprivateKey,keys,digest;
 
 switch(keyType){
@@ -120,6 +133,21 @@ function main({ n, mode, keyFormat, keyType }) {
 privateKey={key: keyObjects[0].export({format: 'der',type: 'pkcs8'}),format: 'der',type: 'pkcs8'};
 break;
 }
+case'raw-private': {
+constexportedKey=keyObjects[0].export({format: 'raw-private'});
+constkeyOpts={key: exportedKey,format: 'raw-private',asymmetricKeyType: keyType};
+if(keyType==='ec')keyOpts.namedCurve=keyObjects[0].asymmetricKeyDetails.namedCurve;
+privateKey=keyOpts;
+break;
+}
+case'raw-seed': {
+privateKey={
+key: keyObjects[0].export({format: 'raw-seed'}),
+format: 'raw-seed',
+asymmetricKeyType: keyType,
+};
+break;
+}
 case'keyObject.unique':
 keys=keyObjects;
 break;