+typedef struct keyset keyset;
+typedef struct algswitch algswitch;
+typedef struct kdata kdata;
+typedef struct admin admin;
+
+typedef struct dhgrp {
+ const struct dhops *ops;
+ size_t scsz;
+} dhgrp;
+
+typedef struct dhsc dhsc;
+typedef struct dhge dhge;
+
+enum {
+ DHFMT_STD, /* Fixed-width format, suitable for encryption */
+ DHFMT_HASH, /* Deterministic format, suitable for hashing */
+ DHFMT_VAR /* Variable-width-format, mostly a bad idea */
+};
+
+typedef struct deriveargs {
+ const char *what; /* Operation name (hashed) */
+ unsigned f; /* Flags */
+#define DF_IN 1u /* Make incoming key */
+#define DF_OUT 2u /* Make outgoing key */
+ const gchash *hc; /* Hash class */
+ const octet *k; /* Pointer to contributions */
+ size_t x, y, z; /* Markers in contributions */
+} deriveargs;
+
+typedef struct bulkalgs {
+ const struct bulkops *ops;
+} bulkalgs;
+
+typedef struct bulkctx {
+ const struct bulkops *ops;
+} bulkctx;
+
+typedef struct bulkchal {
+ const struct bulkops *ops;
+ size_t tagsz;
+} bulkchal;
+
+typedef struct dhops {
+ const char *name;
+
+ int (*ldpriv)(key_file */*kf*/, key */*k*/, key_data */*d*/,
+ kdata */*kd*/, dstr */*t*/, dstr */*e*/);
+ /* Load a private key from @d@, storing the data in @kd@. The key's
+ * file and key object are in @kf@ and @k@, mostly in case its
+ * attributes are interesting; the key tag is in @t@; errors are
+ * reported by writing tokens to @e@ and returning nonzero.
+ */
+
+ int (*ldpub)(key_file */*kf*/, key */*k*/, key_data */*d*/,
+ kdata */*kd*/, dstr */*t*/, dstr */*e*/);
+ /* Load a public key from @d@, storing the data in @kd@. The key's
+ * file and key object are in @kf@ and @k@, mostly in case its
+ * attributes are interesting; the key tag is in @t@; errors are
+ * reported by writing tokens to @e@ and returning nonzero.
+ */
+
+ const char *(*checkgrp)(const dhgrp */*g*/);
+ /* Check that the group is valid; return null on success, or an error
+ * string.
+ */
+
+ void (*grpinfo)(const dhgrp */*g*/, admin */*a*/);
+ /* Report on the group to an admin client. */
+
+ T( void (*tracegrp)(const dhgrp */*g*/); )
+ /* Trace a description of the group. */
+
+ int (*samegrpp)(const dhgrp */*g*/, const dhgrp */*gg*/);
+ /* Return nonzero if the two group objects represent the same
+ * group.
+ */
+
+ void (*freegrp)(dhgrp */*g*/);
+ /* Free a group and the resources it holds. */
+
+ dhsc *(*ldsc)(const dhgrp */*g*/, const void */*p*/, size_t /*sz*/);
+ /* Load a scalar from @p@, @sz@ and return it. Return null on
+ * error.
+ */
+
+ int (*stsc)(const dhgrp */*g*/,
+ void */*p*/, size_t /*sz*/, const dhsc */*x*/);
+ /* Store a scalar at @p@, @sz@. Return nonzero on error. */
+
+ dhsc *(*randsc)(const dhgrp */*g*/);
+ /* Return a random scalar. */
+
+ T( const char *(*scstr)(const dhgrp */*g*/, const dhsc */*x*/); )
+ /* Return a human-readable representation of @x@; @buf_t@ may be used
+ * to hold it.
+ */
+
+ void (*freesc)(const dhgrp */*g*/, dhsc */*x*/);
+ /* Free a scalar and the resources it holds. */
+
+ dhge *(*ldge)(const dhgrp */*g*/, buf */*b*/, int /*fmt*/);
+ /* Load a group element from @b@, encoded using format @fmt@. Return
+ * null on error.
+ */
+
+ int (*stge)(const dhgrp */*g*/, buf */*b*/,
+ const dhge */*Y*/, int /*fmt*/);
+ /* Store a group element in @b@, encoded using format @fmt@. Return
+ * nonzero on error.
+ */
+
+ int (*checkge)(const dhgrp */*h*/, const dhge */*Y*/);
+ /* Check a group element for validity. Return zero if everything
+ * checks out; nonzero on failure.
+ */
+
+ int (*eq)(const dhgrp */*g*/, const dhge */*Y*/, const dhge */*Z*/);
+ /* Return nonzero if @Y@ and @Z@ are equal. */
+
+ dhge *(*mul)(const dhgrp */*g*/, const dhsc */*x*/, const dhge */*Y*/);
+ /* Multiply a group element by a scalar, resulting in a shared-secret
+ * group element. If @y@ is null, then multiply the well-known
+ * generator.
+ */
+
+ T( const char *(*gestr)(const dhgrp */*g*/, const dhge */*Y*/); )
+ /* Return a human-readable representation of @Y@; @buf_t@ may be used
+ * to hold it.
+ */
+
+ void (*freege)(const dhgrp */*g*/, dhge */*Y*/);
+ /* Free a group element and the resources it holds. */
+
+} dhops;
+
+typedef struct bulkops {
+ const char *name;
+
+ bulkalgs *(*getalgs)(const algswitch */*asw*/, dstr */*e*/,
+ key_file */*kf*/, key */*k*/);
+ /* Determine algorithms to use and return a @bulkalgs@ object
+ * representing the decision. On error, write tokens to @e@ and
+ * return null.
+ */
+
+ T( void (*tracealgs)(const bulkalgs */*a*/); )
+ /* Write trace information about the algorithm selection. */
+
+ int (*checkalgs)(bulkalgs */*a*/, const algswitch */*asw*/, dstr */*e*/);
+ /* Check that the algorithms in @a@ and @asw@ are acceptable. On
+ * error, write tokens to @e@ and return @-1@; otherwise return zero.
+ */
+
+ int (*samealgsp)(const bulkalgs */*a*/, const bulkalgs */*aa*/);
+ /* If @a@ and @aa@ represent the same algorithm selection, return
+ * nonzero; if not, return zero.
+ */
+
+ void (*alginfo)(const bulkalgs */*a*/, admin */*adm*/);
+ /* Report on the algorithm selection to an admin client: call
+ * @a_info@ with appropriate key-value pairs.
+ */
+
+ size_t (*overhead)(const bulkalgs */*a*/);
+ /* Return the per-packet overhead of the bulk transform, in bytes. */
+
+ size_t (*expsz)(const bulkalgs */*a*/);
+ /* Return the total size limit for the bulk transform, in bytes,
+ * after which the keys must no longer be used.
+ */
+
+ bulkctx *(*genkeys)(const bulkalgs */*a*/, const deriveargs */*a*/);
+ /* Generate session keys and construct and return an appropriate
+ * context for using them. The offsets @a->x@, @a->y@ and @a->z@
+ * separate the key material into three parts. Between @a->k@ and
+ * @a->k + a->x@ is `my' contribution to the key material; between
+ * @a->k + a->x@ and @a->k + a->y@ is `your' contribution; and
+ * between @a->k + a->y@ and @a->k + a->z@ is a shared value we made
+ * together. These are used to construct (up to) two collections of
+ * symmetric keys: one for outgoing messages, the other for incoming
+ * messages. If @a->x == 0@ (or @a->y == a->x@) then my (or your)
+ * contribution is omitted.
+ */
+
+ bulkchal *(*genchal)(const bulkalgs */*a*/);
+ /* Construct and return a challenge issuing and verification
+ * context with a fresh random key.
+ */
+
+ void (*freealgs)(bulkalgs */*a*/);
+ /* Release an algorithm selection object. (Associated bulk
+ * encryption contexts and challenge contexts may still exist and
+ * must remain valid.)
+ */
+
+ int (*encrypt)(bulkctx */*bc*/, unsigned /*ty*/,
+ buf */*b*/, buf */*bb*/, uint32 /*seq*/);
+ /* Encrypt the packet in @b@, with type @ty@ (which doesn't need
+ * encoding separately) and sequence number @seq@ (which must be
+ * recoverable by @decrypt@), and write the result to @bb@. On
+ * error, return a @KSERR_...@ code and/or break the output buffer.
+ */
+
+ int (*decrypt)(bulkctx */*bc*/, unsigned /*ty*/,
+ buf */*b*/, buf */*bb*/, uint32 */*seq*/);
+ /* Decrypt the packet in @b@, with type @ty@, writing the result to
+ * @bb@ and storing the incoming (claimed) sequence number in @seq@.
+ * On error, return a @KSERR_...@ code.
+ */
+
+ void (*freectx)(bulkctx */*a*/);
+ /* Release a bulk encryption context and the resources it holds. */
+
+ int (*chaltag)(bulkchal */*bc*/, const void */*m*/, size_t /*msz*/,
+ uint32 /*seq*/, void */*t*/);
+ /* Calculate a tag for the challenge in @m@, @msz@, with the sequence
+ * number @seq@, and write it to @t@. Return @-1@ on error, zero on
+ * success.
+ */
+
+ int (*chalvrf)(bulkchal */*bc*/, const void */*m*/, size_t /*msz*/,
+ uint32 /*seq*/, const void */*t*/);
+ /* Check the tag @t@ on @m@, @msz@ and @seq@: return zero if the tag
+ * is OK, nonzero if it's bad.
+ */
+
+ void (*freechal)(bulkchal */*bc*/);
+ /* Release a challenge context and the resources it holds. */
+
+} bulkops;
+
+struct algswitch {
+ const gchash *h; size_t hashsz; /* Hash function */