Merge cdm changes to android repo

Bug: 251924225
Test: GtsMediaTestCases
Change-Id: I1b4e64c0abf701fe1f5017f14dc72b72c3ea6770

libwvdrmengine/oemcrypto/odk/src/core_message_deserialize.cpp

@@ -10,6 +10,7 @@
 #include <cstring>
 #include <string>
 
+#include "OEMCryptoCENCCommon.h"
 #include "odk_serialize.h"
 #include "odk_structs.h"
 #include "odk_structs_priv.h"
@@ -52,6 +53,7 @@ bool ParseRequest(uint32_t message_type,
   core_request->api_minor_version = core_message.nonce_values.api_minor_version;
   core_request->nonce = core_message.nonce_values.nonce;
   core_request->session_id = core_message.nonce_values.session_id;
+
   // Verify that the minor version matches the released version for the given
   // major version.
   if (core_request->api_major_version < ODK_FIRST_VERSION) {
@@ -68,10 +70,13 @@ bool ParseRequest(uint32_t message_type,
   // For v16, a release and a renewal use the same message structure.
   // However, for future API versions, the release might be a separate
   // message. Otherwise, we expect an exact match of message types.
+  // A provisioning request may contain a renewed provisioning message.
   if (message_type != ODK_Common_Request_Type &&
       core_message.message_type != message_type &&
       !(message_type == ODK_Renewal_Request_Type &&
-        core_message.message_type == ODK_Release_Request_Type)) {
+        core_message.message_type == ODK_Release_Request_Type) &&
+      !(message_type == ODK_Provisioning_Request_Type &&
+        core_message.message_type == ODK_Renewed_Provisioning_Request_Type)) {
     return false;
   }
   // Verify that the amount of buffer we read, which is GetOffset, is not more
@@ -125,6 +130,42 @@ bool CoreProvisioningRequestFromMessage(
   }
   core_provisioning_request->device_id.assign(
       reinterpret_cast<const char*>(device_id), device_id_length);
+  core_provisioning_request->renewal_type = OEMCrypto_NoRenewal;
+  core_provisioning_request->renewal_data.clear();
+  return true;
+}
+
+bool CoreRenewedProvisioningRequestFromMessage(
+    const std::string& oemcrypto_core_message,
+    ODK_ProvisioningRequest* core_provisioning_request) {
+  const auto unpacker = Unpack_ODK_PreparedRenewedProvisioningRequest;
+  ODK_PreparedRenewedProvisioningRequest prepared_provision = {};
+  if (!ParseRequest(ODK_Renewed_Provisioning_Request_Type,
+                    oemcrypto_core_message, core_provisioning_request,
+                    &prepared_provision, unpacker)) {
+    return false;
+  }
+  const uint8_t* device_id = prepared_provision.device_id;
+  const uint32_t device_id_length = prepared_provision.device_id_length;
+  if (device_id_length > ODK_DEVICE_ID_LEN_MAX) {
+    return false;
+  }
+  uint8_t zero[ODK_DEVICE_ID_LEN_MAX] = {};
+  if (memcmp(zero, device_id + device_id_length,
+             ODK_DEVICE_ID_LEN_MAX - device_id_length)) {
+    return false;
+  }
+  core_provisioning_request->device_id.assign(
+      reinterpret_cast<const char*>(device_id), device_id_length);
+
+  if (prepared_provision.renewal_data_length >
+      sizeof(prepared_provision.renewal_data)) {
+    return false;
+  }
+  core_provisioning_request->renewal_type = OEMCrypto_RenewalACert;
+  core_provisioning_request->renewal_data.assign(
+      reinterpret_cast<const char*>(prepared_provision.renewal_data),
+      prepared_provision.renewal_data_length);
   return true;
 }
 

libwvdrmengine/oemcrypto/odk/src/core_message_features.cpp

@@ -23,7 +23,7 @@ CoreMessageFeatures CoreMessageFeatures::DefaultFeatures(
       features.maximum_minor_version = 5;  // 16.5
       break;
     case 17:
-      features.maximum_minor_version = 0;  // 17.0
+      features.maximum_minor_version = 2;  // 17.2
       break;
     default:
       features.maximum_minor_version = 0;

libwvdrmengine/oemcrypto/odk/src/core_message_serialize.cpp

@@ -148,7 +148,8 @@ bool CreateCoreLicenseResponse(const CoreMessageFeatures& features,
         license_response.parsed_license->key_array_length;
     uint32_t i;
     for (i = 0; i < license_response_v16.parsed_license.key_array_length &&
-                i < license_response.parsed_license->key_array_length; i++) {
+                i < license_response.parsed_license->key_array_length;
+         i++) {
       license_response_v16.parsed_license.key_array[i] =
           license_response.parsed_license->key_array[i];
     }

libwvdrmengine/oemcrypto/odk/src/odk.c

@@ -72,6 +72,17 @@ static OEMCryptoResult ODK_PrepareRequest(
           &msg, (ODK_PreparedProvisioningRequest*)prepared_request_buffer);
       break;
     }
+    case ODK_Renewed_Provisioning_Request_Type: {
+      core_message->message_length = ODK_RENEWED_PROVISIONING_REQUEST_SIZE;
+      if (sizeof(ODK_PreparedRenewedProvisioningRequest) >
+          prepared_request_buffer_length) {
+        return ODK_ERROR_CORE_MESSAGE;
+      }
+      Pack_ODK_PreparedRenewedProvisioningRequest(
+          &msg,
+          (ODK_PreparedRenewedProvisioningRequest*)prepared_request_buffer);
+      break;
+    }
     default: {
       return ODK_ERROR_CORE_MESSAGE;
     }
@@ -238,6 +249,37 @@ OEMCryptoResult ODK_PrepareCoreProvisioningRequest(
                             sizeof(ODK_PreparedProvisioningRequest));
 }
 
+OEMCryptoResult ODK_PrepareCoreRenewedProvisioningRequest(
+    uint8_t* message, size_t message_length, size_t* core_message_length,
+    const ODK_NonceValues* nonce_values, const uint8_t* device_id,
+    size_t device_id_length, uint16_t renewal_type, const uint8_t* renewal_data,
+    size_t renewal_data_length) {
+  if (core_message_length == NULL || nonce_values == NULL) {
+    return ODK_ERROR_CORE_MESSAGE;
+  }
+  ODK_PreparedRenewedProvisioningRequest provisioning_request = {0};
+  if (device_id_length > sizeof(provisioning_request.device_id)) {
+    return ODK_ERROR_CORE_MESSAGE;
+  }
+  provisioning_request.device_id_length = (uint32_t)device_id_length;
+  if (device_id) {
+    memcpy(provisioning_request.device_id, device_id, device_id_length);
+  }
+  if (renewal_data_length > sizeof(provisioning_request.renewal_data)) {
+    return ODK_ERROR_CORE_MESSAGE;
+  }
+  provisioning_request.renewal_type = renewal_type;
+  provisioning_request.renewal_data_length = (uint32_t)renewal_data_length;
+  if (renewal_data) {
+    memcpy(provisioning_request.renewal_data, renewal_data,
+           renewal_data_length);
+  }
+  return ODK_PrepareRequest(message, message_length, core_message_length,
+                            ODK_Renewed_Provisioning_Request_Type, nonce_values,
+                            &provisioning_request,
+                            sizeof(provisioning_request));
+}
+
 /* @@ parse response functions */
 
 OEMCryptoResult ODK_ParseLicense(

libwvdrmengine/oemcrypto/odk/src/odk_endian.h

@@ -25,6 +25,14 @@ extern "C" {
 #define oemcrypto_be32toh OSSwapBigToHostInt32
 #define oemcrypto_htobe64 OSSwapHostToBigInt64
 #define oemcrypto_be64toh OSSwapBigToHostInt64
+#elif defined(_WIN32)
+#include <winsock2.h>
+#define oemcrypto_htobe16 htons
+#define oemcrypto_be16toh ntohs
+#define oemcrypto_htobe32 htonl
+#define oemcrypto_be32toh ntohl
+#define oemcrypto_htobe64 htonll
+#define oemcrypto_be64toh ntohll
 #else  /* defined(__linux__) || defined(__ANDROID__) */
 uint32_t oemcrypto_htobe16(uint16_t u16);
 uint32_t oemcrypto_be16toh(uint16_t u16);

libwvdrmengine/oemcrypto/odk/src/odk_serialize.c

@@ -128,12 +128,22 @@ void Pack_ODK_PreparedRenewalRequest(ODK_Message* msg,
 }
 
 void Pack_ODK_PreparedProvisioningRequest(
-    ODK_Message* msg, ODK_PreparedProvisioningRequest const* obj) {
+    ODK_Message* msg, const ODK_PreparedProvisioningRequest* obj) {
   Pack_ODK_CoreMessage(msg, &obj->core_message);
   Pack_uint32_t(msg, &obj->device_id_length);
   PackArray(msg, &obj->device_id[0], sizeof(obj->device_id));
 }
 
+void Pack_ODK_PreparedRenewedProvisioningRequest(
+    ODK_Message* msg, const ODK_PreparedRenewedProvisioningRequest* obj) {
+  Pack_ODK_CoreMessage(msg, &obj->core_message);
+  Pack_uint32_t(msg, &obj->device_id_length);
+  PackArray(msg, &obj->device_id[0], sizeof(obj->device_id));
+  Pack_uint16_t(msg, &obj->renewal_type);
+  Pack_uint32_t(msg, &obj->renewal_data_length);
+  PackArray(msg, &obj->renewal_data[0], sizeof(obj->renewal_data));
+}
+
 /* @@ kdo serialize */
 
 void Pack_ODK_LicenseResponse(ODK_Message* msg,
@@ -156,7 +166,7 @@ void Pack_ODK_RenewalResponse(ODK_Message* msg,
 }
 
 void Pack_ODK_ProvisioningResponse(ODK_Message* msg,
-                                   ODK_ProvisioningResponse const* obj) {
+                                   const ODK_ProvisioningResponse* obj) {
   Pack_ODK_PreparedProvisioningRequest(msg, &obj->request);
   Pack_ODK_ParsedProvisioning(
       msg, (const ODK_ParsedProvisioning*)obj->parsed_provisioning);
@@ -202,7 +212,7 @@ static void Unpack_ODK_ParsedLicense(ODK_Message* msg, ODK_ParsedLicense* obj) {
   Unpack_OEMCrypto_Substring(msg, &obj->enc_mac_keys);
   Unpack_OEMCrypto_Substring(msg, &obj->pst);
   Unpack_OEMCrypto_Substring(msg, &obj->srm_restriction_data);
-  obj->license_type = (OEMCrypto_LicenseType)Unpack_enum(msg);
+  Unpack_OEMCrypto_LicenseType(msg, &obj->license_type);
   Unpack_bool(msg, &obj->nonce_required);
   Unpack_ODK_TimerLimits(msg, &obj->timer_limits);
   Unpack_uint32_t(msg, &obj->watermarking);
@@ -260,7 +270,7 @@ static void Unpack_ODK_ParsedLicenseV16(ODK_Message* msg,
   Unpack_OEMCrypto_Substring(msg, &obj->enc_mac_keys);
   Unpack_OEMCrypto_Substring(msg, &obj->pst);
   Unpack_OEMCrypto_Substring(msg, &obj->srm_restriction_data);
-  obj->license_type = (OEMCrypto_LicenseType)Unpack_enum(msg);
+  Unpack_OEMCrypto_LicenseType(msg, &obj->license_type);
   Unpack_bool(msg, &obj->nonce_required);
   Unpack_ODK_TimerLimits(msg, &obj->timer_limits);
   Unpack_uint32_t(msg, &obj->key_array_length);
@@ -276,7 +286,7 @@ static void Unpack_ODK_ParsedLicenseV16(ODK_Message* msg,
 
 static void Unpack_ODK_ParsedProvisioning(ODK_Message* msg,
                                           ODK_ParsedProvisioning* obj) {
-  obj->key_type = (OEMCrypto_PrivateKeyType)Unpack_enum(msg);
+  Unpack_OEMCrypto_PrivateKeyType(msg, &obj->key_type);
   Unpack_OEMCrypto_Substring(msg, &obj->enc_private_key);
   Unpack_OEMCrypto_Substring(msg, &obj->enc_private_key_iv);
   Unpack_OEMCrypto_Substring(msg, &obj->encrypted_message_key);
@@ -302,6 +312,16 @@ void Unpack_ODK_PreparedProvisioningRequest(
   UnpackArray(msg, &obj->device_id[0], sizeof(obj->device_id));
 }
 
+void Unpack_ODK_PreparedRenewedProvisioningRequest(
+    ODK_Message* msg, ODK_PreparedRenewedProvisioningRequest* obj) {
+  Unpack_ODK_CoreMessage(msg, &obj->core_message);
+  Unpack_uint32_t(msg, &obj->device_id_length);
+  UnpackArray(msg, &obj->device_id[0], sizeof(obj->device_id));
+  Unpack_uint16_t(msg, &obj->renewal_type);
+  Unpack_uint32_t(msg, &obj->renewal_data_length);
+  UnpackArray(msg, &obj->renewal_data[0], obj->renewal_data_length);
+}
+
 void Unpack_ODK_PreparedCommonRequest(ODK_Message* msg,
                                       ODK_PreparedCommonRequest* obj) {
   Unpack_ODK_CoreMessage(msg, &obj->core_message);

libwvdrmengine/oemcrypto/odk/src/odk_serialize.h

@@ -22,6 +22,8 @@ void Pack_ODK_PreparedRenewalRequest(ODK_Message* msg,
                                      const ODK_PreparedRenewalRequest* obj);
 void Pack_ODK_PreparedProvisioningRequest(
     ODK_Message* msg, const ODK_PreparedProvisioningRequest* obj);
+void Pack_ODK_PreparedRenewedProvisioningRequest(
+    ODK_Message* msg, const ODK_PreparedRenewedProvisioningRequest* obj);
 
 /* odk unpack */
 void Unpack_ODK_CoreMessage(ODK_Message* msg, ODK_CoreMessage* obj);
@@ -47,6 +49,8 @@ void Unpack_ODK_PreparedRenewalRequest(ODK_Message* msg,
                                        ODK_PreparedRenewalRequest* obj);
 void Unpack_ODK_PreparedProvisioningRequest(
     ODK_Message* msg, ODK_PreparedProvisioningRequest* obj);
+void Unpack_ODK_PreparedRenewedProvisioningRequest(
+    ODK_Message* msg, ODK_PreparedRenewedProvisioningRequest* obj);
 
 void Unpack_ODK_PreparedCommonRequest(ODK_Message* msg,
                                       ODK_PreparedCommonRequest* obj);

libwvdrmengine/oemcrypto/odk/src/odk_structs_priv.h

@@ -24,6 +24,7 @@ typedef uint32_t ODK_MessageType;
 #define ODK_Renewal_Response_Type ((ODK_MessageType)4u)
 #define ODK_Provisioning_Request_Type ((ODK_MessageType)5u)
 #define ODK_Provisioning_Response_Type ((ODK_MessageType)6u)
+#define ODK_Renewed_Provisioning_Request_Type ((ODK_MessageType)11u)
 
 // Reserve future message types to support forward compatibility.
 #define ODK_Release_Request_Type ((ODK_MessageType)7u)
@@ -52,6 +53,15 @@ typedef struct {
   uint8_t device_id[ODK_DEVICE_ID_LEN_MAX];
 } ODK_PreparedProvisioningRequest;
 
+typedef struct {
+  ODK_CoreMessage core_message;
+  uint32_t device_id_length;
+  uint8_t device_id[ODK_DEVICE_ID_LEN_MAX];
+  uint16_t renewal_type;
+  uint32_t renewal_data_length;
+  uint8_t renewal_data[ODK_KEYBOX_RENEWAL_DATA_SIZE];
+} ODK_PreparedRenewedProvisioningRequest;
+
 typedef struct {
   ODK_CoreMessage core_message;
 } ODK_PreparedCommonRequest;
@@ -96,6 +106,7 @@ typedef struct {
 #define ODK_LICENSE_REQUEST_SIZE 20u
 #define ODK_RENEWAL_REQUEST_SIZE 28u
 #define ODK_PROVISIONING_REQUEST_SIZE 88u
+#define ODK_RENEWED_PROVISIONING_REQUEST_SIZE 1694u
 
 // These are the possible timer status values.
 #define ODK_CLOCK_TIMER_STATUS_UNDEFINED 0u  // Should not happen.

libwvdrmengine/oemcrypto/odk/src/serialization_base.c

@@ -38,7 +38,7 @@ static void PackBytes(ODK_Message* message, const uint8_t* ptr, size_t count) {
 }
 
 void Pack_enum(ODK_Message* message, int value) {
-  uint32_t v32 = value;
+  uint32_t v32 = (uint32_t)value;
   Pack_uint32_t(message, &v32);
 }
 
@@ -108,10 +108,28 @@ static void UnpackBytes(ODK_Message* message, uint8_t* ptr, size_t count) {
   }
 }
 
-int Unpack_enum(ODK_Message* message) {
-  uint32_t v32;
+void Unpack_OEMCrypto_LicenseType(ODK_Message* message,
+                                  OEMCrypto_LicenseType* value) {
+  assert(value);
+  uint32_t v32 = 0;
   Unpack_uint32_t(message, &v32);
-  return (int)v32;
+  if (v32 <= OEMCrypto_LicenseType_MaxValue) {
+    *value = (OEMCrypto_LicenseType)v32;
+  } else {
+    ODK_Message_SetStatus(message, MESSAGE_STATUS_PARSE_ERROR);
+  }
+}
+
+void Unpack_OEMCrypto_PrivateKeyType(ODK_Message* message,
+                                     OEMCrypto_PrivateKeyType* value) {
+  assert(value);
+  uint32_t v32 = 0;
+  Unpack_uint32_t(message, &v32);
+  if (v32 <= OEMCrypto_PrivateKeyType_MaxValue) {
+    *value = (OEMCrypto_PrivateKeyType)v32;
+  } else {
+    ODK_Message_SetStatus(message, MESSAGE_STATUS_PARSE_ERROR);
+  }
 }
 
 void Unpack_bool(ODK_Message* message, bool* value) {

libwvdrmengine/oemcrypto/odk/src/serialization_base.h

@@ -25,7 +25,10 @@ void PackArray(ODK_Message* message, const uint8_t* base, size_t size);
 void Pack_OEMCrypto_Substring(ODK_Message* message,
                               const OEMCrypto_Substring* obj);
 
-int Unpack_enum(ODK_Message* message);
+void Unpack_OEMCrypto_LicenseType(ODK_Message* message,
+                                  OEMCrypto_LicenseType* value);
+void Unpack_OEMCrypto_PrivateKeyType(ODK_Message* message,
+                                     OEMCrypto_PrivateKeyType* value);
 void Unpack_bool(ODK_Message* message, bool* value);
 void Unpack_uint8_t(ODK_Message* message, uint8_t* value);
 void Unpack_uint16_t(ODK_Message* message, uint16_t* value);