/src/strongswan/src/libstrongswan/plugins/plugin_feature.c

Source
/*
 * Copyright (C) 2016-2019 Andreas Steffen
 * Copyright (C) 2012-2015 Tobias Brunner
 * Copyright (C) 2011 Martin Willi
 *
 * Copyright (C) secunet Security Networks AG
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 */

#define _GNU_SOURCE
#include <stdio.h>

#include "plugin_feature.h"

#include <utils/debug.h>

ENUM(plugin_feature_names, FEATURE_NONE, FEATURE_CUSTOM,
  "NONE",
  "CRYPTER",
  "AEAD",
  "SIGNER",
  "HASHER",
  "PRF",
  "XOF",
  "KDF",
  "DRBG",
  "KE",
  "RNG",
  "NONCE_GEN",
  "PRIVKEY",
  "PRIVKEY_GEN",
  "PRIVKEY_SIGN",
  "PRIVKEY_DECRYPT",
  "PUBKEY",
  "PUBKEY_VERIFY",
  "PUBKEY_ENCRYPT",
  "CERT_DECODE",
  "CERT_ENCODE",
  "CONTAINER_DECODE",
  "CONTAINER_ENCODE",
  "EAP_SERVER",
  "EAP_CLIENT",
  "XAUTH_SERVER",
  "XAUTH_CLIENT",
  "DATABASE",
  "FETCHER",
  "RESOLVER",
  "CUSTOM",
);

/**
 * See header.
 */
uint32_t plugin_feature_hash(plugin_feature_t *feature)
{
  chunk_t data = chunk_empty;

  switch (feature->type)
  {
    case FEATURE_NONE:
    case FEATURE_RNG:
    case FEATURE_NONCE_GEN:
    case FEATURE_DATABASE:
    case FEATURE_FETCHER:
    case FEATURE_RESOLVER:
      /* put these special cases in their (type-specific) buckets */
      data = chunk_empty;
      break;
    case FEATURE_CRYPTER:
      data = chunk_from_thing(feature->arg.crypter);
      break;
    case FEATURE_AEAD:
      data = chunk_from_thing(feature->arg.aead);
      break;
    case FEATURE_SIGNER:
      data = chunk_from_thing(feature->arg.signer);
      break;
    case FEATURE_HASHER:
      data = chunk_from_thing(feature->arg.hasher);
      break;
    case FEATURE_PRF:
      data = chunk_from_thing(feature->arg.prf);
      break;
    case FEATURE_XOF:
      data = chunk_from_thing(feature->arg.xof);
      break;
    case FEATURE_KDF:
      data = chunk_from_thing(feature->arg.kdf);
      break;
    case FEATURE_DRBG:
      data = chunk_from_thing(feature->arg.drbg);
      break;
    case FEATURE_KE:
      data = chunk_from_thing(feature->arg.ke);
      break;
    case FEATURE_PRIVKEY:
      data = chunk_from_thing(feature->arg.privkey);
      break;
    case FEATURE_PRIVKEY_GEN:
      data = chunk_from_thing(feature->arg.privkey_gen);
      break;
    case FEATURE_PUBKEY:
      data = chunk_from_thing(feature->arg.pubkey);
      break;
    case FEATURE_PRIVKEY_SIGN:
      data = chunk_from_thing(feature->arg.privkey_sign);
      break;
    case FEATURE_PUBKEY_VERIFY:
      data = chunk_from_thing(feature->arg.pubkey_verify);
      break;
    case FEATURE_PRIVKEY_DECRYPT:
      data = chunk_from_thing(feature->arg.privkey_decrypt);
      break;
    case FEATURE_PUBKEY_ENCRYPT:
      data = chunk_from_thing(feature->arg.pubkey_encrypt);
      break;
    case FEATURE_CERT_DECODE:
    case FEATURE_CERT_ENCODE:
      data = chunk_from_thing(feature->arg.cert);
      break;
    case FEATURE_CONTAINER_DECODE:
    case FEATURE_CONTAINER_ENCODE:
      data = chunk_from_thing(feature->arg.container);
      break;
    case FEATURE_EAP_SERVER:
    case FEATURE_EAP_PEER:
      data = chunk_from_thing(feature->arg.eap);
      break;
    case FEATURE_CUSTOM:
      data = chunk_create(feature->arg.custom,
                strlen(feature->arg.custom));
      break;
    case FEATURE_XAUTH_SERVER:
    case FEATURE_XAUTH_PEER:
      data = chunk_create(feature->arg.xauth,
                strlen(feature->arg.xauth));
      break;
  }
  return chunk_hash_inc(chunk_from_thing(feature->type),
              chunk_hash(data));
}

/**
 * See header.
 */
bool plugin_feature_matches(plugin_feature_t *a, plugin_feature_t *b)
{
  if (a->type == b->type)
  {
    switch (a->type)
    {
      case FEATURE_NONE:
        return FALSE;
      case FEATURE_CRYPTER:
        return a->arg.crypter.alg == b->arg.crypter.alg &&
             a->arg.crypter.key_size == b->arg.crypter.key_size;
      case FEATURE_AEAD:
        return a->arg.aead.alg == b->arg.aead.alg &&
             a->arg.aead.key_size == b->arg.aead.key_size;
      case FEATURE_SIGNER:
        return a->arg.signer == b->arg.signer;
      case FEATURE_HASHER:
        return a->arg.hasher == b->arg.hasher;
      case FEATURE_PRF:
        return a->arg.prf == b->arg.prf;
      case FEATURE_XOF:
        return a->arg.xof == b->arg.xof;
      case FEATURE_KDF:
        return a->arg.kdf == b->arg.kdf;
      case FEATURE_DRBG:
        return a->arg.drbg == b->arg.drbg;
      case FEATURE_KE:
        return a->arg.ke == b->arg.ke;
      case FEATURE_RNG:
        return a->arg.rng_quality <= b->arg.rng_quality;
      case FEATURE_NONCE_GEN:
      case FEATURE_RESOLVER:
        return TRUE;
      case FEATURE_PRIVKEY:
      case FEATURE_PRIVKEY_GEN:
      case FEATURE_PUBKEY:
        return a->arg.privkey == b->arg.privkey;
      case FEATURE_PRIVKEY_SIGN:
      case FEATURE_PUBKEY_VERIFY:
        return a->arg.privkey_sign == b->arg.privkey_sign;
      case FEATURE_PRIVKEY_DECRYPT:
      case FEATURE_PUBKEY_ENCRYPT:
        return a->arg.privkey_decrypt == b->arg.privkey_decrypt;
      case FEATURE_CERT_DECODE:
      case FEATURE_CERT_ENCODE:
        return a->arg.cert == b->arg.cert;
      case FEATURE_CONTAINER_DECODE:
      case FEATURE_CONTAINER_ENCODE:
        return a->arg.container == b->arg.container;
      case FEATURE_EAP_SERVER:
      case FEATURE_EAP_PEER:
        return a->arg.eap.vendor == b->arg.eap.vendor &&
             a->arg.eap.type == b->arg.eap.type;
      case FEATURE_DATABASE:
        return a->arg.database == DB_ANY ||
             a->arg.database == b->arg.database;
      case FEATURE_FETCHER:
        return a->arg.fetcher == NULL ||
             streq(a->arg.fetcher, b->arg.fetcher);
      case FEATURE_CUSTOM:
        return streq(a->arg.custom, b->arg.custom);
      case FEATURE_XAUTH_SERVER:
      case FEATURE_XAUTH_PEER:
        return streq(a->arg.xauth, b->arg.xauth);
    }
  }
  return FALSE;
}

/**
 * See header.
 */
bool plugin_feature_equals(plugin_feature_t *a, plugin_feature_t *b)
{
  if (a->type == b->type)
  {
    switch (a->type)
    {
      case FEATURE_NONE:
      case FEATURE_CRYPTER:
      case FEATURE_AEAD:
      case FEATURE_SIGNER:
      case FEATURE_HASHER:
      case FEATURE_PRF:
      case FEATURE_XOF:
      case FEATURE_KDF:
      case FEATURE_DRBG:
      case FEATURE_KE:
      case FEATURE_NONCE_GEN:
      case FEATURE_RESOLVER:
      case FEATURE_PRIVKEY:
      case FEATURE_PRIVKEY_GEN:
      case FEATURE_PUBKEY:
      case FEATURE_PRIVKEY_SIGN:
      case FEATURE_PUBKEY_VERIFY:
      case FEATURE_PRIVKEY_DECRYPT:
      case FEATURE_PUBKEY_ENCRYPT:
      case FEATURE_CERT_DECODE:
      case FEATURE_CERT_ENCODE:
      case FEATURE_CONTAINER_DECODE:
      case FEATURE_CONTAINER_ENCODE:
      case FEATURE_EAP_SERVER:
      case FEATURE_EAP_PEER:
      case FEATURE_CUSTOM:
      case FEATURE_XAUTH_SERVER:
      case FEATURE_XAUTH_PEER:
        return plugin_feature_matches(a, b);
      case FEATURE_RNG:
        return a->arg.rng_quality == b->arg.rng_quality;
      case FEATURE_DATABASE:
        return a->arg.database == b->arg.database;
      case FEATURE_FETCHER:
        if (a->arg.fetcher && b->arg.fetcher)
        {
          return streq(a->arg.fetcher, b->arg.fetcher);
        }
        return !a->arg.fetcher && !b->arg.fetcher;
    }
  }
  return FALSE;
}

/**
 * See header.
 */
char* plugin_feature_get_string(plugin_feature_t *feature)
{
  char *str = NULL;

  if (feature->kind == FEATURE_REGISTER)
  {
    return strdup("(register function)");
  }
  switch (feature->type)
  {
    case FEATURE_NONE:
      return strdup("NONE");
    case FEATURE_CRYPTER:
      if (asprintf(&str, "%N:%N-%d", plugin_feature_names, feature->type,
          encryption_algorithm_names, feature->arg.crypter.alg,
          feature->arg.crypter.key_size) > 0)
      {
        return str;
      }
      break;
    case FEATURE_AEAD:
      if (asprintf(&str, "%N:%N-%d", plugin_feature_names, feature->type,
          encryption_algorithm_names, feature->arg.aead.alg,
          feature->arg.aead.key_size) > 0)
      {
        return str;
      }
      break;
    case FEATURE_SIGNER:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          integrity_algorithm_names, feature->arg.signer) > 0)
      {
        return str;
      }
      break;
    case FEATURE_HASHER:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          hash_algorithm_names, feature->arg.hasher) > 0)
      {
        return str;
      }
      break;
    case FEATURE_PRF:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          pseudo_random_function_names, feature->arg.prf) > 0)
      {
        return str;
      }
      break;
    case FEATURE_XOF:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          ext_out_function_names, feature->arg.xof) > 0)
      {
        return str;
      }
      break;
    case FEATURE_KDF:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          key_derivation_function_names, feature->arg.kdf) > 0)
      {
        return str;
      }
      break;
    case FEATURE_DRBG:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          drbg_type_names, feature->arg.drbg) > 0)
      {
        return str;
      }
      break;
    case FEATURE_KE:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          key_exchange_method_names, feature->arg.ke) > 0)
      {
        return str;
      }
      break;
    case FEATURE_RNG:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          rng_quality_names, feature->arg.rng_quality) > 0)
      {
        return str;
      }
      break;
    case FEATURE_NONCE_GEN:
    case FEATURE_RESOLVER:
      if (asprintf(&str, "%N", plugin_feature_names, feature->type) > 0)
      {
        return str;
      }
      break;
    case FEATURE_PRIVKEY:
    case FEATURE_PRIVKEY_GEN:
    case FEATURE_PUBKEY:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          key_type_names, feature->arg.privkey) > 0)
      {
        return str;
      }
      break;
    case FEATURE_PRIVKEY_SIGN:
    case FEATURE_PUBKEY_VERIFY:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          signature_scheme_names, feature->arg.privkey_sign) > 0)
      {
        return str;
      }
      break;
    case FEATURE_PRIVKEY_DECRYPT:
    case FEATURE_PUBKEY_ENCRYPT:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          encryption_scheme_names, feature->arg.privkey_decrypt) > 0)
      {
        return str;
      }
      break;
    case FEATURE_CERT_DECODE:
    case FEATURE_CERT_ENCODE:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          certificate_type_names, feature->arg.cert) > 0)
      {
        return str;
      }
      break;
    case FEATURE_CONTAINER_DECODE:
    case FEATURE_CONTAINER_ENCODE:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          container_type_names, feature->arg.container) > 0)
      {
        return str;
      }
      break;
    case FEATURE_EAP_SERVER:
    case FEATURE_EAP_PEER:
      if (feature->arg.eap.vendor &&
        asprintf(&str, "%N:%d-%N", plugin_feature_names, feature->type,
          feature->arg.eap.type, pen_names, feature->arg.eap.vendor) > 0)
      {
        return str;
      }
      else if (!feature->arg.eap.vendor &&
        asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          eap_type_short_names, feature->arg.eap.type) > 0)
      {
        return str;
      }
      break;
    case FEATURE_DATABASE:
      if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
          db_driver_names, feature->arg.database) > 0)
      {
        return str;
      }
      break;
    case FEATURE_FETCHER:
      if (asprintf(&str, "%N:%s", plugin_feature_names, feature->type,
          feature->arg.fetcher) > 0)
      {
        return str;
      }
      break;
    case FEATURE_CUSTOM:
      if (asprintf(&str, "%N:%s", plugin_feature_names, feature->type,
          feature->arg.custom) > 0)
      {
        return str;
      }
      break;
    case FEATURE_XAUTH_SERVER:
    case FEATURE_XAUTH_PEER:
      if (asprintf(&str, "%N:%s", plugin_feature_names, feature->type,
          feature->arg.xauth) > 0)
      {
        return str;
      }
      break;
  }
  if (!str)
  {
    str = strdup("(invalid)");
  }
  return str;
}

/**
 * See header.
 */
bool plugin_feature_load(plugin_t *plugin, plugin_feature_t *feature,
             plugin_feature_t *reg)
{
  char *name;

  if (!reg)
  { /* noting to do for this feature */
    return TRUE;
  }
  if (reg->kind == FEATURE_CALLBACK)
  {
    if (!reg->arg.cb.f ||
       reg->arg.cb.f(plugin, feature, TRUE, reg->arg.cb.data))
    {
      return TRUE;
    }
    return FALSE;
  }
  name = plugin->get_name(plugin);
  switch (feature->type)
  {
    case FEATURE_NONE:
    case FEATURE_PRIVKEY_SIGN:
    case FEATURE_PRIVKEY_DECRYPT:
    case FEATURE_PUBKEY_VERIFY:
    case FEATURE_PUBKEY_ENCRYPT:
    case FEATURE_EAP_SERVER:
    case FEATURE_EAP_PEER:
    case FEATURE_XAUTH_SERVER:
    case FEATURE_XAUTH_PEER:
    case FEATURE_CUSTOM:
      break;
    case FEATURE_CRYPTER:
      lib->crypto->add_crypter(lib->crypto, feature->arg.crypter.alg,
                feature->arg.crypter.key_size,
                name, reg->arg.reg.f);
      break;
    case FEATURE_AEAD:
      lib->crypto->add_aead(lib->crypto, feature->arg.aead.alg,
                feature->arg.aead.key_size,
                name, reg->arg.reg.f);
      break;
    case FEATURE_SIGNER:
      lib->crypto->add_signer(lib->crypto, feature->arg.signer,
                name, reg->arg.reg.f);
      break;
    case FEATURE_HASHER:
      lib->crypto->add_hasher(lib->crypto, feature->arg.hasher,
                name, reg->arg.reg.f);
      break;
    case FEATURE_PRF:
      lib->crypto->add_prf(lib->crypto, feature->arg.prf,
                name, reg->arg.reg.f);
      break;
    case FEATURE_XOF:
      lib->crypto->add_xof(lib->crypto, feature->arg.xof,
                name, reg->arg.reg.f);
      break;
    case FEATURE_KDF:
      lib->crypto->add_kdf(lib->crypto, feature->arg.kdf,
                name, reg->arg.reg.f);
      break;
    case FEATURE_DRBG:
      lib->crypto->add_drbg(lib->crypto, feature->arg.drbg,
                name, reg->arg.reg.f);
      break;
    case FEATURE_KE:
      lib->crypto->add_ke(lib->crypto, feature->arg.ke,
                name, reg->arg.reg.f);
      break;
    case FEATURE_RNG:
      lib->crypto->add_rng(lib->crypto, feature->arg.rng_quality,
                name, reg->arg.reg.f);
      break;
    case FEATURE_NONCE_GEN:
      lib->crypto->add_nonce_gen(lib->crypto,
                name, reg->arg.reg.f);
      break;
    case FEATURE_PRIVKEY:
    case FEATURE_PRIVKEY_GEN:
      lib->creds->add_builder(lib->creds, CRED_PRIVATE_KEY,
                feature->arg.privkey, reg->arg.reg.final,
                name, reg->arg.reg.f);
      break;
    case FEATURE_PUBKEY:
      lib->creds->add_builder(lib->creds, CRED_PUBLIC_KEY,
                feature->arg.pubkey, reg->arg.reg.final,
                name, reg->arg.reg.f);
      break;
    case FEATURE_CERT_DECODE:
    case FEATURE_CERT_ENCODE:
      lib->creds->add_builder(lib->creds, CRED_CERTIFICATE,
                feature->arg.cert, reg->arg.reg.final,
                name, reg->arg.reg.f);
      break;
    case FEATURE_CONTAINER_DECODE:
    case FEATURE_CONTAINER_ENCODE:
      lib->creds->add_builder(lib->creds, CRED_CONTAINER,
                feature->arg.container, reg->arg.reg.final,
                name, reg->arg.reg.f);
      break;
    case FEATURE_DATABASE:
      lib->db->add_database(lib->db, reg->arg.reg.f);
      break;
    case FEATURE_FETCHER:
      lib->fetcher->add_fetcher(lib->fetcher, reg->arg.reg.f,
                    feature->arg.fetcher);
      break;
    case FEATURE_RESOLVER:
      lib->resolver->add_resolver(lib->resolver, reg->arg.reg.f);
      break;
  }
  return TRUE;
}

/**
 * See header.
 */
bool plugin_feature_unload(plugin_t *plugin, plugin_feature_t *feature,
               plugin_feature_t *reg)
{
  if (!reg)
  { /* noting to do for this feature */
    return TRUE;
  }
  if (reg->kind == FEATURE_CALLBACK)
  {
    if (!reg->arg.cb.f ||
       reg->arg.cb.f(plugin, feature, FALSE, reg->arg.cb.data))
    {
      return TRUE;
    }
    return FALSE;
  }
  switch (feature->type)
  {
    case FEATURE_NONE:
    case FEATURE_PRIVKEY_SIGN:
    case FEATURE_PRIVKEY_DECRYPT:
    case FEATURE_PUBKEY_VERIFY:
    case FEATURE_PUBKEY_ENCRYPT:
    case FEATURE_EAP_SERVER:
    case FEATURE_EAP_PEER:
    case FEATURE_XAUTH_SERVER:
    case FEATURE_XAUTH_PEER:
    case FEATURE_CUSTOM:
      break;
    case FEATURE_CRYPTER:
      lib->crypto->remove_crypter(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_AEAD:
      lib->crypto->remove_aead(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_SIGNER:
      lib->crypto->remove_signer(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_HASHER:
      lib->crypto->remove_hasher(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_PRF:
      lib->crypto->remove_prf(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_XOF:
      lib->crypto->remove_xof(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_KDF:
      lib->crypto->remove_kdf(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_DRBG:
      lib->crypto->remove_drbg(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_KE:
      lib->crypto->remove_ke(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_RNG:
      lib->crypto->remove_rng(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_NONCE_GEN:
      lib->crypto->remove_nonce_gen(lib->crypto, reg->arg.reg.f);
      break;
    case FEATURE_PRIVKEY:
    case FEATURE_PRIVKEY_GEN:
      lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
      break;
    case FEATURE_PUBKEY:
      lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
      break;
    case FEATURE_CERT_DECODE:
    case FEATURE_CERT_ENCODE:
      lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
      break;
    case FEATURE_CONTAINER_DECODE:
    case FEATURE_CONTAINER_ENCODE:
      lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
      break;
    case FEATURE_DATABASE:
      lib->db->remove_database(lib->db, reg->arg.reg.f);
      break;
    case FEATURE_FETCHER:
      lib->fetcher->remove_fetcher(lib->fetcher, reg->arg.reg.f);
      break;
    case FEATURE_RESOLVER:
      lib->resolver->remove_resolver(lib->resolver, reg->arg.reg.f);
      break;
  }
  return TRUE;
}

Coverage Report

Created: 2026-08-14 06:46

Line	Count	Source
1		/*
2		* Copyright (C) 2016-2019 Andreas Steffen
3		* Copyright (C) 2012-2015 Tobias Brunner
4		* Copyright (C) 2011 Martin Willi
5		*
6		* Copyright (C) secunet Security Networks AG
7		*
8		* This program is free software; you can redistribute it and/or modify it
9		* under the terms of the GNU General Public License as published by the
10		* Free Software Foundation; either version 2 of the License, or (at your
11		* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
12		*
13		* This program is distributed in the hope that it will be useful, but
14		* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15		* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16		* for more details.
17		*/
18
19		#define _GNU_SOURCE
20		#include <stdio.h>
21
22		#include "plugin_feature.h"
23
24		#include <utils/debug.h>
25
26		ENUM(plugin_feature_names, FEATURE_NONE, FEATURE_CUSTOM,
27		"NONE",
28		"CRYPTER",
29		"AEAD",
30		"SIGNER",
31		"HASHER",
32		"PRF",
33		"XOF",
34		"KDF",
35		"DRBG",
36		"KE",
37		"RNG",
38		"NONCE_GEN",
39		"PRIVKEY",
40		"PRIVKEY_GEN",
41		"PRIVKEY_SIGN",
42		"PRIVKEY_DECRYPT",
43		"PUBKEY",
44		"PUBKEY_VERIFY",
45		"PUBKEY_ENCRYPT",
46		"CERT_DECODE",
47		"CERT_ENCODE",
48		"CONTAINER_DECODE",
49		"CONTAINER_ENCODE",
50		"EAP_SERVER",
51		"EAP_CLIENT",
52		"XAUTH_SERVER",
53		"XAUTH_CLIENT",
54		"DATABASE",
55		"FETCHER",
56		"RESOLVER",
57		"CUSTOM",
58		);
59
60		/**
61		* See header.
62		*/
63		uint32_t plugin_feature_hash(plugin_feature_t *feature)
64	20.3M	{
65	20.3M	chunk_t data = chunk_empty;
66
67	20.3M	switch (feature->type)
68	20.3M	{
69	0	case FEATURE_NONE:
70	757k	case FEATURE_RNG:
71	757k	case FEATURE_NONCE_GEN:
72	757k	case FEATURE_DATABASE:
73	757k	case FEATURE_FETCHER:
74	757k	case FEATURE_RESOLVER:
75		/* put these special cases in their (type-specific) buckets */
76	757k	data = chunk_empty;
77	757k	break;
78	1.21M	case FEATURE_CRYPTER:
79	1.21M	data = chunk_from_thing(feature->arg.crypter);
80	1.21M	break;
81	963k	case FEATURE_AEAD:
82	963k	data = chunk_from_thing(feature->arg.aead);
83	963k	break;
84	558k	case FEATURE_SIGNER:
85	558k	data = chunk_from_thing(feature->arg.signer);
86	558k	break;
87	2.73M	case FEATURE_HASHER:
88	2.73M	data = chunk_from_thing(feature->arg.hasher);
89	2.73M	break;
90	352k	case FEATURE_PRF:
91	352k	data = chunk_from_thing(feature->arg.prf);
92	352k	break;
93	922k	case FEATURE_XOF:
94	922k	data = chunk_from_thing(feature->arg.xof);
95	922k	break;
96	0	case FEATURE_KDF:
97	0	data = chunk_from_thing(feature->arg.kdf);
98	0	break;
99	0	case FEATURE_DRBG:
100	0	data = chunk_from_thing(feature->arg.drbg);
101	0	break;
102	1.74M	case FEATURE_KE:
103	1.74M	data = chunk_from_thing(feature->arg.ke);
104	1.74M	break;
105	1.58M	case FEATURE_PRIVKEY:
106	1.58M	data = chunk_from_thing(feature->arg.privkey);
107	1.58M	break;
108	251k	case FEATURE_PRIVKEY_GEN:
109	251k	data = chunk_from_thing(feature->arg.privkey_gen);
110	251k	break;
111	2.07M	case FEATURE_PUBKEY:
112	2.07M	data = chunk_from_thing(feature->arg.pubkey);
113	2.07M	break;
114	1.69M	case FEATURE_PRIVKEY_SIGN:
115	1.69M	data = chunk_from_thing(feature->arg.privkey_sign);
116	1.69M	break;
117	1.69M	case FEATURE_PUBKEY_VERIFY:
118	1.69M	data = chunk_from_thing(feature->arg.pubkey_verify);
119	1.69M	break;
120	352k	case FEATURE_PRIVKEY_DECRYPT:
121	352k	data = chunk_from_thing(feature->arg.privkey_decrypt);
122	352k	break;
123	352k	case FEATURE_PUBKEY_ENCRYPT:
124	352k	data = chunk_from_thing(feature->arg.pubkey_encrypt);
125	352k	break;
126	2.05M	case FEATURE_CERT_DECODE:
127	2.63M	case FEATURE_CERT_ENCODE:
128	2.63M	data = chunk_from_thing(feature->arg.cert);
129	2.63M	break;
130	422k	case FEATURE_CONTAINER_DECODE:
131	422k	case FEATURE_CONTAINER_ENCODE:
132	422k	data = chunk_from_thing(feature->arg.container);
133	422k	break;
134	0	case FEATURE_EAP_SERVER:
135	0	case FEATURE_EAP_PEER:
136	0	data = chunk_from_thing(feature->arg.eap);
137	0	break;
138	50.7k	case FEATURE_CUSTOM:
139	50.7k	data = chunk_create(feature->arg.custom,
140	50.7k	strlen(feature->arg.custom));
141	50.7k	break;
142	0	case FEATURE_XAUTH_SERVER:
143	0	case FEATURE_XAUTH_PEER:
144	0	data = chunk_create(feature->arg.xauth,
145	0	strlen(feature->arg.xauth));
146	0	break;
147	20.3M	}
148	20.3M	return chunk_hash_inc(chunk_from_thing(feature->type),
149	20.3M	chunk_hash(data));
150	20.3M	}
151
152		/**
153		* See header.
154		*/
155		bool plugin_feature_matches(plugin_feature_t a, plugin_feature_t b)
156	25.6M	{
157	25.6M	if (a->type == b->type)
158	13.4M	{
159	13.4M	switch (a->type)
160	13.4M	{
161	0	case FEATURE_NONE:
162	0	return FALSE;
163	608k	case FEATURE_CRYPTER:
164	608k	return a->arg.crypter.alg == b->arg.crypter.alg &&
165	608k	a->arg.crypter.key_size == b->arg.crypter.key_size;
166	481k	case FEATURE_AEAD:
167	481k	return a->arg.aead.alg == b->arg.aead.alg &&
168	481k	a->arg.aead.key_size == b->arg.aead.key_size;
169	278k	case FEATURE_SIGNER:
170	278k	return a->arg.signer == b->arg.signer;
171	2.07M	case FEATURE_HASHER:
172	2.07M	return a->arg.hasher == b->arg.hasher;
173	176k	case FEATURE_PRF:
174	176k	return a->arg.prf == b->arg.prf;
175	606k	case FEATURE_XOF:
176	606k	return a->arg.xof == b->arg.xof;
177	0	case FEATURE_KDF:
178	0	return a->arg.kdf == b->arg.kdf;
179	0	case FEATURE_DRBG:
180	0	return a->arg.drbg == b->arg.drbg;
181	873k	case FEATURE_KE:
182	873k	return a->arg.ke == b->arg.ke;
183	50.7k	case FEATURE_RNG:
184	50.7k	return a->arg.rng_quality <= b->arg.rng_quality;
185	0	case FEATURE_NONCE_GEN:
186	0	case FEATURE_RESOLVER:
187	0	return TRUE;
188	1.29M	case FEATURE_PRIVKEY:
189	1.41M	case FEATURE_PRIVKEY_GEN:
190	3.19M	case FEATURE_PUBKEY:
191	3.19M	return a->arg.privkey == b->arg.privkey;
192	847k	case FEATURE_PRIVKEY_SIGN:
193	2.45M	case FEATURE_PUBKEY_VERIFY:
194	2.45M	return a->arg.privkey_sign == b->arg.privkey_sign;
195	176k	case FEATURE_PRIVKEY_DECRYPT:
196	352k	case FEATURE_PUBKEY_ENCRYPT:
197	352k	return a->arg.privkey_decrypt == b->arg.privkey_decrypt;
198	1.61M	case FEATURE_CERT_DECODE:
199	1.90M	case FEATURE_CERT_ENCODE:
200	1.90M	return a->arg.cert == b->arg.cert;
201	323k	case FEATURE_CONTAINER_DECODE:
202	323k	case FEATURE_CONTAINER_ENCODE:
203	323k	return a->arg.container == b->arg.container;
204	0	case FEATURE_EAP_SERVER:
205	0	case FEATURE_EAP_PEER:
206	0	return a->arg.eap.vendor == b->arg.eap.vendor &&
207	0	a->arg.eap.type == b->arg.eap.type;
208	0	case FEATURE_DATABASE:
209	0	return a->arg.database == DB_ANY \|\|
210	0	a->arg.database == b->arg.database;
211	0	case FEATURE_FETCHER:
212	0	return a->arg.fetcher == NULL \|\|
213	0	streq(a->arg.fetcher, b->arg.fetcher);
214	25.3k	case FEATURE_CUSTOM:
215	25.3k	return streq(a->arg.custom, b->arg.custom);
216	0	case FEATURE_XAUTH_SERVER:
217	0	case FEATURE_XAUTH_PEER:
218	0	return streq(a->arg.xauth, b->arg.xauth);
219	13.4M	}
220	13.4M	}
221	12.2M	return FALSE;
222	25.6M	}
223
224		/**
225		* See header.
226		*/
227		bool plugin_feature_equals(plugin_feature_t a, plugin_feature_t b)
228	9.88M	{
229	9.88M	if (a->type == b->type)
230	9.88M	{
231	9.88M	switch (a->type)
232	9.88M	{
233	0	case FEATURE_NONE:
234	608k	case FEATURE_CRYPTER:
235	1.09M	case FEATURE_AEAD:
236	1.36M	case FEATURE_SIGNER:
237	2.42M	case FEATURE_HASHER:
238	2.60M	case FEATURE_PRF:
239	3.01M	case FEATURE_XOF:
240	3.01M	case FEATURE_KDF:
241	3.01M	case FEATURE_DRBG:
242	3.88M	case FEATURE_KE:
243	3.88M	case FEATURE_NONCE_GEN:
244	3.88M	case FEATURE_RESOLVER:
245	4.78M	case FEATURE_PRIVKEY:
246	4.91M	case FEATURE_PRIVKEY_GEN:
247	6.01M	case FEATURE_PUBKEY:
248	6.86M	case FEATURE_PRIVKEY_SIGN:
249	7.71M	case FEATURE_PUBKEY_VERIFY:
250	7.88M	case FEATURE_PRIVKEY_DECRYPT:
251	8.06M	case FEATURE_PUBKEY_ENCRYPT:
252	9.18M	case FEATURE_CERT_DECODE:
253	9.47M	case FEATURE_CERT_ENCODE:
254	9.70M	case FEATURE_CONTAINER_DECODE:
255	9.70M	case FEATURE_CONTAINER_ENCODE:
256	9.70M	case FEATURE_EAP_SERVER:
257	9.70M	case FEATURE_EAP_PEER:
258	9.72M	case FEATURE_CUSTOM:
259	9.72M	case FEATURE_XAUTH_SERVER:
260	9.72M	case FEATURE_XAUTH_PEER:
261	9.72M	return plugin_feature_matches(a, b);
262	152k	case FEATURE_RNG:
263	152k	return a->arg.rng_quality == b->arg.rng_quality;
264	0	case FEATURE_DATABASE:
265	0	return a->arg.database == b->arg.database;
266	0	case FEATURE_FETCHER:
267	0	if (a->arg.fetcher && b->arg.fetcher)
268	0	{
269	0	return streq(a->arg.fetcher, b->arg.fetcher);
270	0	}
271	0	return !a->arg.fetcher && !b->arg.fetcher;
272	9.88M	}
273	9.88M	}
274	0	return FALSE;
275	9.88M	}
276
277		/**
278		* See header.
279		*/
280		char* plugin_feature_get_string(plugin_feature_t *feature)
281	0	{
282	0	char *str = NULL;
283
284	0	if (feature->kind == FEATURE_REGISTER)
285	0	{
286	0	return strdup("(register function)");
287	0	}
288	0	switch (feature->type)
289	0	{
290	0	case FEATURE_NONE:
291	0	return strdup("NONE");
292	0	case FEATURE_CRYPTER:
293	0	if (asprintf(&str, "%N:%N-%d", plugin_feature_names, feature->type,
294	0	encryption_algorithm_names, feature->arg.crypter.alg,
295	0	feature->arg.crypter.key_size) > 0)
296	0	{
297	0	return str;
298	0	}
299	0	break;
300	0	case FEATURE_AEAD:
301	0	if (asprintf(&str, "%N:%N-%d", plugin_feature_names, feature->type,
302	0	encryption_algorithm_names, feature->arg.aead.alg,
303	0	feature->arg.aead.key_size) > 0)
304	0	{
305	0	return str;
306	0	}
307	0	break;
308	0	case FEATURE_SIGNER:
309	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
310	0	integrity_algorithm_names, feature->arg.signer) > 0)
311	0	{
312	0	return str;
313	0	}
314	0	break;
315	0	case FEATURE_HASHER:
316	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
317	0	hash_algorithm_names, feature->arg.hasher) > 0)
318	0	{
319	0	return str;
320	0	}
321	0	break;
322	0	case FEATURE_PRF:
323	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
324	0	pseudo_random_function_names, feature->arg.prf) > 0)
325	0	{
326	0	return str;
327	0	}
328	0	break;
329	0	case FEATURE_XOF:
330	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
331	0	ext_out_function_names, feature->arg.xof) > 0)
332	0	{
333	0	return str;
334	0	}
335	0	break;
336	0	case FEATURE_KDF:
337	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
338	0	key_derivation_function_names, feature->arg.kdf) > 0)
339	0	{
340	0	return str;
341	0	}
342	0	break;
343	0	case FEATURE_DRBG:
344	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
345	0	drbg_type_names, feature->arg.drbg) > 0)
346	0	{
347	0	return str;
348	0	}
349	0	break;
350	0	case FEATURE_KE:
351	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
352	0	key_exchange_method_names, feature->arg.ke) > 0)
353	0	{
354	0	return str;
355	0	}
356	0	break;
357	0	case FEATURE_RNG:
358	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
359	0	rng_quality_names, feature->arg.rng_quality) > 0)
360	0	{
361	0	return str;
362	0	}
363	0	break;
364	0	case FEATURE_NONCE_GEN:
365	0	case FEATURE_RESOLVER:
366	0	if (asprintf(&str, "%N", plugin_feature_names, feature->type) > 0)
367	0	{
368	0	return str;
369	0	}
370	0	break;
371	0	case FEATURE_PRIVKEY:
372	0	case FEATURE_PRIVKEY_GEN:
373	0	case FEATURE_PUBKEY:
374	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
375	0	key_type_names, feature->arg.privkey) > 0)
376	0	{
377	0	return str;
378	0	}
379	0	break;
380	0	case FEATURE_PRIVKEY_SIGN:
381	0	case FEATURE_PUBKEY_VERIFY:
382	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
383	0	signature_scheme_names, feature->arg.privkey_sign) > 0)
384	0	{
385	0	return str;
386	0	}
387	0	break;
388	0	case FEATURE_PRIVKEY_DECRYPT:
389	0	case FEATURE_PUBKEY_ENCRYPT:
390	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
391	0	encryption_scheme_names, feature->arg.privkey_decrypt) > 0)
392	0	{
393	0	return str;
394	0	}
395	0	break;
396	0	case FEATURE_CERT_DECODE:
397	0	case FEATURE_CERT_ENCODE:
398	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
399	0	certificate_type_names, feature->arg.cert) > 0)
400	0	{
401	0	return str;
402	0	}
403	0	break;
404	0	case FEATURE_CONTAINER_DECODE:
405	0	case FEATURE_CONTAINER_ENCODE:
406	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
407	0	container_type_names, feature->arg.container) > 0)
408	0	{
409	0	return str;
410	0	}
411	0	break;
412	0	case FEATURE_EAP_SERVER:
413	0	case FEATURE_EAP_PEER:
414	0	if (feature->arg.eap.vendor &&
415	0	asprintf(&str, "%N:%d-%N", plugin_feature_names, feature->type,
416	0	feature->arg.eap.type, pen_names, feature->arg.eap.vendor) > 0)
417	0	{
418	0	return str;
419	0	}
420	0	else if (!feature->arg.eap.vendor &&
421	0	asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
422	0	eap_type_short_names, feature->arg.eap.type) > 0)
423	0	{
424	0	return str;
425	0	}
426	0	break;
427	0	case FEATURE_DATABASE:
428	0	if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
429	0	db_driver_names, feature->arg.database) > 0)
430	0	{
431	0	return str;
432	0	}
433	0	break;
434	0	case FEATURE_FETCHER:
435	0	if (asprintf(&str, "%N:%s", plugin_feature_names, feature->type,
436	0	feature->arg.fetcher) > 0)
437	0	{
438	0	return str;
439	0	}
440	0	break;
441	0	case FEATURE_CUSTOM:
442	0	if (asprintf(&str, "%N:%s", plugin_feature_names, feature->type,
443	0	feature->arg.custom) > 0)
444	0	{
445	0	return str;
446	0	}
447	0	break;
448	0	case FEATURE_XAUTH_SERVER:
449	0	case FEATURE_XAUTH_PEER:
450	0	if (asprintf(&str, "%N:%s", plugin_feature_names, feature->type,
451	0	feature->arg.xauth) > 0)
452	0	{
453	0	return str;
454	0	}
455	0	break;
456	0	}
457	0	if (!str)
458	0	{
459	0	str = strdup("(invalid)");
460	0	}
461	0	return str;
462	0	}
463
464		/**
465		* See header.
466		*/
467		bool plugin_feature_load(plugin_t plugin, plugin_feature_t feature,
468		plugin_feature_t *reg)
469	3.53M	{
470	3.53M	char *name;
471
472	3.53M	if (!reg)
473	12.6k	{ /* noting to do for this feature */
474	12.6k	return TRUE;
475	12.6k	}
476	3.52M	if (reg->kind == FEATURE_CALLBACK)
477	0	{
478	0	if (!reg->arg.cb.f \|\|
479	0	reg->arg.cb.f(plugin, feature, TRUE, reg->arg.cb.data))
480	0	{
481	0	return TRUE;
482	0	}
483	0	return FALSE;
484	0	}
485	3.52M	name = plugin->get_name(plugin);
486	3.52M	switch (feature->type)
487	3.52M	{
488	0	case FEATURE_NONE:
489	411k	case FEATURE_PRIVKEY_SIGN:
490	500k	case FEATURE_PRIVKEY_DECRYPT:
491	911k	case FEATURE_PUBKEY_VERIFY:
492	988k	case FEATURE_PUBKEY_ENCRYPT:
493	988k	case FEATURE_EAP_SERVER:
494	988k	case FEATURE_EAP_PEER:
495	988k	case FEATURE_XAUTH_SERVER:
496	988k	case FEATURE_XAUTH_PEER:
497	988k	case FEATURE_CUSTOM:
498	988k	break;
499	304k	case FEATURE_CRYPTER:
500	304k	lib->crypto->add_crypter(lib->crypto, feature->arg.crypter.alg,
501	304k	feature->arg.crypter.key_size,
502	304k	name, reg->arg.reg.f);
503	304k	break;
504	240k	case FEATURE_AEAD:
505	240k	lib->crypto->add_aead(lib->crypto, feature->arg.aead.alg,
506	240k	feature->arg.aead.key_size,
507	240k	name, reg->arg.reg.f);
508	240k	break;
509	139k	case FEATURE_SIGNER:
510	139k	lib->crypto->add_signer(lib->crypto, feature->arg.signer,
511	139k	name, reg->arg.reg.f);
512	139k	break;
513	260k	case FEATURE_HASHER:
514	260k	lib->crypto->add_hasher(lib->crypto, feature->arg.hasher,
515	260k	name, reg->arg.reg.f);
516	260k	break;
517	88.1k	case FEATURE_PRF:
518	88.1k	lib->crypto->add_prf(lib->crypto, feature->arg.prf,
519	88.1k	name, reg->arg.reg.f);
520	88.1k	break;
521	158k	case FEATURE_XOF:
522	158k	lib->crypto->add_xof(lib->crypto, feature->arg.xof,
523	158k	name, reg->arg.reg.f);
524	158k	break;
525	0	case FEATURE_KDF:
526	0	lib->crypto->add_kdf(lib->crypto, feature->arg.kdf,
527	0	name, reg->arg.reg.f);
528	0	break;
529	0	case FEATURE_DRBG:
530	0	lib->crypto->add_drbg(lib->crypto, feature->arg.drbg,
531	0	name, reg->arg.reg.f);
532	0	break;
533	291k	case FEATURE_KE:
534	291k	lib->crypto->add_ke(lib->crypto, feature->arg.ke,
535	291k	name, reg->arg.reg.f);
536	291k	break;
537	25.3k	case FEATURE_RNG:
538	25.3k	lib->crypto->add_rng(lib->crypto, feature->arg.rng_quality,
539	25.3k	name, reg->arg.reg.f);
540	25.3k	break;
541	0	case FEATURE_NONCE_GEN:
542	0	lib->crypto->add_nonce_gen(lib->crypto,
543	0	name, reg->arg.reg.f);
544	0	break;
545	225k	case FEATURE_PRIVKEY:
546	276k	case FEATURE_PRIVKEY_GEN:
547	276k	lib->creds->add_builder(lib->creds, CRED_PRIVATE_KEY,
548	276k	feature->arg.privkey, reg->arg.reg.final,
549	276k	name, reg->arg.reg.f);
550	276k	break;
551	212k	case FEATURE_PUBKEY:
552	212k	lib->creds->add_builder(lib->creds, CRED_PUBLIC_KEY,
553	212k	feature->arg.pubkey, reg->arg.reg.final,
554	212k	name, reg->arg.reg.f);
555	212k	break;
556	347k	case FEATURE_CERT_DECODE:
557	483k	case FEATURE_CERT_ENCODE:
558	483k	lib->creds->add_builder(lib->creds, CRED_CERTIFICATE,
559	483k	feature->arg.cert, reg->arg.reg.final,
560	483k	name, reg->arg.reg.f);
561	483k	break;
562	50.7k	case FEATURE_CONTAINER_DECODE:
563	50.7k	case FEATURE_CONTAINER_ENCODE:
564	50.7k	lib->creds->add_builder(lib->creds, CRED_CONTAINER,
565	50.7k	feature->arg.container, reg->arg.reg.final,
566	50.7k	name, reg->arg.reg.f);
567	50.7k	break;
568	0	case FEATURE_DATABASE:
569	0	lib->db->add_database(lib->db, reg->arg.reg.f);
570	0	break;
571	0	case FEATURE_FETCHER:
572	0	lib->fetcher->add_fetcher(lib->fetcher, reg->arg.reg.f,
573	0	feature->arg.fetcher);
574	0	break;
575	0	case FEATURE_RESOLVER:
576	0	lib->resolver->add_resolver(lib->resolver, reg->arg.reg.f);
577	0	break;
578	3.52M	}
579	3.52M	return TRUE;
580	3.52M	}
581
582		/**
583		* See header.
584		*/
585		bool plugin_feature_unload(plugin_t plugin, plugin_feature_t feature,
586		plugin_feature_t *reg)
587	3.53M	{
588	3.53M	if (!reg)
589	12.6k	{ /* noting to do for this feature */
590	12.6k	return TRUE;
591	12.6k	}
592	3.51M	if (reg->kind == FEATURE_CALLBACK)
593	0	{
594	0	if (!reg->arg.cb.f \|\|
595	0	reg->arg.cb.f(plugin, feature, FALSE, reg->arg.cb.data))
596	0	{
597	0	return TRUE;
598	0	}
599	0	return FALSE;
600	0	}
601	3.51M	switch (feature->type)
602	3.51M	{
603	0	case FEATURE_NONE:
604	411k	case FEATURE_PRIVKEY_SIGN:
605	499k	case FEATURE_PRIVKEY_DECRYPT:
606	911k	case FEATURE_PUBKEY_VERIFY:
607	987k	case FEATURE_PUBKEY_ENCRYPT:
608	987k	case FEATURE_EAP_SERVER:
609	987k	case FEATURE_EAP_PEER:
610	987k	case FEATURE_XAUTH_SERVER:
611	987k	case FEATURE_XAUTH_PEER:
612	987k	case FEATURE_CUSTOM:
613	987k	break;
614	304k	case FEATURE_CRYPTER:
615	304k	lib->crypto->remove_crypter(lib->crypto, reg->arg.reg.f);
616	304k	break;
617	240k	case FEATURE_AEAD:
618	240k	lib->crypto->remove_aead(lib->crypto, reg->arg.reg.f);
619	240k	break;
620	139k	case FEATURE_SIGNER:
621	139k	lib->crypto->remove_signer(lib->crypto, reg->arg.reg.f);
622	139k	break;
623	260k	case FEATURE_HASHER:
624	260k	lib->crypto->remove_hasher(lib->crypto, reg->arg.reg.f);
625	260k	break;
626	88.1k	case FEATURE_PRF:
627	88.1k	lib->crypto->remove_prf(lib->crypto, reg->arg.reg.f);
628	88.1k	break;
629	158k	case FEATURE_XOF:
630	158k	lib->crypto->remove_xof(lib->crypto, reg->arg.reg.f);
631	158k	break;
632	0	case FEATURE_KDF:
633	0	lib->crypto->remove_kdf(lib->crypto, reg->arg.reg.f);
634	0	break;
635	0	case FEATURE_DRBG:
636	0	lib->crypto->remove_drbg(lib->crypto, reg->arg.reg.f);
637	0	break;
638	291k	case FEATURE_KE:
639	291k	lib->crypto->remove_ke(lib->crypto, reg->arg.reg.f);
640	291k	break;
641	25.3k	case FEATURE_RNG:
642	25.3k	lib->crypto->remove_rng(lib->crypto, reg->arg.reg.f);
643	25.3k	break;
644	0	case FEATURE_NONCE_GEN:
645	0	lib->crypto->remove_nonce_gen(lib->crypto, reg->arg.reg.f);
646	0	break;
647	225k	case FEATURE_PRIVKEY:
648	275k	case FEATURE_PRIVKEY_GEN:
649	275k	lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
650	275k	break;
651	212k	case FEATURE_PUBKEY:
652	212k	lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
653	212k	break;
654	347k	case FEATURE_CERT_DECODE:
655	483k	case FEATURE_CERT_ENCODE:
656	483k	lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
657	483k	break;
658	50.7k	case FEATURE_CONTAINER_DECODE:
659	50.7k	case FEATURE_CONTAINER_ENCODE:
660	50.7k	lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
661	50.7k	break;
662	0	case FEATURE_DATABASE:
663	0	lib->db->remove_database(lib->db, reg->arg.reg.f);
664	0	break;
665	0	case FEATURE_FETCHER:
666	0	lib->fetcher->remove_fetcher(lib->fetcher, reg->arg.reg.f);
667	0	break;
668	0	case FEATURE_RESOLVER:
669	0	lib->resolver->remove_resolver(lib->resolver, reg->arg.reg.f);
670	0	break;
671	3.51M	}
672	3.51M	return TRUE;
673	3.51M	}