-- ASN module extracted from ITU-T X.510 (10/2023)

GenAlgo {joint-iso-itu-t ds(5) module(1) genAlgo(48) 10}
DEFINITIONS IMPLICIT TAGS ::=
BEGIN

-- EXPORTS All 

IMPORTS

  ALGORITHM
    FROM
      PKI-Stub {joint-iso-itu-t ds(5) module(1) pki-stub(999) 10} WITH SUCCESSORS ;

-- The following object identifier is allocated by Rec. ITU-T X.501 | ISO/IEC 9594-2

id-algo OBJECT IDENTIFIER ::= {joint-iso-itu-t ds(5) algo(44)}

id-algo-mca  OBJECT IDENTIFIER ::= {id-algo mca(1) }  -- multiple-crypto algorithms
id-algo-ska  OBJECT IDENTIFIER ::= {id-algo ska(2) }  -- symmetric-key algorithms
id-algo-pka  OBJECT IDENTIFIER ::= {id-algo pka(3) }  -- public-key algorithms
id-algo-ha   OBJECT IDENTIFIER ::= {id-algo ha(4) }   -- hash algorithms
id-algo-dsa  OBJECT IDENTIFIER ::= {id-algo dsa(5) }  -- digital dignature algorithms
id-algo-kem  OBJECT IDENTIFIER ::= {id-algo kem(6) }  -- key establishment algorithms

-- =============================== AES ALGORITHMS =====================================

-- AES-ECB algorithms

aes-ecb128 ALGORITHM ::= {
  IDENTIFIED BY {id-algo-ska ecb128(1)} }

aes-ecb192 ALGORITHM ::= {
  IDENTIFIED BY {id-algo-ska ecb192(2)} }

aes-ecb256 ALGORITHM ::= {
  IDENTIFIED BY {id-algo-ska ecb256(3)} }

-- AES-CBC algorithms

aes-cbc128 ALGORITHM ::= {
  DYN-PARMS     AES-InitializationVector
  IDENTIFIED BY {id-algo-ska cbc128(5)} }

aes-cbc192 ALGORITHM ::= {
  DYN-PARMS     AES-InitializationVector
  IDENTIFIED BY {id-algo-ska cbc192(6)} }

aes-cbc256 ALGORITHM ::= {
  DYN-PARMS     AES-InitializationVector
  IDENTIFIED BY {id-algo-ska cbc256(7)} }

AES-InitializationVector ::= OCTET STRING (SIZE (16))

-- AES-OFB algorithms

aes-ofb128 ALGORITHM ::= {
  DYN-PARMS     AES-InitializationVector
  IDENTIFIED BY {id-algo-ska ofb128(9)} }

aes-ofb192 ALGORITHM ::= {
  DYN-PARMS     AES-InitializationVector
  IDENTIFIED BY {id-algo-ska ofb192(10)} }

aes-ofb256 ALGORITHM ::= {
  DYN-PARMS    AES-InitializationVector
  IDENTIFIED BY {id-algo-ska ofb256(11)} }

-- AES-CFB algorithms

aes-cfb128 ALGORITHM ::= {
  PARMS         NumberOfBits
  DYN-PARMS     AES-InitializationVector
  IDENTIFIED BY {id-algo-ska cfb128(13)} }

aes-cfb192 ALGORITHM ::= {
  PARMS         NumberOfBits
  DYN-PARMS     AES-InitializationVector
  IDENTIFIED BY {id-algo-ska cfb192(14)} }

aes-cfb256 ALGORITHM ::= {
  PARMS         NumberOfBits
  DYN-PARMS     AES-InitializationVector
  IDENTIFIED BY {id-algo-ska cfb256(15)} }

NumberOfBits ::= INTEGER(1..128)

-- AES-CTR algorithms

aes-ctr128 ALGORITHM ::= {
  DYN-PARMS     CtrNonce
  IDENTIFIED BY {id-algo-ska ctr128(17)} }

aes-ctr192 ALGORITHM ::= {
  DYN-PARMS     CtrNonce
  IDENTIFIED BY {id-algo-ska ctr192(18)} }

aes-ctr256 ALGORITHM ::= {
  DYN-PARMS     CtrNonce
  IDENTIFIED BY {id-algo-ska ctr256(19)} }

CtrNonce ::= OCTET STRING (SIZE (8))

-- AES-GCM algorithms

aes-128gcm ALGORITHM ::= {
  PARMS         GCM-ICVlen
  DYN-PARMS     GCM-nonce
  IDENTIFIED BY {id-algo-ska gcm128(21)} }

aes-192gcm ALGORITHM ::= {
  PARMS         GCM-ICVlen
  DYN-PARMS     GCM-nonce
  IDENTIFIED BY {id-algo-ska gcm192(22)} }

aes-256gcm ALGORITHM ::= {
  PARMS         GCM-ICVlen
  DYN-PARMS     GCM-nonce
  IDENTIFIED BY {id-algo-ska gcm256(23)} }

GCM-ICVlen ::= INTEGER (16)
GCM-nonce  ::= OCTET STRING (SIZE (12))

-- AES-SIV algorithms

aes-128gcm-siv ALGORITHM ::= {
  PARMS         GCM-SIV-ICVlen
  DYN-PARMS     GCM-SIV-nonce
  IDENTIFIED BY {id-algo-ska gcm128-siv(25)} }

aes-192gcm-siv ALGORITHM ::= {
  PARMS         GCM-SIV-ICVlen
  DYN-PARMS     GCM-SIV-nonce
  IDENTIFIED BY {id-algo-ska gcm192-siv(26)} }

aes-256gcm-siv ALGORITHM ::= {
  PARMS         GCM-SIV-ICVlen
  DYN-PARMS     GCM-SIV-nonce
  IDENTIFIED BY {id-algo-ska gcm256-siv(27)} }

GCM-SIV-ICVlen ::= INTEGER (16)
GCM-SIV-nonce  ::= OCTET STRING (SIZE (12))

-- AES-CCM algorithms

aes-128ccm ALGORITHM ::= {
  PARMS         CCM-ICVlen
  DYN-PARMS     CCM-nonce
  IDENTIFIED BY {id-algo-ska ccm128(29)} }

aes-192ccm ALGORITHM ::= {
  PARMS         CCM-ICVlen
  DYN-PARMS     CCM-nonce
  IDENTIFIED BY {id-algo-ska ccm192(30)} }

aes-256ccm ALGORITHM ::= {
  PARMS         CCM-ICVlen
  DYN-PARMS     CCM-nonce
  IDENTIFIED BY {id-algo-ska ccm256(31)} }

CCM-ICVlen ::= INTEGER (16)
CCM-nonce ::= OCTET STRING (SIZE (12))

-- AES-GMAC algorithms

aes-128gmac ALGORITHM ::= {
  PARMS         MACLength
  DYN-PARMS     GMAC-nonce
  IDENTIFIED BY {id-algo-ska gmac128(33)} }

aes-192gmac ALGORITHM ::= {
  PARMS         MACLength
  DYN-PARMS     GMAC-nonce
  IDENTIFIED BY {id-algo-ska gmac192(34)} }

aes-256gmac ALGORITHM ::= {
  PARMS         MACLength
  DYN-PARMS     GMAC-nonce
  IDENTIFIED BY {id-algo-ska gmac256(35)} }

MACLength  ::= INTEGER (12 | 13 | 14 | 15 | 16)
GMAC-nonce ::= OCTET STRING (SIZE (12))

-- AES-CMAC algorithms

aes-128cmac ALGORITHM ::= {
  PARMS         CMACLength
  IDENTIFIED BY {id-algo-ska cmac128(37)} }

aes-192cmac ALGORITHM ::= {
  PARMS         CMACLength
  IDENTIFIED BY {id-algo-ska cmac192(38)} }

aes-256cmac ALGORITHM ::= {
  PARMS         CMACLength 
  IDENTIFIED BY {id-algo-ska cmac256(39)} }

CMACLength ::= INTEGER

-- ============================ CAMMELLIA ALGORITHMS ==================================

-- CAM-ECB algorithms

cam-ecb128 ALGORITHM ::= {
  IDENTIFIED BY {id-algo-ska ecb128(1) cam(2)} }

cam-ecb192 ALGORITHM ::= {
  IDENTIFIED BY {id-algo-ska ecb192(2) cam(2)} }

cam-ecb256 ALGORITHM ::= {
  IDENTIFIED BY {id-algo-ska ecb256(3) cam(2)} }

-- CAM-CBC algorithms

cam-cbc128 ALGORITHM ::= {
  DYN-PARMS     CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska cbc128(5) cam(2)} }

cam-cbc192 ALGORITHM ::= {
  DYN-PARMS     CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska cbc192(6) cam(2)} }

cam-cbc256 ALGORITHM ::= {
  DYN-PARMS     CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska cbc256(7) cam(2)} }

CAM-InitializationVector ::= OCTET STRING (SIZE (16))

-- CAM-OFB algorithms

cam-ofb128 ALGORITHM ::= {
  DYN-PARMS     CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska ofb128(9) cam(2)} }

cam-ofb192 ALGORITHM ::= {
  DYN-PARMS     CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska ofb192(10) cam(2)} }

cam-ofb256 ALGORITHM ::= {
  DYN-PARMS    CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska ofb256(11) cam(2)} }

-- CAM-CFB algorithms

cam-cfb128 ALGORITHM ::= {
  PARMS         CamNumberOfBits
  DYN-PARMS     CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska cfb128(13) cam(2)} }

cam-cfb192 ALGORITHM ::= {
  PARMS         CamNumberOfBits
  DYN-PARMS     CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska cfb192(14) cam(2)} }

cam-cfb256 ALGORITHM ::= {
  PARMS         CamNumberOfBits
  DYN-PARMS     CAM-InitializationVector
  IDENTIFIED BY {id-algo-ska cfb256(15) cam(2)} }

CamNumberOfBits ::= INTEGER(1..128)

-- CAM-CTR algorithms

cam-ctr128 ALGORITHM ::= {
  DYN-PARMS     CAM-CtrNonce
  IDENTIFIED BY {id-algo-ska ctr128(17) cam(2)} }

cam-ctr192 ALGORITHM ::= {
  DYN-PARMS     CAM-CtrNonce
  IDENTIFIED BY {id-algo-ska ctr192(18) cam(2)} }

cam-ctr256 ALGORITHM ::= {
  DYN-PARMS     CAM-CtrNonce
  IDENTIFIED BY {id-algo-ska ctr256(19) cam(2)} }

CAM-CtrNonce ::= OCTET STRING (SIZE (8))

-- CAM-GCM algorithms

cam-128gcm ALGORITHM ::= {
  PARMS         CAM-GCM-ICVlen
  DYN-PARMS     CAM-GCM-nonce
  IDENTIFIED BY {id-algo-ska gcm128(21) cam(2)} }

cam-192gcm ALGORITHM ::= {
  PARMS         CAM-GCM-ICVlen
  DYN-PARMS     CAM-GCM-nonce
  IDENTIFIED BY {id-algo-ska gcm192(22) cam(2)} }

cam-256gcm ALGORITHM ::= {
  PARMS         CAM-GCM-ICVlen
  DYN-PARMS     CAM-GCM-nonce
  IDENTIFIED BY {id-algo-ska gcm256(23) cam(2)} }

CAM-GCM-ICVlen ::= INTEGER (16)
CAM-GCM-nonce  ::= OCTET STRING (SIZE (12))

-- CAM-SIV algorithms

cam-128gcm-siv ALGORITHM ::= {
  PARMS         CAM-GCM-SIV-ICVlen
  DYN-PARMS     CAM-GCM-SIV-nonce
  IDENTIFIED BY {id-algo-ska gcm128-siv(25) cam(2)} }

cam-192gcm-siv ALGORITHM ::= {
  PARMS         CAM-GCM-SIV-ICVlen
  DYN-PARMS     CAM-GCM-SIV-nonce
  IDENTIFIED BY {id-algo-ska gcm192-siv(26) cam(2)} }

cam-256gcm-siv ALGORITHM ::= {
  PARMS         CAM-GCM-SIV-ICVlen
  DYN-PARMS     CAM-GCM-SIV-nonce
  IDENTIFIED BY {id-algo-ska gcm256-siv(27) cam(2)} }

CAM-GCM-SIV-ICVlen ::= INTEGER (16)
CAM-GCM-SIV-nonce  ::= OCTET STRING (SIZE (12))

-- CAM-CCM algorithms

cam-128ccm ALGORITHM ::= {
  PARMS         CAM-CCM-ICVlen
  DYN-PARMS     CAM-CCM-nonce
  IDENTIFIED BY {id-algo-ska ccm128(29) cam(2)} }

cam-192ccm ALGORITHM ::= {
  PARMS         CAM-CCM-ICVlen
  DYN-PARMS     CAM-CCM-nonce
  IDENTIFIED BY {id-algo-ska ccm192(30) cam(2)} }

cam-256ccm ALGORITHM ::= {
  PARMS         CAM-CCM-ICVlen
  DYN-PARMS     CAM-CCM-nonce
  IDENTIFIED BY {id-algo-ska ccm256(31) cam(2)} }

CAM-CCM-ICVlen ::= INTEGER (16)
CAM-CCM-nonce ::= OCTET STRING (SIZE (12))

-- CAM-GMAC algorithms

cam-128gmac ALGORITHM ::= {
  PARMS         CAM-MACLength
  DYN-PARMS     CAM-GMAC-nonce
  IDENTIFIED BY {id-algo-ska gmac128(33) cam(2)} }

cam-192gmac ALGORITHM ::= {
  PARMS         CAM-MACLength
  DYN-PARMS     CAM-GMAC-nonce
  IDENTIFIED BY {id-algo-ska gmac192(34) cam(2)} }

cam-256gmac ALGORITHM ::= {
  PARMS         CAM-MACLength
  DYN-PARMS     CAM-GMAC-nonce
  IDENTIFIED BY {id-algo-ska gmac256(35) cam(2)} }

CAM-MACLength  ::= INTEGER (12 | 13 | 14 | 15 | 16)
CAM-GMAC-nonce ::= OCTET STRING (SIZE (12))

-- CAM-CMAC algorithms

cam-128cmac ALGORITHM ::= {
  PARMS         CAM-CMACLength
  IDENTIFIED BY {id-algo-ska cmac128(37) cam(2)} }

cam-192cmac ALGORITHM ::= {
  PARMS         CAM-CMACLength
  IDENTIFIED BY {id-algo-ska cmac192(38) cam(2)} }

cam-256cmac ALGORITHM ::= {
  PARMS         CAM-CMACLength 
  IDENTIFIED BY {id-algo-ska cmac256(39)cam(2) } }

CAM-CMACLength ::= INTEGER

-- ============================== SEED ALGORITHMS =====================================

-- SEED-ECB algorithm

seed-ecb128 ALGORITHM ::= {
  IDENTIFIED BY {id-algo-ska ecb128(1) seed(3)} }

-- SEED-CBC algorithm

seed-cbc128 ALGORITHM ::= {
  DYN-PARMS     SEED-InitializationVector
  IDENTIFIED BY {id-algo-ska cbc128(5) seed(3)} }

SEED-InitializationVector ::= OCTET STRING (SIZE (16))

-- SEED-OFB algorithm

seed-ofb128 ALGORITHM ::= {
  DYN-PARMS     SEED-InitializationVector
  IDENTIFIED BY {id-algo-ska ofb128(9) seed(3)} }

-- SEED-CFB algorithm

seed-cfb128 ALGORITHM ::= {
  PARMS         SEED-NumberOfBits
  DYN-PARMS     SEED-InitializationVector
  IDENTIFIED BY {id-algo-ska cfb128(13) seed(3)} }

SEED-NumberOfBits ::= INTEGER(1..128)

-- SEED-CTR algorithm

seed-ctr128 ALGORITHM ::= {
  DYN-PARMS     SEED-CtrNonce
  IDENTIFIED BY {id-algo-ska ctr128(17) seed(3)} }

SEED-CtrNonce ::= OCTET STRING (SIZE (8))

-- SEED-GCM algorithm

seed-128gcm ALGORITHM ::= {
  PARMS         SEED-GCM-ICVlen
  DYN-PARMS     SEED-GCM-nonce
  IDENTIFIED BY {id-algo-ska gcm128(21) seed(3)} }

SEED-GCM-ICVlen ::= INTEGER (16)
SEED-GCM-nonce  ::= OCTET STRING (SIZE (12))

-- SEED-SIV algorithm

seed-128gcm-siv ALGORITHM ::= {
  PARMS         SEED-GCM-SIV-ICVlen
  DYN-PARMS     SEED-GCM-SIV-nonce
  IDENTIFIED BY {id-algo-ska gcm128-siv(25) seed(3)} }

SEED-GCM-SIV-ICVlen ::= INTEGER (16)
SEED-GCM-SIV-nonce  ::= OCTET STRING (SIZE (12))

-- SEED-CCM algorithm

seed-128ccm ALGORITHM ::= {
  PARMS         SEED-CCM-ICVlen
  DYN-PARMS     SEED-CCM-nonce
  IDENTIFIED BY {id-algo-ska ccm128(29) seed(3)} }

SEED-CCM-ICVlen ::= INTEGER (16)
SEED-CCM-nonce ::= OCTET STRING (SIZE (12))

-- SEED-GMAC algorithm

seed-128gmac ALGORITHM ::= {
  PARMS         SEED-MACLength
  DYN-PARMS     SEED-GMAC-nonce
  IDENTIFIED BY {id-algo-ska gmac128(33) seed(3)} }

SEED-MACLength  ::= INTEGER (12 | 13 | 14 | 15 | 16)
SEED-GMAC-nonce ::= OCTET STRING (SIZE (12))

-- SEED-CMAC algorithm

seed-128cmac ALGORITHM ::= {
  PARMS         SEED-CMACLength
  IDENTIFIED BY {id-algo-ska cmac128(37) seed(3)} }

SEED-CMACLength ::= INTEGER

-- =============================== SM4 ALGORITHMS =====================================

-- SM4-ECB algorithm

sm4-ecb128 ALGORITHM ::= {
  IDENTIFIED BY {id-algo-ska ecb128(1) sm4(4)} }

-- SM4-CBC algorithm

sm4-cbc128 ALGORITHM ::= {
  DYN-PARMS     SM4-InitializationVector
  IDENTIFIED BY {id-algo-ska cbc128(5) sm4(4)} }

SM4-InitializationVector ::= OCTET STRING (SIZE (16))

-- SM4-OFB algorithm

sm4-ofb128 ALGORITHM ::= {
  DYN-PARMS     SM4-InitializationVector
  IDENTIFIED BY {id-algo-ska ofb128(9) sm4(4)} }

-- SM4-CFB algorithm

sm4-cfb128 ALGORITHM ::= {
  PARMS         SM4-NumberOfBits
  DYN-PARMS     SM4-InitializationVector
  IDENTIFIED BY {id-algo-ska cfb128(13) sm4(4)} }

SM4-NumberOfBits ::= INTEGER(1..128)

-- SM4-CTR algorithm

sm4-ctr128 ALGORITHM ::= {
  DYN-PARMS     SM4-CtrNonce
  IDENTIFIED BY {id-algo-ska ctr128(17) sm4(4)} }

SM4-CtrNonce ::= OCTET STRING (SIZE (8))

-- SM4-GCM algorithm

sm4-128gcm ALGORITHM ::= {
  PARMS         SM4-GCM-ICVlen
  DYN-PARMS     SM4-GCM-nonce
  IDENTIFIED BY {id-algo-ska gcm128(21) sm4(4)} }

SM4-GCM-ICVlen ::= INTEGER (16)
SM4-GCM-nonce  ::= OCTET STRING (SIZE (12))

-- SM4-SIV algorithm

sm4-128gcm-siv ALGORITHM ::= {
  PARMS         SM4-GCM-SIV-ICVlen
  DYN-PARMS     SM4-GCM-SIV-nonce
  IDENTIFIED BY {id-algo-ska gcm128-siv(25) sm4(4)} }

SM4-GCM-SIV-ICVlen ::= INTEGER (16)
SM4-GCM-SIV-nonce  ::= OCTET STRING (SIZE (12))

-- SM4-CCM algorithm

sm4-128ccm ALGORITHM ::= {
  PARMS         SM4-CCM-ICVlen
  DYN-PARMS     SM4-CCM-nonce
  IDENTIFIED BY {id-algo-ska ccm128(29) sm4(4)} }

SM4-CCM-ICVlen ::= INTEGER (16)
SM4-CCM-nonce ::= OCTET STRING (SIZE (12))

-- SM4-GMAC algorithm

sm4-128gmac ALGORITHM ::= {
  PARMS         SM4-MACLength
  DYN-PARMS     SM4-GMAC-nonce
  IDENTIFIED BY {id-algo-ska gmac128(33) sm4(4)} }

SM4-MACLength  ::= INTEGER (12 | 13 | 14 | 15 | 16)
SM4-GMAC-nonce ::= OCTET STRING (SIZE (12))

-- SM4-CMAC algorithm

sm4-128cmac ALGORITHM ::= {
  PARMS         SM4-CMACLength
  IDENTIFIED BY {id-algo-ska cmac128(37) sm4(4)} }

SM4-CMACLength ::= INTEGER

-- Key establishment algorithms

dhModpGr14Hkdf256Algo ALGORITHM ::= {
  PARMS         Group14
  DYN-PARMS     Payload14
  IDENTIFIED BY id-algo-dhModpGr14Hkdf256Algo }

Group14 ::= INTEGER (14)

Payload14 ::= SEQUENCE {
  dhPublicKey OCTET STRING (SIZE (256)),
  nonce       OCTET STRING (SIZE (32)),
  ... }

dhModpGr15Hkdf384Algo ALGORITHM ::= {
  PARMS         Group15
  DYN-PARMS     Payload15
  IDENTIFIED BY id-algo-dhModpGr15Hkdf384Algo }

Group15 ::= INTEGER (15)

Payload15 ::= SEQUENCE {
  dhPublicKey OCTET STRING (SIZE (384)),
  nonce       OCTET STRING (SIZE (32)),
  ... }

dhModpGr16Hkdf512Algo ALGORITHM ::= {
  PARMS         Group16
  DYN-PARMS     Payload16
  IDENTIFIED BY id-algo-dhModpGr16Hkdf512Algo }

Group16 ::= INTEGER (16)

Payload16 ::= SEQUENCE {
  dhPublicKey OCTET STRING (SIZE (512)),
  nonce       OCTET STRING (SIZE (32)),
  ... }

dhModpGr17Hkdf768Algo ALGORITHM ::= {
  PARMS         Group17
  DYN-PARMS     Payload17
  IDENTIFIED BY id-algo-dhModpGr17Hkdf768Algo }

Group17 ::= INTEGER (17)

Payload17 ::= SEQUENCE {
  dhPublicKey OCTET STRING (SIZE (768)),
  nonce       OCTET STRING (SIZE (32)),
  ... }

dhModpGr18Hkdf1024Algo ALGORITHM ::= {
  PARMS         Group18
  DYN-PARMS     Payload18
  IDENTIFIED BY id-algo-dhModpGr18Hkdf1024Algo }

Group18 ::= INTEGER (18)

Payload18 ::= SEQUENCE {
  dhPublicKey OCTET STRING (SIZE (1024)),
  nonce       OCTET STRING (SIZE (32)),
  ... }

dhModpGr23Hkdf256Algo ALGORITHM ::= {
  PARMS         Group23
  DYN-PARMS     Payload23
  IDENTIFIED BY id-algo-dhModpGr23Hkdf256Algo }

Group23 ::= INTEGER (23)

Payload23 ::= SEQUENCE {
  dhPublicKey OCTET STRING (SIZE (512)),
  nonce       OCTET STRING (SIZE (32)),
  ... }

dhModpGr28Hkdf256Algo ALGORITHM ::= {
  PARMS         Group28
  DYN-PARMS     Payload28
  IDENTIFIED BY id-algo-dhModpGr28Hkdf256Algo }

Group28 ::= INTEGER (28)

Payload28 ::= SEQUENCE {
  dhPublicKey OCTET STRING (SIZE (512)),
  nonce       OCTET STRING (SIZE (32)),
  ... }

-- Object identifier allocation

id-algo-dhModpGr14Hkdf256Algo       OBJECT IDENTIFIER ::= {id-algo-kem 1}
id-algo-dhModpGr15Hkdf384Algo       OBJECT IDENTIFIER ::= {id-algo-kem 2}
id-algo-dhModpGr16Hkdf512Algo       OBJECT IDENTIFIER ::= {id-algo-kem 3}
id-algo-dhModpGr17Hkdf768Algo       OBJECT IDENTIFIER ::= {id-algo-kem 4}
id-algo-dhModpGr18Hkdf1024Algo      OBJECT IDENTIFIER ::= {id-algo-kem 5}

id-algo-dhModpGr23Hkdf256Algo       OBJECT IDENTIFIER ::= {id-algo-kem 10}

id-algo-dhModpGr28Hkdf256Algo       OBJECT IDENTIFIER ::= {id-algo-kem 15}

END -- GenAlgo