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 const char *pkcs_1_v1_5_decode_emsa(const unsigned char *msg
,
35 unsigned long modulus_bitlen
,
36 unsigned long *outlen
)
38 unsigned long modulus_len
, ps_len
, i
;
40 modulus_len
= (modulus_bitlen
>> 3) + (modulus_bitlen
& 7 ? 1 : 0);
42 /* test message size */
43 if ((msglen
> modulus_len
) || (modulus_len
< 11))
46 /* separate encoded message */
47 if (msg
[0] != 0x00 || msg
[1] != 0x01)
50 for (i
= 2; i
< modulus_len
- 1; i
++)
56 /* There was no octet with hexadecimal value 0x00
57 to separate ps from m. */
62 *outlen
= (msglen
- (2 + ps_len
+ 1));
64 return msg
+ 2 + ps_len
+ 1;
68 * RSA Signature verification with public key
70 static int digsig_verify_rsa(struct key
*key
,
71 const char *sig
, int siglen
,
72 const char *h
, int hlen
)
76 unsigned long mlen
, mblen
;
79 unsigned char *out1
= NULL
;
81 MPI in
= NULL
, res
= NULL
, pkey
[2];
84 const struct user_key_payload
*ukp
;
85 struct pubkey_hdr
*pkh
;
88 ukp
= user_key_payload(key
);
90 if (ukp
->datalen
< sizeof(*pkh
))
93 pkh
= (struct pubkey_hdr
*)ukp
->data
;
95 if (pkh
->version
!= 1)
98 if (pkh
->algo
!= PUBKEY_ALGO_RSA
)
105 endp
= ukp
->data
+ ukp
->datalen
;
109 for (i
= 0; i
< pkh
->nmpi
; i
++) {
110 unsigned int remaining
= endp
- datap
;
111 pkey
[i
] = mpi_read_from_buffer(datap
, &remaining
);
117 mblen
= mpi_get_nbits(pkey
[0]);
118 mlen
= DIV_ROUND_UP(mblen
, 8);
123 out1
= kzalloc(mlen
, GFP_KERNEL
);
128 in
= mpi_read_from_buffer(sig
, &nret
);
132 res
= mpi_alloc(mpi_get_nlimbs(in
) * 2);
136 err
= mpi_powm(res
, in
, pkey
[1], pkey
[0]);
140 if (mpi_get_nlimbs(res
) * BYTES_PER_MPI_LIMB
> mlen
) {
145 p
= mpi_get_buffer(res
, &l
, NULL
);
153 memset(out1
, 0, head
);
154 memcpy(out1
+ head
, p
, l
);
158 m
= pkcs_1_v1_5_decode_emsa(out1
, len
, mblen
, &len
);
160 if (!m
|| len
!= hlen
|| memcmp(m
, h
, hlen
))
176 * digsig_verify() - digital signature verification with public key
177 * @keyring: keyring to search key in
178 * @sig: digital signature
179 * @siglen: length of the signature
181 * @datalen: length of the data
183 * Returns 0 on success, -EINVAL otherwise
185 * Verifies data integrity against digital signature.
186 * Currently only RSA is supported.
187 * Normally hash of the content is used as a data for this function.
190 int digsig_verify(struct key
*keyring
, const char *sig
, int siglen
,
191 const char *data
, int datalen
)
194 struct signature_hdr
*sh
= (struct signature_hdr
*)sig
;
195 struct shash_desc
*desc
= NULL
;
196 unsigned char hash
[SHA1_DIGEST_SIZE
];
200 if (siglen
< sizeof(*sh
) + 2)
203 if (sh
->algo
!= PUBKEY_ALGO_RSA
)
206 sprintf(name
, "%llX", __be64_to_cpup((uint64_t *)sh
->keyid
));
209 /* search in specific keyring */
211 kref
= keyring_search(make_key_ref(keyring
, 1UL),
212 &key_type_user
, name
);
214 key
= ERR_CAST(kref
);
216 key
= key_ref_to_ptr(kref
);
218 key
= request_key(&key_type_user
, name
, NULL
);
221 pr_err("key not found, id: %s\n", name
);
225 desc
= kzalloc(sizeof(*desc
) + crypto_shash_descsize(shash
),
231 desc
->flags
= CRYPTO_TFM_REQ_MAY_SLEEP
;
233 crypto_shash_init(desc
);
234 crypto_shash_update(desc
, data
, datalen
);
235 crypto_shash_update(desc
, sig
, sizeof(*sh
));
236 crypto_shash_final(desc
, hash
);
240 /* pass signature mpis address */
241 err
= digsig_verify_rsa(key
, sig
+ sizeof(*sh
), siglen
- sizeof(*sh
),
247 return err
? -EINVAL
: 0;
249 EXPORT_SYMBOL_GPL(digsig_verify
);
251 static int __init
digsig_init(void)
253 shash
= crypto_alloc_shash("sha1", 0, 0);
255 pr_err("shash allocation failed\n");
256 return PTR_ERR(shash
);
263 static void __exit
digsig_cleanup(void)
265 crypto_free_shash(shash
);
268 module_init(digsig_init
);
269 module_exit(digsig_cleanup
);
271 MODULE_LICENSE("GPL");