hpke 1.1.4 → 1.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.js CHANGED
@@ -3472,9 +3472,11 @@ export const KEM_DHKEM_X448_HKDF_SHA512 = function ()
3472
3472
 
3473
3473
 
3474
3474
 
3475
- function MLKEM_SHARED() {
3475
+
3476
+
3477
+ function DIRECT_KEM_SHARED() {
3476
3478
  return {
3477
- async DeriveKeyPair( ikm, extractable) {
3479
+ async DeriveKeyPair( ikm, extractable) {
3478
3480
  const dk = await LabeledDerive(
3479
3481
  this.kdf,
3480
3482
  this.suite_id,
@@ -3491,7 +3493,7 @@ function MLKEM_SHARED() {
3491
3493
 
3492
3494
  return { privateKey, publicKey }
3493
3495
  },
3494
- async GenerateKeyPair( extractable) {
3496
+ async GenerateKeyPair( extractable) {
3495
3497
 
3496
3498
  const usages = ['encapsulateBits', 'decapsulateBits']
3497
3499
  return (await subtle(
@@ -3499,14 +3501,14 @@ function MLKEM_SHARED() {
3499
3501
  this.name,
3500
3502
  ))
3501
3503
  },
3502
- async SerializePublicKey( key) {
3504
+ async SerializePublicKey( key) {
3503
3505
  assertKeyAlgorithm(key, this.algorithm)
3504
3506
  assertCryptoKey(key)
3505
3507
 
3506
3508
  const format = 'raw-public'
3507
3509
  return new Uint8Array(await subtle((c) => c.exportKey(format, key), this.name))
3508
3510
  },
3509
- async DeserializePublicKey( key) {
3511
+ async DeserializePublicKey( key) {
3510
3512
 
3511
3513
  const format = 'raw-public'
3512
3514
 
@@ -3516,14 +3518,14 @@ function MLKEM_SHARED() {
3516
3518
  this.name,
3517
3519
  )
3518
3520
  },
3519
- async SerializePrivateKey( key) {
3521
+ async SerializePrivateKey( key) {
3520
3522
  assertKeyAlgorithm(key, this.algorithm)
3521
3523
  assertCryptoKey(key)
3522
3524
 
3523
3525
  const format = 'raw-seed'
3524
3526
  return new Uint8Array(await subtle((c) => c.exportKey(format, key), this.name))
3525
3527
  },
3526
- async DeserializePrivateKey( key, extractable) {
3528
+ async DeserializePrivateKey( key, extractable) {
3527
3529
 
3528
3530
  const format = 'raw-seed'
3529
3531
 
@@ -3533,7 +3535,7 @@ function MLKEM_SHARED() {
3533
3535
  this.name,
3534
3536
  )
3535
3537
  },
3536
- async Encap( pkR) {
3538
+ async Encap( pkR) {
3537
3539
  assertKeyAlgorithm(pkR, this.algorithm)
3538
3540
 
3539
3541
  const { sharedKey, ciphertext } = (await subtle(
@@ -3544,7 +3546,7 @@ function MLKEM_SHARED() {
3544
3546
 
3545
3547
  return { shared_secret: new Uint8Array(sharedKey), enc: new Uint8Array(ciphertext) }
3546
3548
  },
3547
- async Decap( enc, skR, _pkR) {
3549
+ async Decap( enc, skR, _pkR) {
3548
3550
  assertKeyAlgorithm(skR, this.algorithm)
3549
3551
  return new Uint8Array(
3550
3552
  await subtle(
@@ -3557,6 +3559,25 @@ function MLKEM_SHARED() {
3557
3559
  }
3558
3560
  }
3559
3561
 
3562
+ function createDirectKEM({ id, name, Nsecret, Nenc, Npk, Nsk } ) {
3563
+ const kdf = KDF_SHAKE256()
3564
+
3565
+ kdf.name = name
3566
+ return {
3567
+ id,
3568
+ suite_id: concat(L_KEM, I2OSP(id, 2)),
3569
+ type: 'KEM',
3570
+ name,
3571
+ Nsecret,
3572
+ Nenc,
3573
+ Npk,
3574
+ Nsk,
3575
+ algorithm: { name },
3576
+ kdf,
3577
+ ...DIRECT_KEM_SHARED(),
3578
+ }
3579
+ }
3580
+
3560
3581
 
3561
3582
 
3562
3583
 
@@ -3584,25 +3605,14 @@ function MLKEM_SHARED() {
3584
3605
 
3585
3606
 
3586
3607
 
3587
- export const KEM_ML_KEM_512 = function () {
3608
+ export const KEM_ML_KEM_512 = function () {
3588
3609
  const id = 0x0040
3589
3610
  const name = 'ML-KEM-512'
3590
- const kdf = KDF_SHAKE256()
3591
-
3592
- kdf.name = name
3593
- return {
3594
- id,
3595
- suite_id: concat(L_KEM, I2OSP(id, 2)),
3596
- type: 'KEM',
3597
- name,
3598
- Nsecret: 32,
3599
- Nenc: 768,
3600
- Npk: 800,
3601
- Nsk: 64,
3602
- algorithm: { name: 'ML-KEM-512' },
3603
- kdf,
3604
- ...MLKEM_SHARED(),
3605
- }
3611
+ const Nsecret = 32
3612
+ const Nenc = 768
3613
+ const Npk = 800
3614
+ const Nsk = 64
3615
+ return createDirectKEM({ id, name, Nsecret, Nenc, Npk, Nsk })
3606
3616
  }
3607
3617
 
3608
3618
 
@@ -3624,25 +3634,14 @@ export const KEM_ML_KEM_512 = function () {
3624
3634
 
3625
3635
 
3626
3636
 
3627
- export const KEM_ML_KEM_768 = function () {
3637
+ export const KEM_ML_KEM_768 = function () {
3628
3638
  const id = 0x0041
3629
3639
  const name = 'ML-KEM-768'
3630
- const kdf = KDF_SHAKE256()
3631
-
3632
- kdf.name = name
3633
- return {
3634
- id,
3635
- suite_id: concat(L_KEM, I2OSP(id, 2)),
3636
- type: 'KEM',
3637
- name,
3638
- Nsecret: 32,
3639
- Nenc: 1088,
3640
- Npk: 1184,
3641
- Nsk: 64,
3642
- algorithm: { name: 'ML-KEM-768' },
3643
- kdf,
3644
- ...MLKEM_SHARED(),
3645
- }
3640
+ const Nsecret = 32
3641
+ const Nenc = 1088
3642
+ const Npk = 1184
3643
+ const Nsk = 64
3644
+ return createDirectKEM({ id, name, Nsecret, Nenc, Npk, Nsk })
3646
3645
  }
3647
3646
 
3648
3647
 
@@ -3664,25 +3663,14 @@ export const KEM_ML_KEM_768 = function () {
3664
3663
 
3665
3664
 
3666
3665
 
3667
- export const KEM_ML_KEM_1024 = function () {
3666
+ export const KEM_ML_KEM_1024 = function () {
3668
3667
  const id = 0x0042
3669
3668
  const name = 'ML-KEM-1024'
3670
- const kdf = KDF_SHAKE256()
3671
-
3672
- kdf.name = name
3673
- return {
3674
- id,
3675
- suite_id: concat(L_KEM, I2OSP(id, 2)),
3676
- type: 'KEM',
3677
- name,
3678
- Nsecret: 32,
3679
- Nenc: 1568,
3680
- Npk: 1568,
3681
- Nsk: 64,
3682
- algorithm: { name: 'ML-KEM-1024' },
3683
- kdf,
3684
- ...MLKEM_SHARED(),
3685
- }
3669
+ const Nsecret = 32
3670
+ const Nenc = 1568
3671
+ const Npk = 1568
3672
+ const Nsk = 64
3673
+ return createDirectKEM({ id, name, Nsecret, Nenc, Npk, Nsk })
3686
3674
  }
3687
3675
 
3688
3676
 
@@ -3956,7 +3944,7 @@ function split(N1 , N2 , x )
3956
3944
  return [x1, x2]
3957
3945
  }
3958
3946
 
3959
- function RandomScalarNist(t , seed ) {
3947
+ function RandomScalarNist(t , seed ) {
3960
3948
  let sk_bigint = 0n
3961
3949
  let start = 0
3962
3950
  let end = t.Nscalar
@@ -3974,69 +3962,69 @@ function RandomScalarNist(t , seed ) {
3974
3962
  }
3975
3963
 
3976
3964
 
3977
- async function expandDecapsKeyG(PQTKEM , seed ) {
3978
- const Nout = PQTKEM.pq.Nseed + PQTKEM.t.Nseed
3965
+ async function expandDecapsKeyG(kem , seed ) {
3966
+ const Nout = kem.pq.Nseed + kem.t.Nseed
3979
3967
  const bits = Nout << 3
3980
3968
 
3981
3969
  const algorithm = { name: 'cSHAKE256', length: bits, outputLength: bits }
3982
- const seed_full = await subtle((c) => c.digest(algorithm, seed ), PQTKEM.name)
3970
+ const seed_full = await subtle((c) => c.digest(algorithm, seed ), kem.name)
3983
3971
 
3984
- const [seed_PQ, seed_T] = split(PQTKEM.pq.Nseed, PQTKEM.t.Nseed, new Uint8Array(seed_full))
3972
+ const [seed_PQ, seed_T] = split(kem.pq.Nseed, kem.t.Nseed, new Uint8Array(seed_full))
3985
3973
 
3986
3974
 
3987
3975
  const format = 'raw-seed'
3988
3976
 
3989
3977
  const usages = ['decapsulateBits', 'encapsulateBits']
3990
3978
  const dk_PQ = await subtle(
3991
- (c) => c.importKey(format, seed_PQ , PQTKEM.pq.algorithm, true, [usages[0]]),
3992
- PQTKEM.name,
3979
+ (c) => c.importKey(format, seed_PQ , kem.pq.algorithm, true, [usages[0]]),
3980
+ kem.name,
3993
3981
  )
3994
- const ek_PQ = await getPublicKey(PQTKEM.name, dk_PQ, [usages[1]])
3982
+ const ek_PQ = await getPublicKey(kem.name, dk_PQ, [usages[1]])
3995
3983
 
3996
- const sk = PQTKEM.t.RandomScalar?.(seed_T) ?? seed_T
3997
- const { privateKey: dk_T, publicKey: ek_T } = await PQTKEM.t.GetKeyPair(sk)
3984
+ const sk = kem.t.RandomScalar?.(seed_T) ?? seed_T
3985
+ const { privateKey: dk_T, publicKey: ek_T } = await kem.t.GetKeyPair(sk)
3998
3986
 
3999
3987
  return { ek_PQ, ek_T, dk_PQ, dk_T }
4000
3988
  }
4001
3989
 
4002
3990
 
4003
3991
  async function C2PRICombiner(
4004
- PQTKEM ,
3992
+ kem ,
4005
3993
  ss_PQ ,
4006
3994
  ss_T ,
4007
3995
  ct_T ,
4008
3996
  _ek_T ,
4009
3997
  label ,
4010
3998
  ) {
4011
- const ek_T = new Uint8Array(await subtle((c) => c.exportKey('raw', _ek_T), PQTKEM.name))
3999
+ const ek_T = new Uint8Array(await subtle((c) => c.exportKey('raw', _ek_T), kem.name))
4012
4000
  const data = concat(ss_PQ, ss_T, ct_T, ek_T, label)
4013
- return new Uint8Array(await subtle((c) => c.digest('SHA3-256', data), PQTKEM.name))
4001
+ return new Uint8Array(await subtle((c) => c.digest('SHA3-256', data), kem.name))
4014
4002
  }
4015
4003
 
4016
4004
 
4017
4005
  async function prepareEncapsG(
4018
- PQTKEM ,
4006
+ kem ,
4019
4007
  ek_PQ ,
4020
4008
  ek_T ,
4021
4009
  ) {
4022
4010
  const res = (await subtle(
4023
4011
 
4024
- (c) => c.encapsulateBits(PQTKEM.pq.algorithm, ek_PQ),
4025
- PQTKEM.name,
4012
+ (c) => c.encapsulateBits(kem.pq.algorithm, ek_PQ),
4013
+ kem.name,
4026
4014
  ))
4027
4015
  const ss_PQ = new Uint8Array(res.sharedKey)
4028
4016
  const ct_PQ = new Uint8Array(res.ciphertext)
4029
4017
 
4030
4018
  const { privateKey: sk_E, publicKey } = (await subtle(
4031
- (c) => c.generateKey(PQTKEM.t.algorithm, false, ['deriveBits']),
4032
- PQTKEM.name,
4019
+ (c) => c.generateKey(kem.t.algorithm, true, ['deriveBits']),
4020
+ kem.name,
4033
4021
  ))
4034
- const ct_T = new Uint8Array(await subtle((c) => c.exportKey('raw', publicKey), PQTKEM.name))
4022
+ const ct_T = new Uint8Array(await subtle((c) => c.exportKey('raw', publicKey), kem.name))
4035
4023
 
4036
4024
  const ss_T = new Uint8Array(
4037
4025
  await subtle(
4038
- (c) => c.deriveBits({ name: PQTKEM.t.algorithm.name, public: ek_T }, sk_E, PQTKEM.t.Nss << 3),
4039
- PQTKEM.name,
4026
+ (c) => c.deriveBits({ name: kem.t.algorithm.name, public: ek_T }, sk_E, kem.t.Nss << 3),
4027
+ kem.name,
4040
4028
  ),
4041
4029
  )
4042
4030
  checkNotAllZeros(ss_T)
@@ -4046,7 +4034,7 @@ async function prepareEncapsG(
4046
4034
 
4047
4035
 
4048
4036
  async function prepareDecapsG(
4049
- PQTKEM ,
4037
+ kem ,
4050
4038
  dk_PQ ,
4051
4039
  dk_T ,
4052
4040
  ct_PQ ,
@@ -4055,20 +4043,20 @@ async function prepareDecapsG(
4055
4043
  const ss_PQ = new Uint8Array(
4056
4044
  await subtle(
4057
4045
 
4058
- (c) => c.decapsulateBits(PQTKEM.pq.algorithm, dk_PQ, ct_PQ),
4059
- PQTKEM.name,
4046
+ (c) => c.decapsulateBits(kem.pq.algorithm, dk_PQ, ct_PQ),
4047
+ kem.name,
4060
4048
  ),
4061
4049
  )
4062
4050
 
4063
4051
  const pub = await subtle(
4064
- (c) => c.importKey('raw', ct_T , PQTKEM.t.algorithm, true, []),
4065
- PQTKEM.name,
4052
+ (c) => c.importKey('raw', ct_T , kem.t.algorithm, true, []),
4053
+ kem.name,
4066
4054
  )
4067
4055
 
4068
4056
  const ss_T = new Uint8Array(
4069
4057
  await subtle(
4070
- (c) => c.deriveBits({ name: PQTKEM.t.algorithm.name, public: pub }, dk_T, PQTKEM.t.Nss << 3),
4071
- PQTKEM.name,
4058
+ (c) => c.deriveBits({ name: kem.t.algorithm.name, public: pub }, dk_T, kem.t.Nss << 3),
4059
+ kem.name,
4072
4060
  ),
4073
4061
  )
4074
4062
  checkNotAllZeros(ss_T)
@@ -4104,10 +4092,12 @@ async function prepareDecapsG(
4104
4092
 
4105
4093
 
4106
4094
 
4107
- function PQTKEM_SHARED() {
4095
+
4096
+
4097
+ function COMPOSITE_HYBRID_KEM_SHARED() {
4108
4098
  Object.freeze(HybridKey.prototype)
4109
4099
  return {
4110
- async DeriveKeyPair( ikm , extractable) {
4100
+ async DeriveKeyPair( ikm , extractable) {
4111
4101
  const seed = await LabeledDerive(
4112
4102
  this.kdf,
4113
4103
  this.suite_id,
@@ -4133,10 +4123,10 @@ function PQTKEM_SHARED() {
4133
4123
 
4134
4124
  return { privateKey, publicKey }
4135
4125
  },
4136
- async GenerateKeyPair( extractable) {
4126
+ async GenerateKeyPair( extractable) {
4137
4127
  return await this.DeriveKeyPair(crypto.getRandomValues(new Uint8Array(32)), extractable)
4138
4128
  },
4139
- async SerializePublicKey( key) {
4129
+ async SerializePublicKey( key) {
4140
4130
  assertKeyAlgorithm(key, this.algorithm)
4141
4131
  HybridKey.validate(key, true)
4142
4132
 
@@ -4150,7 +4140,7 @@ function PQTKEM_SHARED() {
4150
4140
 
4151
4141
  return concat(ek_PQ, ek_T)
4152
4142
  },
4153
- async DeserializePublicKey( key) {
4143
+ async DeserializePublicKey( key) {
4154
4144
 
4155
4145
  const format = 'raw-public'
4156
4146
 
@@ -4164,13 +4154,13 @@ function PQTKEM_SHARED() {
4164
4154
 
4165
4155
  return new HybridKey(priv, this.algorithm, 'public', true, ek_PQ, ek_T)
4166
4156
  },
4167
- async SerializePrivateKey( key) {
4157
+ async SerializePrivateKey( key) {
4168
4158
  assertKeyAlgorithm(key, this.algorithm)
4169
4159
  HybridKey.validate(key, true)
4170
4160
 
4171
4161
  return key.getSeed(priv)
4172
4162
  },
4173
- async DeserializePrivateKey( key, extractable) {
4163
+ async DeserializePrivateKey( key, extractable) {
4174
4164
  const { ek_PQ, ek_T, dk_PQ, dk_T } = await expandDecapsKeyG(this, key)
4175
4165
  const publicKey = new HybridKey(priv, this.algorithm, 'public', true, ek_PQ, ek_T)
4176
4166
  const privateKey = new HybridKey(
@@ -4186,7 +4176,7 @@ function PQTKEM_SHARED() {
4186
4176
 
4187
4177
  return privateKey
4188
4178
  },
4189
- async Encap( pkR) {
4179
+ async Encap( pkR) {
4190
4180
  assertKeyAlgorithm(pkR, this.algorithm)
4191
4181
  HybridKey.validate(pkR)
4192
4182
 
@@ -4198,7 +4188,7 @@ function PQTKEM_SHARED() {
4198
4188
 
4199
4189
  return { shared_secret: ss_H, enc: ct_H }
4200
4190
  },
4201
- async Decap( enc, skR, pkR) {
4191
+ async Decap( enc, skR, pkR) {
4202
4192
  assertKeyAlgorithm(skR, this.algorithm)
4203
4193
  HybridKey.validate(skR)
4204
4194
 
@@ -4220,6 +4210,22 @@ function PQTKEM_SHARED() {
4220
4210
  }
4221
4211
  }
4222
4212
 
4213
+ function createCompositeHybridKEM(parameters ) {
4214
+ const kdf = KDF_SHAKE256()
4215
+
4216
+ kdf.name = parameters.name
4217
+ return {
4218
+ ...parameters,
4219
+ suite_id: concat(L_KEM, I2OSP(parameters.id, 2)),
4220
+ type: 'KEM',
4221
+ algorithm: { name: parameters.name },
4222
+ kdf,
4223
+ ...COMPOSITE_HYBRID_KEM_SHARED(),
4224
+ }
4225
+ }
4226
+
4227
+
4228
+
4223
4229
 
4224
4230
 
4225
4231
 
@@ -4243,24 +4249,25 @@ function PQTKEM_SHARED() {
4243
4249
 
4244
4250
 
4245
4251
 
4246
- export const KEM_MLKEM768_X25519 = function () {
4252
+
4253
+
4254
+
4255
+ export const KEM_MLKEM768_X25519 = function () {
4247
4256
  const id = 0x647a
4248
4257
  const name = 'MLKEM768-X25519'
4249
- const kdf = KDF_SHAKE256()
4250
- const pkcs8 = Uint8Array.of(0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e, 0x04, 0x22, 0x04, 0x20)
4258
+ const Nsecret = 32
4259
+ const Nenc = 1120
4260
+ const Npk = 1216
4261
+ const Nsk = 32
4262
+ const kem = { id, name, Nsecret, Nenc, Npk, Nsk }
4263
+
4264
+ if (SubtleCrypto.supports?.('generateKey', name) ?? false) {
4265
+ return createDirectKEM(kem)
4266
+ }
4251
4267
 
4252
- kdf.name = name
4253
- return {
4254
- id,
4255
- kdf,
4256
- suite_id: concat(L_KEM, I2OSP(id, 2)),
4257
- type: 'KEM',
4258
- name,
4259
- Nsecret: 32,
4260
- Nenc: 1120,
4261
- Npk: 1216,
4262
- Nsk: 32,
4263
- algorithm: { name: 'MLKEM768-X25519' },
4268
+ const pkcs8 = Uint8Array.of(0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e, 0x04, 0x22, 0x04, 0x20)
4269
+ return createCompositeHybridKEM({
4270
+ ...kem,
4264
4271
  pq: { algorithm: { name: 'ML-KEM-768' }, Nseed: 64, Npk: 1184, Nct: 1088 },
4265
4272
  t: {
4266
4273
  algorithm: { name: 'X25519' },
@@ -4277,8 +4284,7 @@ export const KEM_MLKEM768_X25519 = function () {
4277
4284
  },
4278
4285
  },
4279
4286
  label: Uint8Array.of(0x5c, 0x2e, 0x2f, 0x2f, 0x5e, 0x5c),
4280
- ...PQTKEM_SHARED(),
4281
- }
4287
+ })
4282
4288
  }
4283
4289
 
4284
4290
 
@@ -4300,23 +4306,26 @@ export const KEM_MLKEM768_X25519 = function () {
4300
4306
 
4301
4307
 
4302
4308
 
4303
- export const KEM_MLKEM768_P256 = function () {
4309
+
4310
+
4311
+
4312
+
4313
+
4314
+ export const KEM_MLKEM768_P256 = function () {
4304
4315
  const id = 0x0050
4305
4316
  const name = 'MLKEM768-P256'
4306
- const kdf = KDF_SHAKE256()
4317
+ const Nsecret = 32
4318
+ const Nenc = 1153
4319
+ const Npk = 1249
4320
+ const Nsk = 32
4321
+ const kem = { id, name, Nsecret, Nenc, Npk, Nsk }
4322
+
4323
+ if (SubtleCrypto.supports?.('generateKey', name) ?? false) {
4324
+ return createDirectKEM(kem)
4325
+ }
4307
4326
 
4308
- kdf.name = name
4309
- return {
4310
- id,
4311
- kdf,
4312
- suite_id: concat(L_KEM, I2OSP(id, 2)),
4313
- type: 'KEM',
4314
- name,
4315
- Nsecret: 32,
4316
- Nenc: 1153,
4317
- Npk: 1249,
4318
- Nsk: 32,
4319
- algorithm: { name: 'MLKEM768-P256' },
4327
+ return createCompositeHybridKEM({
4328
+ ...kem,
4320
4329
  pq: { algorithm: { name: 'ML-KEM-768' }, Nseed: 64, Npk: 1184, Nct: 1088 },
4321
4330
  t: {
4322
4331
  ...P256,
@@ -4333,8 +4342,7 @@ export const KEM_MLKEM768_P256 = function () {
4333
4342
  },
4334
4343
  },
4335
4344
  label: Uint8Array.of(0x4d, 0x4c, 0x4b, 0x45, 0x4d, 0x37, 0x36, 0x38, 0x2d, 0x50, 0x32, 0x35, 0x36),
4336
- ...PQTKEM_SHARED(),
4337
- }
4345
+ })
4338
4346
  }
4339
4347
 
4340
4348
 
@@ -4356,23 +4364,26 @@ export const KEM_MLKEM768_P256 = function () {
4356
4364
 
4357
4365
 
4358
4366
 
4359
- export const KEM_MLKEM1024_P384 = function () {
4367
+
4368
+
4369
+
4370
+
4371
+
4372
+ export const KEM_MLKEM1024_P384 = function () {
4360
4373
  const id = 0x0051
4361
4374
  const name = 'MLKEM1024-P384'
4362
- const kdf = KDF_SHAKE256()
4375
+ const Nsecret = 32
4376
+ const Nenc = 1665
4377
+ const Npk = 1665
4378
+ const Nsk = 32
4379
+ const kem = { id, name, Nsecret, Nenc, Npk, Nsk }
4380
+
4381
+ if (SubtleCrypto.supports?.('generateKey', name) ?? false) {
4382
+ return createDirectKEM(kem)
4383
+ }
4363
4384
 
4364
- kdf.name = name
4365
- return {
4366
- id,
4367
- kdf,
4368
- suite_id: concat(L_KEM, I2OSP(id, 2)),
4369
- type: 'KEM',
4370
- name,
4371
- Nsecret: 32,
4372
- Nenc: 1665,
4373
- Npk: 1665,
4374
- Nsk: 32,
4375
- algorithm: { name: 'MLKEM1024-P384' },
4385
+ return createCompositeHybridKEM({
4386
+ ...kem,
4376
4387
  pq: { algorithm: { name: 'ML-KEM-1024' }, Nseed: 64, Npk: 1568, Nct: 1568 },
4377
4388
  t: {
4378
4389
  ...P384,
@@ -4390,6 +4401,5 @@ export const KEM_MLKEM1024_P384 = function () {
4390
4401
  },
4391
4402
  },
4392
4403
  label: Uint8Array.of(0x4d, 0x4c, 0x4b, 0x45, 0x4d, 0x31, 0x30, 0x32, 0x34, 0x2d, 0x50, 0x33, 0x38, 0x34),
4393
- ...PQTKEM_SHARED(),
4394
- }
4404
+ })
4395
4405
  }