KNF

1 files changed, 197 insertions, 229 deletions

diff --git a/lib/libcrypto/rsa/rsa_pmeth.c b/lib/libcrypto/rsa/rsa_pmeth.c
index 1f9d826014d..4a662c2894e 100644
--- a/lib/libcrypto/rsa/rsa_pmeth.c
+++ b/lib/libcrypto/rsa/rsa_pmeth.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: rsa_pmeth.c,v 1.8 2014/06/12 20:40:57 deraadt Exp $ */
+/* $OpenBSD: rsa_pmeth.c,v 1.9 2014/07/09 08:20:08 miod Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -72,8 +72,7 @@
 
 /* RSA pkey context structure */
 
-typedef struct
-	{
+typedef struct {
 	/* Key gen parameters */
 	int nbits;
 	BIGNUM *pub_exp;
@@ -89,11 +88,13 @@ typedef struct
 	int saltlen;
 	/* Temp buffer */
 	unsigned char *tbuf;
-	} RSA_PKEY_CTX;
+} RSA_PKEY_CTX;
 
-static int pkey_rsa_init(EVP_PKEY_CTX *ctx)
-	{
+static int
+pkey_rsa_init(EVP_PKEY_CTX *ctx)
+{
 	RSA_PKEY_CTX *rctx;
+
 	rctx = malloc(sizeof(RSA_PKEY_CTX));
 	if (!rctx)
 		return 0;
@@ -111,424 +112,390 @@ static int pkey_rsa_init(EVP_PKEY_CTX *ctx)
 	ctx->keygen_info_count = 2;
 	
 	return 1;
-	}
+}
 
-static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
-	{
+static int
+pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
+{
 	RSA_PKEY_CTX *dctx, *sctx;
+
 	if (!pkey_rsa_init(dst))
 		return 0;
        	sctx = src->data;
 	dctx = dst->data;
 	dctx->nbits = sctx->nbits;
-	if (sctx->pub_exp)
-		{
+	if (sctx->pub_exp) {
 		dctx->pub_exp = BN_dup(sctx->pub_exp);
 		if (!dctx->pub_exp)
 			return 0;
-		}
+	}
 	dctx->pad_mode = sctx->pad_mode;
 	dctx->md = sctx->md;
 	return 1;
-	}
+}
 
-static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk)
-	{
+static int
+setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk)
+{
 	if (ctx->tbuf)
 		return 1;
 	ctx->tbuf = malloc(EVP_PKEY_size(pk->pkey));
 	if (!ctx->tbuf)
 		return 0;
 	return 1;
-	}
+}
 
-static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx)
-	{
+static void
+pkey_rsa_cleanup(EVP_PKEY_CTX *ctx)
+{
 	RSA_PKEY_CTX *rctx = ctx->data;
-	if (rctx)
-		{
+
+	if (rctx) {
 		if (rctx->pub_exp)
 			BN_free(rctx->pub_exp);
 		free(rctx->tbuf);
 		free(rctx);
-		}
 	}
-static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
-					const unsigned char *tbs, size_t tbslen)
-	{
+}
+
+static int
+pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+    const unsigned char *tbs, size_t tbslen)
+{
 	int ret;
 	RSA_PKEY_CTX *rctx = ctx->data;
 	RSA *rsa = ctx->pkey->pkey.rsa;
 
-	if (rctx->md)
-		{
-		if (tbslen != (size_t)EVP_MD_size(rctx->md))
-			{
+	if (rctx->md) {
+		if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
 			RSAerr(RSA_F_PKEY_RSA_SIGN,
-					RSA_R_INVALID_DIGEST_LENGTH);
+			    RSA_R_INVALID_DIGEST_LENGTH);
 			return -1;
-			}
+		}
 
-		if (EVP_MD_type(rctx->md) == NID_mdc2)
-			{
+		if (EVP_MD_type(rctx->md) == NID_mdc2) {
 			unsigned int sltmp;
+
 			if (rctx->pad_mode != RSA_PKCS1_PADDING)
 				return -1;
-			ret = RSA_sign_ASN1_OCTET_STRING(NID_mdc2,
-						tbs, tbslen, sig, &sltmp, rsa);
+			ret = RSA_sign_ASN1_OCTET_STRING(NID_mdc2, tbs, tbslen,
+			    sig, &sltmp, rsa);
 
 			if (ret <= 0)
 				return ret;
 			ret = sltmp;
-			}
-		else if (rctx->pad_mode == RSA_X931_PADDING)
-			{
+		} else if (rctx->pad_mode == RSA_X931_PADDING) {
 			if (!setup_tbuf(rctx, ctx))
 				return -1;
 			memcpy(rctx->tbuf, tbs, tbslen);
 			rctx->tbuf[tbslen] =
-				RSA_X931_hash_id(EVP_MD_type(rctx->md));
-			ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf,
-						sig, rsa, RSA_X931_PADDING);
-			}
-		else if (rctx->pad_mode == RSA_PKCS1_PADDING)
-			{
+			    RSA_X931_hash_id(EVP_MD_type(rctx->md));
+			ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf, sig,
+			    rsa, RSA_X931_PADDING);
+		} else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
 			unsigned int sltmp;
-			ret = RSA_sign(EVP_MD_type(rctx->md),
-						tbs, tbslen, sig, &sltmp, rsa);
+
+			ret = RSA_sign(EVP_MD_type(rctx->md), tbs, tbslen, sig,
+			    &sltmp, rsa);
 			if (ret <= 0)
 				return ret;
 			ret = sltmp;
-			}
-		else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING)
-			{
+		} else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 			if (!setup_tbuf(rctx, ctx))
 				return -1;
-			if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa,
-						rctx->tbuf, tbs,
-						rctx->md, rctx->mgf1md,
-						rctx->saltlen))
+			if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa, rctx->tbuf,
+			    tbs, rctx->md, rctx->mgf1md, rctx->saltlen))
 				return -1;
 			ret = RSA_private_encrypt(RSA_size(rsa), rctx->tbuf,
-						sig, rsa, RSA_NO_PADDING);
-			}
-		else
+			    sig, rsa, RSA_NO_PADDING);
+		} else
 			return -1;
-		}
-	else
+	} else
 		ret = RSA_private_encrypt(tbslen, tbs, sig, ctx->pkey->pkey.rsa,
-							rctx->pad_mode);
+		    rctx->pad_mode);
 	if (ret < 0)
 		return ret;
 	*siglen = ret;
 	return 1;
-	}
-
+}
 
-static int pkey_rsa_verifyrecover(EVP_PKEY_CTX *ctx,
-					unsigned char *rout, size_t *routlen,
-					const unsigned char *sig, size_t siglen)
-	{
+static int
+pkey_rsa_verifyrecover(EVP_PKEY_CTX *ctx, unsigned char *rout, size_t *routlen,
+    const unsigned char *sig, size_t siglen)
+{
 	int ret;
 	RSA_PKEY_CTX *rctx = ctx->data;
 
-	if (rctx->md)
-		{
-		if (rctx->pad_mode == RSA_X931_PADDING)
-			{
+	if (rctx->md) {
+		if (rctx->pad_mode == RSA_X931_PADDING) {
 			if (!setup_tbuf(rctx, ctx))
 				return -1;
-			ret = RSA_public_decrypt(siglen, sig,
-						rctx->tbuf, ctx->pkey->pkey.rsa,
-						RSA_X931_PADDING);
+			ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
+			    ctx->pkey->pkey.rsa, RSA_X931_PADDING);
 			if (ret < 1)
 				return 0;
 			ret--;
 			if (rctx->tbuf[ret] !=
-				RSA_X931_hash_id(EVP_MD_type(rctx->md)))
-				{
+			    RSA_X931_hash_id(EVP_MD_type(rctx->md))) {
 				RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
-						RSA_R_ALGORITHM_MISMATCH);
+				    RSA_R_ALGORITHM_MISMATCH);
 				return 0;
-				}
-			if (ret != EVP_MD_size(rctx->md))
-				{
+			}
+			if (ret != EVP_MD_size(rctx->md)) {
 				RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
-					RSA_R_INVALID_DIGEST_LENGTH);
+				    RSA_R_INVALID_DIGEST_LENGTH);
 				return 0;
-				}
+			}
 			if (rout)
 				memcpy(rout, rctx->tbuf, ret);
-			}
-		else if (rctx->pad_mode == RSA_PKCS1_PADDING)
-			{
+		} else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
 			size_t sltmp;
-			ret = int_rsa_verify(EVP_MD_type(rctx->md),
-						NULL, 0, rout, &sltmp,
-					sig, siglen, ctx->pkey->pkey.rsa);
+
+			ret = int_rsa_verify(EVP_MD_type(rctx->md), NULL, 0,
+			    rout, &sltmp, sig, siglen, ctx->pkey->pkey.rsa);
 			if (ret <= 0)
 				return 0;
 			ret = sltmp;
-			}
-		else
+		} else
 			return -1;
-		}
-	else
+	} else
 		ret = RSA_public_decrypt(siglen, sig, rout, ctx->pkey->pkey.rsa,
-							rctx->pad_mode);
+		    rctx->pad_mode);
 	if (ret < 0)
 		return ret;
 	*routlen = ret;
 	return 1;
-	}
+}
 
-static int pkey_rsa_verify(EVP_PKEY_CTX *ctx,
-					const unsigned char *sig, size_t siglen,
-					const unsigned char *tbs, size_t tbslen)
-	{
+static int
+pkey_rsa_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
+    const unsigned char *tbs, size_t tbslen)
+{
 	RSA_PKEY_CTX *rctx = ctx->data;
 	RSA *rsa = ctx->pkey->pkey.rsa;
 	size_t rslen;
-	if (rctx->md)
-		{
+
+	if (rctx->md) {
 		if (rctx->pad_mode == RSA_PKCS1_PADDING)
 			return RSA_verify(EVP_MD_type(rctx->md), tbs, tbslen,
-					sig, siglen, rsa);
-		if (rctx->pad_mode == RSA_X931_PADDING)
-			{
-			if (pkey_rsa_verifyrecover(ctx, NULL, &rslen,
-					sig, siglen) <= 0)
+			    sig, siglen, rsa);
+		if (rctx->pad_mode == RSA_X931_PADDING) {
+			if (pkey_rsa_verifyrecover(ctx, NULL, &rslen, sig,
+			    siglen) <= 0)
 				return 0;
-			}
-		else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING)
-			{
+		} else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 			int ret;
+
 			if (!setup_tbuf(rctx, ctx))
 				return -1;
 			ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
-							rsa, RSA_NO_PADDING);
+			    rsa, RSA_NO_PADDING);
 			if (ret <= 0)
 				return 0;
-			ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs,
-						rctx->md, rctx->mgf1md,
-						rctx->tbuf, rctx->saltlen);
+			ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs, rctx->md,
+			    rctx->mgf1md, rctx->tbuf, rctx->saltlen);
 			if (ret <= 0)
 				return 0;
 			return 1;
-			}
-		else
+		} else
 			return -1;
-		}
-	else
-		{
+	} else {
 		if (!setup_tbuf(rctx, ctx))
 			return -1;
-		rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf,
-						rsa, rctx->pad_mode);
+		rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf, rsa,
+		    rctx->pad_mode);
 		if (rslen == 0)
 			return 0;
-		}
+	}
 
-	if ((rslen != tbslen) || memcmp(tbs, rctx->tbuf, rslen))
+	if (rslen != tbslen || memcmp(tbs, rctx->tbuf, rslen))
 		return 0;
 
 	return 1;
-			
-	}
-	
+}
 
-static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx,
-					unsigned char *out, size_t *outlen,
-					const unsigned char *in, size_t inlen)
-	{
+static int
+pkey_rsa_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+    const unsigned char *in, size_t inlen)
+{
 	int ret;
 	RSA_PKEY_CTX *rctx = ctx->data;
+
 	ret = RSA_public_encrypt(inlen, in, out, ctx->pkey->pkey.rsa,
-							rctx->pad_mode);
+	    rctx->pad_mode);
 	if (ret < 0)
 		return ret;
 	*outlen = ret;
 	return 1;
-	}
+}
 
-static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx,
-					unsigned char *out, size_t *outlen,
-					const unsigned char *in, size_t inlen)
-	{
+static int
+pkey_rsa_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+    const unsigned char *in, size_t inlen)
+{
 	int ret;
 	RSA_PKEY_CTX *rctx = ctx->data;
+
 	ret = RSA_private_decrypt(inlen, in, out, ctx->pkey->pkey.rsa,
-							rctx->pad_mode);
+	    rctx->pad_mode);
 	if (ret < 0)
 		return ret;
 	*outlen = ret;
 	return 1;
-	}
+}
 
-static int check_padding_md(const EVP_MD *md, int padding)
-	{
+static int
+check_padding_md(const EVP_MD *md, int padding)
+{
 	if (!md)
 		return 1;
 
-	if (padding == RSA_NO_PADDING)
-		{
+	if (padding == RSA_NO_PADDING) {
 		RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_PADDING_MODE);
 		return 0;
-		}
+	}
 
-	if (padding == RSA_X931_PADDING)
-		{
-		if (RSA_X931_hash_id(EVP_MD_type(md)) == -1)
-			{
+	if (padding == RSA_X931_PADDING) {
+		if (RSA_X931_hash_id(EVP_MD_type(md)) == -1) {
 			RSAerr(RSA_F_CHECK_PADDING_MD,
-						RSA_R_INVALID_X931_DIGEST);
+			    RSA_R_INVALID_X931_DIGEST);
 			return 0;
-			}
-		return 1;
 		}
+		return 1;
+	}
 
 	return 1;
-	}
-			
+}
 
-static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
-	{
+static int
+pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
+{
 	RSA_PKEY_CTX *rctx = ctx->data;
-	switch (type)
-		{
-		case EVP_PKEY_CTRL_RSA_PADDING:
-		if ((p1 >= RSA_PKCS1_PADDING) && (p1 <= RSA_PKCS1_PSS_PADDING))
-			{
+	switch (type) {
+	case EVP_PKEY_CTRL_RSA_PADDING:
+		if (p1 >= RSA_PKCS1_PADDING && p1 <= RSA_PKCS1_PSS_PADDING) {
 			if (!check_padding_md(rctx->md, p1))
 				return 0;
-			if (p1 == RSA_PKCS1_PSS_PADDING) 
-				{
+			if (p1 == RSA_PKCS1_PSS_PADDING) {
 				if (!(ctx->operation &
-				     (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)))
+				    (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)))
 					goto bad_pad;
 				if (!rctx->md)
 					rctx->md = EVP_sha1();
-				}
-			if (p1 == RSA_PKCS1_OAEP_PADDING) 
-				{
+			}
+			if (p1 == RSA_PKCS1_OAEP_PADDING) {
 				if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))
 					goto bad_pad;
 				if (!rctx->md)
 					rctx->md = EVP_sha1();
-				}
+			}
 			rctx->pad_mode = p1;
 			return 1;
-			}
-		bad_pad:
+		}
+bad_pad:
 		RSAerr(RSA_F_PKEY_RSA_CTRL,
-				RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
+		    RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
 		return -2;
 
-		case EVP_PKEY_CTRL_GET_RSA_PADDING:
+	case EVP_PKEY_CTRL_GET_RSA_PADDING:
 		*(int *)p2 = rctx->pad_mode;
 		return 1;
 
-		case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
-		case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
-		if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING)
-			{
+	case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
+	case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
+		if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
 			RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
 			return -2;
-			}
+		}
 		if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN)
 			*(int *)p2 = rctx->saltlen;
-		else
-			{
+		else {
 			if (p1 < -2)
 				return -2;
 			rctx->saltlen = p1;
-			}
+		}
 		return 1;
 
-		case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
-		if (p1 < 256)
-			{
+	case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
+		if (p1 < 256) {
 			RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_KEYBITS);
 			return -2;
-			}
+		}
 		rctx->nbits = p1;
 		return 1;
 
-		case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
+	case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
 		if (!p2)
 			return -2;
 		rctx->pub_exp = p2;
 		return 1;
 
-		case EVP_PKEY_CTRL_MD:
+	case EVP_PKEY_CTRL_MD:
 		if (!check_padding_md(p2, rctx->pad_mode))
 			return 0;
 		rctx->md = p2;
 		return 1;
 
-		case EVP_PKEY_CTRL_RSA_MGF1_MD:
-		case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
-		if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING)
-			{
+	case EVP_PKEY_CTRL_RSA_MGF1_MD:
+	case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
+		if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
 			RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD);
 			return -2;
-			}
-		if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD)
-			{
+		}
+		if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) {
 			if (rctx->mgf1md)
 				*(const EVP_MD **)p2 = rctx->mgf1md;
 			else
 				*(const EVP_MD **)p2 = rctx->md;
-			}
-		else
+		} else
 			rctx->mgf1md = p2;
 		return 1;
 
-		case EVP_PKEY_CTRL_DIGESTINIT:
-		case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
-		case EVP_PKEY_CTRL_PKCS7_DECRYPT:
-		case EVP_PKEY_CTRL_PKCS7_SIGN:
+	case EVP_PKEY_CTRL_DIGESTINIT:
+	case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
+	case EVP_PKEY_CTRL_PKCS7_DECRYPT:
+	case EVP_PKEY_CTRL_PKCS7_SIGN:
 		return 1;
 #ifndef OPENSSL_NO_CMS
-		case EVP_PKEY_CTRL_CMS_DECRYPT:
-		{
+	case EVP_PKEY_CTRL_CMS_DECRYPT:
+	    {
 		X509_ALGOR *alg = NULL;
 		ASN1_OBJECT *encalg = NULL;
+
 		if (p2)
 			CMS_RecipientInfo_ktri_get0_algs(p2, NULL, NULL, &alg);
 		if (alg)
 			X509_ALGOR_get0(&encalg, NULL, NULL, alg);
 		if (encalg && OBJ_obj2nid(encalg) == NID_rsaesOaep)
 			rctx->pad_mode = RSA_PKCS1_OAEP_PADDING;
-		}
-		case EVP_PKEY_CTRL_CMS_ENCRYPT:
-		case EVP_PKEY_CTRL_CMS_SIGN:
+	    }
+		/* FALLTHROUGH */
+
+	case EVP_PKEY_CTRL_CMS_ENCRYPT:
+	case EVP_PKEY_CTRL_CMS_SIGN:
 		return 1;
 #endif
-		case EVP_PKEY_CTRL_PEER_KEY:
-			RSAerr(RSA_F_PKEY_RSA_CTRL,
-			RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
-			return -2;	
+	case EVP_PKEY_CTRL_PEER_KEY:
+		RSAerr(RSA_F_PKEY_RSA_CTRL,
+		RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+		return -2;	
 
-		default:
+	default:
 		return -2;
-
-		}
 	}
+}
 			
-static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
-			const char *type, const char *value)
-	{
+static int
+pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value)
+{
  	long lval;
 	char *ep;
 
-	if (!value)
-		{
+	if (!value) {
 		RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
 		return 0;
-		}
-	if (!strcmp(type, "rsa_padding_mode"))
-		{
+	}
+	if (!strcmp(type, "rsa_padding_mode")) {
 		int pm;
 		if (!strcmp(value, "pkcs1"))
 			pm = RSA_PKCS1_PADDING;
@@ -544,14 +511,13 @@ static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 			pm = RSA_X931_PADDING;
 		else if (!strcmp(value, "pss"))
 			pm = RSA_PKCS1_PSS_PADDING;
-		else
-			{
+		else {
 			RSAerr(RSA_F_PKEY_RSA_CTRL_STR,
-						RSA_R_UNKNOWN_PADDING_TYPE);
+			    RSA_R_UNKNOWN_PADDING_TYPE);
 			return -2;
-			}
-		return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
 		}
+		return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
+	}
 
 	if (!strcmp(type, "rsa_pss_saltlen")) {
 		int saltlen;
@@ -560,7 +526,8 @@ static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 		lval = strtol(value, &ep, 10);
 		if (value[0] == '\0' || *ep != '\0')
 			goto not_a_number;
-		if ((errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN)) ||
+		if ((errno == ERANGE &&
+		    (lval == LONG_MAX || lval == LONG_MIN)) ||
 		    (lval > INT_MAX || lval < INT_MIN))
 			goto out_of_range;
 		saltlen = lval;
@@ -574,7 +541,8 @@ static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 		lval = strtol(value, &ep, 10);
 		if (value[0] == '\0' || *ep != '\0')
 			goto not_a_number;
-		if ((errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN)) ||
+		if ((errno == ERANGE &&
+		    (lval == LONG_MAX || lval == LONG_MIN)) ||
 		    (lval > INT_MAX || lval < INT_MIN))
 			goto out_of_range;
 		nbits = lval;
@@ -584,6 +552,7 @@ static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 	if (!strcmp(type, "rsa_keygen_pubexp")) {
 		int ret;
 		BIGNUM *pubexp = NULL;
+
 		if (!BN_asc2bn(&pubexp, value))
 			return 0;
 		ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
@@ -597,27 +566,26 @@ out_of_range:
 	return -2;
 }
 
-static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
-	{
+static int
+pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
+{
 	RSA *rsa = NULL;
 	RSA_PKEY_CTX *rctx = ctx->data;
 	BN_GENCB *pcb, cb;
 	int ret;
-	if (!rctx->pub_exp)
-		{
+
+	if (!rctx->pub_exp) {
 		rctx->pub_exp = BN_new();
 		if (!rctx->pub_exp || !BN_set_word(rctx->pub_exp, RSA_F4))
 			return 0;
-		}
+	}
 	rsa = RSA_new();
 	if (!rsa)
 		return 0;
-	if (ctx->pkey_gencb)
-		{
+	if (ctx->pkey_gencb) {
 		pcb = &cb;
 		evp_pkey_set_cb_translate(pcb, ctx);
-		}
-	else
+	} else
 		pcb = NULL;
 	ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
 	if (ret > 0)
@@ -625,7 +593,7 @@ static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 	else
 		RSA_free(rsa);
 	return ret;
-	}
+}
 
 const EVP_PKEY_METHOD rsa_pkey_meth = {
 	.pkey_id = EVP_PKEY_RSA,