| /* |
| * |
| * Copyright (c) 2013-2017 Nest Labs, Inc. |
| * All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file |
| * This file implements a process to effect a functional test for |
| * the Weave Token Authenticated Key Exchange (TAKE) protocol |
| * engine. |
| * |
| */ |
| |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include "ToolCommon.h" |
| #include <Weave/Support/ErrorStr.h> |
| #include <Weave/Profiles/security/WeaveSecurity.h> |
| #include <Weave/Profiles/security/WeaveTAKE.h> |
| #include <Weave/Support/crypto/AESBlockCipher.h> |
| #include "TAKEOptions.h" |
| |
| #if WEAVE_SYSTEM_CONFIG_USE_LWIP |
| #include "lwip/tcpip.h" |
| #endif // WEAVE_SYSTEM_CONFIG_USE_LWIP |
| |
| using namespace nl::Inet; |
| using namespace nl::Weave::Profiles::Security; |
| using namespace nl::Weave::Profiles::Security::TAKE; |
| |
| #define DEBUG_PRINT_ENABLE 0 |
| #define DEBUG_PRINT_MESSAGE_LENGTH 0 |
| |
| #define Clean() \ |
| do { \ |
| if (encodedMsg) \ |
| PacketBuffer::Free(encodedMsg); \ |
| } while (0) |
| |
| #define VerifyOrFail(TST, MSG) \ |
| do { \ |
| if (!(TST)) \ |
| { \ |
| fprintf(stderr, "%s FAILED: ", __FUNCTION__); \ |
| fputs(MSG, stderr); \ |
| Clean(); \ |
| exit(-1); \ |
| } \ |
| } while (0) |
| |
| #define SuccessOrFail(ERR, MSG) \ |
| do { \ |
| if ((ERR) != WEAVE_NO_ERROR) \ |
| { \ |
| fprintf(stderr, "%s FAILED: ", __FUNCTION__); \ |
| fputs(MSG, stderr); \ |
| fputs(ErrorStr(ERR), stderr); \ |
| fputs("\n", stderr); \ |
| Clean(); \ |
| exit(-1); \ |
| } \ |
| } while (0) |
| |
| class TAKEConfigNoAuthorized : public MockTAKEChallengerDelegate |
| { |
| public: |
| |
| WEAVE_ERROR GetNextIdentificationKey(uint64_t & tokenId, uint8_t *identificationKey, uint16_t & identificationKeyLen) |
| { |
| tokenId = kNodeIdNotSpecified; |
| return WEAVE_NO_ERROR; |
| } |
| }; |
| |
| uint8_t junk0[] = { 0x6a, 0x75, 0x6e, 0x6b, 0x6a, 0x75, 0x6e, 0x6b, 0x6a, 0x75, 0x6e, 0x6b, 0x6a, 0x75, 0x6e, 0x6b }; |
| uint8_t junk1[] = { 0x74, 0x72, 0x61, 0x73, 0x68, 0x74, 0x72, 0x61, 0x73, 0x68, 0x74, 0x72, 0x61, 0x73, 0x68, 0x74 }; |
| uint8_t junk2[] = { 0x74, 0x68, 0x69, 0x73, 0x69, 0x73, 0x61, 0x70, 0x69, 0x6c, 0x65, 0x6f, 0x73, 0x68, 0x69, 0x74 }; |
| |
| class TAKEConfigJunkAuthorized : public MockTAKEChallengerDelegate |
| { |
| int position; |
| public: |
| |
| TAKEConfigJunkAuthorized() : position(0) { } |
| |
| WEAVE_ERROR RewindIdentificationKeyIterator() |
| { |
| position = 0; |
| return WEAVE_NO_ERROR; |
| } |
| |
| // Get next {tokenId, IK} pair. |
| // returns tokenId = kNodeIdNotSpecified if no more IKs are available. |
| WEAVE_ERROR GetNextIdentificationKey(uint64_t & tokenId, uint8_t *identificationKey, uint16_t & identificationKeyLen) |
| { |
| if (identificationKeyLen < kIdentificationKeySize) |
| return WEAVE_ERROR_BUFFER_TOO_SMALL; |
| identificationKeyLen = kIdentificationKeySize; |
| |
| switch (position) |
| { |
| case 0: |
| memcpy(identificationKey, junk0, identificationKeyLen); |
| break; |
| case 1: |
| memcpy(identificationKey, junk1, identificationKeyLen); |
| break; |
| case 2: |
| memcpy(identificationKey, junk2, identificationKeyLen); |
| break; |
| default: |
| tokenId = kNodeIdNotSpecified; |
| break; |
| } |
| position++; |
| return WEAVE_NO_ERROR; |
| } |
| }; |
| |
| |
| // This IK correspond to an IK generated with takeTime = 17167, (number of days til 01/01/2017) which is the value used by the test Token auth delegate |
| uint8_t IK_timeLimited[] = { 0x0F, 0x8E, 0x23, 0x34, 0xA4, 0xA1, 0xF7, 0x60, 0x29, 0x42, 0xB3, 0x4C, 0xA5, 0x28, 0xC5, 0xA9 }; |
| |
| class TAKEConfigTimeLimitedIK : public MockTAKEChallengerDelegate |
| { |
| public: |
| |
| // Get next {tokenId, IK} pair. |
| // returns tokenId = kNodeIdNotSpecified if no more IKs are available. |
| WEAVE_ERROR GetNextIdentificationKey(uint64_t & tokenId, uint8_t *identificationKey, uint16_t & identificationKeyLen) |
| { |
| if (Rewinded) |
| { |
| if (identificationKeyLen < kIdentificationKeySize) |
| return WEAVE_ERROR_BUFFER_TOO_SMALL; |
| tokenId = 1; |
| identificationKeyLen = kIdentificationKeySize; |
| memcpy(identificationKey, IK_timeLimited, identificationKeyLen); |
| Rewinded = false; |
| } |
| else |
| { |
| tokenId = nl::Weave::kNodeIdNotSpecified; |
| } |
| return WEAVE_NO_ERROR; |
| } |
| }; |
| |
| uint8_t IK_ChallengerIdIsNodeId[] = { 0xAE, 0x2D, 0xD8, 0x16, 0x4B, 0xAE, 0x1A, 0x77, 0xB8, 0xCF, 0x52, 0x0D, 0x20, 0x21, 0xE2, 0x45 }; |
| class TAKEConfigChallengerIdIsNodeId : public MockTAKEChallengerDelegate |
| { |
| public: |
| |
| // Get next {tokenId, IK} pair. |
| // returns tokenId = kNodeIdNotSpecified if no more IKs are available. |
| WEAVE_ERROR GetNextIdentificationKey(uint64_t & tokenId, uint8_t *identificationKey, uint16_t & identificationKeyLen) |
| { |
| if (Rewinded) |
| { |
| if (identificationKeyLen < kIdentificationKeySize) |
| return WEAVE_ERROR_BUFFER_TOO_SMALL; |
| tokenId = 1; |
| identificationKeyLen = kIdentificationKeySize; |
| memcpy(identificationKey, IK_ChallengerIdIsNodeId, identificationKeyLen); |
| Rewinded = false; |
| } |
| else |
| { |
| tokenId = nl::Weave::kNodeIdNotSpecified; |
| } |
| return WEAVE_NO_ERROR; |
| } |
| }; |
| |
| |
| uint8_t MasterKey[] = { 0x11, 0xFF, 0xF1, 0x1F, 0xD1, 0x3F, 0xB1, 0x5F, 0x91, 0x7F, 0x71, 0x9F, 0x51, 0xBF, 0x31, 0xDF, 0x11, 0xFF, 0xF1, 0x1F, 0xD1, 0x3F, 0xB1, 0x5F, 0x91, 0x7F, 0x71, 0x9F, 0x51, 0xBF, 0x31, 0xDF }; |
| |
| void TestTAKEEngine(WeaveTAKEChallengerAuthDelegate& ChallengerAuthDelegate, bool authorized = true, uint8_t config = kTAKEConfig_Config1, bool encryptAuthPhase = false, bool encryptCommPhase = true, bool timeLimitedIK = false, bool canDoReauth = false, bool sendChallengerId = true) |
| { |
| WEAVE_ERROR err; |
| WeaveTAKEEngine initEng; |
| WeaveTAKEEngine respEng; |
| uint16_t sessionKeyIdInitiator = sTestDefaultSessionKeyId; |
| MockTAKETokenDelegate takeTokenAuthDelegate; |
| uint64_t challengerNodeId = 1337; |
| |
| PacketBuffer *encodedMsg = NULL; |
| const WeaveEncryptionKey *initSessionKey; |
| const WeaveEncryptionKey *respSessionKey; |
| |
| // Init TAKE Engines |
| initEng.Init(); |
| respEng.Init(); |
| |
| initEng.ChallengerAuthDelegate = &ChallengerAuthDelegate; |
| respEng.TokenAuthDelegate = &takeTokenAuthDelegate; |
| |
| // Initiator generates and sends Identify Token message. |
| { |
| encodedMsg = PacketBuffer::New(); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateIdentifyTokenMessage (Started):\n"); |
| #endif |
| err = initEng.GenerateIdentifyTokenMessage(sessionKeyIdInitiator, config, encryptAuthPhase, encryptCommPhase, timeLimitedIK, sendChallengerId, kWeaveEncryptionType_AES128CTRSHA1, challengerNodeId, encodedMsg); |
| if (config != kTAKEConfig_Config1) |
| { |
| VerifyOrFail(err == WEAVE_ERROR_UNSUPPORTED_TAKE_CONFIGURATION, "GenerateIdentifyTokenMessage: should have returned an error"); |
| Clean(); |
| return; |
| } |
| SuccessOrFail(err, "WeaveTAKEEngine::GenerateIdentifyTokenMessage failed\n"); |
| |
| #if DEBUG_PRINT_MESSAGE_LENGTH |
| fprintf(stdout, "GenerateIdentifyTokenMessage: Message Size = %d \n", encodedMsg->DataLength()); |
| #endif |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateIdentifyTokenMessage (Finished):\n"); |
| #endif |
| } |
| |
| // Responder receives and processes Identify Token message. |
| { |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessIdentifyTokenMessage (Started):\n"); |
| #endif |
| |
| err = respEng.ProcessIdentifyTokenMessage(challengerNodeId, encodedMsg); // peerNodeId parameter is not used |
| if (err == WEAVE_ERROR_TAKE_RECONFIGURE_REQUIRED) |
| { |
| VerifyOrFail(config != kTAKEConfig_Config1, "WeaveTAKEEngine::ProcessIdentifyTokenMessage asks for unescessary reconfigure"); |
| Clean(); |
| return; |
| } |
| else |
| { |
| VerifyOrFail(config == kTAKEConfig_Config1, "WeaveTAKEEngine::ProcessIdentifyTokenMessage do not asks for reconfigure"); |
| SuccessOrFail(err, "WeaveTAKEEngine::ProcessIdentifyTokenMessage failed\n"); |
| } |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessIdentifyTokenMessage (Finished):\n"); |
| #endif |
| PacketBuffer::Free(encodedMsg); |
| encodedMsg = NULL; |
| } |
| |
| // Responder generates and sends Identify Token Response message. |
| { |
| encodedMsg = PacketBuffer::New(); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateIdentifyTokenResponseMessage (Started):\n"); |
| #endif |
| err = respEng.GenerateIdentifyTokenResponseMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::GenerateIdentifyTokenResponseMessage failed\n"); |
| |
| #if DEBUG_PRINT_MESSAGE_LENGTH |
| fprintf(stdout, "GenerateIdentifyTokenResponseMessage: Message Size = %d \n", encodedMsg->DataLength()); |
| #endif |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateIdentifyTokenResponseMessage (Finished):\n"); |
| #endif |
| } |
| |
| // Initiator receives and processes Identify token Response message. |
| { |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessIdentifyTokenResponseMessage (Started):\n"); |
| #endif |
| |
| err = initEng.ProcessIdentifyTokenResponseMessage(encodedMsg); |
| if (!authorized) |
| { |
| VerifyOrFail(err == WEAVE_ERROR_TAKE_TOKEN_IDENTIFICATION_FAILED, "Initiator accepted key, but shouldn't have done so\n"); |
| Clean(); |
| return; |
| } |
| if (canDoReauth) |
| { |
| VerifyOrFail(err == WEAVE_ERROR_TAKE_REAUTH_POSSIBLE, "Initiator should have initiated a Reauth\n"); |
| } |
| else |
| { |
| SuccessOrFail(err, "WeaveTAKEEngine::ProcessIdentifyTokenResponseMessage failed\n"); |
| } |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessIdentifyTokenResponseMessage (Finished):\n"); |
| #endif |
| PacketBuffer::Free(encodedMsg); |
| encodedMsg = NULL; |
| } |
| |
| VerifyOrFail(initEng.SessionKeyId == respEng.SessionKeyId, "Initiator SessionKeyId != Responder SessionKeyId\n"); |
| VerifyOrFail(initEng.ControlHeader == respEng.ControlHeader, "Initiator controlHeader != Responder controlHeader\n"); |
| VerifyOrFail(initEng.EncryptionType == respEng.EncryptionType, "Initiator encryptionType != Responder encryptionType\n"); |
| VerifyOrFail(initEng.ProtocolConfig == respEng.ProtocolConfig, "Initiator protocolConfig != Responder protocolConfig\n"); |
| VerifyOrFail(initEng.GetNumOptionalConfigurations() == respEng.GetNumOptionalConfigurations(), "Initiator numOptionalConfigurations != Responder numOptionalConfigurations\n"); |
| VerifyOrFail(initEng.ProtocolConfig == respEng.ProtocolConfig, "Initiator protocolConfig != Responder protocolConfig\n"); |
| VerifyOrFail(memcmp(initEng.OptionalConfigurations, respEng.OptionalConfigurations, respEng.GetNumOptionalConfigurations()*sizeof(uint8_t)) == 0, "Initiator optionalConfigurations != Responder optionalConfigurations\n"); |
| |
| VerifyOrFail(initEng.IsEncryptAuthPhase() == respEng.IsEncryptAuthPhase(), "Initiator EAP != Responder EAP\n"); |
| VerifyOrFail(initEng.IsEncryptCommPhase() == respEng.IsEncryptCommPhase(), "Initiator ECP != Responder ECP\n"); |
| VerifyOrFail(initEng.IsTimeLimitedIK() == respEng.IsTimeLimitedIK(), "Initiator TL != Responder TL\n"); |
| |
| VerifyOrFail(initEng.ChallengerIdLen == respEng.ChallengerIdLen, "Initiator ChallengerIdLen != Responder ChallengerIdLen\n"); |
| VerifyOrFail(memcmp(initEng.ChallengerId, respEng.ChallengerId, initEng.ChallengerIdLen) == 0, "Initiator ChallengerId != Responder ChallengerId\n"); |
| VerifyOrFail(memcmp(initEng.ChallengerNonce, respEng.ChallengerNonce, kNonceSize) == 0, "Initiator ChallengerNonce != Responder ChallengerNonce\n"); |
| VerifyOrFail(memcmp(initEng.TokenNonce, respEng.TokenNonce, kNonceSize) == 0, "Initiator TokenNonce != Responder TokenNonce\n"); |
| |
| if (encryptAuthPhase) |
| { |
| err = initEng.GetSessionKey(initSessionKey); |
| SuccessOrFail(err, "WeaveTAKEEngine::GetSessionKey() failed\n"); |
| |
| err = respEng.GetSessionKey(respSessionKey); |
| SuccessOrFail(err, "WeaveTAKEEngine::GetSessionKey() failed\n"); |
| |
| VerifyOrFail(memcmp(initSessionKey->AES128CTRSHA1.DataKey, respSessionKey->AES128CTRSHA1.DataKey, WeaveEncryptionKey_AES128CTRSHA1::DataKeySize) == 0, |
| "Data key mismatch\n"); |
| |
| VerifyOrFail(memcmp(initSessionKey->AES128CTRSHA1.IntegrityKey, respSessionKey->AES128CTRSHA1.IntegrityKey, WeaveEncryptionKey_AES128CTRSHA1::IntegrityKeySize) == 0, |
| "Integrity key mismatch\n"); |
| } |
| |
| if (canDoReauth) |
| { |
| // Initiator generates and sends ReAuthenticate Token message. |
| { |
| encodedMsg = PacketBuffer::New(); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateReAuthenticateTokenMessage (Started):\n"); |
| #endif |
| err = initEng.GenerateReAuthenticateTokenMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::GenerateReAuthenticateTokenMessage failed\n"); |
| |
| #if DEBUG_PRINT_MESSAGE_LENGTH |
| fprintf(stdout, "GenerateReAuthenticateTokenMessage: Message Size = %d \n", encodedMsg->DataLength()); |
| #endif |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateReAuthenticateTokenMessage (Finished):\n"); |
| #endif |
| } |
| |
| // Responder receives and processes REAuthenticate Token message. |
| { |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessReAuthenticateTokenMessage (Started):\n"); |
| #endif |
| |
| err = respEng.ProcessReAuthenticateTokenMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::ProcessReAuthenticateTokenMessage failed\n"); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessReAuthenticateTokenMessage (Finished):\n"); |
| #endif |
| PacketBuffer::Free(encodedMsg); |
| encodedMsg = NULL; |
| } |
| |
| // Responder generates and sends ReAuthenticate Token Response message. |
| { |
| encodedMsg = PacketBuffer::New(); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateReAuthenticateTokenResponseMessage (Started):\n"); |
| #endif |
| err = respEng.GenerateReAuthenticateTokenResponseMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::GenerateReAuthenticateTokenResponseMessage failed\n"); |
| |
| #if DEBUG_PRINT_MESSAGE_LENGTH |
| fprintf(stdout, "GenerateReAuthenticateTokenResponseMessage: Message Size = %d \n", encodedMsg->DataLength()); |
| #endif |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateReAuthenticateTokenResponseMessage (Finished):\n"); |
| #endif |
| } |
| |
| // Initiator receives and processes ReAuthenticate Token Response message. |
| { |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessReAuthenticateTokenResponseMessage (Started):\n"); |
| #endif |
| |
| err = initEng.ProcessReAuthenticateTokenResponseMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::ProcessReAuthenticateTokenResponseMessage failed\n"); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessReAuthenticateTokenResponseMessage (Finished):\n"); |
| #endif |
| PacketBuffer::Free(encodedMsg); |
| encodedMsg = NULL; |
| } |
| |
| } |
| else |
| { |
| // Initiator generates and sends Authenticate Token message. |
| { |
| encodedMsg = PacketBuffer::New(); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateAuthenticateTokenMessage (Started):\n"); |
| #endif |
| err = initEng.GenerateAuthenticateTokenMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::GenerateAuthenticateTokenMessage failed\n"); |
| |
| #if DEBUG_PRINT_MESSAGE_LENGTH |
| fprintf(stdout, "GenerateAuthenticateTokenMessage: Message Size = %d \n", encodedMsg->DataLength()); |
| #endif |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateAuthenticateTokenMessage (Finished):\n"); |
| #endif |
| } |
| |
| // Responder receives and processes Authenticate Token message. |
| { |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessAuthenticateTokenMessage (Started):\n"); |
| #endif |
| |
| err = respEng.ProcessAuthenticateTokenMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::ProcessAuthenticateTokenMessage failed\n"); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessAuthenticateTokenMessage (Finished):\n"); |
| #endif |
| PacketBuffer::Free(encodedMsg); |
| encodedMsg = NULL; |
| } |
| |
| // Responder generates and sends Authenticate Token Response message. |
| { |
| encodedMsg = PacketBuffer::New(); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateAuthenticateTokenResponseMessage (Started):\n"); |
| #endif |
| err = respEng.GenerateAuthenticateTokenResponseMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::GenerateAuthenticateTokenResponseMessage failed\n"); |
| |
| #if DEBUG_PRINT_MESSAGE_LENGTH |
| fprintf(stdout, "GenerateAuthenticateTokenResponseMessage: Message Size = %d \n", encodedMsg->DataLength()); |
| #endif |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "GenerateAuthenticateTokenResponseMessage (Finished):\n"); |
| #endif |
| } |
| |
| // Initiator receives and processes Authenticate Token Response message. |
| { |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessAuthenticateTokenResponseMessage (Started):\n"); |
| #endif |
| |
| err = initEng.ProcessAuthenticateTokenResponseMessage(encodedMsg); |
| SuccessOrFail(err, "WeaveTAKEEngine::ProcessAuthenticateTokenResponseMessage failed\n"); |
| |
| #if DEBUG_PRINT_ENABLE |
| fprintf(stdout, "ProcessAuthenticateTokenResponseMessage (Finished):\n"); |
| #endif |
| PacketBuffer::Free(encodedMsg); |
| encodedMsg = NULL; |
| } |
| } |
| |
| if (encryptCommPhase) |
| { |
| err = initEng.GetSessionKey(initSessionKey); |
| SuccessOrFail(err, "WeaveTAKEEngine::GetSessionKey() failed\n"); |
| |
| err = respEng.GetSessionKey(respSessionKey); |
| SuccessOrFail(err, "WeaveTAKEEngine::GetSessionKey() failed\n"); |
| |
| VerifyOrFail(memcmp(initSessionKey->AES128CTRSHA1.DataKey, respSessionKey->AES128CTRSHA1.DataKey, WeaveEncryptionKey_AES128CTRSHA1::DataKeySize) == 0, |
| "Data key mismatch\n"); |
| |
| VerifyOrFail(memcmp(initSessionKey->AES128CTRSHA1.IntegrityKey, respSessionKey->AES128CTRSHA1.IntegrityKey, WeaveEncryptionKey_AES128CTRSHA1::IntegrityKeySize) == 0, |
| "Integrity key mismatch\n"); |
| } |
| } |
| |
| void test1(bool EAP, bool ECP) |
| { |
| // Standard test, Authenticate |
| MockTAKEChallengerDelegate config; |
| TestTAKEEngine(config, true, kTAKEConfig_Config1, EAP, ECP); |
| } |
| |
| void test2(bool EAP, bool ECP) |
| { |
| // No authorised Tokens |
| TAKEConfigNoAuthorized config; |
| TestTAKEEngine(config, false, kTAKEConfig_Config1, EAP, ECP); |
| } |
| void test3(bool EAP, bool ECP) |
| { |
| // 3 authorised tokens, none of them are the correct one |
| TAKEConfigJunkAuthorized config; |
| TestTAKEEngine(config, false, kTAKEConfig_Config1, EAP, ECP); |
| } |
| void test4(bool EAP, bool ECP) |
| { |
| // Tries to use an invalid config |
| MockTAKEChallengerDelegate config; |
| TestTAKEEngine(config, true, 27, EAP, ECP); |
| } |
| void test5(bool EAP, bool ECP) |
| { |
| // TL is true, invalid argument |
| TAKEConfigTimeLimitedIK config; |
| TestTAKEEngine(config, true, kTAKEConfig_Config1, EAP, ECP, true); // TL is true => error |
| } |
| |
| void test6(bool EAP, bool ECP) |
| { |
| uint8_t AK[] = { 0x9F, 0x0F, 0x92, 0xE3, 0xB9, 0x04, 0x96, 0xA1, 0xCB, 0x7C, 0x94, 0x99, 0xAB, 0x34, 0xDD, 0x04 }; |
| uint8_t ENC_AK[] = { 0xE6, 0xC4, 0x03, 0xE8, 0xEE, 0xA3, 0x80, 0x56, 0xE0, 0xB1, 0x9C, 0xE9, 0xE3, 0xA6, 0xD8, 0x3A }; |
| |
| MockTAKEChallengerDelegate config; |
| uint16_t authKeyLen = TAKE::kAuthenticationKeySize; |
| uint16_t encryptedAuthKeyLen = kTokenEncryptedStateSize; |
| WEAVE_ERROR err = config.StoreTokenAuthData(1, kTAKEConfig_Config1, AK, authKeyLen, ENC_AK, encryptedAuthKeyLen); |
| if (err != WEAVE_NO_ERROR) |
| { |
| fprintf(stderr, "%s FAILED: ", __FUNCTION__); |
| fputs("TAKEConfig::UpdateAuthenticationKeys", stderr); |
| fputs(ErrorStr(err), stderr); |
| fputs("\n", stderr); |
| exit(-1); |
| } |
| TestTAKEEngine(config, true, kTAKEConfig_Config1, EAP, ECP, false, true); |
| } |
| |
| void test7(bool EAP, bool ECP) |
| { |
| // Standard test, Authenticate |
| TAKEConfigChallengerIdIsNodeId config; |
| TestTAKEEngine(config, true, kTAKEConfig_Config1, EAP, ECP, false, false, false); |
| } |
| |
| // Parameters are EAP and ECP |
| typedef void(*testFunction)(bool, bool); |
| |
| int main(int argc, char *argv[]) |
| { |
| WEAVE_ERROR err; |
| int i; |
| time_t sec_now; |
| time_t sec_last; |
| |
| #if WEAVE_SYSTEM_CONFIG_USE_LWIP |
| tcpip_init(NULL, NULL); |
| #endif // WEAVE_SYSTEM_CONFIG_USE_LWIP |
| |
| err = nl::Weave::Platform::Security::InitSecureRandomDataSource(NULL, 64, NULL, 0); |
| FAIL_ERROR(err, "InitSecureRandomDataSource() failed"); |
| |
| #define NUMBER_OF_ITERATIONS 1 |
| #define NUMBER_OF_TESTS 7 |
| #define NUMBER_OF_CONFIGS 4 |
| |
| testFunction tests[NUMBER_OF_TESTS] = { test1, test2, test3, test4, test5, test6, test7 }; |
| bool configs[NUMBER_OF_CONFIGS][2] = { { false, false }, { true, false }, { false, true }, { true, true } }; |
| |
| for (int test = 0; test < NUMBER_OF_TESTS; test++) |
| { |
| for (int conf = 0; conf < NUMBER_OF_CONFIGS; conf++) |
| { |
| bool EAP = configs[conf][0]; |
| bool ECP = configs[conf][1]; |
| printf("\nTEST%d, EAP = %s, ECP = %s (%d iterations)\n", test+1, EAP ? "true" : "false", ECP ? "true" : "false", NUMBER_OF_ITERATIONS); |
| sec_last = time(NULL); |
| for (i=0; i < NUMBER_OF_ITERATIONS; i++) |
| { |
| tests[test](EAP, ECP); |
| } |
| sec_now = time(NULL); |
| printf("TIME DELTA (sec) = %ld sec\n", (sec_now - sec_last)); |
| } |
| } |
| |
| printf("All tests succeeded\n"); |
| } |
