Probe for supported AF_ALG algorithms, register dynamically

src/libstrongswan/plugins/af_alg/af_alg_crypter.c

@@ -49,47 +49,76 @@ struct private_af_alg_crypter_t {
 	size_t iv_size;
 };
 
+/**
+ * Algorithm database
+ */
+static struct {
+	encryption_algorithm_t id;
+	char *name;
+	size_t block_size;
+	/* key size of the algorithm */
+	size_t key_size;
+	/* size of the keying material (key + nonce for ctr mode) */
+	size_t keymat_size;
+	size_t iv_size;
+} algs[] = {
+	{ENCR_DES,			"cbc(des)",					 8,	 8,	 8,	 8,	},
+	{ENCR_3DES,			"cbc(des3_ede)",			 8,	24,	24,	 8,	},
+	{ENCR_AES_CBC,		"cbc(aes)",					16,	16,	16,	16,	},
+	{ENCR_AES_CBC,		"cbc(aes)",					16,	24,	24,	16,	},
+	{ENCR_AES_CBC,		"cbc(aes)",					16,	32,	32,	16,	},
+	{ENCR_AES_CTR,		"rfc3686(ctr(aes))",		 1,	16,	20,	 8,	},
+	{ENCR_AES_CTR,		"rfc3686(ctr(aes))",		 1,	24,	28,	 8,	},
+	{ENCR_AES_CTR,		"rfc3686(ctr(aes))",		 1,	32,	36,	 8,	},
+	{ENCR_CAMELLIA_CBC,	"cbc(camellia)",			16,	16,	16,	16,	},
+	{ENCR_CAMELLIA_CBC,	"cbc(camellia)",			16,	24,	24,	16,	},
+	{ENCR_CAMELLIA_CBC,	"cbc(camellia)",			16,	32,	32,	16,	},
+	{ENCR_CAMELLIA_CTR,	"rfc3686(ctr(camellia))",	 1,	16,	20,	 8,	},
+	{ENCR_CAMELLIA_CTR,	"rfc3686(ctr(camellia))",	 1,	24,	28,	 8,	},
+	{ENCR_CAMELLIA_CTR,	"rfc3686(ctr(camellia))",	 1,	32,	36,	 8,	},
+	{ENCR_CAST,			"cbc(cast5)",				 8,	16,	16,	 8,	},
+	{ENCR_BLOWFISH,		"cbc(blowfish)",			 8,	16,	16,	 8,	},
+	{ENCR_BLOWFISH,		"cbc(blowfish)",			 8,	24,	24,	 8,	},
+	{ENCR_BLOWFISH,		"cbc(blowfish)",			 8,	32,	32,	 8,	},
+	{ENCR_SERPENT_CBC,	"cbc(serpent)",				16,	16,	16,	16,	},
+	{ENCR_SERPENT_CBC,	"cbc(serpent)",				16,	24,	24,	16,	},
+	{ENCR_SERPENT_CBC,	"cbc(serpent)",				16,	32,	32,	16,	},
+	{ENCR_TWOFISH_CBC,	"cbc(twofish)",				16,	16,	16,	16,	},
+	{ENCR_TWOFISH_CBC,	"cbc(twofish)",				16,	24,	24,	16,	},
+	{ENCR_TWOFISH_CBC,	"cbc(twofish)",				16,	32,	32,	16,	},
+};
+
+/**
+ * See header.
+ */
+void af_alg_crypter_probe()
+{
+	encryption_algorithm_t prev = -1;
+	af_alg_ops_t *ops;
+	int i;
+
+	for (i = 0; i < countof(algs); i++)
+	{
+		if (prev != algs[i].id)
+		{
+			ops = af_alg_ops_create("skcipher", algs[i].name);
+			if (ops)
+			{
+				ops->destroy(ops);
+				lib->crypto->add_crypter(lib->crypto, algs[i].id, "af_alg",
+								(crypter_constructor_t)af_alg_crypter_create);
+			}
+		}
+		prev = algs[i].id;
+	}
+}
+
 /**
  * Get the kernel algorithm string and block/key size for our identifier
  */
 static size_t lookup_alg(encryption_algorithm_t algo, char **name,
 						 size_t key_size, size_t *keymat_size, size_t *iv_size)
 {
-	static struct {
-		encryption_algorithm_t id;
-		char *name;
-		size_t block_size;
-		/* key size of the algorithm */
-		size_t key_size;
-		/* size of the keying material (key + nonce for ctr mode) */
-		size_t keymat_size;
-		size_t iv_size;
-	} algs[] = {
-		{ENCR_DES,			"cbc(des)",					 8,	 8,	 8,	 8,	},
-		{ENCR_3DES,			"cbc(des3_ede)",			 8,	24,	24,	 8,	},
-		{ENCR_AES_CBC,		"cbc(aes)",					16,	16,	16,	16,	},
-		{ENCR_AES_CBC,		"cbc(aes)",					16,	24,	24,	16,	},
-		{ENCR_AES_CBC,		"cbc(aes)",					16,	32,	32,	16,	},
-		{ENCR_AES_CTR,		"rfc3686(ctr(aes))",		 1,	16,	20,	 8,	},
-		{ENCR_AES_CTR,		"rfc3686(ctr(aes))",		 1,	24,	28,	 8,	},
-		{ENCR_AES_CTR,		"rfc3686(ctr(aes))",		 1,	32,	36,	 8,	},
-		{ENCR_CAMELLIA_CBC,	"cbc(camellia)",			16,	16,	16,	16,	},
-		{ENCR_CAMELLIA_CBC,	"cbc(camellia)",			16,	24,	24,	16,	},
-		{ENCR_CAMELLIA_CBC,	"cbc(camellia)",			16,	32,	32,	16,	},
-		{ENCR_CAMELLIA_CTR,	"rfc3686(ctr(camellia))",	 1,	16,	20,	 8,	},
-		{ENCR_CAMELLIA_CTR,	"rfc3686(ctr(camellia))",	 1,	24,	28,	 8,	},
-		{ENCR_CAMELLIA_CTR,	"rfc3686(ctr(camellia))",	 1,	32,	36,	 8,	},
-		{ENCR_CAST,			"cbc(cast5)",				 8,	16,	16,	 8,	},
-		{ENCR_BLOWFISH,		"cbc(blowfish)",			 8,	16,	16,	 8,	},
-		{ENCR_BLOWFISH,		"cbc(blowfish)",			 8,	24,	24,	 8,	},
-		{ENCR_BLOWFISH,		"cbc(blowfish)",			 8,	32,	32,	 8,	},
-		{ENCR_SERPENT_CBC,	"cbc(serpent)",				16,	16,	16,	16,	},
-		{ENCR_SERPENT_CBC,	"cbc(serpent)",				16,	24,	24,	16,	},
-		{ENCR_SERPENT_CBC,	"cbc(serpent)",				16,	32,	32,	16,	},
-		{ENCR_TWOFISH_CBC,	"cbc(twofish)",				16,	16,	16,	16,	},
-		{ENCR_TWOFISH_CBC,	"cbc(twofish)",				16,	24,	24,	16,	},
-		{ENCR_TWOFISH_CBC,	"cbc(twofish)",				16,	32,	32,	16,	},
-	};
 	int i;
 
 	for (i = 0; i < countof(algs); i++)

src/libstrongswan/plugins/af_alg/af_alg_crypter.h

@@ -46,4 +46,9 @@ struct af_alg_crypter_t {
 af_alg_crypter_t *af_alg_crypter_create(encryption_algorithm_t algo,
 										size_t key_size);
 
+/**
+ * Probe algorithms and register af_alg_crypter_create().
+ */
+void af_alg_crypter_probe();
+
 #endif /** AF_ALG_CRYPTER_H_ @}*/

src/libstrongswan/plugins/af_alg/af_alg_hasher.c

@@ -39,24 +39,48 @@ struct private_af_alg_hasher_t {
 	size_t size;
 };
 
+/**
+ * Algorithm database
+ */
+static struct {
+	hash_algorithm_t id;
+	char *name;
+	size_t size;
+} algs[] = {
+	{HASH_SHA1,			"sha1",			HASH_SIZE_SHA1		},
+	{HASH_MD5,			"md5",			HASH_SIZE_MD5 		},
+	{HASH_SHA224,		"sha224",		HASH_SIZE_SHA224	},
+	{HASH_SHA256,		"sha256",		HASH_SIZE_SHA256	},
+	{HASH_SHA384,		"sha384",		HASH_SIZE_SHA384	},
+	{HASH_SHA512,		"sha512",		HASH_SIZE_SHA512	},
+	{HASH_MD4,			"md4",			HASH_SIZE_MD4 		},
+};
+
+/**
+ * See header.
+ */
+void af_alg_hasher_probe()
+{
+	af_alg_ops_t *ops;
+	int i;
+
+	for (i = 0; i < countof(algs); i++)
+	{
+		ops = af_alg_ops_create("hash", algs[i].name);
+		if (ops)
+		{
+			ops->destroy(ops);
+			lib->crypto->add_hasher(lib->crypto, algs[i].id, "af_alg",
+							(hasher_constructor_t)af_alg_hasher_create);
+		}
+	}
+}
+
 /**
  * Get the kernel algorithm string and hash size for our identifier
  */
 static size_t lookup_alg(hash_algorithm_t algo, char **name)
 {
-	static struct {
-		hash_algorithm_t id;
-		char *name;
-		size_t size;
-	} algs[] = {
-		{HASH_MD4 ,			"md4",			HASH_SIZE_MD4 		},
-		{HASH_MD5 ,			"md5",			HASH_SIZE_MD5 		},
-		{HASH_SHA1,			"sha1",			HASH_SIZE_SHA1		},
-		{HASH_SHA224,		"sha224",		HASH_SIZE_SHA224	},
-		{HASH_SHA256,		"sha256",		HASH_SIZE_SHA256	},
-		{HASH_SHA384,		"sha384",		HASH_SIZE_SHA384	},
-		{HASH_SHA512,		"sha512",		HASH_SIZE_SHA512	},
-	};
 	int i;
 
 	for (i = 0; i < countof(algs); i++)

src/libstrongswan/plugins/af_alg/af_alg_hasher.h

@@ -44,4 +44,9 @@ struct af_alg_hasher_t {
  */
 af_alg_hasher_t *af_alg_hasher_create(hash_algorithm_t algo);
 
+/**
+ * Probe algorithms and register af_alg_hasher_create().
+ */
+void af_alg_hasher_probe();
+
 #endif /** af_alg_HASHER_H_ @}*/

src/libstrongswan/plugins/af_alg/af_alg_ops.c

@@ -212,8 +212,11 @@ af_alg_ops_t *af_alg_ops_create(char *type, char *alg)
 	}
 	if (bind(this->tfm, (struct sockaddr*)&sa, sizeof(sa)) == -1)
 	{
-		DBG1(DBG_LIB, "binding AF_ALG socket for '%s' failed: %s",
+		if (errno != ENOENT)
-			 sa.salg_name, strerror(errno));
+		{	/* fail silently if algorithm not supported */
+			DBG1(DBG_LIB, "binding AF_ALG socket for '%s' failed: %s",
+				 sa.salg_name, strerror(errno));
+		}
 		destroy(this);
 		return NULL;
 	}

src/libstrongswan/plugins/af_alg/af_alg_plugin.c

@@ -65,83 +65,10 @@ plugin_t *af_alg_plugin_create()
 		},
 	);
 
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA1,
+	af_alg_hasher_probe();
-					(hasher_constructor_t)af_alg_hasher_create);
+	af_alg_signer_probe();
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA224,
+	af_alg_prf_probe();
-					(hasher_constructor_t)af_alg_hasher_create);
+	af_alg_crypter_probe();
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA256,
-					(hasher_constructor_t)af_alg_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA384,
-					(hasher_constructor_t)af_alg_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA512,
-					(hasher_constructor_t)af_alg_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_MD5,
-					(hasher_constructor_t)af_alg_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_MD4,
-					(hasher_constructor_t)af_alg_hasher_create);
-
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_MD5_96,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_MD5_128,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_96,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_128,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_160,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_256_96,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_256_128,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_256_256,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_384_192,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_384_384,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_512_256,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_AES_XCBC_96,
-					(signer_constructor_t)af_alg_signer_create);
-	lib->crypto->add_signer(lib->crypto, AUTH_CAMELLIA_XCBC_96,
-					(signer_constructor_t)af_alg_signer_create);
-
-	lib->crypto->add_prf(lib->crypto, PRF_HMAC_MD5,
-					(prf_constructor_t)af_alg_prf_create);
-	lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA1,
-					(prf_constructor_t)af_alg_prf_create);
-	lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_256,
-					(prf_constructor_t)af_alg_prf_create);
-	lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_384,
-					(prf_constructor_t)af_alg_prf_create);
-	lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_512,
-					(prf_constructor_t)af_alg_prf_create);
-	lib->crypto->add_prf(lib->crypto, PRF_AES128_XCBC,
-					(prf_constructor_t)af_alg_prf_create);
-	lib->crypto->add_prf(lib->crypto, PRF_CAMELLIA128_XCBC,
-					(prf_constructor_t)af_alg_prf_create);
-
-	lib->crypto->add_crypter(lib->crypto, ENCR_DES,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_3DES,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CTR,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CBC,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CTR,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_CAST,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_BLOWFISH,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_SERPENT_CBC,
-					(crypter_constructor_t)af_alg_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_TWOFISH_CBC,
-					(crypter_constructor_t)af_alg_crypter_create);
 
 	return &this->public.plugin;
 }

src/libstrongswan/plugins/af_alg/af_alg_prf.c

@@ -49,25 +49,49 @@ struct private_af_alg_prf_t {
 	bool xcbc;
 };
 
+/**
+ * Algorithm database
+ */
+static struct {
+	pseudo_random_function_t id;
+	char *name;
+	size_t block_size;
+	bool xcbc;
+} algs[] = {
+	{PRF_HMAC_SHA1,			"hmac(sha1)",		20,		FALSE,	},
+	{PRF_HMAC_SHA2_256,		"hmac(sha256)",		32,		FALSE,	},
+	{PRF_HMAC_MD5,			"hmac(md5)",		16,		FALSE,	},
+	{PRF_HMAC_SHA2_384,		"hmac(sha384)",		48,		FALSE,	},
+	{PRF_HMAC_SHA2_512,		"hmac(sha512)",		64,		FALSE,	},
+	{PRF_AES128_XCBC,		"xcbc(aes)",		16,		TRUE,	},
+	{PRF_CAMELLIA128_XCBC,	"xcbc(camellia)",	16,		TRUE,	},
+};
+
+/**
+ * See header.
+ */
+void af_alg_prf_probe()
+{
+	af_alg_ops_t *ops;
+	int i;
+
+	for (i = 0; i < countof(algs); i++)
+	{
+		ops = af_alg_ops_create("hash", algs[i].name);
+		if (ops)
+		{
+			ops->destroy(ops);
+			lib->crypto->add_prf(lib->crypto, algs[i].id, "af_alg",
+							(prf_constructor_t)af_alg_prf_create);
+		}
+	}
+}
+
 /**
  * Get the kernel algorithm string and block size for our identifier
  */
 static size_t lookup_alg(integrity_algorithm_t algo, char **name, bool *xcbc)
 {
-	static struct {
-		integrity_algorithm_t id;
-		char *name;
-		size_t block_size;
-		bool xcbc;
-	} algs[] = {
-		{PRF_HMAC_MD5,			"hmac(md5)",		16,		FALSE,	},
-		{PRF_HMAC_SHA1,			"hmac(sha1)",		20,		FALSE,	},
-		{PRF_HMAC_SHA2_256,		"hmac(sha256)",		32,		FALSE,	},
-		{PRF_HMAC_SHA2_384,		"hmac(sha384)",		48,		FALSE,	},
-		{PRF_HMAC_SHA2_512,		"hmac(sha512)",		64,		FALSE,	},
-		{PRF_AES128_XCBC,		"xcbc(aes)",		16,		TRUE,	},
-		{PRF_CAMELLIA128_XCBC,	"xcbc(camellia)",	16,		TRUE,	},
-	};
 	int i;
 
 	for (i = 0; i < countof(algs); i++)

src/libstrongswan/plugins/af_alg/af_alg_prf.h

@@ -44,4 +44,9 @@ struct af_alg_prf_t {
  */
 af_alg_prf_t *af_alg_prf_create(pseudo_random_function_t algo);
 
+/**
+ * Probe algorithms and register af_alg_prf_create().
+ */
+void af_alg_prf_probe();
+
 #endif /** AF_ALG_PRF_H_ @}*/

src/libstrongswan/plugins/af_alg/af_alg_signer.c

@@ -44,32 +44,56 @@ struct private_af_alg_signer_t {
 	size_t key_size;
 };
 
+/**
+ * Algorithm database
+ */
+static struct {
+	integrity_algorithm_t id;
+	char *name;
+	size_t block_size;
+	size_t key_size;
+} algs[] = {
+	{AUTH_HMAC_SHA1_96,			"hmac(sha1)",		12,		20,	},
+	{AUTH_HMAC_SHA1_128,		"hmac(sha1)",		16,		20,	},
+	{AUTH_HMAC_SHA1_160,		"hmac(sha1)",		20,		20,	},
+	{AUTH_HMAC_SHA2_256_96,		"hmac(sha256)",		12,		32,	},
+	{AUTH_HMAC_SHA2_256_128,	"hmac(sha256)",		16,		32,	},
+	{AUTH_HMAC_MD5_96,			"hmac(md5)",		12,		16,	},
+	{AUTH_HMAC_MD5_128,			"hmac(md5)",		16,		16,	},
+	{AUTH_HMAC_SHA2_256_256,	"hmac(sha384)",		32,		32,	},
+	{AUTH_HMAC_SHA2_384_192,	"hmac(sha384)",		24,		48,	},
+	{AUTH_HMAC_SHA2_384_384,	"hmac(sha384)",		48,		48,	},
+	{AUTH_HMAC_SHA2_512_256,	"hmac(sha512)",		32,		64,	},
+	{AUTH_AES_XCBC_96,			"xcbc(aes)",		12,		16,	},
+	{AUTH_CAMELLIA_XCBC_96,		"xcbc(camellia)",	12,		16,	},
+};
+
+/**
+ * See header.
+ */
+void af_alg_signer_probe()
+{
+	af_alg_ops_t *ops;
+	int i;
+
+	for (i = 0; i < countof(algs); i++)
+	{
+		ops = af_alg_ops_create("hash", algs[i].name);
+		if (ops)
+		{
+			ops->destroy(ops);
+			lib->crypto->add_signer(lib->crypto, algs[i].id, "af_alg",
+							(signer_constructor_t)af_alg_signer_create);
+		}
+	}
+}
+
 /**
  * Get the kernel algorithm string and block/key size for our identifier
  */
 static size_t lookup_alg(integrity_algorithm_t algo, char **name,
 						 size_t *key_size)
 {
-	static struct {
-		integrity_algorithm_t id;
-		char *name;
-		size_t block_size;
-		size_t key_size;
-	} algs[] = {
-		{AUTH_HMAC_MD5_96,			"hmac(md5)",		12,		16,	},
-		{AUTH_HMAC_MD5_128,			"hmac(md5)",		16,		16,	},
-		{AUTH_HMAC_SHA1_96,			"hmac(sha1)",		12,		20,	},
-		{AUTH_HMAC_SHA1_128,		"hmac(sha1)",		16,		20,	},
-		{AUTH_HMAC_SHA1_160,		"hmac(sha1)",		20,		20,	},
-		{AUTH_HMAC_SHA2_256_96,		"hmac(sha256)",		12,		32,	},
-		{AUTH_HMAC_SHA2_256_128,	"hmac(sha256)",		16,		32,	},
-		{AUTH_HMAC_SHA2_256_256,	"hmac(sha384)",		32,		32,	},
-		{AUTH_HMAC_SHA2_384_192,	"hmac(sha384)",		24,		48,	},
-		{AUTH_HMAC_SHA2_384_384,	"hmac(sha384)",		48,		48,	},
-		{AUTH_HMAC_SHA2_512_256,	"hmac(sha512)",		32,		64,	},
-		{AUTH_AES_XCBC_96,			"xcbc(aes)",		12,		16,	},
-		{AUTH_CAMELLIA_XCBC_96,		"xcbc(camellia)",	12,		16,	},
-	};
 	int i;
 
 	for (i = 0; i < countof(algs); i++)

src/libstrongswan/plugins/af_alg/af_alg_signer.h

@@ -44,4 +44,9 @@ struct af_alg_signer_t {
  */
 af_alg_signer_t *af_alg_signer_create(integrity_algorithm_t algo);
 
+/**
+ * Probe algorithms and register af_alg_signer_create().
+ */
+void af_alg_signer_probe();
+
 #endif /** AF_ALG_SIGNER_H_ @}*/