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++)
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_ @}*/
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++)
*/
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_ @}*/
}
if (bind(this->tfm, (struct sockaddr*)&sa, sizeof(sa)) == -1)
{
- DBG1(DBG_LIB, "binding AF_ALG socket for '%s' failed: %s",
- sa.salg_name, strerror(errno));
+ if (errno != ENOENT)
+ { /* 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;
}
},
);
- lib->crypto->add_hasher(lib->crypto, HASH_SHA1,
- (hasher_constructor_t)af_alg_hasher_create);
- lib->crypto->add_hasher(lib->crypto, HASH_SHA224,
- (hasher_constructor_t)af_alg_hasher_create);
- 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);
+ af_alg_hasher_probe();
+ af_alg_signer_probe();
+ af_alg_prf_probe();
+ af_alg_crypter_probe();
return &this->public.plugin;
}
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++)
*/
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_ @}*/
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++)
*/
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_ @}*/
projects / thirdparty / strongswan.git / commitdiff
