硬件授权认证

身份认证原理

软件授权认证

芯片身份认证可在软件授权认证中应用，特别是在需要确保软件仅能运行在特定芯片或硬件平台上时。通过芯片身份认证，软件厂商可以确保其软件和算法只在合法、授权的硬件上运行，从而保护知识产权并防止未经授权的使用。

在实际应用中，设备可能会集成了不同厂商的软件和算法。软件厂商会有相关知识产权保护、软件授权上的需求，确保能够限定自身的软件只能运行在指定芯片型号上。

通过 PSK (Partner Secret Key) 机制，可以实现芯片身份认证在软件授权认证中的应用，具体步骤如下：

烧写保护密钥

生成 RSA 密钥

RSA 算法需要有密钥对（私钥和公钥），详细的密钥生成流程如下：

1. 在主机端执行以下命令生成 RSA 私钥和公钥：

   openssl genrsa -out rsa_private_key.pem 2048

   结果：生成一对公钥和私钥，保存在 rsa_private_key.pem 文件中。

2. 执行下列命令从密钥对中提取公钥：

   openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem

   在实际使用时，通常私钥保密存储，公钥需要发送给其他相关方，因此需要提取公钥。

3. 执行以下命令将生成的公钥和私钥转换为 DER 二进制。

   openssl base64 -d -in rsa_public_key.pem -out rsa_public_key.der
   openssl base64 -d -in rsa_private_key.pem -out rsa_private_key.der
   

   DER 是 ASN.1 密钥结构描述的二进制编码实现。

4. 使用 PSK0 加密私钥。

   ./tools/scripts/encrypt_rsa_key.py -h -d psk0.bin -r rsa_private_key.der
   

   通过上述命令，得到加密过的私钥文件 rsa_private_key_encrypted.der。

5. 使用 xxd -i rsa_private_key_encrypted.der 和 xxd -i rsa_public_key.der 命令，将加密私钥和公钥转成 C 语言数组格式，方便在代码中直接使用。

   xxd 是 Linux 的一个 16 进制处理命令。

完成上述所有操作后，编译镜像并直接使用 AiBurn 工具进行烧录，重启后在开发板平台执行 aic_hw_authorization_test 即可进行测试，当显示 App xxx running. 则表示授权认证成功，否则授权认证失败。

接口设计

API 使用 DEMO

授权的检查可以在 APP/中间件 启动时进行，或者在运行时随机进行。

Demo 见 source/artinchip/aic-authorization/test/test_aic_hw_authorization.c

int app_hw_authorization_check(unsigned char *from, int flen,
                unsigned char *esk, int esk_len,
                unsigned char *pk, int pk_len, char *algo)
{
    struct ak_options opts = {0};
    uint8_t *inbuf = NULL, *outbuf = NULL;
    uint8_t esk_buf[esk_len];
    uint8_t pk_buf[pk_len];
    size_t pagesize = (size_t)sysconf(_SC_PAGESIZE);
    int ret = 0, rlen, nonce;

    if (posix_memalign((void **)&inbuf, pagesize, 2 * pagesize)) {
        printf("Failed to allocate inbuf.\n");
        ret = -ENOMEM;
        goto out;
    }
    if (posix_memalign((void **)&outbuf, pagesize, 2 * pagesize)) {
        printf("Failed to allocate outbuf.\n");
        ret = -ENOMEM;
        goto out;
    }

    // 1. Set RSA key parameters
    memcpy(esk_buf, esk, esk_len);
    memcpy(pk_buf, pk, pk_len);
    opts.esk_buf = esk_buf;
    opts.esk_len = esk_len;
    opts.pk_buf = pk_buf;
    opts.pk_len = pk_len;

    // 2. Nonce private key encryption
    rlen = aic_hwp_rsa_priv_enc(flen, from, outbuf, &opts, algo);
    if (rlen < 0) {
        printf("aic_hwp_rsa_priv_enc failed.\n");
        goto out;
    }
    memcpy(inbuf, outbuf, rlen);
    memset(outbuf, 0, 2 * pagesize);

    // 3. EncNonce public key decryption
    rlen = aic_rsa_pub_dec(rlen, inbuf, outbuf, &opts);
    if (rlen < 0) {
        printf("aic_rsa_pub_dec failed.\n");
        goto out;
    }

    // 4. Compare Nonce and DecNonce
    if (memcmp(from, outbuf, rlen))
    {
        hexdump("Expect", (unsigned char *)&nonce, rlen);
        hexdump("Got Result", (unsigned char *)outbuf, rlen);
        printf("App %s stop.\n", algo);
        ret = -1;
    } else {
        printf("App %s running.\n", algo);
        ret = 0;
    }

out:
    if (inbuf)
        free(inbuf);
    if (outbuf)
        free(outbuf);

    return ret;
}

int main()
{
    int ret = 0;
    int nonce, flen, esk_len, pk_len;
    unsigned char *esk, *pk;
    char *algo;

    esk = rsa_private_key2048_encrypted_der;
    esk_len = rsa_private_key2048_encrypted_der_len;
    pk = rsa_public_key2048_der;
    pk_len = rsa_public_key2048_der_len;
    while(1) {
        nonce = rand();     /* Generate random number Nonce */
        flen = sizeof(nonce);
        algo = PNK_PROTECTED_RSA;   /* Specify hardware protection key */
        ret = app_hw_authorization_check((unsigned char *)&nonce, flen,
                        esk, esk_len, pk, pk_len, algo);
        if (ret < 0) {
            printf("Application %s not authorization.\n", algo);
        }

        nonce = rand();     /* Generate random number Nonce */
        flen = sizeof(nonce);
        algo = PSK0_PROTECTED_RSA;  /* Specify hardware protection key */
        ret = app_hw_authorization_check((unsigned char *)&nonce, flen,
                        esk, esk_len, pk, pk_len, algo);
        if (ret < 0) {
            printf("Application %s not authorization.\n", algo);
        }

        nonce = rand();     /* Generate random number Nonce */
        flen = sizeof(nonce);
        algo = PSK1_PROTECTED_RSA;  /* Specify hardware protection key */
        ret = app_hw_authorization_check((unsigned char *)&nonce, flen,
                        esk, esk_len, pk, pk_len, algo);
        if (ret < 0) {
            printf("Application %s not authorization.\n", algo);
        }

        nonce = rand();     /* Generate random number Nonce */
        flen = sizeof(nonce);
        algo = PSK2_PROTECTED_RSA;  /* Specify hardware protection key */
        ret = app_hw_authorization_check((unsigned char *)&nonce, flen,
                        esk, esk_len, pk, pk_len, algo);
        if (ret < 0) {
            printf("Application %s not authorization.\n", algo);
        }

        nonce = rand();     /* Generate random number Nonce */
        flen = sizeof(nonce);
        algo = PSK3_PROTECTED_RSA;  /* Specify hardware protection key */
        ret = app_hw_authorization_check((unsigned char *)&nonce, flen,
                        esk, esk_len, pk, pk_len, algo);
        if (ret < 0) {
            printf("Application %s not authorization.\n", algo);
        }

        sleep(2);
    }

    return 0;
}