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

Source (jump to first uncovered line)
/*
 * 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: 2024-02-29 06:05

Line	Count	Source (jump to first uncovered line)
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	2.36M	{
65	2.36M	chunk_t data = chunk_empty;
66
67	2.36M	switch (feature->type)
68	2.36M	{
69	0	case FEATURE_NONE:
70	188k	case FEATURE_RNG:
71	188k	case FEATURE_NONCE_GEN:
72	188k	case FEATURE_DATABASE:
73	188k	case FEATURE_FETCHER:
74	188k	case FEATURE_RESOLVER:
75		/* put these special cases in their (type-specific) buckets */
76	188k	data = chunk_empty;
77	188k	break;
78	0	case FEATURE_CRYPTER:
79	0	data = chunk_from_thing(feature->arg.crypter);
80	0	break;
81	0	case FEATURE_AEAD:
82	0	data = chunk_from_thing(feature->arg.aead);
83	0	break;
84	0	case FEATURE_SIGNER:
85	0	data = chunk_from_thing(feature->arg.signer);
86	0	break;
87	439k	case FEATURE_HASHER:
88	439k	data = chunk_from_thing(feature->arg.hasher);
89	439k	break;
90	15.6k	case FEATURE_PRF:
91	15.6k	data = chunk_from_thing(feature->arg.prf);
92	15.6k	break;
93	70.5k	case FEATURE_XOF:
94	70.5k	data = chunk_from_thing(feature->arg.xof);
95	70.5k	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	188k	case FEATURE_KE:
103	188k	data = chunk_from_thing(feature->arg.ke);
104	188k	break;
105	250k	case FEATURE_PRIVKEY:
106	250k	data = chunk_from_thing(feature->arg.privkey);
107	250k	break;
108	15.6k	case FEATURE_PRIVKEY_GEN:
109	15.6k	data = chunk_from_thing(feature->arg.privkey_gen);
110	15.6k	break;
111	329k	case FEATURE_PUBKEY:
112	329k	data = chunk_from_thing(feature->arg.pubkey);
113	329k	break;
114	188k	case FEATURE_PRIVKEY_SIGN:
115	188k	data = chunk_from_thing(feature->arg.privkey_sign);
116	188k	break;
117	188k	case FEATURE_PUBKEY_VERIFY:
118	188k	data = chunk_from_thing(feature->arg.pubkey_verify);
119	188k	break;
120	15.6k	case FEATURE_PRIVKEY_DECRYPT:
121	15.6k	data = chunk_from_thing(feature->arg.privkey_decrypt);
122	15.6k	break;
123	15.6k	case FEATURE_PUBKEY_ENCRYPT:
124	15.6k	data = chunk_from_thing(feature->arg.pubkey_encrypt);
125	15.6k	break;
126	313k	case FEATURE_CERT_DECODE:
127	407k	case FEATURE_CERT_ENCODE:
128	407k	data = chunk_from_thing(feature->arg.cert);
129	407k	break;
130	54.8k	case FEATURE_CONTAINER_DECODE:
131	54.8k	case FEATURE_CONTAINER_ENCODE:
132	54.8k	data = chunk_from_thing(feature->arg.container);
133	54.8k	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	0	case FEATURE_CUSTOM:
139	0	data = chunk_create(feature->arg.custom,
140	0	strlen(feature->arg.custom));
141	0	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	2.36M	}
148	2.36M	return chunk_hash_inc(chunk_from_thing(feature->type),
149	2.36M	chunk_hash(data));
150	2.36M	}
151
152		/**
153		* See header.
154		*/
155		bool plugin_feature_matches(plugin_feature_t a, plugin_feature_t b)
156	1.37M	{
157	1.37M	if (a->type == b->type)
158	1.37M	{
159	1.37M	switch (a->type)
160	1.37M	{
161	0	case FEATURE_NONE:
162	0	return FALSE;
163	0	case FEATURE_CRYPTER:
164	0	return a->arg.crypter.alg == b->arg.crypter.alg &&
165	0	a->arg.crypter.key_size == b->arg.crypter.key_size;
166	0	case FEATURE_AEAD:
167	0	return a->arg.aead.alg == b->arg.aead.alg &&
168	0	a->arg.aead.key_size == b->arg.aead.key_size;
169	0	case FEATURE_SIGNER:
170	0	return a->arg.signer == b->arg.signer;
171	262k	case FEATURE_HASHER:
172	262k	return a->arg.hasher == b->arg.hasher;
173	7.84k	case FEATURE_PRF:
174	7.84k	return a->arg.prf == b->arg.prf;
175	0	case FEATURE_XOF:
176	0	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	94.1k	case FEATURE_KE:
182	94.1k	return a->arg.ke == b->arg.ke;
183	0	case FEATURE_RNG:
184	0	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	196k	case FEATURE_PRIVKEY:
189	203k	case FEATURE_PRIVKEY_GEN:
190	478k	case FEATURE_PUBKEY:
191	478k	return a->arg.privkey == b->arg.privkey;
192	94.1k	case FEATURE_PRIVKEY_SIGN:
193	188k	case FEATURE_PUBKEY_VERIFY:
194	188k	return a->arg.privkey_sign == b->arg.privkey_sign;
195	7.84k	case FEATURE_PRIVKEY_DECRYPT:
196	15.6k	case FEATURE_PUBKEY_ENCRYPT:
197	15.6k	return a->arg.privkey_decrypt == b->arg.privkey_decrypt;
198	243k	case FEATURE_CERT_DECODE:
199	290k	case FEATURE_CERT_ENCODE:
200	290k	return a->arg.cert == b->arg.cert;
201	39.2k	case FEATURE_CONTAINER_DECODE:
202	39.2k	case FEATURE_CONTAINER_ENCODE:
203	39.2k	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	0	case FEATURE_CUSTOM:
215	0	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	1.37M	}
220	1.37M	}
221	0	return FALSE;
222	1.37M	}
223
224		/**
225		* See header.
226		*/
227		bool plugin_feature_equals(plugin_feature_t a, plugin_feature_t b)
228	952k	{
229	952k	if (a->type == b->type)
230	952k	{
231	952k	switch (a->type)
232	952k	{
233	0	case FEATURE_NONE:
234	0	case FEATURE_CRYPTER:
235	0	case FEATURE_AEAD:
236	0	case FEATURE_SIGNER:
237	113k	case FEATURE_HASHER:
238	121k	case FEATURE_PRF:
239	121k	case FEATURE_XOF:
240	121k	case FEATURE_KDF:
241	121k	case FEATURE_DRBG:
242	215k	case FEATURE_KE:
243	215k	case FEATURE_NONCE_GEN:
244	215k	case FEATURE_RESOLVER:
245	341k	case FEATURE_PRIVKEY:
246	348k	case FEATURE_PRIVKEY_GEN:
247	513k	case FEATURE_PUBKEY:
248	607k	case FEATURE_PRIVKEY_SIGN:
249	701k	case FEATURE_PUBKEY_VERIFY:
250	709k	case FEATURE_PRIVKEY_DECRYPT:
251	717k	case FEATURE_PUBKEY_ENCRYPT:
252	882k	case FEATURE_CERT_DECODE:
253	929k	case FEATURE_CERT_ENCODE:
254	952k	case FEATURE_CONTAINER_DECODE:
255	952k	case FEATURE_CONTAINER_ENCODE:
256	952k	case FEATURE_EAP_SERVER:
257	952k	case FEATURE_EAP_PEER:
258	952k	case FEATURE_CUSTOM:
259	952k	case FEATURE_XAUTH_SERVER:
260	952k	case FEATURE_XAUTH_PEER:
261	952k	return plugin_feature_matches(a, b);
262	0	case FEATURE_RNG:
263	0	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	952k	}
273	952k	}
274	0	return FALSE;
275	952k	}
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	192k	{
470	192k	char *name;
471
472	192k	if (!reg)
473	0	{ /* noting to do for this feature */
474	0	return TRUE;
475	0	}
476	192k	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	192k	name = plugin->get_name(plugin);
486	192k	switch (feature->type)
487	192k	{
488	0	case FEATURE_NONE:
489	27.4k	case FEATURE_PRIVKEY_SIGN:
490	31.3k	case FEATURE_PRIVKEY_DECRYPT:
491	58.8k	case FEATURE_PUBKEY_VERIFY:
492	58.8k	case FEATURE_PUBKEY_ENCRYPT:
493	58.8k	case FEATURE_EAP_SERVER:
494	58.8k	case FEATURE_EAP_PEER:
495	58.8k	case FEATURE_XAUTH_SERVER:
496	58.8k	case FEATURE_XAUTH_PEER:
497	58.8k	case FEATURE_CUSTOM:
498	58.8k	break;
499	0	case FEATURE_CRYPTER:
500	0	lib->crypto->add_crypter(lib->crypto, feature->arg.crypter.alg,
501	0	feature->arg.crypter.key_size,
502	0	name, reg->arg.reg.f);
503	0	break;
504	0	case FEATURE_AEAD:
505	0	lib->crypto->add_aead(lib->crypto, feature->arg.aead.alg,
506	0	feature->arg.aead.key_size,
507	0	name, reg->arg.reg.f);
508	0	break;
509	0	case FEATURE_SIGNER:
510	0	lib->crypto->add_signer(lib->crypto, feature->arg.signer,
511	0	name, reg->arg.reg.f);
512	0	break;
513	19.6k	case FEATURE_HASHER:
514	19.6k	lib->crypto->add_hasher(lib->crypto, feature->arg.hasher,
515	19.6k	name, reg->arg.reg.f);
516	19.6k	break;
517	3.92k	case FEATURE_PRF:
518	3.92k	lib->crypto->add_prf(lib->crypto, feature->arg.prf,
519	3.92k	name, reg->arg.reg.f);
520	3.92k	break;
521	0	case FEATURE_XOF:
522	0	lib->crypto->add_xof(lib->crypto, feature->arg.xof,
523	0	name, reg->arg.reg.f);
524	0	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	0	case FEATURE_KE:
534	0	lib->crypto->add_ke(lib->crypto, feature->arg.ke,
535	0	name, reg->arg.reg.f);
536	0	break;
537	0	case FEATURE_RNG:
538	0	lib->crypto->add_rng(lib->crypto, feature->arg.rng_quality,
539	0	name, reg->arg.reg.f);
540	0	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	19.6k	case FEATURE_PRIVKEY:
546	19.6k	case FEATURE_PRIVKEY_GEN:
547	19.6k	lib->creds->add_builder(lib->creds, CRED_PRIVATE_KEY,
548	19.6k	feature->arg.privkey, reg->arg.reg.final,
549	19.6k	name, reg->arg.reg.f);
550	19.6k	break;
551	19.6k	case FEATURE_PUBKEY:
552	19.6k	lib->creds->add_builder(lib->creds, CRED_PUBLIC_KEY,
553	19.6k	feature->arg.pubkey, reg->arg.reg.final,
554	19.6k	name, reg->arg.reg.f);
555	19.6k	break;
556	50.9k	case FEATURE_CERT_DECODE:
557	70.5k	case FEATURE_CERT_ENCODE:
558	70.5k	lib->creds->add_builder(lib->creds, CRED_CERTIFICATE,
559	70.5k	feature->arg.cert, reg->arg.reg.final,
560	70.5k	name, reg->arg.reg.f);
561	70.5k	break;
562	0	case FEATURE_CONTAINER_DECODE:
563	0	case FEATURE_CONTAINER_ENCODE:
564	0	lib->creds->add_builder(lib->creds, CRED_CONTAINER,
565	0	feature->arg.container, reg->arg.reg.final,
566	0	name, reg->arg.reg.f);
567	0	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	192k	}
579	192k	return TRUE;
580	192k	}
581
582		/**
583		* See header.
584		*/
585		bool plugin_feature_unload(plugin_t plugin, plugin_feature_t feature,
586		plugin_feature_t *reg)
587	192k	{
588	192k	if (!reg)
589	0	{ /* noting to do for this feature */
590	0	return TRUE;
591	0	}
592	192k	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	192k	switch (feature->type)
602	192k	{
603	0	case FEATURE_NONE:
604	27.4k	case FEATURE_PRIVKEY_SIGN:
605	31.3k	case FEATURE_PRIVKEY_DECRYPT:
606	58.8k	case FEATURE_PUBKEY_VERIFY:
607	58.8k	case FEATURE_PUBKEY_ENCRYPT:
608	58.8k	case FEATURE_EAP_SERVER:
609	58.8k	case FEATURE_EAP_PEER:
610	58.8k	case FEATURE_XAUTH_SERVER:
611	58.8k	case FEATURE_XAUTH_PEER:
612	58.8k	case FEATURE_CUSTOM:
613	58.8k	break;
614	0	case FEATURE_CRYPTER:
615	0	lib->crypto->remove_crypter(lib->crypto, reg->arg.reg.f);
616	0	break;
617	0	case FEATURE_AEAD:
618	0	lib->crypto->remove_aead(lib->crypto, reg->arg.reg.f);
619	0	break;
620	0	case FEATURE_SIGNER:
621	0	lib->crypto->remove_signer(lib->crypto, reg->arg.reg.f);
622	0	break;
623	19.6k	case FEATURE_HASHER:
624	19.6k	lib->crypto->remove_hasher(lib->crypto, reg->arg.reg.f);
625	19.6k	break;
626	3.92k	case FEATURE_PRF:
627	3.92k	lib->crypto->remove_prf(lib->crypto, reg->arg.reg.f);
628	3.92k	break;
629	0	case FEATURE_XOF:
630	0	lib->crypto->remove_xof(lib->crypto, reg->arg.reg.f);
631	0	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	0	case FEATURE_KE:
639	0	lib->crypto->remove_ke(lib->crypto, reg->arg.reg.f);
640	0	break;
641	0	case FEATURE_RNG:
642	0	lib->crypto->remove_rng(lib->crypto, reg->arg.reg.f);
643	0	break;
644	0	case FEATURE_NONCE_GEN:
645	0	lib->crypto->remove_nonce_gen(lib->crypto, reg->arg.reg.f);
646	0	break;
647	19.6k	case FEATURE_PRIVKEY:
648	19.6k	case FEATURE_PRIVKEY_GEN:
649	19.6k	lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
650	19.6k	break;
651	19.6k	case FEATURE_PUBKEY:
652	19.6k	lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
653	19.6k	break;
654	50.9k	case FEATURE_CERT_DECODE:
655	70.5k	case FEATURE_CERT_ENCODE:
656	70.5k	lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
657	70.5k	break;
658	0	case FEATURE_CONTAINER_DECODE:
659	0	case FEATURE_CONTAINER_ENCODE:
660	0	lib->creds->remove_builder(lib->creds, reg->arg.reg.f);
661	0	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	192k	}
672	192k	return TRUE;
673	192k	}