Updated gcrypt plugin to the new builder API

src/libstrongswan/plugins/gcrypt/gcrypt_plugin.c

@@ -107,9 +107,11 @@ static void destroy(private_gcrypt_plugin_t *this)
 	lib->crypto->remove_dh(lib->crypto,
 					(dh_constructor_t)gcrypt_dh_create);
 	lib->creds->remove_builder(lib->creds,
-					(builder_constructor_t)gcrypt_rsa_private_key_builder);
+					(builder_function_t)gcrypt_rsa_private_key_gen);
 	lib->creds->remove_builder(lib->creds,
-					(builder_constructor_t)gcrypt_rsa_public_key_builder);
+					(builder_function_t)gcrypt_rsa_private_key_load);
+	lib->creds->remove_builder(lib->creds,
+					(builder_function_t)gcrypt_rsa_public_key_load);
 	free(this);
 }
 
@@ -205,9 +207,11 @@ plugin_t *plugin_create()
 
 	/* RSA */
 	lib->creds->add_builder(lib->creds, CRED_PRIVATE_KEY, KEY_RSA,
-					(builder_constructor_t)gcrypt_rsa_private_key_builder);
+					(builder_function_t)gcrypt_rsa_private_key_gen);
+	lib->creds->add_builder(lib->creds, CRED_PRIVATE_KEY, KEY_RSA,
+					(builder_function_t)gcrypt_rsa_private_key_load);
 	lib->creds->add_builder(lib->creds, CRED_PUBLIC_KEY, KEY_RSA,
-					(builder_constructor_t)gcrypt_rsa_public_key_builder);
+					(builder_function_t)gcrypt_rsa_public_key_load);
 
 	return &this->public.plugin;
 }

src/libstrongswan/plugins/gcrypt/gcrypt_rsa_private_key.c

@@ -455,13 +455,34 @@ static private_gcrypt_rsa_private_key_t *gcrypt_rsa_private_key_create_empty()
 }
 
 /**
- * Generate an RSA key of specified key size
+ * See header.
  */
-static gcrypt_rsa_private_key_t *generate(size_t key_size)
+gcrypt_rsa_private_key_t *gcrypt_rsa_private_key_gen(key_type_t type,
+													 va_list args)
 {
 	private_gcrypt_rsa_private_key_t *this;
-	gcry_sexp_t param, key;
+	gcry_sexp_t param;
 	gcry_error_t err;
+	u_int key_size = 0;
+
+	while (TRUE)
+	{
+		switch (va_arg(args, builder_part_t))
+		{
+			case BUILD_KEY_SIZE:
+				key_size = va_arg(args, u_int);
+				continue;
+			case BUILD_END:
+				break;
+			default:
+				return NULL;
+		}
+		break;
+	}
+	if (!key_size)
+	{
+		return NULL;
+	}
 
 	err = gcry_sexp_build(&param, NULL, "(genkey(rsa(nbits %d)))", key_size);
 	if (err)
@@ -469,29 +490,65 @@ static gcrypt_rsa_private_key_t *generate(size_t key_size)
 		DBG1("building S-expression failed: %s", gpg_strerror(err));
 		return NULL;
 	}
-
+	this = gcrypt_rsa_private_key_create_empty();
-	err = gcry_pk_genkey(&key, param);
+	err = gcry_pk_genkey(&this->key, param);
 	gcry_sexp_release(param);
 	if (err)
 	{
+		free(this);
 		DBG1("generating RSA key failed: %s", gpg_strerror(err));
 		return NULL;
 	}
-	this = gcrypt_rsa_private_key_create_empty();
-	this->key = key;
-
 	return &this->public;
 }
 
 /**
- * Load a private key from components
+ * See header.
  */
-static gcrypt_rsa_private_key_t *load(chunk_t n, chunk_t e, chunk_t d,
+gcrypt_rsa_private_key_t *gcrypt_rsa_private_key_load(key_type_t type,
-									  chunk_t p, chunk_t q, chunk_t u)
+													  va_list args)
 {
+	private_gcrypt_rsa_private_key_t *this;
+	chunk_t n, e, d, p, q, u;
 	gcry_error_t err;
-	private_gcrypt_rsa_private_key_t *this = gcrypt_rsa_private_key_create_empty();
 
+	n = e = d = p = q = u = chunk_empty;
+	while (TRUE)
+	{
+		switch (va_arg(args, builder_part_t))
+		{
+			case BUILD_RSA_MODULUS:
+				n = va_arg(args, chunk_t);
+				continue;
+			case BUILD_RSA_PUB_EXP:
+				e = va_arg(args, chunk_t);
+				continue;
+			case BUILD_RSA_PRIV_EXP:
+				d = va_arg(args, chunk_t);
+				continue;
+			case BUILD_RSA_PRIME1:
+				/* swap p and q, gcrypt expects p < q */
+				q = va_arg(args, chunk_t);
+				continue;
+			case BUILD_RSA_PRIME2:
+				p = va_arg(args, chunk_t);
+				continue;
+			case BUILD_RSA_EXP1:
+			case BUILD_RSA_EXP2:
+				/* not required for gcrypt */
+				continue;
+			case BUILD_RSA_COEFF:
+				u = va_arg(args, chunk_t);
+				continue;
+			case BUILD_END:
+				break;
+			default:
+				return NULL;
+		}
+		break;
+	}
+
+	this = gcrypt_rsa_private_key_create_empty();
 	err = gcry_sexp_build(&this->key, NULL,
 					"(private-key(rsa(n %b)(e %b)(d %b)(p %b)(q %b)(u %b)))",
 					n.len, n.ptr, e.len, e.ptr, d.len, d.ptr,
@@ -512,101 +569,3 @@ static gcrypt_rsa_private_key_t *load(chunk_t n, chunk_t e, chunk_t d,
 	return &this->public;
 }
 
-typedef struct private_builder_t private_builder_t;
-
-/**
- * Builder implementation for key loading/generation
- */
-struct private_builder_t {
-	/** implements the builder interface */
-	builder_t public;
-	/** key size, if generating */
-	u_int key_size;
-	/** rsa key parameters */
-	chunk_t n, e, d, p, q, u;
-};
-
-/**
- * Implementation of builder_t.build
- */
-static gcrypt_rsa_private_key_t *build(private_builder_t *this)
-{
-	gcrypt_rsa_private_key_t *key = NULL;
-
-	if (this->key_size)
-	{
-		key = generate(this->key_size);
-	}
-	else
-	{
-		key = load(this->n, this->e, this->d, this->p, this->q, this->u);
-	}
-	free(this);
-	return key;
-}
-
-/**
- * Implementation of builder_t.add
- */
-static void add(private_builder_t *this, builder_part_t part, ...)
-{
-	va_list args;
-
-	va_start(args, part);
-	switch (part)
-	{
-		case BUILD_KEY_SIZE:
-			this->key_size = va_arg(args, u_int);
-			return;
-		case BUILD_RSA_MODULUS:
-			this->n = va_arg(args, chunk_t);
-			break;
-		case BUILD_RSA_PUB_EXP:
-			this->e = va_arg(args, chunk_t);
-			break;
-		case BUILD_RSA_PRIV_EXP:
-			this->d = va_arg(args, chunk_t);
-			break;
-		case BUILD_RSA_PRIME1:
-			/* swap p and q, gcrypt expects p < q */
-			this->q = va_arg(args, chunk_t);
-			break;
-		case BUILD_RSA_PRIME2:
-			this->p = va_arg(args, chunk_t);
-			break;
-		case BUILD_RSA_EXP1:
-		case BUILD_RSA_EXP2:
-			/* not required for gcrypt */
-			break;
-		case BUILD_RSA_COEFF:
-			this->u = va_arg(args, chunk_t);
-			break;
-		default:
-			builder_cancel(&this->public);
-			break;
-	}
-	va_end(args);
-}
-
-/**
- * Builder construction function
- */
-builder_t *gcrypt_rsa_private_key_builder(key_type_t type)
-{
-	private_builder_t *this;
-
-	if (type != KEY_RSA)
-	{
-		return NULL;
-	}
-
-	this = malloc_thing(private_builder_t);
-
-	this->key_size = 0;
-	this->n = this->e = this->d = this->p = this->q = this->u = chunk_empty;
-	this->public.add = (void(*)(builder_t *this, builder_part_t part, ...))add;
-	this->public.build = (void*(*)(builder_t *this))build;
-
-	return &this->public;
-}
-

src/libstrongswan/plugins/gcrypt/gcrypt_rsa_private_key.h

@@ -21,6 +21,7 @@
 #ifndef GCRYPT_RSA_PRIVATE_KEY_H_
 #define GCRYPT_RSA_PRIVATE_KEY_H_
 
+#include <credentials/builder.h>
 #include <credentials/keys/private_key.h>
 
 typedef struct gcrypt_rsa_private_key_t gcrypt_rsa_private_key_t;
@@ -37,11 +38,27 @@ struct gcrypt_rsa_private_key_t {
 };
 
 /**
- * Create the builder for a private key.
+ * Generate a private key using gcrypt.
+ *
+ * Accepts the BUILD_KEY_SIZE argument.
  *
  * @param type		type of the key, must be KEY_RSA
- * @return 			builder instance
+ * @param args		builder_part_t argument list
+ * @return			generated key, NULL on failure
  */
-builder_t *gcrypt_rsa_private_key_builder(key_type_t type);
+gcrypt_rsa_private_key_t *gcrypt_rsa_private_key_gen(key_type_t type,
+													 va_list args);
+
+/**
+ * Load a gcrypt RSA private keys.
+ *
+ * Accepts BUILD_RSA_* components.
+ *
+ * @param type		type of the key, must be KEY_RSA
+ * @param args		builder_part_t argument list
+ * @return			loaded key, NULL on failure
+ */
+gcrypt_rsa_private_key_t *gcrypt_rsa_private_key_load(key_type_t type,
+													  va_list args);
 
 #endif /** GCRYPT_RSA_PRIVATE_KEY_H_ @}*/

src/libstrongswan/plugins/gcrypt/gcrypt_rsa_public_key.c

@@ -295,11 +295,35 @@ static void destroy(private_gcrypt_rsa_public_key_t *this)
 }
 
 /**
- * Generic private constructor
+ * See header.
  */
-static private_gcrypt_rsa_public_key_t *gcrypt_rsa_public_key_create_empty()
+gcrypt_rsa_public_key_t *gcrypt_rsa_public_key_load(key_type_t type,
+													va_list args)
 {
-	private_gcrypt_rsa_public_key_t *this = malloc_thing(private_gcrypt_rsa_public_key_t);
+	private_gcrypt_rsa_public_key_t *this;
+	gcry_error_t err;
+	chunk_t n, e;
+
+	n = e = chunk_empty;
+	while (TRUE)
+	{
+		switch (va_arg(args, builder_part_t))
+		{
+			case BUILD_RSA_MODULUS:
+				n = va_arg(args, chunk_t);
+				continue;
+			case BUILD_RSA_PUB_EXP:
+				e = va_arg(args, chunk_t);
+				continue;
+			case BUILD_END:
+				break;
+			default:
+				return NULL;
+		}
+		break;
+	}
+
+	this = malloc_thing(private_gcrypt_rsa_public_key_t);
 
 	this->public.interface.get_type = (key_type_t (*)(public_key_t *this))get_type;
 	this->public.interface.verify = (bool (*)(public_key_t *this, signature_scheme_t scheme, chunk_t data, chunk_t signature))verify;
@@ -314,18 +338,6 @@ static private_gcrypt_rsa_public_key_t *gcrypt_rsa_public_key_create_empty()
 	this->key = NULL;
 	this->ref = 1;
 
-	return this;
-}
-
-/**
- * Load a public key from components
- */
-static gcrypt_rsa_public_key_t *load(chunk_t n, chunk_t e)
-{
-	private_gcrypt_rsa_public_key_t *this;
-	gcry_error_t err;
-
-	this = gcrypt_rsa_public_key_create_empty();
 	err = gcry_sexp_build(&this->key, NULL, "(public-key(rsa(n %b)(e %b)))",
 						  n.len, n.ptr, e.len, e.ptr);
 	if (err)
@@ -334,73 +346,6 @@ static gcrypt_rsa_public_key_t *load(chunk_t n, chunk_t e)
 		free(this);
 		return NULL;
 	}
-	return &this->public;
-}
-
-typedef struct private_builder_t private_builder_t;
-
-/**
- * Builder implementation for key loading
- */
-struct private_builder_t {
-	/** implements the builder interface */
-	builder_t public;
-	/** rsa key parameters */
-	chunk_t n, e;
-};
-
-/**
- * Implementation of builder_t.build
- */
-static gcrypt_rsa_public_key_t *build(private_builder_t *this)
-{
-	gcrypt_rsa_public_key_t *key;
-
-	key = load(this->n, this->e);
-	free(this);
-	return key;
-}
-
-/**
- * Implementation of builder_t.add
- */
-static void add(private_builder_t *this, builder_part_t part, ...)
-{
-	va_list args;
-
-	va_start(args, part);
-	switch (part)
-	{
-		case BUILD_RSA_MODULUS:
-			this->n = va_arg(args, chunk_t);
-			break;
-		case BUILD_RSA_PUB_EXP:
-			this->e = va_arg(args, chunk_t);
-			break;
-		default:
-			builder_cancel(&this->public);
-			break;
-	}
-	va_end(args);
-}
-
-/**
- * Builder construction function
- */
-builder_t *gcrypt_rsa_public_key_builder(key_type_t type)
-{
-	private_builder_t *this;
-
-	if (type != KEY_RSA)
-	{
-		return NULL;
-	}
-
-	this = malloc_thing(private_builder_t);
-
-	this->n = this->e = chunk_empty;
-	this->public.add = (void(*)(builder_t *this, builder_part_t part, ...))add;
-	this->public.build = (void*(*)(builder_t *this))build;
 
 	return &this->public;
 }

src/libstrongswan/plugins/gcrypt/gcrypt_rsa_public_key.h

@@ -21,10 +21,11 @@
 #ifndef GCRYPT_RSA_PUBLIC_KEY_H_
 #define GCRYPT_RSA_PUBLIC_KEY_H_
 
-typedef struct gcrypt_rsa_public_key_t gcrypt_rsa_public_key_t;
+#include <credentials/builder.h>
-
 #include <credentials/keys/public_key.h>
 
+typedef struct gcrypt_rsa_public_key_t gcrypt_rsa_public_key_t;
+
 /**
  * public_key_t implementation of RSA algorithm using libgcrypt.
  */
@@ -37,11 +38,15 @@ struct gcrypt_rsa_public_key_t {
 };
 
 /**
- * Create the builder for a public key.
+ * Load a RSA public key using gcrypt.
+ *
+ * Accepts BUILD_RSA_* components.
  *
  * @param type		type of the key, must be KEY_RSA
- * @return			builder instance
+ * @param args		builder_part_t argument list
+ * @return			loaded key, NULL on failure
  */
-builder_t *gcrypt_rsa_public_key_builder(key_type_t type);
+gcrypt_rsa_public_key_t *gcrypt_rsa_public_key_load(key_type_t type,
+													va_list args);
 
 #endif /** GCRYPT_RSA_PUBLIC_KEY_H_ @}*/