projects / deliverable / linux.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
crypto: rsa-pkcs1pad - Remove bogus page splitting
[deliverable/linux.git] / crypto / rsa-pkcs1pad.c
diff --git a/crypto/rsa-pkcs1pad.c b/crypto/rsa-pkcs1pad.c
index ead8dc0d084e749e35733abc164f1e209aca3f6f..d9baefb7d5d1ad58d19e7ba9ed3be057af7a6304 100644 (file)
--- a/crypto/rsa-pkcs1pad.c
+++ b/crypto/rsa-pkcs1pad.c
@@ -92,19 +92,18 @@ static const struct rsa_asn1_template *rsa_lookup_asn1(const char *name)
 
 struct pkcs1pad_ctx {
        struct crypto_akcipher *child;
-       const char *hash_name;
        unsigned int key_size;
 };
 
 struct pkcs1pad_inst_ctx {
        struct crypto_akcipher_spawn spawn;
-       const char *hash_name;
+       const struct rsa_asn1_template *digest_info;
 };
 
 struct pkcs1pad_request {
        struct akcipher_request child_req;
 
-       struct scatterlist in_sg[3], out_sg[2];
+       struct scatterlist in_sg[2], out_sg[1];
        uint8_t *in_buf, *out_buf;
 };
 
@@ -164,19 +163,10 @@ static int pkcs1pad_get_max_size(struct crypto_akcipher *tfm)
 static void pkcs1pad_sg_set_buf(struct scatterlist *sg, void *buf, size_t len,
                struct scatterlist *next)
 {
-       int nsegs = next ? 1 : 0;
-
-       if (offset_in_page(buf) + len <= PAGE_SIZE) {
-               nsegs += 1;
-               sg_init_table(sg, nsegs);
-               sg_set_buf(sg, buf, len);
-       } else {
-               nsegs += 2;
-               sg_init_table(sg, nsegs);
-               sg_set_buf(sg + 0, buf, PAGE_SIZE - offset_in_page(buf));
-               sg_set_buf(sg + 1, buf + PAGE_SIZE - offset_in_page(buf),
-                               offset_in_page(buf) + len - PAGE_SIZE);
-       }
+       int nsegs = next ? 2 : 1;
+
+       sg_init_table(sg, nsegs);
+       sg_set_buf(sg, buf, len);
 
        if (next)
                sg_chain(sg, nsegs, next);
@@ -416,20 +406,16 @@ static int pkcs1pad_sign(struct akcipher_request *req)
        struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
        struct pkcs1pad_ctx *ctx = akcipher_tfm_ctx(tfm);
        struct pkcs1pad_request *req_ctx = akcipher_request_ctx(req);
-       const struct rsa_asn1_template *digest_info = NULL;
+       struct akcipher_instance *inst = akcipher_alg_instance(tfm);
+       struct pkcs1pad_inst_ctx *ictx = akcipher_instance_ctx(inst);
+       const struct rsa_asn1_template *digest_info = ictx->digest_info;
        int err;
        unsigned int ps_end, digest_size = 0;
 
        if (!ctx->key_size)
                return -EINVAL;
 
-       if (ctx->hash_name) {
-               digest_info = rsa_lookup_asn1(ctx->hash_name);
-               if (!digest_info)
-                       return -EINVAL;
-
-               digest_size = digest_info->size;
-       }
+       digest_size = digest_info->size;
 
        if (req->src_len + digest_size > ctx->key_size - 11)
                return -EOVERFLOW;
@@ -462,10 +448,8 @@ static int pkcs1pad_sign(struct akcipher_request *req)
        memset(req_ctx->in_buf + 1, 0xff, ps_end - 1);
        req_ctx->in_buf[ps_end] = 0x00;
 
-       if (digest_info) {
-               memcpy(req_ctx->in_buf + ps_end + 1, digest_info->data,
-                      digest_info->size);
-       }
+       memcpy(req_ctx->in_buf + ps_end + 1, digest_info->data,
+              digest_info->size);
 
        pkcs1pad_sg_set_buf(req_ctx->in_sg, req_ctx->in_buf,
                        ctx->key_size - 1 - req->src_len, req->src);
@@ -499,7 +483,9 @@ static int pkcs1pad_verify_complete(struct akcipher_request *req, int err)
        struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
        struct pkcs1pad_ctx *ctx = akcipher_tfm_ctx(tfm);
        struct pkcs1pad_request *req_ctx = akcipher_request_ctx(req);
-       const struct rsa_asn1_template *digest_info;
+       struct akcipher_instance *inst = akcipher_alg_instance(tfm);
+       struct pkcs1pad_inst_ctx *ictx = akcipher_instance_ctx(inst);
+       const struct rsa_asn1_template *digest_info = ictx->digest_info;
        unsigned int pos;
 
        if (err == -EOVERFLOW)
@@ -527,17 +513,11 @@ static int pkcs1pad_verify_complete(struct akcipher_request *req, int err)
                goto done;
        pos++;
 
-       if (ctx->hash_name) {
-               digest_info = rsa_lookup_asn1(ctx->hash_name);
-               if (!digest_info)
-                       goto done;
-
-               if (memcmp(req_ctx->out_buf + pos, digest_info->data,
-                          digest_info->size))
-                       goto done;
+       if (memcmp(req_ctx->out_buf + pos, digest_info->data,
+                  digest_info->size))
+               goto done;
 
-               pos += digest_info->size;
-       }
+       pos += digest_info->size;
 
        err = 0;
 
@@ -626,12 +606,11 @@ static int pkcs1pad_init_tfm(struct crypto_akcipher *tfm)
        struct pkcs1pad_ctx *ctx = akcipher_tfm_ctx(tfm);
        struct crypto_akcipher *child_tfm;
 
-       child_tfm = crypto_spawn_akcipher(akcipher_instance_ctx(inst));
+       child_tfm = crypto_spawn_akcipher(&ictx->spawn);
        if (IS_ERR(child_tfm))
                return PTR_ERR(child_tfm);
 
        ctx->child = child_tfm;
-       ctx->hash_name = ictx->hash_name;
        return 0;
 }
 
@@ -648,12 +627,12 @@ static void pkcs1pad_free(struct akcipher_instance *inst)
        struct crypto_akcipher_spawn *spawn = &ctx->spawn;
 
        crypto_drop_akcipher(spawn);
-       kfree(ctx->hash_name);
        kfree(inst);
 }
 
 static int pkcs1pad_create(struct crypto_template *tmpl, struct rtattr **tb)
 {
+       const struct rsa_asn1_template *digest_info;
        struct crypto_attr_type *algt;
        struct akcipher_instance *inst;
        struct pkcs1pad_inst_ctx *ctx;
@@ -676,7 +655,11 @@ static int pkcs1pad_create(struct crypto_template *tmpl, struct rtattr **tb)
 
        hash_name = crypto_attr_alg_name(tb[2]);
        if (IS_ERR(hash_name))
-               hash_name = NULL;
+               return PTR_ERR(hash_name);
+
+       digest_info = rsa_lookup_asn1(hash_name);
+       if (!digest_info)
+               return -EINVAL;
 
        inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
        if (!inst)
@@ -684,7 +667,7 @@ static int pkcs1pad_create(struct crypto_template *tmpl, struct rtattr **tb)
 
        ctx = akcipher_instance_ctx(inst);
        spawn = &ctx->spawn;
-       ctx->hash_name = hash_name ? kstrdup(hash_name, GFP_KERNEL) : NULL;
+       ctx->digest_info = digest_info;
 
        crypto_set_spawn(&spawn->base, akcipher_crypto_instance(inst));
        err = crypto_grab_akcipher(spawn, rsa_alg_name, 0,
@@ -696,27 +679,14 @@ static int pkcs1pad_create(struct crypto_template *tmpl, struct rtattr **tb)
 
        err = -ENAMETOOLONG;
 
-       if (!hash_name) {
-               if (snprintf(inst->alg.base.cra_name,
-                            CRYPTO_MAX_ALG_NAME, "pkcs1pad(%s)",
-                            rsa_alg->base.cra_name) >=
-                                       CRYPTO_MAX_ALG_NAME ||
-                   snprintf(inst->alg.base.cra_driver_name,
-                            CRYPTO_MAX_ALG_NAME, "pkcs1pad(%s)",
-                            rsa_alg->base.cra_driver_name) >=
-                                       CRYPTO_MAX_ALG_NAME)
+       if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
+                    "pkcs1pad(%s,%s)", rsa_alg->base.cra_name, hash_name) >=
+           CRYPTO_MAX_ALG_NAME ||
+           snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
+                    "pkcs1pad(%s,%s)",
+                    rsa_alg->base.cra_driver_name, hash_name) >=
+           CRYPTO_MAX_ALG_NAME)
                goto out_drop_alg;
-       } else {
-               if (snprintf(inst->alg.base.cra_name,
-                            CRYPTO_MAX_ALG_NAME, "pkcs1pad(%s,%s)",
-                            rsa_alg->base.cra_name, hash_name) >=
-                               CRYPTO_MAX_ALG_NAME ||
-                   snprintf(inst->alg.base.cra_driver_name,
-                            CRYPTO_MAX_ALG_NAME, "pkcs1pad(%s,%s)",
-                            rsa_alg->base.cra_driver_name, hash_name) >=
-                                       CRYPTO_MAX_ALG_NAME)
-               goto out_free_hash;
-       }
 
        inst->alg.base.cra_flags = rsa_alg->base.cra_flags & CRYPTO_ALG_ASYNC;
        inst->alg.base.cra_priority = rsa_alg->base.cra_priority;
@@ -738,12 +708,10 @@ static int pkcs1pad_create(struct crypto_template *tmpl, struct rtattr **tb)
 
        err = akcipher_register_instance(tmpl, inst);
        if (err)
-               goto out_free_hash;
+               goto out_drop_alg;
 
        return 0;
 
-out_free_hash:
-       kfree(ctx->hash_name);
 out_drop_alg:
        crypto_drop_akcipher(spawn);
 out_free_inst:
Linux kernel - Deliverables
This page took 0.02649 seconds and 5 git commands to generate.