First Publicly Shared Version of ODKiTEE v15

oemcrypto_ta/oemcrypto_usage_table.h

@@ -0,0 +1,142 @@
+/* Copyright 2020 Google LLC. All Rights Reserved. This file and proprietary
+   source code may only be used and distributed under the Widevine Master
+   License Agreement. */
+
+#ifndef OEMCRYPTO_TA_OEMCRYPTO_USAGE_TABLE_H_
+#define OEMCRYPTO_TA_OEMCRYPTO_USAGE_TABLE_H_
+
+#include "stdbool.h"
+#include "stdint.h"
+
+#include "OEMCryptoCENC.h"
+#include "oemcrypto_config_macros.h"
+#include "oemcrypto_key_types.h"
+#include "oemcrypto_session.h"
+
+/**
+ * Clear out memory for the usage table. No other usage table functions may be
+ * called before this.  */
+OEMCryptoResult InitializeUsageTable(void);
+
+/**
+ *  Erase data from usage table. No other usage table functions may be called
+ *  without calling InitializeUsageTable. */
+OEMCryptoResult TerminateUsageTable(void);
+
+/** Create a new empty usage table header.  */
+OEMCryptoResult CreateUsageTableHeader(uint8_t* header_buffer,
+                                       size_t* header_buffer_length);
+
+/** Load a usage table header. */
+OEMCryptoResult LoadUsageTableHeader(const uint8_t* buffer,
+                                     size_t buffer_length);
+
+/**
+ * Create a new usage table entry and attach it to the |session|. This may
+ * return an error if the usage table is full, or if too many open sessions have
+ * active usage entries. |session| must be open and not already have an entry
+ * associated with it.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult CreateNewUsageEntry(OEMCryptoSession* session,
+                                    uint32_t* usage_entry_number);
+
+/**
+ * Load a usage table entry and attach it to the |session|. This may return an
+ * error if too many open sessions have active usage entries. |session| must be
+ * open and not already have an entry associated with it. The usage_entry_number
+ * must match that in the loaded entry.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult LoadUsageEntry(OEMCryptoSession* session,
+                               uint32_t usage_entry_number,
+                               const uint8_t* buffer, size_t buffer_length);
+
+/**
+ * Release the active usage entry associated with |session|.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult ReleaseEntry(OEMCryptoSession* session,
+                             uint32_t usage_entry_number);
+
+/**
+ * Update all values in the usage entry associated with |session|. After
+ * updating values, the generation numbers are all updated and the master
+ * generation number is saved to persistent storage. Then the entry and the
+ * usage table header are saved to the specified buffer. If the buffer lengths
+ * are not large enough, none of the work above is completed -- instead the
+ * lengths are updated and OEMCrypto_ERROR_SHORT_BUFFER is returned.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult UpdateUsageEntry(OEMCryptoSession* session,
+                                 uint8_t* header_buffer,
+                                 size_t* header_buffer_length,
+                                 uint8_t* entry_buffer,
+                                 size_t* entry_buffer_length);
+
+/**
+ * Update the playback times in the usage entry attached to |session|.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult UpdateLastPlaybackTime(const OEMCryptoSession* session);
+
+/**
+ * Set the provider session token in the usage entry associated with |session|.
+ * This is done when a license is first loaded.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult SetUsageEntryPST(OEMCryptoSession* session, const uint8_t* pst,
+                                 size_t pst_length);
+
+/**
+ * Verify the provider session token in the usage entry associated with
+ * |session|.  This is done when a license is reloaded to verify the license
+ * matches the usage entry.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult VerfiyUsageEntryPST(OEMCryptoSession* session,
+                                    const uint8_t* pst, size_t pst_length);
+
+/**
+ * Set the mac keys in the usage entry associated with |session|.
+ * This is done when a license is first loaded.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult SetUsageEntryMacKeys(const OEMCryptoSession* session);
+
+/**
+ * Verify the mac keys in the usage entry associated with
+ * |session|.  This is done when a license is reloaded to verify the license
+ * matches the usage entry.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult VerifysageEntryMacKeys(const OEMCryptoSession* session);
+
+/**
+ * Mark the usage entry associated with |session| as deactivated. After this,
+ * the license may not be used to decrypt content.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult DeactivateUsageEntry(OEMCryptoSession* session,
+                                     const uint8_t* pst, size_t pst_length);
+
+/**
+ * Generate a usage report from the entry associated with |session|.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult ReportUsage(OEMCryptoSession* session, const uint8_t* pst,
+                            size_t pst_length, uint8_t* buffer,
+                            size_t* buffer_length);
+
+/**
+ * Sign |buffer| with the client mac key in the entry associated with |session|.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult SignReleaseRequest(OEMCryptoSession* session,
+                                   const uint8_t* message,
+                                   size_t message_length, uint8_t* signature,
+                                   size_t* signature_length);
+
+/**
+ * Move the usage entry associated with |session| to the new index in the usage
+ * table header. The generation numbers are updated as specified in the
+ * OEMCrypto spec.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult MoveEntry(OEMCryptoSession* session, uint32_t new_index);
+
+/**
+ * Shrink the usage table to the size specified.
+ * Pointers must be non-null and are owned by the caller. */
+OEMCryptoResult ShrinkUsageTableHeader(uint32_t new_entry_count,
+                                       uint8_t* header_buffer,
+                                       size_t* header_buffer_length);
+
+#endif /* OEMCRYPTO_TA_OEMCRYPTO_USAGE_TABLE_H_ */