//----------------------------------------------------------------------------- // // Security.cpp // // Implementation of the Z-Wave COMMAND_CLASS_Security // // Copyright (c) 2011 Mal Lansell // // SOFTWARE NOTICE AND LICENSE // // This file is part of OpenZWave. // // OpenZWave is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published // by the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // OpenZWave is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with OpenZWave. If not, see . // //----------------------------------------------------------------------------- #include #include "command_classes/CommandClasses.h" #include "command_classes/Security.h" #include "Defs.h" #include "Msg.h" #include "Node.h" #include "Driver.h" #include "platform/Log.h" #include "Utils.h" #include "value_classes/ValueBool.h" namespace OpenZWave { namespace Internal { namespace CC { Security::Security(uint32 const _homeId, uint8 const _nodeId) : CommandClass(_homeId, _nodeId), m_schemeagreed(false) { /* We don't want the Driver to route "Security" messages back to us for Encryption, * so disable SecureSupport for the Security Command Class * (This stops this Command Class getting Marked as as IsSecured() if its listed * in the SecurityCmd_SupportedReport from the device - Which some devices do) */ ClearSecureSupport(); for (int i = 0; i < 255; i++) m_secured[i] = false; } Security::~Security() { } bool Security::Init(uint32 const _instance) { Msg* msg = new Msg("SecurityCmd_SupportedGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId()); msg->SetInstance(this, _instance); msg->Append(GetNodeId()); msg->Append(2); msg->Append(GetCommandClassId()); msg->Append(SecurityCmd_SupportedGet); msg->Append(GetDriver()->GetTransmitOptions()); msg->setEncrypted(); GetDriver()->SendMsg(msg, Driver::MsgQueue_Command); return true; } //----------------------------------------------------------------------------- // // Request current state from the device //----------------------------------------------------------------------------- bool Security::ExchangeNetworkKeys() { if (GetNodeUnsafe()->IsAddingNode()) { Msg * msg = new Msg("SecurityCmd_SchemeGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId()); msg->Append(GetNodeId()); msg->Append(3); msg->Append(GetCommandClassId()); msg->Append(SecurityCmd_SchemeGet); msg->Append(0); msg->Append(GetDriver()->GetTransmitOptions()); /* SchemeGet is unencrypted */ GetDriver()->SendMsg(msg, Driver::MsgQueue_Command); return true; } return false; } //----------------------------------------------------------------------------- // // Request current state from the device //----------------------------------------------------------------------------- bool Security::RequestState(uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue) { #if 0 if( _requestFlags & RequestFlag_Static ) { } return false; #endif return true; } //----------------------------------------------------------------------------- // // Request current state from the device //----------------------------------------------------------------------------- bool Security::RequestValue(uint32 const _requestFlags, uint16 const _index, uint8 const _instance, Driver::MsgQueue const _queue) { Log::Write(LogLevel_Info, GetNodeId(), "Got a RequestValue Call"); return true; } bool Security::HandleSupportedReport(uint8 const* _data, uint32 const _length, uint32 const _instance) { #ifdef DEBUG PrintHex("Security Classes", _data, _length); #endif GetNodeUnsafe()->SetSecuredClasses(_data, _length, _instance); return true; } //----------------------------------------------------------------------------- // // Handle a message from the Z-Wave network //----------------------------------------------------------------------------- bool Security::HandleMsg(uint8 const* _data, uint32 const _length, uint32 const _instance // = 1 ) { switch ((SecurityCmd) _data[0]) { case SecurityCmd_SupportedReport: { /* this is a list of CommandClasses that should be Encrypted. * and it might contain new command classes that were not present in the NodeInfoFrame * so we have to run through, mark existing Command Classes as SetSecured (so SendMsg in the Driver * class will route the unecrypted messages to our SendMsg) and for New Command * Classes, create them, and of course, also do a SetSecured on them. * * This means we must do a SecurityCmd_SupportedGet request ASAP so we dont have * Command Classes created after the Discovery Phase is completed! */ Log::Write(LogLevel_Info, GetNodeId(), "Received SecurityCmd_SupportedReport from node %d (instance %d)", GetNodeId(), _instance); m_secured[_instance] = true; if (Internal::VC::ValueBool* value = static_cast(GetValue(_instance, ValueID_Index_Security::Secured))) { value->OnValueRefreshed(m_secured[_instance]); value->Release(); } HandleSupportedReport(&_data[2], _length - 3, _instance); break; } case SecurityCmd_SchemeReport: { Log::Write(LogLevel_Info, GetNodeId(), "Received SecurityCmd_SchemeReport from node %d: %d", GetNodeId(), _data[1]); uint8 schemes = _data[1]; if (m_schemeagreed == true) { Log::Write(LogLevel_Warning, GetNodeId(), " Already Received a SecurityCmd_SchemeReport from the node. Ignoring"); break; } if (schemes == SecurityScheme_Zero) { /* We're good to go. We now should send our NetworkKey to the device if this is the first * time we have seen it */ Log::Write(LogLevel_Info, GetNodeId(), " Security scheme agreed."); /* create the NetworkKey Packet. EncryptMessage will encrypt it for us (And request the NONCE) */ Msg * msg = new Msg("SecurityCmd_NetworkKeySet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId()); msg->Append(GetNodeId()); msg->Append(18); msg->Append(GetCommandClassId()); msg->Append(SecurityCmd_NetworkKeySet); for (int i = 0; i < 16; i++) msg->Append(GetDriver()->GetNetworkKey()[i]); msg->Append(GetDriver()->GetTransmitOptions()); msg->setEncrypted(); GetDriver()->SendMsg(msg, Driver::MsgQueue_Command); m_schemeagreed = true; } else { /* No common security scheme. The device should continue as an unsecured node. * but Some Command Classes might not be present... */ Log::Write(LogLevel_Warning, GetNodeId(), " No common security scheme. The device will continue as an unsecured node."); } break; } case SecurityCmd_NetworkKeySet: { /* we shouldn't get a NetworkKeySet from a node if we are the controller * as we send it out to the Devices */ Log::Write(LogLevel_Info, GetNodeId(), "Received SecurityCmd_NetworkKeySet from node %d", GetNodeId()); break; } case SecurityCmd_NetworkKeyVerify: { /* if we can decrypt this packet, then we are assured that our NetworkKeySet is successfull * and thus should set the Flag referenced in SecurityCmd_SchemeReport */ Log::Write(LogLevel_Info, GetNodeId(), "Received SecurityCmd_NetworkKeyVerify from node %d", GetNodeId()); /* now as for our SupportedGet */ Msg* msg = new Msg("SecurityCmd_SupportedGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId()); msg->Append(GetNodeId()); msg->Append(2); msg->Append(GetCommandClassId()); msg->Append(SecurityCmd_SupportedGet); msg->Append(GetDriver()->GetTransmitOptions()); msg->setEncrypted(); GetDriver()->SendMsg(msg, Driver::MsgQueue_Command); break; } case SecurityCmd_SchemeInherit: { /* only used in a Controller Replication Type enviroment. * */ Log::Write(LogLevel_Info, GetNodeId(), "Received SecurityCmd_SchemeInherit from node %d", GetNodeId()); break; } /* the rest of these should be handled by the Driver Code (in Driver::ProcessMsg) */ case SecurityCmd_NonceGet: case SecurityCmd_NonceReport: case SecurityCmd_MessageEncap: case SecurityCmd_MessageEncapNonceGet: { Log::Write(LogLevel_Warning, GetNodeId(), "Received a Security Message that should have been handled in the Driver"); break; } default: { return false; } } return true; } //----------------------------------------------------------------------------- // // Create the values managed by this command class //----------------------------------------------------------------------------- void Security::CreateVars(uint8 const _instance) { if (Node* node = GetNodeUnsafe()) { node->CreateValueBool(ValueID::ValueGenre_System, GetCommandClassId(), _instance, ValueID_Index_Security::Secured, "Secured", "", true, false, false, 0); if (Internal::VC::ValueBool* value = static_cast(GetValue(_instance, ValueID_Index_Security::Secured))) { value->OnValueRefreshed(m_secured[_instance]); value->Release(); } } } } // namespace CC } // namespace Internal } // namespace OpenZWave