Here SHA256 denotes the NIST standard hash function [FIPS180]. SHA256-16 denotes the SHA256 hash function with its final output truncated to return the leftmost 16 bytes.

4.4. Private Key

The LM-OTS private key consists of an array of size p containing n-byte strings. Let x denote the private key. This private key must be used to sign one and only one message. It must therefore be unique from all other private keys. The following algorithm shows pseudocode for generating x.

Algorithm 0: Generating a Private Key

  set type to the typecode of the algorithm
  set n and p according to the typecode and Table 1
  for ( i = 0; i < p; i = i + 1 ) {
    set x[i] to a uniformly random n-byte string 
  }
  return u32str(type) || x[0] || x[1] || ... || x[p-1]

An implementation MAY use a pseudorandom method to compute x[i], as suggested in [Merkle79], page 46. The details of the pseudorandom method do not affect interoperability, but the cryptographic strength MUST match that of the LM-OTS algorithm.

4.5. Public Key

The LM-OTS public key is generated from the private key by iteratively applying the function H to each individual element of x, for 2^w - 1 iterations, then hashing all of the resulting values.

Each public/private key pair is associated with a single identifier I. This string MUST be 31 bytes long, and be generated as described in Section 3.2. It MUST be generated by a uniform random or pseudorandom process during the LM-OTS key pair generation, unless a structured identifier is provided as an input to the algorithm.

The diversification parameter q is an input to the algorithm, as described in Section 3.2. (In the LMS scheme, this parameter is set to the leaf number, as each LM-OTS key pair is associated with the leaf of a tree.)

The following algorithm shows pseudocode for generating the public key, where the array x is the private key.

Algorithm 1: Generating a Public Key From a Private Key

  set type to the typecode of the algorithm
  set n and p according to the typecode and Table 1
  for ( i = 0; i < p; i = i + 1 ) {
    tmp = x[i] 
    for ( j = 0; j < 2^w - 1; j = j + 1 ) {
       tmp = H(tmp || I || q || u16str(i) || u8str(j) || D_ITER)
    }
    y[i] = tmp
  }
  return H(I || q || y[0] || y[1] || ... || y[p-1] || D_PBLC)

The public key the value returned by Algorithm 1.

4.6. Checksum

A checksum is used to ensure that any forgery attempt that manipulates the elements of an existing signature will be detected. The security property that it provides is detailed in Section 11. The checksum function Cksm is defined as follows, where S denotes the byte string that is input to that function, and the value sum is a 16-bit unsigned integer:

Algorithm 2: Checksum Calculation

  sum = 0
  for ( i = 0; i < u; i = i + 1 ) {
    sum = sum + (2^w - 1) - coef(S, i, w)
  }
  return (sum << ls)

Because of the left-shift operation, the rightmost bits of the result of Cksm will often be zeros. Due to the value of p, these bits will not be used during signature generation or verification.

4.7. Signature Generation

The LM-OTS signature of a message is generated by first appending the randomizer C, the identifier string I, the diversification string q, and D_MESG to the message, then using H to compute the hash of the resulting string, concatenating the checksum of the hash to the hash itself, then considering the resulting value as a sequence of w-bit values, and using each of the the w-bit values to determine the number of times to apply the function H to the corresponding element of the private key. The outputs of the function H are concatenated together and returned as the signature. The pseudocode for this procedure is shown below.

The identifier string I and diversification string q are the same as in Section 4.5.

Algorithm 3: Generating a Signature From a Private Key and a Message

  set type to the typecode of the algorithm
  set n and p according to the typecode and Table 1
  set C to a uniformly random n-byte string 
  Q = H(C || I || q || D_MESG || message)
  for ( i = 0; i < p; i = i + 1 ) {
    a = coef(Q || Cksm(Q), i, w)
    tmp = x[i] 
    for ( j = 0; j < a; j = j + 1 ) {
       tmp = H(tmp || I || q || u16str(i) || u8str(j) || D_ITER)
    }
    y[i] = tmp
  }
  return u32str(type) || C || q || y[0] || y[1] || ... || y[p-1]

Note that this algorithm results in a signature whose elements are intermediate values of the elements computed by the public key algorithm in Section 4.5.

The signature is the string returned by Algorithm 3. Section 7 specifies the typecode and more formally defines the encoding and decoding of the string.

4.8. Signature Verification

In order to verify a message with its signature (an array of n-byte strings, denoted as y), the receiver must "complete" the series of applications of H using the w-bit values of the message hash and its checksum. This computation should result in a value that matches the provided public key.

Algorithm 4: Verifying a Signature and Message Using a Public Key

  if the signature is not at least four bytes long, return INVALID

  set type by applying uint32str() to the first four bytes of the
  signature

  if the type computed from the signature is not equal to the 
  type of the public key, return INVALID

  set n and p according to the type and Table 1
  
  if the signature is not exactly 8 + n * (p+1) bytes long, return
  INVALID
  
  parse C, q, and y from the signature as follows:
     type = first 4 bytes
     C = next n bytes 
     q = next four bytes 
     y[0] = next n bytes
     y[1] = next n bytes
     ...
     y[p-1] = next n bytes
  Q = H(C || I || q || D_MESG || message)
  for ( i = 0; i < p; i = i + 1 ) {
    a = (2^w - 1) - coef(Q || Cksm(Q), i, w)
    tmp = y[i] 
    for ( j = a+1; j < 2^w - 1; j = j + 1 ) {
       tmp = H(tmp || I || q || u16str(i) || u8str(j) || D_ITER)
    }
    z[i] = tmp
  }
  candidate = H(I || q || z[0] || z[1] || ... || z[p-1] || D_PBLC) 
  if (candidate = public_key)
    return VALID
  else
    return INVALID

5. Leighton Micali Signatures

The Leighton Micali Signature (LMS) method can sign a potentially large but fixed number of messages. An LMS system uses two cryptographic components: a one-time signature method and a hash function. Each LMS public/private key pair is associated with a perfect binary tree, each node of which contains an n-byte value. Each leaf of the tree contains the value of the public key of an LM-OTS public/private key pair. The value contained by the root of the tree is the LMS public key. Each interior node is computed by applying the hash function to the concatenation of the values of its children nodes.

An LMS system has the following parameters:

• h : the height (number of levels - 1) in the tree, and
• n : the number of bytes associated with each node.

There are 2^h leaves in the tree.

5.1. LMS Private Key

An LMS private key consists of 2^h one-time signature private keys and the leaf number of the next LM-OTS private key that has not yet been used. The leaf number is initialized to zero when the LMS private key is created.

An LMS private key MAY be generated pseudorandomly from a secret value, in which case the secret value MUST be at least n bytes long, be uniformly random, and MUST NOT be used for any other purpose than the generation of the LMS private key. The details of how this process is done do not affect interoperability; that is, the public key verification operation is independent of these details.

5.2. LMS Public Key

An LMS public key is defined as follows, where we denote the public key associated with the i^th LM-OTS private key as OTS_PUBKEY[i], with i ranging from 0 to (2^h)-1. Each instance of an LMS public/private key pair is associated with a perfect binary tree, and the nodes of that tree are indexed from 1 to 2^(h+1)-1. Each node is associated with an n-byte string, and the string for the rth node is denoted as T[r] and is defined as

 T[r] = / H(OTS_PUBKEY[r-2^h]  || I || u32str(r) || D_LEAF) if r >= 2^h
        \ H(T[2*r] || T[2*r+1] || I || u32str(r) || D_INTR) otherwise.        

The LMS public key is the string u32str(type) || I || T[1]. Section 7 specifies the typecode and more formally defines the format. The value T[1] can be computed via recursive application of the above equation, or by any equivalent method. An iterative procedure is outlined in Appendix B.

5.3. LMS Signature

An LMS signature consists of Section 7 specifies the typecode and more formally defines the format. The array of values contains the siblings of the nodes on the path from the leaf to the root but does not contain the nodes on the path itself. The array for a tree with height h will have h values. The first value is the sibling of the leaf, the next value is the sibling of the parent of the leaf, and so on up the path to the root.

• a typecode indicating the particular LMS algorithm,
• an LM-OTS signature, and
• an array of values that is associated with the path through the tree from the leaf associated with the LM-OTS signature to the root.

Symbolically, the signature can be represented as u32str(type) || lmots_signature || path[0] || path[1] || ... || path[p-1].

5.3.1. LMS Signature Generation

To compute the LMS signature of a message with an LMS private key, the signer first computes the LM-OTS signature of the message using the leaf number of the next unused LM-OTS private key. Before releasing the signature, the leaf number in the LMS private key MUST be incremented to prevent the LM-OTS private key from being used again. The node number in the signature is set to the leaf number of the LMS private key that was used in the signature. Then the signature and the LMS private key are returned.

The array of node values in the signature MAY be computed in any way. There are many potential time/storage tradeoffs that can be applied. The fastest alternative is to store all of the nodes of the tree and set the array in the signature by copying them. The least storage intensive alternative is to recompute all of the nodes for each signature. Note that the details of this procedure are not important for interoperability; it is not necessary to know any of these details in order to perform the signature verification operation. The internal nodes of the tree need not be kept secret, and thus a node-caching scheme that stores only internal nodes can sidestep the need for strong protections.

One useful time/storage tradeoff is described in Column 19 of [USPTO5432852].

5.4. LMS Signature Verification

An LMS signature is verified by first using the LM-OTS signature verification algorithm to compute the LM-OTS public key from the LM-OTS signature and the message. The value of that public key is then assigned to the associated leaf of the LMS tree, then the root of the tree is computed from the leaf value and the node array (path[]) as described below. If the root value matches the public key, then the signature is valid; otherwise, the signature fails.

Algorithm 5: LMS Signature Verification

  set pubtype by applying uint32str() to the first four bytes of the
  public key

  set sigtype by applying uint32str() to the first four bytes of the
  signature

  if pubtype is not equal to sigtype, return INVALID; otherwise,
  continue

  identify the height h of the tree from pubtype
 
  parse q from the LM-OTS signature in the LMS signature

  parse the path from the LMS signature

  parse the LMS public key value from the lms_public_key

  tmp = candidate public key computed from LM-OTS signature and message
  tmp = H(tmp || I || u32str(node_num) || D_LEAF)
  i = 0
  n = node number = 2^h + q
  while (node_num > 1) {
      if (node_num is odd):
          tmp = H(path[i] || tmp || I || u32str(node_num/2) || D_INTR)
      else:
          tmp = H(tmp || path[i] || I || u32str(node_num/2) || D_INTR)
      node_num = node_num/2
      i = i + 1
  if (tmp == LMS public key vaule) 
    return 1  // message/signature pair is valid
  else
    return 0  // message/signature pair is invalid

Upon completion, v contains the value of the root of the LMS tree for comparison.

The verifier MAY cache interior node values that have been computed during a successful signature verification for use in subsequent signature verifications. However, any implementation that does so MUST make sure any nodes that are cached during a signature verification process are deleted if that process does not result in a successful match between the root of the tree and the LMS public key.

6. Hierarchical signatures

In scenarios where it is necessary to minimize the time taken by the public key generation process, a hierarchical N-time signature scheme can be used. Leighton and Micali describe a scheme in which an LMS public key is used to sign a second LMS public key, which is then distributed along with the signatures generated with the second public key [USPTO5432852]. This hierarchical scheme, which we describe in this section, uses an LMS scheme as a component. Each level is associated with an LMS public key, private key, and signature. The number of levels denoted L, and is between two and eight, inclusive. The following notation is used, where i is an integer between 1 and L inclusive:

• prv[i] is the private key of the ith level,
• pub[i] is the public key of the ith level,
• sig[i] is the signature of the ith level, and
• info[i] is lms_key_info, a structure containing information describing the public key of the ith level, including the LMS algorithm type, OTS algorithm type, and the Identifier I.

In this section, we say that an N-time private key is exhausted when it has signed all N messages, and thus it can no longer be used for signing.

6.1. Key Generation

To generate an HSS private and public key pair, new LMS private and public keys are generated for prv[i] and pub[i] for i=1, ..., L. These key pairs MUST be generated independently, and each key pair MUST use a distinct Identity I.

The public key of the HSS scheme is pub[1], the public key of the first level, followed by the lms_key_info structures for the remaining levels.

The HSS private key consists of prv[1], ... , prv[L]. The values pub[1] and prv[1] do not change, though the values of pub[i] and prv[i] are dynamic for i > 1, and are changed by the signature generation algorithm.

6.2. Signature Generation

To sign a message using the private key prv, the following steps are performed:

• The message is signed with prv[L], and the value sig[L] is set to that result.
• The value of the HSS signature is set to sig[1] || ... || sig[L].
• If prv[L] is exhausted, then the key pair associated with that level is regenerated as follows. A new LMS public and private key pair with the same algorithm parameters is generated, and pub[L] and prv[L] are set to those values. pub[L] is signed with prv[L-1], and sig[L-1] is set to the resulting value. If prv[L-1] is exhausted, then the regeneration process is applied to that key, and so on for L-1 up to 2.

6.3. Signature Verification

To verify a signature sig and message using the public key pub, the following steps are performed:

• The signature sig is parsed into its components sig[1] || ... || sig[L].
• The signature sig[L] and message is verified using the public key pub[L]. If verification fails, then an indication of failure is returned. Otherwise, processing continues as follows.
• The signature sig[L-1] of the "message" pub[L] is verified using the public key pub[L-1]. If verification fails, then an indication of failure is returned. Otherwise, this process is repeated for all levels from L-1 down to 2.
• The signature sig[1] of the "message" pub[2] is verified using the value of the HSS public key. If verification fails, then an indication of failure is returned. Otherwise, an indication of success is returned.

7. Formats

The signature and public key formats are formally defined using the External Data Representation (XDR) [RFC4506] in order to provide an unambiguous, machine readable definition. For clarity, we also include a private key format as well, though consistency is not needed for interoperability and an implementation MAY use any private key format. Though XDR is used, these formats are simple and easy to parse without any special tools. An illustration of the layout of data in these objects is provided below. The definitions are as follows:

/*
 * one-time signature primitives
 */
enum ots_algorithm_type {
  ots_reserved         = 0,
  lmots_sha256_n16_w1  = 1,
  lmots_sha256_n16_w2  = 2,
  lmots_sha256_n16_w4  = 3,
  lmots_sha256_n16_w8  = 4,
  lmots_sha256_n32_w1  = 5,
  lmots_sha256_n32_w2  = 6,
  lmots_sha256_n32_w4  = 7,
  lmots_sha256_n32_w8  = 8
};

typedef opaque bytestring4[4];
typedef opaque bytestring16[16];
typedef opaque bytestring32[32];

struct lmots_signature_n16_p265 {
  bytestring16 C;
  bytestring4  q;
  bytestring16 y[265];
};

struct lmots_signature_n16_p133 {
  bytestring16 C;
  bytestring4  q;
  bytestring16 y[133];
};

struct lmots_signature_n16_p67 {
  bytestring16 C;
  bytestring4  q;
  bytestring16 y[67];
};

struct lmots_signature_n16_p34 {
  bytestring16 C;
  bytestring4  q;
  bytestring16 y[34];
};

struct lmots_signature_n32_p265 {
  bytestring32 C;
  bytestring4  q;
  bytestring32 y[265];
};

struct lmots_signature_n32_p133 {
  bytestring32 C;
  bytestring4  q;
  bytestring32 y[133];
};

struct lmots_signature_n32_p67 {
  bytestring32 C;
  bytestring4  q;
  bytestring32 y[67];
};

struct lmots_signature_n32_p34 {
  bytestring32 C;
  bytestring4  q;
  bytestring32 y[34];
};

union ots_signature switch (ots_algorithm_type type) {
 case lmots_sha256_n16_w1:
   lmots_signature_n16_p256 sig_n16_p265;
 case lmots_sha256_n16_w2:
   lmots_signature_n16_p133 sig_n16_p133;
 case lmots_sha256_n16_w4:
   lmots_signature_n16_p67  sig_n16_p67;
 case lmots_sha256_n16_w8:
   lmots_signature_n16_p43  sig_n16_p34;
 case lmots_sha256_n32_w1:
   lmots_signature_n32_p256 sig_n32_p265;
 case lmots_sha256_n32_w2:
   lmots_signature_n32_p133 sig_n32_p133;
 case lmots_sha256_n32_w4:
   lmots_signature_n32_p67  sig_n32_p67;
 case lmots_sha256_n32_w8:
   lmots_signature_n32_p43  sig_n32_p34;
 default:
   void;   /* error condition */
}; 

union ots_private_key switch (ots_algorithm_type type) {
 case lmots_sha256_n16_w1:
 case lmots_sha256_n16_w2:
 case lmots_sha256_n16_w4:
 case lmots_sha256_n16_w8:
      bytestring16 x16;
 case lmots_sha256_n32_w1:
 case lmots_sha256_n32_w2:
 case lmots_sha256_n32_w4:
 case lmots_sha256_n32_w8:
      bytestring32 x32;
 default:
   void;   /* error condition */
 };

/* leighton micali signature (lms) data types  */

enum lms_algorithm_type {
  lms_reserved       = 0,
  lms_sha256_n32_h20 = 1,
  lms_sha256_n32_h10 = 2,
  lms_sha256_n32_h5  = 3,
  lms_sha256_n16_h20 = 4,
  lms_sha256_n16_h10 = 5,
  lms_sha256_n16_h5  = 6
};

union lms_path switch (lms_algorithm_type type) {
 case lms_sha256_n32_h20:
   bytestring32 path_n32_h20[20]; 
 case lms_sha256_n32_h10:
   bytestring32 path_n32_h10[10];
 case lms_sha256_n32_h5:
   bytestring32 path_n32_h5[5];
 case lms_sha256_n16_h20:
   bytestring16 path_n16_h20[20]; 
 case lms_sha256_n16_h10:
   bytestring16 path_n16_h10[10];
 case lms_sha256_n16_h5:
   bytestring16 path_n16_h5[5];
 default:
   void;     /* error condition */
};

struct lms_signature {
  ots_signature lmots_sig;               
  lms_path nodes;
};

struct lms_key_n16 {
  ots_algorithm_type ots_alg_type;
  opaque I[31];                    
  opaque value[16];                
};    

struct lms_key_n32 {
  ots_algorithm_type ots_alg_type;
  opaque I[31];                    
  opaque value[32];                
};    

union lms_public_key switch (lms_algorithm_type type) {
 case lms_sha256_n32_h20:
 case lms_sha256_n32_h10:
 case lms_sha256_n32_h5:
      lms_key_n32 z_n32;
 case lms_sha256_n16_h20:
 case lms_sha256_n16_h10:
 case lms_sha256_n16_h5:
      lms_key_n16 z_n16;
  default:
   void;     /* error condition */
};

struct lms_key_info {
  lms_algorithm_type lms_alg_type;
  ots_algorithm_type ots_alg_type;
  opaque I[31];
};

union lms_private_key switch (lms_algorithm_type type) {
 case lms_sha256_n32_h20:
 case lms_sha256_n32_h10:
 case lms_sha256_n32_h5:
      lms_key_n32 z_n32;
 case lms_sha256_n16_h20:
 case lms_sha256_n16_h10:
 case lms_sha256_n16_h5:
      lms_key_n16 z_n16;
  default:
   void;     /* error condition */
};

/*
 * hierarchical signature scheme (hss)
 */

struct hss_public_key {
  lms_public_key pub;
  lms_key_info   info<7>;  
};

struct hss_private_key {
  lms_private_key pub<8>;
};

struct hss_signature {
  lms_signature sig<8>;   /* maximum of eight levels */
};

/*
 * hss_data_type and hss_data provide high level data types for all of
 * the objects that might need to be stored on a file system, as a
 * convenience to the implementer
 */
enum hss_data_type {
  reserved             = 0,
  type_lms_public_key  = 1,  
  type_lms_private_key = 2, 
  type_hss_public_key  = 3,  
  type_hss_private_key = 4, 
  type_hss_signature   = 5
};

union hss_data switch (hss_data_type type) {
 case type_lms_public_key:
   lms_public_key lms_public_key_data;
 case type_lms_private_key: 
   lms_private_key lms_private_key_data;
 case type_hss_public_key:
   hss_public_key hss_public_key_data;
 case type_hss_private_key:
   hss_private_key hss_private_key_data;
 case type_hss_signature:
   hss_signature hss_signature_data;
 default:
   void;
};   

Many of the objects start with a typecode. A verifier MUST check each of these typecodes, and a verification operation on a signature with an unknown type MUST return INVALID. The expected length of a variable-length object can be determined from its typecode, and if an object has a different length, then any signature computed from the object is INVALID.

The layout of the data inside of public keys, signatures, and private keys is illustrated below, using the following notation. Each line describes a single object, and indentation is used to show that an object is contained in another object. Some of these objects do not appear explicitly in the data format, as they are merely logical groupings. Objects that do appear explicitly are indicated by an asterisk (*). The lengths of some objects is variable, and some object names are incomplete (because more than one name might appear), so this diagriam is meant as a conceptual aid only, and not a precise definition.

hss_public_key  
   * hss_algorithm_type
     lms_public_key       
        * lms_algorithm_type
          lms_public_key_n   
             * ots_algorithm_type 
             * I
             * value
     lms_key_info         
        * lms_algorithm_type
        * ots_algorithm_type
        * I

hss_private_key 
   * hss_algorithm_type
     lms_private_key      
        * lms_algorithm_type
          lms_public_key_n    
             * ots_algorithm_type
             * I
             * value
     lms_private_key      
        * lms_algorithm_type
          lms_public_key_n    
             * ots_algorithm_type
             * I
             * value

hss_signature   
   * hss_algorithm_type
     lms_public_key
        * lms_algorithm_type
          lms_key_n   
             * ots_algorithm_type 
             * I
             * value
     lms_signature        
        ots_signature
           * ots_algorithm_type 
           * C
           * q
           * y[p]
        lms_path               
           * lms_algorithm_type
           * path[h]
     lms_signature        
        ots_signature
           * ots_algorithm_type 
           * C
           * q
           * y[p]
        lms_path               
           * lms_algorithm_type
           * path[h]

8. Rationale

The goal of this note is to describe the LM-OTS and LMS algorithms following the original references and present the modern security analysis of those algorithms. Other signature methods are out of scope and may be interesting follow-on work.

We adopt the techniques described by Leighton and Micali to mitigate attacks that amortize their work over multiple invocations of the hash function.

The values taken by the identifier I across different LMS public/private key pairs are required to be distinct in order to improve security. That distinctness ensures the uniqueness of the inputs to H across all of those public/private key pair instances, which is important for provable security in the random oracle model. The length of I is set at 31 bytes so that randomly chosen values of I will be distinct with probability at least 1 - 1/2^128 as long as there are 2^60 or fewer instances of LMS public/private key pairs.

The sizes of the parameters in the security string are such that, for n=16, the LM-OTS iterates a 55-byte value (that is, the string that is input to H() during the iteration over j during signature generation and verification is 55 bytes long). Thus, when SHA-256 is used as the function H, only a single invocation of its compression function is needed.

The signature and public key formats are designed so that they are easy to parse. Each format starts with a 32-bit enumeration value that indicates all of the details of the signature algorithm and hence defines all of the information that is needed in order to parse the format.

The Checksum Section 4.6 is calculated using a non-negative integer "sum", whose width was chosen to be an integer number of w-bit fields such that it is capable of holding the difference of the total possible number of applications of the function H as defined in the signing algorithm of Section 4.7 and the total actual number. In the worst case (i.e. the actual number of times H is iteratively applied is 0), the sum is (2^w - 1) * ceil(8*n/w). Thus for the purposes of this document, which describes signature methods based on H = SHA256 (n = 32 bytes) and w = { 1, 2, 4, 8 }, the sum variable is a 16-bit non-negative integer for all combinations of n and w. The calculation uses the parameter ls defined in Section 4.1 and calculated in Appendix A, which indicates the number of bits used in the left-shift operation.

9. History

This is the fourth version of this draft. It has the following changes from the previous version:

• In Algorithms 3 and 4, the message was moved from the initial position of the input to the function H to the final position, in the computation of the intermediate variable Q. This was done to improve security by preventing an an attacker that can find a collision in H from taking advantage of that fact via the forward chaining property of Merkle-Damgard.
• The Hierarchical Signature Scheme was generalized slightly so that it can use more than two levels.
• Several points of confusion were corrected; these had resulted from incomplete or inconsistent changes from the Merkle approach of the earlier draft to the Leighton-Micali approach.

This section is to be removed by the RFC editor upon publication.

10. IANA Considerations

The Internet Assigned Numbers Authority (IANA) is requested to create two registries: one for OTS signatures, which includes all of the LM-OTS signatures as defined in Section 3, and one for Leighton-Micali Signatures, as defined in Section 4. Additions to these registries require that a specification be documented in an RFC or another permanent and readily available reference in sufficient detail that interoperability between independent implementations is possible. Each entry in the registry contains the following elements:

• a short name, such as "LMS_SHA256_n32_h10",
• a positive number, and
• a reference to a specification that completely defines the signature method test cases that can be used to verify the correctness of an implementation.

Requests to add an entry to the registry MUST include the name and the reference. The number is assigned by IANA. These number assignments SHOULD use the smallest available palindromic number. Submitters SHOULD have their requests reviewed by the IRTF Crypto Forum Research Group (CFRG) at cfrg@ietf.org. Interested applicants that are unfamiliar with IANA processes should visit http://www.iana.org.

The numbers between 0xDDDDDDDD (decimal 3,722,304,989) and 0xFFFFFFFF (decimal 4,294,967,295) inclusive, will not be assigned by IANA, and are reserved for private use; no attempt will be made to prevent multiple sites from using the same value in different (and incompatible) ways [RFC2434].

The LM-OTS registry is as follows.

  u = ceil(8*n/w)
  v = ceil((floor(lg((2^w - 1) * u)) + 1) / w)
  ls = (number of bits in sum) - (v * w)
  p = u + v

  for ( i = 0; i < num_lmots_keys; i = i + 2 ) {
    level = 0;
    for ( j = 0; j < 2; j = j + 1 ) {
      r = node number 
      push H(OTS_PUBKEY[i+j] || I || u32str(r) || D_LEAF) onto data stack
      push level onto the integer stack
    }
    while ( height of the integer stack >= 2 ) {
      if level of the top 2 elements on the integer stack are equal {
        hash_init()
        siblings = ""
        repeat ( 2 ) {
          siblings = (pop(data stack) || siblings)
          level = pop(integer stack)
        }
        hash_update(siblings)
        r = node number 
        hash_update(I || u32str(r) || D_INTR)
        push hash_final() onto the data stack
        push (level + 1) onto the integer stack
      }
    }
  }
  public_key = pop(data stack)

     --- Pending Revision ---