使用Linux内核加密API的HMAC与使用OpenSSL命令的HMAC不同

我尝试了在文件上计算HMAC-SHA512的代码（使用Linux内核加密API）。 令人惊讶的是，从内核代码和OpenSSL命令计算的HMAC是不同的

OpenSSL命令包括：

openssl rand -base64 16
plakOhrXlfnBENPVBo91kg==
openssl dgst -sha512 -mac hmac -macopt key:plakOhrXlfnBENPVBo91kg== ../hello6.ko  
HMAC-SHA512(../hello6.ko)=   9605f40851630f5b7a18fa30c7e5d6f1e77afb011d319efa515556d12ba6930f459825b3695a0d0d910a714724c0d99b36ccea5c878962b32a8de65dcbcc247d

内核代码中的HMAC-SHA512是：

84306723b713379aa666fe9aa75af3192a9707d19136c25dd2286c5f6d86dfd8f76ceaa0ce147b53c0e9f7bfab485f38f5139c687c34c840db7f7fa9438bf8b0d8df8e770088ffffc8de8e770088ffffc3f027a0ffffffff672c00000088fffff0de8e770088ffff1900000000000080672c000000000000e8de8e770088ffff    

为什么这些HMAC对于相同的内容是不同的？任何解决这个问题的方法都非常有用

Base64编码密钥由以下命令生成并存储在文件中：

openssl rand -base64 -out $Module_name.sha512key 16

HMAC在文件上生成并存储在文件中。 openssl dgst-sha512-mac hmac-macopt密钥：$hmac_密钥$hmac_路径/$Module_名称>temp.txt

密钥和文件内容由以下代码读取：

    static char hmac[HMAC_SHA512_SIZE];
    const char *kofilename = "/home/sri/Documents/Hello/hello6.ko";
    const char *hmackey_file = "/home/sri/Documents/Hello/hello6.ko.sha512key"; 
    const char *hmac_file = "/home/sri/Documents/Hello/hello6.ko.sha512"; 

    unsigned char *data = NULL;
    int readkostatus;
    int readkeystatus;
    int readhmacstatus;

    unsigned char *hmackey = NULL;
    unsigned char *stored_hmac = NULL; 

    readkeystatus = read_file(hmackey_file, &hmackey); 

    if(readkeystatus < 0)
        goto readkeyerr;

    printk(KERN_INFO "HMAC Key is :%s", hmackey);

    readkostatus = read_kofile(kofilename, &data);

    if(readkostatus < 0)
        goto readkoerr;

    printk(KERN_INFO "File data size is :%ld", strlen(data)); 
    printk(KERN_INFO "File data is :%s", data);

    hmac_sha512(hmackey, data, hmac, sizeof(hmac)); 
    printk(KERN_INFO "FINAL HMAC:%s", hmac);

    readhmacstatus = read_file(hmac_file, &stored_hmac); 

    if(readhmacstatus < 0)
    goto readhmacerr;

    printk(KERN_INFO "Stored HMAC:%s", stored_hmac);

    if(!memcmp(stored_hmac, hmac, HMAC_SHA512_SIZE))    
    printk(KERN_INFO "HMACs match");
    else
        printk(KERN_INFO "HMACs do not match"); 

    vfree(stored_hmac); 
    vfree(data); 
    vfree(hmackey); 

    return 0;

   readkeyerr:
   {
       printk(KERN_INFO "hmac key read error:%d", readkeystatus);    
       return readkeystatus;
   }

   readkoerr:
   {
       printk(KERN_INFO "ko read error:%d", readkostatus);        
       return readkostatus;
   }

   readhmacerr:
   {
       printk(KERN_INFO "hmac read error:%d", readhmacstatus);
       return readhmacstatus;
   }

---

如果缺少什么，请告诉我。

hash.h中定义的加密请求已完成

 #include <linux/kernel.h>

#include <linux/module.h>
#include <linux/pci.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/device.h>
#include <linux/dmi.h>
#include <linux/gfp.h>
#include <linux/msi.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_cmnd.h>
#include <linux/libata.h>
#include <linux/ahci-remap.h>
#include <linux/io-64-nonatomic-lo-hi.h>
#include <net/sock.h>

#include <linux/fs.h>
#include <asm/segment.h>
#include <linux/buffer_head.h>
#include <linux/libata.h>
#include <asm/uaccess.h>
#include <asm/traps.h>
#include <linux/cdev.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/sched/signal.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/hashtable.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/signal_types.h>
#include <linux/fcntl.h>
#include <linux/fs.h>
#include <linux/wait.h>
#include <linux/slab.h>
#include <linux/crypto.h>

#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))
#define TESTMGR_POISON_BYTE 0xfe

static int do_ahash_op(int (*op)(struct ahash_request *req), struct ahash_request *req, struct crypto_wait *wait)
{
    int err;
    err = op(req);
    return crypto_wait_req(err, wait);
}
static int check_nonfinal_ahash_op(const char *op, int err){
    if(err < 0){
        pr_err("alg: ahash: %s() failed with err %d on test vector %s\n", op, err, get_error(err));
        return 1;
    }
    return 0;
}

摔断腿

int hkdf_extract(unsigned char *salt, size_t salt_len, unsigned char *ikm, size_t ikm_len, unsigned char *okm, size_t okm_len){
    return hmac_sha256(salt, salt_len, ikm, ikm_len, okm, okm_len);
}

---

内核的“hmac”比它应该的要长得多，并且很明显在末尾打印了垃圾。基于对二进制数据的错误处理，我猜测您没有将正确的参数传递给内核函数。您没有给它base-64编码的密钥，是吗？我正在将base-64编码的密钥传递给函数。我通过vfs_read（）从文件中读取字节，并将其传递给cryptoapi。应该是。文件数据是base64编码的吗？还有什么我遗漏的吗？在你的问题中包括你在内核加密中使用的代码。现在您只提供结果，而不提供获得结果的方式（上面也指出了）。立即包含代码。立即包含完整代码。请看一看。

 #include <linux/kernel.h>

#include <linux/module.h>
#include <linux/pci.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/device.h>
#include <linux/dmi.h>
#include <linux/gfp.h>
#include <linux/msi.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_cmnd.h>
#include <linux/libata.h>
#include <linux/ahci-remap.h>
#include <linux/io-64-nonatomic-lo-hi.h>
#include <net/sock.h>

#include <linux/fs.h>
#include <asm/segment.h>
#include <linux/buffer_head.h>
#include <linux/libata.h>
#include <asm/uaccess.h>
#include <asm/traps.h>
#include <linux/cdev.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/sched/signal.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/hashtable.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/signal_types.h>
#include <linux/fcntl.h>
#include <linux/fs.h>
#include <linux/wait.h>
#include <linux/slab.h>
#include <linux/crypto.h>

#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))
#define TESTMGR_POISON_BYTE 0xfe

static int do_ahash_op(int (*op)(struct ahash_request *req), struct ahash_request *req, struct crypto_wait *wait)
{
    int err;
    err = op(req);
    return crypto_wait_req(err, wait);
}
static int check_nonfinal_ahash_op(const char *op, int err){
    if(err < 0){
        pr_err("alg: ahash: %s() failed with err %d on test vector %s\n", op, err, get_error(err));
        return 1;
    }
    return 0;
}

int hmac_sha256(unsigned char *key, size_t key_size, unsigned char *ikm, size_t ikm_len, unsigned char *okm, size_t okm_len){
    int rc, key_is_null;
    struct crypto_ahash *tfm;
    struct ahash_request *req;
    struct scatterlist pending_sgl;
    DECLARE_CRYPTO_WAIT(wait);

    if(key == NULL){
        key = kzalloc(32, GFP_KERNEL);
        key_size = 32;
        key_is_null = 1;
    }else{key_is_null = 0;}
    tfm = crypto_alloc_ahash("hmac(sha256)", 0, 0);
    if(IS_ERR(tfm)) {
        rc=PTR_ERR(tfm);
        printk(KERN_ERR "hmac_sha256: crypto_alloc_ahash failed(%s).\n", get_error(rc));
        goto err_tfm;
    }
    if(!(req = ahash_request_alloc(tfm, GFP_KERNEL))) {
        rc =- ENOMEM;
        printk(KERN_ERR "hmac_sha256: failed to allocate request for hmac(sha512)(%s).\n", get_error(rc));
    }
    if(key_size){
        if((rc = crypto_ahash_setkey(tfm, key, key_size))){
            printk(KERN_ERR "hmac_sha256: crypto_ahash_setkey failed.(%s)\n", get_error(rc));
            goto out;
        }
    }
    sg_init_table(&pending_sgl, 1);
    memset(req->__ctx, TESTMGR_POISON_BYTE, crypto_ahash_reqsize(tfm));
    ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, crypto_req_done, &wait);
    ahash_request_set_crypt(req, NULL, okm, 0);
    rc = do_ahash_op(crypto_ahash_init, req, &wait);
    rc = check_nonfinal_ahash_op("crypto_ahash_init", rc);
    if (rc)
        goto out;

    sg_set_buf(&pending_sgl, ikm, ikm_len);
    ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, crypto_req_done, &wait);
    ahash_request_set_crypt(req, &pending_sgl, okm, okm_len);
    rc = do_ahash_op(crypto_ahash_update, req, &wait);
    rc = check_nonfinal_ahash_op("crypto_ahash_update", rc);
    if(rc)
        goto out;
    rc = do_ahash_op(crypto_ahash_final, req, &wait);
    rc = check_nonfinal_ahash_op("crypto_ahash_final", rc);
    if (rc)
        goto out;
    dump_memory(okm, "hmac_sha256", okm_len);
out:
    ahash_request_free(req);
    crypto_free_ahash(tfm);
err_tfm:
    if(key_is_null)
        kfree(key);
    return rc;
}

int hkdf_extract(unsigned char *salt, size_t salt_len, unsigned char *ikm, size_t ikm_len, unsigned char *okm, size_t okm_len){
    return hmac_sha256(salt, salt_len, ikm, ikm_len, okm, okm_len);
}