2 * Copyright (C) 2011 Nokia Corporation
3 * Copyright (C) 2011 Intel Corporation
6 * Dmitry Kasatkin <dmitry.kasatkin@nokia.com>
7 * <dmitry.kasatkin@intel.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation, version 2 of the License.
14 * implements signature (RSA) verification
15 * pkcs decoding is based on LibTomCrypt code
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/err.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/key.h>
24 #include <linux/crypto.h>
25 #include <crypto/hash.h>
26 #include <crypto/sha.h>
27 #include <keys/user-type.h>
28 #include <linux/mpi.h>
29 #include <linux/digsig.h>
31 static struct crypto_shash
*shash
;
33 static int pkcs_1_v1_5_decode_emsa(const unsigned char *msg
,
35 unsigned long modulus_bitlen
,
37 unsigned long *outlen
)
39 unsigned long modulus_len
, ps_len
, i
;
41 modulus_len
= (modulus_bitlen
>> 3) + (modulus_bitlen
& 7 ? 1 : 0);
43 /* test message size */
44 if ((msglen
> modulus_len
) || (modulus_len
< 11))
47 /* separate encoded message */
48 if ((msg
[0] != 0x00) || (msg
[1] != (unsigned char)1))
51 for (i
= 2; i
< modulus_len
- 1; i
++)
57 /* There was no octet with hexadecimal value 0x00
58 to separate ps from m. */
63 if (*outlen
< (msglen
- (2 + ps_len
+ 1))) {
64 *outlen
= msglen
- (2 + ps_len
+ 1);
68 *outlen
= (msglen
- (2 + ps_len
+ 1));
69 memcpy(out
, &msg
[2 + ps_len
+ 1], *outlen
);
75 * RSA Signature verification with public key
77 static int digsig_verify_rsa(struct key
*key
,
78 const char *sig
, int siglen
,
79 const char *h
, int hlen
)
83 unsigned long mlen
, mblen
;
86 unsigned char *out1
= NULL
, *out2
= NULL
;
87 MPI in
= NULL
, res
= NULL
, pkey
[2];
88 uint8_t *p
, *datap
, *endp
;
89 struct user_key_payload
*ukp
;
90 struct pubkey_hdr
*pkh
;
93 ukp
= key
->payload
.data
;
95 if (ukp
->datalen
< sizeof(*pkh
))
98 pkh
= (struct pubkey_hdr
*)ukp
->data
;
100 if (pkh
->version
!= 1)
103 if (pkh
->algo
!= PUBKEY_ALGO_RSA
)
110 endp
= ukp
->data
+ ukp
->datalen
;
114 for (i
= 0; i
< pkh
->nmpi
; i
++) {
115 unsigned int remaining
= endp
- datap
;
116 pkey
[i
] = mpi_read_from_buffer(datap
, &remaining
);
122 mblen
= mpi_get_nbits(pkey
[0]);
123 mlen
= (mblen
+ 7)/8;
128 out1
= kzalloc(mlen
, GFP_KERNEL
);
132 out2
= kzalloc(mlen
, GFP_KERNEL
);
137 in
= mpi_read_from_buffer(sig
, &nret
);
141 res
= mpi_alloc(mpi_get_nlimbs(in
) * 2);
145 err
= mpi_powm(res
, in
, pkey
[1], pkey
[0]);
149 if (mpi_get_nlimbs(res
) * BYTES_PER_MPI_LIMB
> mlen
) {
154 p
= mpi_get_buffer(res
, &l
, NULL
);
162 memset(out1
, 0, head
);
163 memcpy(out1
+ head
, p
, l
);
165 err
= pkcs_1_v1_5_decode_emsa(out1
, len
, mblen
, out2
, &len
);
167 if (!err
&& len
== hlen
)
168 err
= memcmp(out2
, h
, hlen
);
184 * digsig_verify() - digital signature verification with public key
185 * @keyring: keyring to search key in
186 * @sig: digital signature
187 * @sigen: length of the signature
189 * @datalen: length of the data
190 * @return: 0 on success, -EINVAL otherwise
192 * Verifies data integrity against digital signature.
193 * Currently only RSA is supported.
194 * Normally hash of the content is used as a data for this function.
197 int digsig_verify(struct key
*keyring
, const char *sig
, int siglen
,
198 const char *data
, int datalen
)
201 struct signature_hdr
*sh
= (struct signature_hdr
*)sig
;
202 struct shash_desc
*desc
= NULL
;
203 unsigned char hash
[SHA1_DIGEST_SIZE
];
207 if (siglen
< sizeof(*sh
) + 2)
210 if (sh
->algo
!= PUBKEY_ALGO_RSA
)
213 sprintf(name
, "%llX", __be64_to_cpup((uint64_t *)sh
->keyid
));
216 /* search in specific keyring */
218 kref
= keyring_search(make_key_ref(keyring
, 1UL),
219 &key_type_user
, name
);
221 key
= ERR_PTR(PTR_ERR(kref
));
223 key
= key_ref_to_ptr(kref
);
225 key
= request_key(&key_type_user
, name
, NULL
);
228 pr_err("key not found, id: %s\n", name
);
232 desc
= kzalloc(sizeof(*desc
) + crypto_shash_descsize(shash
),
238 desc
->flags
= CRYPTO_TFM_REQ_MAY_SLEEP
;
240 crypto_shash_init(desc
);
241 crypto_shash_update(desc
, data
, datalen
);
242 crypto_shash_update(desc
, sig
, sizeof(*sh
));
243 crypto_shash_final(desc
, hash
);
247 /* pass signature mpis address */
248 err
= digsig_verify_rsa(key
, sig
+ sizeof(*sh
), siglen
- sizeof(*sh
),
254 return err
? -EINVAL
: 0;
256 EXPORT_SYMBOL_GPL(digsig_verify
);
258 static int __init
digsig_init(void)
260 shash
= crypto_alloc_shash("sha1", 0, 0);
262 pr_err("shash allocation failed\n");
263 return PTR_ERR(shash
);
270 static void __exit
digsig_cleanup(void)
272 crypto_free_shash(shash
);
275 module_init(digsig_init
);
276 module_exit(digsig_cleanup
);
278 MODULE_LICENSE("GPL");
This page took 0.035093 seconds and 5 git commands to generate.