Quelle  turris-omnia-mcu-keyctl.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * CZ.NIC's Turris Omnia MCU ECDSA message signing via keyctl
 *
 * 2025 by Marek Behún <kabel@kernel.org>
 */

#include <crypto/sha2.h>
#include <linux/cleanup.h>
#include <linux/completion.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/key.h>
#include <linux/mutex.h>
#include <linux/string.h>
#include <linux/types.h>

#include <linux/turris-omnia-mcu-interface.h>
#include <linux/turris-signing-key.h>
#include "turris-omnia-mcu.h"

static irqreturn_t omnia_msg_signed_irq_handler(int irq, void *dev_id)
{
 u8 reply[1 + OMNIA_MCU_CRYPTO_SIGNATURE_LEN];
 struct omnia_mcu *mcu = dev_id;
 int err;

 err = omnia_cmd_read(mcu->client, OMNIA_CMD_CRYPTO_COLLECT_SIGNATURE,
        reply, sizeof(reply));
 if (!err && reply[0] != OMNIA_MCU_CRYPTO_SIGNATURE_LEN)
  err = -EIO;

 guard(mutex)(&mcu->sign_lock);

 if (mcu->sign_requested) {
  mcu->sign_err = err;
  if (!err)
   memcpy(mcu->signature, &reply[1],
          OMNIA_MCU_CRYPTO_SIGNATURE_LEN);
  mcu->sign_requested = false;
  complete(&mcu->msg_signed);
 }

 return IRQ_HANDLED;
}

static int omnia_mcu_sign(const struct key *key, const void *msg,
     void *signature)
{
 struct omnia_mcu *mcu = dev_get_drvdata(turris_signing_key_get_dev(key));
 u8 cmd[1 + SHA256_DIGEST_SIZE], reply;
 int err;

 scoped_guard(mutex, &mcu->sign_lock) {
  if (mcu->sign_requested)
   return -EBUSY;

  cmd[0] = OMNIA_CMD_CRYPTO_SIGN_MESSAGE;
  memcpy(&cmd[1], msg, SHA256_DIGEST_SIZE);

  err = omnia_cmd_write_read(mcu->client, cmd, sizeof(cmd),
        &reply, 1);
  if (err)
   return err;

  if (!reply)
   return -EBUSY;

  mcu->sign_requested = true;
 }

 if (wait_for_completion_interruptible(&mcu->msg_signed))
  return -EINTR;

 guard(mutex)(&mcu->sign_lock);

 if (mcu->sign_err)
  return mcu->sign_err;

 memcpy(signature, mcu->signature, OMNIA_MCU_CRYPTO_SIGNATURE_LEN);

 /* forget the signature, for security */
 memzero_explicit(mcu->signature, sizeof(mcu->signature));

 return OMNIA_MCU_CRYPTO_SIGNATURE_LEN;
}

static const void *omnia_mcu_get_public_key(const struct key *key)
{
 struct omnia_mcu *mcu = dev_get_drvdata(turris_signing_key_get_dev(key));

 return mcu->board_public_key;
}

static const struct turris_signing_key_subtype omnia_signing_key_subtype = {
 .key_size  = 256,
 .data_size  = SHA256_DIGEST_SIZE,
 .sig_size  = OMNIA_MCU_CRYPTO_SIGNATURE_LEN,
 .public_key_size = OMNIA_MCU_CRYPTO_PUBLIC_KEY_LEN,
 .hash_algo  = "sha256",
 .get_public_key  = omnia_mcu_get_public_key,
 .sign   = omnia_mcu_sign,
};

static int omnia_mcu_read_public_key(struct omnia_mcu *mcu)
{
 u8 reply[1 + OMNIA_MCU_CRYPTO_PUBLIC_KEY_LEN];
 int err;

 err = omnia_cmd_read(mcu->client, OMNIA_CMD_CRYPTO_GET_PUBLIC_KEY,
        reply, sizeof(reply));
 if (err)
  return err;

 if (reply[0] != OMNIA_MCU_CRYPTO_PUBLIC_KEY_LEN)
  return -EIO;

 memcpy(mcu->board_public_key, &reply[1],
        OMNIA_MCU_CRYPTO_PUBLIC_KEY_LEN);

 return 0;
}

int omnia_mcu_register_keyctl(struct omnia_mcu *mcu)
{
 struct device *dev = &mcu->client->dev;
 char desc[48];
 int err;

 if (!(mcu->features & OMNIA_FEAT_CRYPTO))
  return 0;

 err = omnia_mcu_read_public_key(mcu);
 if (err)
  return dev_err_probe(dev, err,
         "Cannot read board public key\n");

 err = devm_mutex_init(dev, &mcu->sign_lock);
 if (err)
  return err;

 init_completion(&mcu->msg_signed);

 err = omnia_mcu_request_irq(mcu, OMNIA_INT_MESSAGE_SIGNED,
        omnia_msg_signed_irq_handler,
        "turris-omnia-mcu-keyctl");
 if (err)
  return dev_err_probe(dev, err,
         "Cannot request MESSAGE_SIGNED IRQ\n");

 sprintf(desc, "Turris Omnia SN %016llX MCU ECDSA key",
  mcu->board_serial_number);

 err = devm_turris_signing_key_create(dev, &omnia_signing_key_subtype,
          desc);
 if (err)
  return dev_err_probe(dev, err, "Cannot create signing key\n");

 return 0;
}