android/libclearkeydrmengine/oemcrypto/mock/OEMCryptoWrapper.cpp

/*********************************************************************
 * OEMCryptoWrapper.cpp
 *
 * (c) Copyright 2011-2012 Google, Inc.
 *
 * OEMCryptoDASH fuctions wrapped around a Mock OEMCrypto object.
 *********************************************************************/

#define LOG_TAG "WV.MockOEMCrypto"
#include <utils/Log.h>
#include <utils/String8.h>

#include "OEMCryptoDASH.h"
#include "MockOEMCrypto.h"
#include "openssl/rand.h"

using namespace android;
using namespace wvdrm;

extern "C"
OEMCryptoResult OEMCrypto_Initialize(void) {
    if (MockOEMCrypto::sSingleton == NULL) MockOEMCrypto::sSingleton = new MockOEMCrypto();
    return MockOEMCrypto::sSingleton->initialize();
}

extern "C"
OEMCryptoResult OEMCrypto_Terminate(void) {
    if (!MockOEMCrypto::sSingleton) {
        ALOGE( "[OEMCrypto_Terminate(): failed - not initialized, no engine]\n" );
        return OEMCrypto_ERROR_TERMINATE_FAILED;
    }
    return MockOEMCrypto::sSingleton->terminate();
}

extern "C"
OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION *session) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_OPEN_SESSION_FAILED;
    }
    return MockOEMCrypto::sSingleton->openSession(session);
}

extern "C"
OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_TERMINATE_FAILED;
    }
    return MockOEMCrypto::sSingleton->closeSession(session);
}

extern "C"
OEMCryptoResult OEMCrypto_GenerateDerivedKeys(OEMCrypto_SESSION session,
                                              const uint8_t *mac_key_context,
                                              uint32_t mac_key_context_length,
                                              const uint8_t *enc_key_context,
                                              uint32_t enc_key_context_length) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
    if (!s) {
        ALOGE("OEMCrypto no session for id %d", session);
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    return s->generateDerivedKeys(mac_key_context,mac_key_context_length,
                                  enc_key_context, enc_key_context_length);
}

extern "C"
OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
                                        uint32_t* nonce) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
    if (!s) {
        ALOGE("OEMCrypto no session for id %d", session);
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    return s->generateNonce(nonce);
}

extern "C"
OEMCryptoResult OEMCrypto_GenerateSignature(OEMCrypto_SESSION session,
                                            const uint8_t* message,
                                            size_t message_length,
                                            uint8_t* signature,
                                            size_t* signature_length) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
    if (!s) {
        ALOGE("OEMCrypto no session for id %d", session);
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    return s->generateSignature(message, message_length,
                                signature, signature_length);
}

extern "C"
OEMCryptoResult OEMCrypto_LoadKeys(OEMCrypto_SESSION session,
                                   const uint8_t* message,
                                   size_t message_length,
                                   const uint8_t* signature,
                                   size_t signature_length,
                                   const uint8_t* enc_mac_key_iv,
                                   const uint8_t* enc_mac_key,
                                   size_t num_keys,
                                   const OEMCrypto_KeyObject* key_array) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
    if (!s) {
        ALOGE("OEMCrypto no session for id %d", session);
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    return s->loadKeys(message, message_length, signature, signature_length,
                       enc_mac_key_iv, enc_mac_key,
                       num_keys, key_array);
}

extern "C"
OEMCryptoResult
OEMCrypto_RefreshKeys(OEMCrypto_SESSION session,
                      const uint8_t* message,
                      size_t message_length,
                      const uint8_t* signature,
                      size_t signature_length,
                      size_t num_keys,
                      const OEMCrypto_KeyRefreshObject* key_array) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
    if (!s) {
        ALOGE("OEMCrypto no session for id %d", session);
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    return s->refreshKeys(message, message_length, signature,
                          signature_length, num_keys, key_array);
}

extern "C"
OEMCryptoResult OEMCrypto_SelectKey(const OEMCrypto_SESSION session,
                                    const uint8_t* key_id,
                                    size_t key_id_length) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
    if (!s) {
        ALOGE("OEMCrypto no session for id %d", session);
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    return s->selectKey(key_id, key_id_length);
}

extern "C"
OEMCryptoResult OEMCrypto_DecryptCTR(OEMCrypto_SESSION session,
                                     const uint8_t *data_addr,
                                     size_t data_length,
                                     bool is_encrypted,
                                     const uint8_t *iv,
                                     size_t offset,
                                     const OEMCrypto_DestBufferDesc* out_buffer) {
    if (! MockOEMCrypto::sSingleton) {
        ALOGE("OEMCrypto not initialized");
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
    if (!s) {
        ALOGE("OEMCrypto no session for id %d", session);
        return OEMCrypto_ERROR_INVALID_SESSION;
    }
    return s->decryptCTR(data_addr, data_length, is_encrypted,
                         iv, offset, out_buffer);
}

extern "C"
OEMCryptoResult OEMCrypto_InstallKeybox(uint8_t *keybox,
                                        size_t keyBoxLength) {
    if (!MockOEMCrypto::sSingleton) {
        MockOEMCrypto::sSingleton = new MockOEMCrypto(NULL);
    }
    return MockOEMCrypto::sSingleton->installKeybox(keybox, keyBoxLength);
}

extern "C"
OEMCryptoResult OEMCrypto_IsKeyboxValid(void) {
    if (!MockOEMCrypto::sSingleton) {
        MockOEMCrypto::sSingleton = new MockOEMCrypto(NULL);
    }
    return MockOEMCrypto::sSingleton->isKeyboxValid();
}

extern "C"
OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,
                                      size_t *idLength) {
    if (MockOEMCrypto::sSingleton == NULL) MockOEMCrypto::sSingleton = new MockOEMCrypto();
    return MockOEMCrypto::sSingleton->getDeviceID(deviceID, idLength);
}

extern "C"
OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
                                     size_t *keyDataLength) {
    if (MockOEMCrypto::sSingleton == NULL) MockOEMCrypto::sSingleton = new MockOEMCrypto();
    return MockOEMCrypto::sSingleton->getKeyData(keyData, keyDataLength);
}

extern "C"
OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData,
                                    size_t dataLength) {
    ALOGV("OEMCryptoResult OEMCrypto_GetRandom\n");
    if (RAND_bytes(randomData, dataLength)) {
        return OEMCrypto_SUCCESS;
    } else {
        return OEMCrypto_ERROR_RNG_FAILED;
    }
}

extern "C"
OEMCryptoResult OEMCrypto_WrapKeybox(uint8_t *keybox,
                                     size_t keyBoxLength,
                                     uint8_t *wrappedKeybox,
                                     size_t *wrappedKeyBoxLength,
                                     uint8_t *transportKey,
                                     size_t transportKeyLength) {
    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}