int AJ_Main(void)
{
AJ_Status status = AJ_OK;
size_t i;
char out[128];
for (i = 0; i < ArraySize(testVector); i++) {
uint8_t key[16];
uint8_t msg[64];
uint8_t nonce[16];
uint32_t nlen = (uint32_t)strlen(testVector[i].nonce) / 2;
uint32_t mlen = (uint32_t)strlen(testVector[i].input) / 2;
AJ_HexToRaw(testVector[i].key, 0, key, sizeof(key));
AJ_HexToRaw(testVector[i].nonce, 0, nonce, nlen);
AJ_HexToRaw(testVector[i].input, 0, msg, mlen);
status = AJ_Encrypt_CCM(key, msg, mlen, testVector[i].hdrLen, testVector[i].authLen, nonce, nlen);
if (status != AJ_OK) {
AJ_AlwaysPrintf(("Encryption failed (%d) for test #%zu\n", status, i));
goto ErrorExit;
}
AJ_RawToHex(msg, mlen + testVector[i].authLen, out, sizeof(out), FALSE);
if (strcmp(out, testVector[i].output) != 0) {
AJ_AlwaysPrintf(("Encrypt verification failure for test #%zu\n%s\n", i, out));
goto ErrorExit;
}
/*
* Verify decryption.
*/
status = AJ_Decrypt_CCM(key, msg, mlen, testVector[i].hdrLen, testVector[i].authLen, nonce, nlen);
if (status != AJ_OK) {
AJ_AlwaysPrintf(("Authentication failure (%d) for test #%zu\n", status, i));
goto ErrorExit;
}
AJ_RawToHex(msg, mlen, out, sizeof(out), FALSE);
if (strcmp(out, testVector[i].input) != 0) {
AJ_AlwaysPrintf(("Decrypt verification failure for test #%zu\n%s\n", i, out));
goto ErrorExit;
}
AJ_AlwaysPrintf(("Passed and verified test #%zu\n", i));
}
AJ_AlwaysPrintf(("AES CCM unit test PASSED\n"));
return 0;
ErrorExit:
AJ_AlwaysPrintf(("AES CCM unit test FAILED\n"));
return 1;
}
AJ_Status AJ_WSL_NET_SetPassphrase(const char* SSID, const char* passphrase, uint32_t passLen)
{
AJ_Status status;
AJ_BufList* passphraseList;
passphraseList = AJ_BufListCreate();
uint8_t* hexPassphrase = NULL;
if (passLen == 64) {
hexPassphrase = (uint8_t*)AJ_WSL_Malloc(32);
status = AJ_HexToRaw(passphrase, 64, hexPassphrase, 32);
if (status == AJ_OK) {
WSL_MarshalPacket(passphraseList, WMI_SET_PMK, 0, hexPassphrase, 32);
} else {
AJ_WSL_Free(hexPassphrase);
// Passphrase was not valid HEX data
return AJ_ERR_INVALID;
}
} else {
WSL_MarshalPacket(passphraseList, WSL_SET_PASSPHRASE, 0, SSID, passphrase, strlen(SSID), passLen);
}
WMI_MarshalHeader(passphraseList, 1, 1);
AJ_InfoPrintf(("AJ_WSL_NET_SetPassphrase(): SET_PASSPHRASE\n"));
AJ_WSL_WMI_PadPayload(passphraseList);
//AJ_BufListPrintDumpContinuous(passphraseList);
status = AJ_WSL_WMI_QueueWorkItem(0, AJ_WSL_WORKITEM(AJ_WSL_WORKITEM_NETWORK, WSL_SET_PASSPHRASE), AJ_WSL_HTC_DATA_ENDPOINT1, passphraseList);
AJ_WSL_Free(hexPassphrase);
return status;
}
static uint32_t PasswordCallback(uint8_t* buffer, uint32_t bufLen)
{
AJ_Status status = AJ_OK;
#ifdef CONFIG_SERVICE
const char* hexPassword = AJSVC_PropertyStore_GetValue(AJSVC_PROPERTY_STORE_PASSCODE);
#else
const char* hexPassword = "******";
#endif
size_t hexPasswordLen;
uint32_t len = 0;
if (hexPassword == NULL) {
AJ_AlwaysPrintf(("Password is NULL!\n"));
return len;
}
AJ_AlwaysPrintf(("Configured password=%s\n", hexPassword));
hexPasswordLen = strlen(hexPassword);
len = hexPasswordLen / 2;
status = AJ_HexToRaw(hexPassword, hexPasswordLen, buffer, bufLen);
if (status == AJ_ERR_RESOURCES) {
len = 0;
}
return len;
}
/*
* Inplace decode a hex encoded ascii string
*/
static AJ_Status HexDecode(char* str)
{
AJ_Status status = AJ_OK;
size_t sz = strlen(str);
if (sz) {
status = AJ_HexToRaw(str, sz, (uint8_t*)str, sz - 1);
}
/*
* NUL terminate the result
*/
str[sz / 2] = '\0';
return status;
}
static uint32_t PasswordCallback(uint8_t* buffer, uint32_t bufLen)
{
AJ_Status status = AJ_OK;
const char* hexPassword = "******";
size_t hexPasswordLen;
uint32_t len = 0;
AJ_InfoPrintf(("Configured password=%s\n", hexPassword));
hexPasswordLen = strlen(hexPassword);
len = (uint32_t)hexPasswordLen / 2;
status = AJ_HexToRaw(hexPassword, hexPasswordLen, buffer, bufLen);
if (status == AJ_ERR_RESOURCES) {
len = 0;
}
return len;
}
static AJ_Status MarshalAppId(AJ_Message* msg, const char* appId)
{
AJ_Status status;
uint8_t binAppId[UUID_LENGTH];
uint32_t sz = strlen(appId);
if (sz > UUID_LENGTH * 2) { // Crop application id that is too long
sz = UUID_LENGTH * 2;
}
status = AJ_HexToRaw(appId, sz, binAppId, UUID_LENGTH);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "{sv}", "AppId", APP_ID_SIGNATURE, binAppId, sz / 2);
return status;
}
static uint32_t PasswordCallback(uint8_t* buffer, uint32_t bufLen)
{
AJ_Status status = AJ_OK;
const char* hexPassword;
size_t hexPasswordLen;
uint32_t len = 0;
hexPassword = AJSVC_PropertyStore_GetValue(AJSVC_PROPERTY_STORE_PASSCODE);
if (hexPassword == NULL) {
AJ_AlwaysPrintf(("Password is NULL!\n"));
return len;
}
AJ_AlwaysPrintf(("Retrieved password=%s\n", hexPassword));
hexPasswordLen = strlen(hexPassword);
len = hexPasswordLen / 2;
status = AJ_HexToRaw(hexPassword, hexPasswordLen, buffer, bufLen);
if (status == AJ_ERR_RESOURCES) {
len = 0;
}
return len;
}
static AJ_Status DoConnectWifi(AJOBS_Info* connectInfo)
{
AJ_Status status = AJ_OK;
AJ_WiFiSecurityType secType = AJ_WIFI_SECURITY_NONE;
AJ_WiFiCipherType cipherType = AJ_WIFI_CIPHER_NONE;
AJOBS_AuthType fallback = AJOBS_AUTH_TYPE_OPEN;
AJOBS_AuthType fallbackUntil = AJOBS_AUTH_TYPE_OPEN;
uint8_t retries = 0;
AJ_WiFiConnectState wifiConnectState;
AJ_InfoPrintf(("Attempting to connect to %s with passcode=%s and auth=%d\n", connectInfo->ssid, connectInfo->pc, connectInfo->authType));
switch (connectInfo->authType) {
case AJOBS_AUTH_TYPE_ANY:
if (strlen(connectInfo->pc) == 0) {
break;
}
fallback = AJOBS_AUTH_TYPE_WPA2_CCMP;
fallbackUntil = AJOBS_AUTH_TYPE_OPEN;
break;
case AJOBS_AUTH_TYPE_WPA_AUTO:
if (strlen(connectInfo->pc) == 0) {
break;
}
fallback = AJOBS_AUTH_TYPE_WPA_CCMP;
fallbackUntil = AJOBS_AUTH_TYPE_WPA_TKIP;
break;
case AJOBS_AUTH_TYPE_WPA2_AUTO:
if (strlen(connectInfo->pc) == 0) {
break;
}
fallback = AJOBS_AUTH_TYPE_WPA2_CCMP;
fallbackUntil = AJOBS_AUTH_TYPE_WPA2_TKIP;
break;
default:
fallback = connectInfo->authType;
}
secType = GetSecType(fallback);
cipherType = GetCipherType(fallback);
AJ_InfoPrintf(("Trying to connect with auth=%d (secType=%d, cipherType=%d)\n", fallback, secType, cipherType));
while (1) {
if (connectInfo->state == AJOBS_STATE_CONFIGURED_NOT_VALIDATED) {
connectInfo->state = AJOBS_STATE_CONFIGURED_VALIDATING;
}
uint8_t raw[(AJOBS_PASSCODE_MAX_LENGTH / 2) + 1];
char* password = connectInfo->pc;
if (AJ_WIFI_CIPHER_WEP != cipherType) {
size_t hexLen = strlen(connectInfo->pc);
AJ_HexToRaw(connectInfo->pc, hexLen, raw, (AJOBS_PASSCODE_MAX_LENGTH / 2) + 1);
password = (char*)raw;
password[hexLen / 2] = '\0';
}
status = AJ_ConnectWiFi(connectInfo->ssid, secType, cipherType, password);
AJ_InfoPrintf(("AJ_ConnectWifi returned %s\n", AJ_StatusText(status)));
wifiConnectState = AJ_GetWifiConnectState();
// Set last error and state
if ((status == AJ_OK) /* (wifiConnectState == AJ_WIFI_CONNECT_OK)*/) {
obLastError.code = AJOBS_STATE_LAST_ERROR_VALIDATED;
obLastError.message[0] = '\0';
obState = AJOBS_STATE_CONFIGURED_VALIDATED;
connectInfo->authType = fallback;
} else if ((status == AJ_ERR_CONNECT) /* (wifiConnectState == AJ_WIFI_CONNECT_FAILED)*/) {
obLastError.code = AJOBS_STATE_LAST_ERROR_UNREACHABLE;
strncpy(obLastError.message, "Network unreachable!", AJOBS_ERROR_MESSAGE_LEN);
if (connectInfo->state == AJOBS_STATE_CONFIGURED_VALIDATED || connectInfo->state == AJOBS_STATE_CONFIGURED_RETRY) {
obState = AJOBS_STATE_CONFIGURED_RETRY;
} else {
obState = AJOBS_STATE_CONFIGURED_ERROR;
}
} else if ((status == AJ_ERR_SECURITY) /* (wifiConnectState == AJ_WIFI_AUTH_FAILED)*/) {
obLastError.code = AJOBS_STATE_LAST_ERROR_UNAUTHORIZED;
strncpy(obLastError.message, "Authorization failed!", AJOBS_ERROR_MESSAGE_LEN);
if (connectInfo->state == AJOBS_STATE_CONFIGURED_VALIDATED || connectInfo->state == AJOBS_STATE_CONFIGURED_RETRY) {
obState = AJOBS_STATE_CONFIGURED_RETRY;
} else {
obState = AJOBS_STATE_CONFIGURED_ERROR;
}
} else if (status == AJ_ERR_DRIVER) {
obLastError.code = AJOBS_STATE_LAST_ERROR_ERROR_MESSAGE;
strncpy(obLastError.message, "Driver error", AJOBS_ERROR_MESSAGE_LEN);
obState = AJOBS_STATE_CONFIGURED_ERROR;
} else if (status == AJ_ERR_DHCP) {
obLastError.code = AJOBS_STATE_LAST_ERROR_ERROR_MESSAGE;
strncpy(obLastError.message, "Failed to establish IP!", AJOBS_ERROR_MESSAGE_LEN);
if (connectInfo->state == AJOBS_STATE_CONFIGURED_VALIDATED || connectInfo->state == AJOBS_STATE_CONFIGURED_RETRY) {
obState = AJOBS_STATE_CONFIGURED_RETRY;
} else {
obState = AJOBS_STATE_CONFIGURED_ERROR;
}
} else {
obLastError.code = AJOBS_STATE_LAST_ERROR_ERROR_MESSAGE;
strncpy(obLastError.message, "Failed to connect! Unexpected error", AJOBS_ERROR_MESSAGE_LEN);
obState = AJOBS_STATE_CONFIGURED_ERROR;
}
if (obState == AJOBS_STATE_CONFIGURED_VALIDATED) {
break;
}
AJ_WarnPrintf(("Warning - DoConnectWifi wifiConnectState = %s\n", AJ_WiFiConnectStateText(wifiConnectState)));
AJ_WarnPrintf(("Last error set to \"%s\" (code=%d)\n", obLastError.message, obLastError.code));
if (obState == AJOBS_STATE_CONFIGURED_ERROR || obState == AJOBS_STATE_CONFIGURED_RETRY) {
if (retries++ >= obSettings->AJOBS_MAX_RETRIES) {
if (obState == AJOBS_STATE_CONFIGURED_ERROR && connectInfo->state == AJOBS_STATE_CONFIGURED_VALIDATING) {
if (connectInfo->authType < 0 && fallback > fallbackUntil) {
obLastError.code = AJOBS_STATE_LAST_ERROR_UNSUPPORTED_PROTOCOL;
strncpy(obLastError.message, "Unsupported protocol", AJOBS_ERROR_MESSAGE_LEN);
fallback--; // Try next authentication protocol
secType = GetSecType(fallback);
cipherType = GetCipherType(fallback);
retries = 0;
AJ_InfoPrintf(("Trying to connect with fallback auth=%d (secType=%d, cipherType=%d)\n", fallback, secType, cipherType));
continue;
}
}
break;
}
AJ_InfoPrintf(("Retry number %d out of %d\n", retries, obSettings->AJOBS_MAX_RETRIES));
}
}
connectInfo->state = obState;
status = (*obWriteInfo)(connectInfo);
return status;
}
AJ_Status AJSVC_PropertyStore_ReadAll(AJ_Message* msg, AJSVC_PropertyStoreCategoryFilter filter, int8_t langIndex)
{
AJ_Status status = AJ_OK;
AJ_Arg array;
AJ_Arg array2;
AJ_Arg dict;
const char* value;
AJ_Arg arg;
uint8_t rawValue[16];
uint8_t index;
const char* ajVersion;
AJ_InfoPrintf(("PropertyStore_ReadAll()\n"));
status = AJ_MarshalContainer(msg, &array, AJ_ARG_ARRAY);
if (status != AJ_OK) {
return status;
}
//AJSVC_PropertyStoreFieldIndices fieldIndex = 0;
int fieldIndex = 0;
for (; fieldIndex < AJSVC_PROPERTY_STORE_NUMBER_OF_KEYS; fieldIndex++) {
#ifdef CONFIG_SERVICE
if (propertyStoreProperties[fieldIndex].mode7Public && (filter.bit0About || (filter.bit1Config && propertyStoreProperties[fieldIndex].mode0Write) || (filter.bit2Announce && propertyStoreProperties[fieldIndex].mode1Announce))) {
#else
if (propertyStoreProperties[fieldIndex].mode7Public && (filter.bit0About || (filter.bit2Announce && propertyStoreProperties[fieldIndex].mode1Announce))) {
#endif
value = AJSVC_PropertyStore_GetValueForLang((AJSVC_PropertyStoreFieldIndices)fieldIndex, langIndex);
if (value == NULL && fieldIndex >= AJSVC_PROPERTY_STORE_NUMBER_OF_MANDATORY_KEYS) { // Non existing values are skipped!
AJ_WarnPrintf(("PropertyStore_ReadAll - Failed to get value for field=(name=%s, index=%d) and language=(name=%s, index=%d), skipping.\n", AJSVC_PropertyStore_GetFieldName((AJSVC_PropertyStoreFieldIndices)fieldIndex), (int)fieldIndex, AJSVC_PropertyStore_GetLanguageName(langIndex), (int)langIndex));
} else {
if (fieldIndex == AJSVC_PROPERTY_STORE_APP_ID) {
if (value == NULL) {
AJ_ErrPrintf(("PropertyStore_ReadAll - Failed to get value for mandatory field=(name=%s, index=%d) and language=(name=%s, index=%d), aborting.\n", AJSVC_PropertyStore_GetFieldName((AJSVC_PropertyStoreFieldIndices)fieldIndex), (int)fieldIndex, AJSVC_PropertyStore_GetLanguageName(langIndex), (int)langIndex));
return AJ_ERR_NULL;
}
status = AJ_MarshalContainer(msg, &dict, AJ_ARG_DICT_ENTRY);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "s", propertyStoreProperties[fieldIndex].keyName);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalVariant(msg, "ay");
if (status != AJ_OK) {
return status;
}
status = AJ_HexToRaw(value, 0, rawValue, (size_t)sizeof(rawValue));
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArg(msg, AJ_InitArg(&arg, AJ_ARG_BYTE, AJ_ARRAY_FLAG, rawValue, sizeof(rawValue)));
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalCloseContainer(msg, &dict);
if (status != AJ_OK) {
return status;
}
#ifdef CONFIG_SERVICE
} else if (fieldIndex == AJSVC_PROPERTY_STORE_MAX_LENGTH) {
status = AJ_MarshalContainer(msg, &dict, AJ_ARG_DICT_ENTRY);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "s", propertyStoreProperties[fieldIndex].keyName);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalVariant(msg, "q");
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "q", DEVICE_NAME_VALUE_LENGTH);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalCloseContainer(msg, &dict);
if (status != AJ_OK) {
return status;
}
AJ_InfoPrintf(("Has key [%s] runtime Value [%d]\n", propertyStoreProperties[AJSVC_PROPERTY_STORE_MAX_LENGTH].keyName, DEVICE_NAME_VALUE_LENGTH));
#endif
} else if (fieldIndex == AJSVC_PROPERTY_STORE_AJ_SOFTWARE_VERSION) {
ajVersion = AJ_GetVersion();
if (ajVersion == NULL) {
AJ_ErrPrintf(("PropertyStore_ReadAll - Failed to get value for mandatory field=(name=%s, index=%d) and language=(name=%s, index=%d), aborting.\n", AJSVC_PropertyStore_GetFieldName((AJSVC_PropertyStoreFieldIndices)fieldIndex), (int)fieldIndex, AJSVC_PropertyStore_GetLanguageName(langIndex), (int)langIndex));
return AJ_ERR_NULL;
}
status = AJ_MarshalContainer(msg, &dict, AJ_ARG_DICT_ENTRY);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "s", propertyStoreProperties[fieldIndex].keyName);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalVariant(msg, "s");
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "s", ajVersion);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalCloseContainer(msg, &dict);
if (status != AJ_OK) {
return status;
}
AJ_InfoPrintf(("Has key [%s] runtime Value [%s]\n", propertyStoreProperties[AJSVC_PROPERTY_STORE_AJ_SOFTWARE_VERSION].keyName, ajVersion));
} else {
if (value == NULL) {
AJ_ErrPrintf(("PropertyStore_ReadAll - Failed to get value for mandatory field=(name=%s, index=%d) and language=(name=%s, index=%d), aborting.\n", AJSVC_PropertyStore_GetFieldName((AJSVC_PropertyStoreFieldIndices)fieldIndex), (int)fieldIndex, AJSVC_PropertyStore_GetLanguageName(langIndex), (int)langIndex));
return AJ_ERR_NULL;
}
status = AJ_MarshalContainer(msg, &dict, AJ_ARG_DICT_ENTRY);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "s", propertyStoreProperties[fieldIndex].keyName);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalVariant(msg, "s");
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "s", value);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalCloseContainer(msg, &dict);
if (status != AJ_OK) {
return status;
}
}
}
}
}
if (filter.bit0About) {
// Add supported languages
status = AJ_MarshalContainer(msg, &dict, AJ_ARG_DICT_ENTRY);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(msg, "s", defaultLanguagesKeyName);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalVariant(msg, "as");
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalContainer(msg, &array2, AJ_ARG_ARRAY);
if (status != AJ_OK) {
return status;
}
index = AJSVC_PROPERTY_STORE_NO_LANGUAGE_INDEX;
for (; index < AJSVC_PROPERTY_STORE_NUMBER_OF_LANGUAGES; index++) {
status = AJ_MarshalArgs(msg, "s", propertyStoreDefaultLanguages[index]);
if (status != AJ_OK) {
return status;
}
}
status = AJ_MarshalCloseContainer(msg, &array2);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalCloseContainer(msg, &dict);
if (status != AJ_OK) {
return status;
}
}
status = AJ_MarshalCloseContainer(msg, &array);
if (status != AJ_OK) {
return status;
}
return status;
}
#ifdef CONFIG_SERVICE
AJ_Status AJSVC_PropertyStore_Update(const char* key, int8_t langIndex, const char* value)
{
AJSVC_PropertyStoreFieldIndices fieldIndex = AJSVC_PropertyStore_GetFieldIndex(key);
if (fieldIndex == AJSVC_PROPERTY_STORE_ERROR_FIELD_INDEX || fieldIndex >= AJSVC_PROPERTY_STORE_NUMBER_OF_CONFIG_KEYS) {
return AJ_ERR_INVALID;
}
if (!UpdateFieldInRAM(fieldIndex, langIndex, value)) {
return AJ_ERR_FAILURE;
}
return AJ_OK;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
size_t i;
char out[128];
for (i = 0; i < ArraySize(testVector); i++) {
uint8_t key[16];
uint8_t msg[64];
uint8_t nonce[16];
uint32_t nlen = (uint32_t)strlen(testVector[i].nonce) / 2;
uint32_t mlen = (uint32_t)strlen(testVector[i].input) / 2;
AJ_HexToRaw(testVector[i].key, 0, key, sizeof(key));
AJ_HexToRaw(testVector[i].nonce, 0, nonce, nlen);
AJ_HexToRaw(testVector[i].input, 0, msg, mlen);
status = AJ_Encrypt_CCM(key, msg, mlen, testVector[i].hdrLen, testVector[i].authLen, nonce, nlen);
if (status != AJ_OK) {
AJ_Printf("Encryption failed (%d) for test #%zu\n", status, i);
goto ErrorExit;
}
AJ_RawToHex(msg, mlen + testVector[i].authLen, out, sizeof(out), FALSE);
if (strcmp(out, testVector[i].output) != 0) {
AJ_Printf("Encrypt verification failure for test #%zu\n%s\n", i, out);
goto ErrorExit;
}
/*
* Verify decryption.
*/
status = AJ_Decrypt_CCM(key, msg, mlen, testVector[i].hdrLen, testVector[i].authLen, nonce, nlen);
if (status != AJ_OK) {
AJ_Printf("Authentication failure (%d) for test #%zu\n", status, i);
goto ErrorExit;
}
AJ_RawToHex(msg, mlen, out, sizeof(out), FALSE);
if (strcmp(out, testVector[i].input) != 0) {
AJ_Printf("Decrypt verification failure for test #%zu\n%s\n", i, out);
goto ErrorExit;
}
AJ_Printf("Passed and verified test #%zu\n", i);
}
AJ_Printf("AES CCM unit test PASSED\n");
{
static const char expect[] = "F19787716404918CA20F174CFF2E165F21B17A70C472480AE91891B5BB8DD261CBD4273612D41BC6";
const char secret[] = "1234ABCDE";
const char seed[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234";
uint8_t key[40];
const char* inputs[3];
uint8_t length[3];
inputs[0] = secret;
length[0] = (uint8_t)strlen(secret);
inputs[1] = seed;
length[1] = (uint8_t)strlen(seed);
inputs[2] = "prf test";
length[2] = 8;
status = AJ_Crypto_PRF((const uint8_t**)inputs, length, ArraySize(inputs), key, sizeof(key));
if (status != AJ_OK) {
AJ_Printf("AJ_Crypto_PRF %d\n", status);
goto ErrorExit;
}
AJ_RawToHex(key, sizeof(key), out, sizeof(out), FALSE);
if (strcmp(out, expect) != 0) {
AJ_Printf("AJ_Crypto_PRF failed: %d\n", status);
goto ErrorExit;
}
AJ_Printf("AJ_Crypto_PRF test PASSED: %d\n", status);
}
return 0;
ErrorExit:
AJ_Printf("AES CCM unit test FAILED\n");
return 1;
}
AJ_Status AJ_GUID_FromString(AJ_GUID* guid, const char* str)
{
return AJ_HexToRaw(str, 32, guid->val, 16);
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
uint32_t i;
AJ_AlwaysPrintf(("AES CCM unit test start\n"));
for (i = 0; i < ArraySize(testVector); i++) {
uint8_t key[16];
uint8_t input[64];
uint8_t* msg;
uint8_t nonce[16];
uint32_t nlen = (uint32_t)strlen(testVector[i].nonce) / 2;
uint32_t ilen = (uint32_t)strlen(testVector[i].input) / 2;
uint32_t mlen = ilen * testVector[i].repeat;
uint32_t j;
char* out;
size_t olen;
AJ_HexToRaw(testVector[i].key, 0, key, sizeof(key));
AJ_HexToRaw(testVector[i].nonce, 0, nonce, nlen);
AJ_HexToRaw(testVector[i].input, 0, input, mlen);
msg = AJ_Malloc(mlen + testVector[i].authLen);
if (!msg) {
AJ_AlwaysPrintf(("Allocation failed for test #%zu\n", i));
goto ErrorExit;
}
for (j = 0; j < testVector[i].repeat; j++) {
memcpy(&msg[ilen * j], &input[0], ilen);
}
olen = 2 * (mlen + testVector[i].authLen) + 1;
out = AJ_Malloc(olen);
if (!out) {
AJ_AlwaysPrintf(("Allocation failed for test #%zu\n", i));
goto ErrorExit;
}
status = AJ_Encrypt_CCM(key, msg, mlen, testVector[i].hdrLen, testVector[i].authLen, nonce, nlen);
if (status != AJ_OK) {
AJ_AlwaysPrintf(("Encryption failed (%d) for test #%u\n", status, i));
goto ErrorExit;
}
AJ_RawToHex(msg, mlen + testVector[i].authLen, out, olen, FALSE);
if (strcmp(out, testVector[i].output) != 0) {
AJ_AlwaysPrintf(("Encrypt verification failure for test #%u\n%s\n", i, out));
goto ErrorExit;
}
/*
* Verify decryption.
*/
status = AJ_Decrypt_CCM(key, msg, mlen, testVector[i].hdrLen, testVector[i].authLen, nonce, nlen);
if (status != AJ_OK) {
AJ_AlwaysPrintf(("Authentication failure (%d) for test #%u\n", status, i));
goto ErrorExit;
}
AJ_RawToHex(msg, mlen, out, olen, FALSE);
for (j = 0; j < testVector[i].repeat; j++) {
if (strncmp(&out[2 * ilen * j], testVector[i].input, ilen * 2) != 0) {
AJ_AlwaysPrintf(("Decrypt verification failure for test #%u\n%s\n", i, out));
goto ErrorExit;
}
}
AJ_AlwaysPrintf(("Passed and verified test #%zu\n", i));
AJ_Free(msg);
AJ_Free(out);
}
AJ_AlwaysPrintf(("AES CCM unit test PASSED\n"));
return 0;
ErrorExit:
AJ_AlwaysPrintf(("AES CCM unit test FAILED\n"));
return 1;
}
AJ_Status MyAboutPropGetter(AJ_Message* reply, const char* language)
{
AJ_Status status = (0 == strcmp(language, "")) ? AJ_OK : AJ_ERR_NO_MATCH;
int langIndex = -1;
while(languages[++langIndex] && status == AJ_ERR_NO_MATCH){
fflush(stdout);
if ((0 != strcmp(language, languages[langIndex]))) continue;
status = AJ_OK;
}
if (status != AJ_OK) {
return status;
}
AJ_Arg array;
// char guidStr[16 * 2 + 1];
uint8_t appId[16];
// memset(guidStr, '\0', sizeof(guidStr));
char* propDeviceId = (char*)GetProperty("DeviceId");
// if (propDeviceId){
// strcpy(guidStr, propDeviceId);
// } else {
// AJ_GUID guid;
// status = AJ_GetLocalGUID(&guid);
// if (status != AJ_OK) {
// return status;
// }
// AJ_GUID_ToString(&guid, guidStr, sizeof(guidStr));
// }
char* propAppId = (char*)GetProperty("AppId");
status = AJ_HexToRaw(propAppId, 0, appId, 16);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalContainer(reply, &array, AJ_ARG_ARRAY);
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "AppId", "ay", appId, 16);
}
if (status == AJ_OK) {
// printf("AppName: %s\n", (char*)GetProperty("AppName"));
status = AJ_MarshalArgs(reply, "{sv}", "AppName", "s", (char*)GetProperty("AppName"));
}
if (status == AJ_OK) {
// printf("DeviceId: %s\n", propDeviceId);
status = AJ_MarshalArgs(reply, "{sv}", "DeviceId", "s", propDeviceId);
}
if (status == AJ_OK) {
// not mandatory
char * DeviceName = (char*)GetProperty("DeviceName");
if (DeviceName){
// printf("DeviceName: %s\n", DeviceName);
status = AJ_MarshalArgs(reply, "{sv}", "DeviceName", "s", DeviceName);
}
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "Manufacturer", "s", (char*)GetProperty("Manufacturer"));
}
if (status == AJ_OK) {
// not mandatory
char * DateOfManufacture = (char*)GetProperty("DateOfManufacture");
if (DateOfManufacture){
status = AJ_MarshalArgs(reply, "{sv}", "DateOfManufacture", "s", DateOfManufacture);
}
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "ModelNumber", "s", (char*)GetProperty("ModelNumber"));
}
if (status == AJ_OK) {
// not mandatory
char * SupportUrl = (char*)GetProperty("SupportUrl");
if (SupportUrl){
status = AJ_MarshalArgs(reply, "{sv}", "SupportUrl", "s", SupportUrl);
}
}
//SupportedLanguages
if (status == AJ_OK) {
AJ_Arg dict;
AJ_Arg languageListArray;
status = AJ_MarshalContainer(reply, &dict, AJ_ARG_DICT_ENTRY);
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "s", "SupportedLanguages");
}
if (status == AJ_OK) {
status = AJ_MarshalVariant(reply, "as");
}
if (status == AJ_OK) {
status = AJ_MarshalContainer(reply, &languageListArray, AJ_ARG_ARRAY);
}
int langIndex = -1;
while(languages[++langIndex]){
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "s", languages[langIndex]);
}
}
if (status == AJ_OK) {
status = AJ_MarshalCloseContainer(reply, &languageListArray);
}
if (status == AJ_OK) {
status = AJ_MarshalCloseContainer(reply, &dict);
}
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "Description", "s", (char*)GetProperty("Description"));
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "DefaultLanguage", "s", languages[0]);
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "SoftwareVersion", "s", AJ_GetVersion());
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "AJSoftwareVersion", "s", AJ_GetVersion());
}
if (status == AJ_OK) {
status = AJ_MarshalCloseContainer(reply, &array);
}
return status;
}
