MODSIGN: Move the magic string to the end of a module and eliminate the search

Emit the magic string that indicates a module has a signature after the
signature data instead of before it.  This allows module_sig_check() to
be made simpler and faster by the elimination of the search for the
magic string.  Instead we just need to do a single memcmp().

This works because at the end of the signature data there is the
fixed-length signature information block.  This block then falls
immediately prior to the magic number.

From the contents of the information block, it is trivial to calculate
the size of the signature data and thus the size of the actual module
data.

Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 15 insertions, 9 deletions

diff --git a/kernel/module_signing.c b/kernel/module_signing.c
index 6b09f6983ac0..d492a23df99c 100644
--- a/kernel/module_signing.c
+++ b/kernel/module_signing.c
@@ -183,27 +183,33 @@ static struct key *request_asymmetric_key(const char *signer, size_t signer_len,
 /*
  * Verify the signature on a module.
  */
-int mod_verify_sig(const void *mod, unsigned long modlen,
-                   const void *sig, unsigned long siglen)
+int mod_verify_sig(const void *mod, unsigned long *_modlen)
 {
         struct public_key_signature *pks;
         struct module_signature ms;
         struct key *key;
-        size_t sig_len;
+        const void *sig;
+        size_t modlen = *_modlen, sig_len;
         int ret;
 
-        pr_devel("==>%s(,%lu,,%lu,)\n", __func__, modlen, siglen);
+        pr_devel("==>%s(,%lu)\n", __func__, modlen);
 
-        if (siglen <= sizeof(ms))
+        if (modlen <= sizeof(ms))
                 return -EBADMSG;
 
-        memcpy(&ms, sig + (siglen - sizeof(ms)), sizeof(ms));
-        siglen -= sizeof(ms);
+        memcpy(&ms, mod + (modlen - sizeof(ms)), sizeof(ms));
+        modlen -= sizeof(ms);
 
         sig_len = be32_to_cpu(ms.sig_len);
-        if (sig_len >= siglen ||
-            siglen - sig_len != (size_t)ms.signer_len + ms.key_id_len)
+        if (sig_len >= modlen)
                 return -EBADMSG;
+        modlen -= sig_len;
+        if ((size_t)ms.signer_len + ms.key_id_len >= modlen)
+                return -EBADMSG;
+        modlen -= (size_t)ms.signer_len + ms.key_id_len;
+
+        *_modlen = modlen;
+        sig = mod + modlen;
 
         /* For the moment, only support RSA and X.509 identifiers */
         if (ms.algo != PKEY_ALGO_RSA ||