cose_rs_ffi.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the Apache 2.0 License.
 
#pragma once
 
#include <cstddef>
#include <cstdint>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  struct CoseEvpKey;
 
  CoseEvpKey* cose_key_from_der_private(
    const uint8_t* key_der_ptr,
    size_t key_der_len,
    uint8_t** err_ptr,
    size_t* err_len);
 
  void cose_key_free(CoseEvpKey* key);
 
  int cose_sign_ledger(
    const CoseEvpKey* key,
    const uint8_t* kid_ptr,
    size_t kid_len,
    int64_t iat,
    const uint8_t* issuer_ptr,
    size_t issuer_len,
    const uint8_t* subject_ptr,
    size_t subject_len,
    const uint8_t* txid_ptr,
    size_t txid_len,
    const uint8_t* payload_ptr,
    size_t payload_len,
    uint8_t** out_ptr,
    size_t* out_len,
    uint8_t** err_ptr,
    size_t* err_len);
 
  int cose_sign_endorsement(
    const CoseEvpKey* key,
    int64_t iat,
    const uint8_t* epoch_begin_ptr,
    size_t epoch_begin_len,
    const uint8_t* epoch_end_ptr,
    size_t epoch_end_len,
    const uint8_t* prev_root_ptr,
    size_t prev_root_len,
    const uint8_t* payload_ptr,
    size_t payload_len,
    uint8_t** out_ptr,
    size_t* out_len,
    uint8_t** err_ptr,
    size_t* err_len);
 
  CoseEvpKey* cose_key_from_der_public(
    const uint8_t* key_der_ptr,
    size_t key_der_len,
    uint8_t** err_ptr,
    size_t* err_len);
 
  CoseEvpKey* cose_key_from_pem_public(
    const uint8_t* pem_ptr, size_t pem_len, uint8_t** err_ptr, size_t* err_len);
 
  CoseEvpKey* cose_key_from_pem_cert(
    const uint8_t* pem_ptr, size_t pem_len, uint8_t** err_ptr, size_t* err_len);
 
  CoseEvpKey* cose_key_from_der_cert(
    const uint8_t* der_ptr, size_t der_len, uint8_t** err_ptr, size_t* err_len);
 
  int cose_verify1(
    const CoseEvpKey* key,
    int64_t alg,
    const uint8_t* phdr_cbor_ptr,
    size_t phdr_cbor_len,
    const uint8_t* payload_ptr,
    size_t payload_len,
    const uint8_t* sig_ptr,
    size_t sig_len,
    uint8_t** err_ptr,
    size_t* err_len);
 
  void cose_free(uint8_t* ptr, size_t len);
 
#ifdef __cplusplus
}
 
#  include <stdexcept>
#  include <string>
#  include <vector>
 
class CoseBuffer
{
  uint8_t* ptr = nullptr;
  size_t len = 0;
 
public:
  CoseBuffer() = default;
  CoseBuffer(const CoseBuffer&) = delete;
  CoseBuffer& operator=(const CoseBuffer&) = delete;
 
  CoseBuffer(CoseBuffer&& other) noexcept : ptr(other.ptr), len(other.len)
  {
    other.ptr = nullptr;
    other.len = 0;
  }
 
  CoseBuffer& operator=(CoseBuffer&& other) noexcept
  {
    if (this != &other)
    {
      reset();
      ptr = other.ptr;
      len = other.len;
      other.ptr = nullptr;
      other.len = 0;
    }
    return *this;
  }
 
  ~CoseBuffer()
  {
    reset();
  }
 
  uint8_t** data()
  {
    return &ptr;
  }
 
  size_t* size()
  {
    return &len;
  }
 
  void reset()
  {
    if (ptr != nullptr)
    {
      cose_free(ptr, len);
      ptr = nullptr;
      len = 0;
    }
  }
 
  // -- Buffer accessors --
 
  [[nodiscard]] std::vector<uint8_t> to_vector() const
  {
    return {ptr, ptr + len};
  }
 
  [[nodiscard]] std::string to_string() const
  {
    if (ptr != nullptr && len > 0)
    {
      return {reinterpret_cast<const char*>(ptr), len};
    }
    return {};
  }
 
  [[nodiscard]] bool is_set() const
  {
    return ptr != nullptr && len > 0;
  }
};
 
class CoseKey
{
  CoseEvpKey* key = nullptr;
 
  explicit CoseKey(CoseEvpKey* k) : key(k) {}
 
public:
  CoseKey() = default;
 
  static CoseKey from_private(
    const uint8_t* der_ptr, size_t der_len, CoseBuffer& err)
  {
    return CoseKey(
      cose_key_from_der_private(der_ptr, der_len, err.data(), err.size()));
  }
 
  static CoseKey from_public(
    const uint8_t* der_ptr, size_t der_len, CoseBuffer& err)
  {
    return CoseKey(
      cose_key_from_der_public(der_ptr, der_len, err.data(), err.size()));
  }
 
  static CoseKey from_pem_public(
    const uint8_t* pem_ptr, size_t pem_len, CoseBuffer& err)
  {
    return CoseKey(
      cose_key_from_pem_public(pem_ptr, pem_len, err.data(), err.size()));
  }
 
  static CoseKey from_pem_cert(
    const uint8_t* pem_ptr, size_t pem_len, CoseBuffer& err)
  {
    return CoseKey(
      cose_key_from_pem_cert(pem_ptr, pem_len, err.data(), err.size()));
  }
 
  static CoseKey from_der_cert(
    const uint8_t* der_ptr, size_t der_len, CoseBuffer& err)
  {
    return CoseKey(
      cose_key_from_der_cert(der_ptr, der_len, err.data(), err.size()));
  }
 
  CoseKey(const CoseKey&) = delete;
  CoseKey& operator=(const CoseKey&) = delete;
 
  CoseKey(CoseKey&& other) noexcept : key(other.key)
  {
    other.key = nullptr;
  }
 
  CoseKey& operator=(CoseKey&& other) noexcept
  {
    if (this != &other)
    {
      reset();
      key = other.key;
      other.key = nullptr;
    }
    return *this;
  }
 
  ~CoseKey()
  {
    reset();
  }
 
  void reset()
  {
    if (key != nullptr)
    {
      cose_key_free(key);
      key = nullptr;
    }
  }
 
  [[nodiscard]] const CoseEvpKey* get() const
  {
    return key;
  }
 
  [[nodiscard]] bool is_set() const
  {
    return key != nullptr;
  }
};
 
inline int cose_sign_ledger(
  const CoseKey& key,
  const uint8_t* kid_ptr,
  size_t kid_len,
  int64_t iat,
  const uint8_t* issuer_ptr,
  size_t issuer_len,
  const uint8_t* subject_ptr,
  size_t subject_len,
  const uint8_t* txid_ptr,
  size_t txid_len,
  const uint8_t* payload_ptr,
  size_t payload_len,
  CoseBuffer& out,
  CoseBuffer& err)
{
  return ::cose_sign_ledger(
    key.get(),
    kid_ptr,
    kid_len,
    iat,
    issuer_ptr,
    issuer_len,
    subject_ptr,
    subject_len,
    txid_ptr,
    txid_len,
    payload_ptr,
    payload_len,
    out.data(),
    out.size(),
    err.data(),
    err.size());
}
 
inline int cose_sign_endorsement(
  const CoseKey& key,
  int64_t iat,
  const uint8_t* epoch_begin_ptr,
  size_t epoch_begin_len,
  const uint8_t* epoch_end_ptr,
  size_t epoch_end_len,
  const uint8_t* prev_root_ptr,
  size_t prev_root_len,
  const uint8_t* payload_ptr,
  size_t payload_len,
  CoseBuffer& out,
  CoseBuffer& err)
{
  return ::cose_sign_endorsement(
    key.get(),
    iat,
    epoch_begin_ptr,
    epoch_begin_len,
    epoch_end_ptr,
    epoch_end_len,
    prev_root_ptr,
    prev_root_len,
    payload_ptr,
    payload_len,
    out.data(),
    out.size(),
    err.data(),
    err.size());
}
 
inline int cose_verify1(
  const CoseKey& key,
  int64_t alg,
  const uint8_t* phdr_cbor_ptr,
  size_t phdr_cbor_len,
  const uint8_t* payload_ptr,
  size_t payload_len,
  const uint8_t* sig_ptr,
  size_t sig_len,
  CoseBuffer& err)
{
  return ::cose_verify1(
    key.get(),
    alg,
    phdr_cbor_ptr,
    phdr_cbor_len,
    payload_ptr,
    payload_len,
    sig_ptr,
    sig_len,
    err.data(),
    err.size());
}
 
#endif