1 /*
2 * Copyright (c) 2016, The OpenThread Authors.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. Neither the name of the copyright holder nor the
13 * names of its contributors may be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /**
30 * @file
31 * This file implements the Joiner Router role.
32 */
33
34 #include "joiner_router.hpp"
35
36 #if OPENTHREAD_FTD
37
38 #include <stdio.h>
39
40 #include "common/as_core_type.hpp"
41 #include "common/code_utils.hpp"
42 #include "common/encoding.hpp"
43 #include "common/instance.hpp"
44 #include "common/locator_getters.hpp"
45 #include "common/log.hpp"
46 #include "meshcop/meshcop.hpp"
47 #include "meshcop/meshcop_tlvs.hpp"
48 #include "thread/mle.hpp"
49 #include "thread/thread_netif.hpp"
50 #include "thread/uri_paths.hpp"
51
52 namespace ot {
53 namespace MeshCoP {
54
55 RegisterLogModule("JoinerRouter");
56
JoinerRouter(Instance & aInstance)57 JoinerRouter::JoinerRouter(Instance &aInstance)
58 : InstanceLocator(aInstance)
59 , mSocket(aInstance)
60 , mRelayTransmit(UriPath::kRelayTx, &JoinerRouter::HandleRelayTransmit, this)
61 , mTimer(aInstance, JoinerRouter::HandleTimer)
62 , mJoinerUdpPort(0)
63 , mIsJoinerPortConfigured(false)
64 {
65 Get<Tmf::Agent>().AddResource(mRelayTransmit);
66 }
67
HandleNotifierEvents(Events aEvents)68 void JoinerRouter::HandleNotifierEvents(Events aEvents)
69 {
70 if (aEvents.Contains(kEventThreadNetdataChanged))
71 {
72 Start();
73 }
74 }
75
Start(void)76 void JoinerRouter::Start(void)
77 {
78 VerifyOrExit(Get<Mle::MleRouter>().IsFullThreadDevice());
79
80 if (Get<NetworkData::Leader>().IsJoiningEnabled())
81 {
82 uint16_t port = GetJoinerUdpPort();
83
84 VerifyOrExit(!mSocket.IsBound());
85
86 IgnoreError(mSocket.Open(&JoinerRouter::HandleUdpReceive, this));
87 IgnoreError(mSocket.Bind(port));
88 IgnoreError(Get<Ip6::Filter>().AddUnsecurePort(port));
89 LogInfo("Joiner Router: start");
90 }
91 else
92 {
93 VerifyOrExit(mSocket.IsBound());
94
95 IgnoreError(Get<Ip6::Filter>().RemoveUnsecurePort(mSocket.GetSockName().mPort));
96
97 IgnoreError(mSocket.Close());
98 }
99
100 exit:
101 return;
102 }
103
GetJoinerUdpPort(void)104 uint16_t JoinerRouter::GetJoinerUdpPort(void)
105 {
106 uint16_t rval = OPENTHREAD_CONFIG_JOINER_UDP_PORT;
107 const JoinerUdpPortTlv *joinerUdpPort;
108
109 VerifyOrExit(!mIsJoinerPortConfigured, rval = mJoinerUdpPort);
110
111 joinerUdpPort = As<JoinerUdpPortTlv>(Get<NetworkData::Leader>().GetCommissioningDataSubTlv(Tlv::kJoinerUdpPort));
112 VerifyOrExit(joinerUdpPort != nullptr);
113
114 rval = joinerUdpPort->GetUdpPort();
115
116 exit:
117 return rval;
118 }
119
SetJoinerUdpPort(uint16_t aJoinerUdpPort)120 void JoinerRouter::SetJoinerUdpPort(uint16_t aJoinerUdpPort)
121 {
122 mJoinerUdpPort = aJoinerUdpPort;
123 mIsJoinerPortConfigured = true;
124 Start();
125 }
126
HandleUdpReceive(void * aContext,otMessage * aMessage,const otMessageInfo * aMessageInfo)127 void JoinerRouter::HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
128 {
129 static_cast<JoinerRouter *>(aContext)->HandleUdpReceive(AsCoreType(aMessage), AsCoreType(aMessageInfo));
130 }
131
HandleUdpReceive(Message & aMessage,const Ip6::MessageInfo & aMessageInfo)132 void JoinerRouter::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
133 {
134 Error error;
135 Coap::Message * message = nullptr;
136 Tmf::MessageInfo messageInfo(GetInstance());
137 ExtendedTlv tlv;
138 uint16_t borderAgentRloc;
139 uint16_t offset;
140
141 LogInfo("JoinerRouter::HandleUdpReceive");
142
143 SuccessOrExit(error = GetBorderAgentRloc(Get<ThreadNetif>(), borderAgentRloc));
144
145 message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(UriPath::kRelayRx);
146 VerifyOrExit(message != nullptr, error = kErrorNoBufs);
147
148 SuccessOrExit(error = Tlv::Append<JoinerUdpPortTlv>(*message, aMessageInfo.GetPeerPort()));
149 SuccessOrExit(error = Tlv::Append<JoinerIidTlv>(*message, aMessageInfo.GetPeerAddr().GetIid()));
150 SuccessOrExit(error = Tlv::Append<JoinerRouterLocatorTlv>(*message, Get<Mle::MleRouter>().GetRloc16()));
151
152 tlv.SetType(Tlv::kJoinerDtlsEncapsulation);
153 tlv.SetLength(aMessage.GetLength() - aMessage.GetOffset());
154 SuccessOrExit(error = message->Append(tlv));
155 offset = message->GetLength();
156 SuccessOrExit(error = message->SetLength(offset + tlv.GetLength()));
157 aMessage.CopyTo(aMessage.GetOffset(), offset, tlv.GetLength(), *message);
158
159 messageInfo.SetSockAddrToRlocPeerAddrTo(borderAgentRloc);
160
161 SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, messageInfo));
162
163 LogInfo("Sent relay rx");
164
165 exit:
166 FreeMessageOnError(message, error);
167 }
168
HandleRelayTransmit(void * aContext,otMessage * aMessage,const otMessageInfo * aMessageInfo)169 void JoinerRouter::HandleRelayTransmit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
170 {
171 static_cast<JoinerRouter *>(aContext)->HandleRelayTransmit(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
172 }
173
HandleRelayTransmit(Coap::Message & aMessage,const Ip6::MessageInfo & aMessageInfo)174 void JoinerRouter::HandleRelayTransmit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
175 {
176 OT_UNUSED_VARIABLE(aMessageInfo);
177
178 Error error;
179 uint16_t joinerPort;
180 Ip6::InterfaceIdentifier joinerIid;
181 Kek kek;
182 uint16_t offset;
183 uint16_t length;
184 Message * message = nullptr;
185 Message::Settings settings(Message::kNoLinkSecurity, Message::kPriorityNet);
186 Ip6::MessageInfo messageInfo;
187
188 VerifyOrExit(aMessage.IsNonConfirmablePostRequest(), error = kErrorDrop);
189
190 LogInfo("Received relay transmit");
191
192 SuccessOrExit(error = Tlv::Find<JoinerUdpPortTlv>(aMessage, joinerPort));
193 SuccessOrExit(error = Tlv::Find<JoinerIidTlv>(aMessage, joinerIid));
194
195 SuccessOrExit(error = Tlv::FindTlvValueOffset(aMessage, Tlv::kJoinerDtlsEncapsulation, offset, length));
196
197 VerifyOrExit((message = mSocket.NewMessage(0, settings)) != nullptr, error = kErrorNoBufs);
198
199 SuccessOrExit(error = message->SetLength(length));
200 aMessage.CopyTo(offset, 0, length, *message);
201
202 messageInfo.GetPeerAddr().SetToLinkLocalAddress(joinerIid);
203 messageInfo.SetPeerPort(joinerPort);
204
205 SuccessOrExit(error = mSocket.SendTo(*message, messageInfo));
206
207 if (Tlv::Find<JoinerRouterKekTlv>(aMessage, kek) == kErrorNone)
208 {
209 LogInfo("Received kek");
210
211 DelaySendingJoinerEntrust(messageInfo, kek);
212 }
213
214 exit:
215 FreeMessageOnError(message, error);
216 }
217
DelaySendingJoinerEntrust(const Ip6::MessageInfo & aMessageInfo,const Kek & aKek)218 void JoinerRouter::DelaySendingJoinerEntrust(const Ip6::MessageInfo &aMessageInfo, const Kek &aKek)
219 {
220 Error error = kErrorNone;
221 Message * message = Get<MessagePool>().Allocate(Message::kTypeOther);
222 JoinerEntrustMetadata metadata;
223
224 VerifyOrExit(message != nullptr, error = kErrorNoBufs);
225
226 metadata.mMessageInfo = aMessageInfo;
227 metadata.mMessageInfo.SetPeerPort(Tmf::kUdpPort);
228 metadata.mSendTime = TimerMilli::GetNow() + kJoinerEntrustTxDelay;
229 metadata.mKek = aKek;
230
231 SuccessOrExit(error = metadata.AppendTo(*message));
232
233 mDelayedJoinEnts.Enqueue(*message);
234
235 if (!mTimer.IsRunning())
236 {
237 mTimer.FireAt(metadata.mSendTime);
238 }
239
240 exit:
241 FreeMessageOnError(message, error);
242 LogError("schedule joiner entrust", error);
243 }
244
HandleTimer(Timer & aTimer)245 void JoinerRouter::HandleTimer(Timer &aTimer)
246 {
247 aTimer.Get<JoinerRouter>().HandleTimer();
248 }
249
HandleTimer(void)250 void JoinerRouter::HandleTimer(void)
251 {
252 SendDelayedJoinerEntrust();
253 }
254
SendDelayedJoinerEntrust(void)255 void JoinerRouter::SendDelayedJoinerEntrust(void)
256 {
257 JoinerEntrustMetadata metadata;
258 Message * message = mDelayedJoinEnts.GetHead();
259
260 VerifyOrExit(message != nullptr);
261 VerifyOrExit(!mTimer.IsRunning());
262
263 metadata.ReadFrom(*message);
264
265 if (TimerMilli::GetNow() < metadata.mSendTime)
266 {
267 mTimer.FireAt(metadata.mSendTime);
268 }
269 else
270 {
271 mDelayedJoinEnts.DequeueAndFree(*message);
272
273 Get<KeyManager>().SetKek(metadata.mKek);
274
275 if (SendJoinerEntrust(metadata.mMessageInfo) != kErrorNone)
276 {
277 mTimer.Start(0);
278 }
279 }
280
281 exit:
282 return;
283 }
284
SendJoinerEntrust(const Ip6::MessageInfo & aMessageInfo)285 Error JoinerRouter::SendJoinerEntrust(const Ip6::MessageInfo &aMessageInfo)
286 {
287 Error error = kErrorNone;
288 Coap::Message *message;
289
290 message = PrepareJoinerEntrustMessage();
291 VerifyOrExit(message != nullptr, error = kErrorNoBufs);
292
293 IgnoreError(Get<Tmf::Agent>().AbortTransaction(&JoinerRouter::HandleJoinerEntrustResponse, this));
294
295 LogInfo("Sending JOIN_ENT.ntf");
296 SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMessageInfo,
297 &JoinerRouter::HandleJoinerEntrustResponse, this));
298
299 LogInfo("Sent joiner entrust length = %d", message->GetLength());
300 LogCert("[THCI] direction=send | type=JOIN_ENT.ntf");
301
302 exit:
303 FreeMessageOnError(message, error);
304 return error;
305 }
306
PrepareJoinerEntrustMessage(void)307 Coap::Message *JoinerRouter::PrepareJoinerEntrustMessage(void)
308 {
309 Error error;
310 Coap::Message *message = nullptr;
311 Dataset dataset;
312 NetworkNameTlv networkName;
313 const Tlv * tlv;
314 NetworkKey networkKey;
315
316 message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kJoinerEntrust);
317 VerifyOrExit(message != nullptr, error = kErrorNoBufs);
318
319 message->SetSubType(Message::kSubTypeJoinerEntrust);
320
321 Get<KeyManager>().GetNetworkKey(networkKey);
322 SuccessOrExit(error = Tlv::Append<NetworkKeyTlv>(*message, networkKey));
323 SuccessOrExit(error = Tlv::Append<MeshLocalPrefixTlv>(*message, Get<Mle::MleRouter>().GetMeshLocalPrefix()));
324 SuccessOrExit(error = Tlv::Append<ExtendedPanIdTlv>(*message, Get<ExtendedPanIdManager>().GetExtPanId()));
325
326 networkName.Init();
327 networkName.SetNetworkName(Get<NetworkNameManager>().GetNetworkName().GetAsData());
328 SuccessOrExit(error = networkName.AppendTo(*message));
329
330 IgnoreError(Get<ActiveDatasetManager>().Read(dataset));
331
332 if ((tlv = dataset.GetTlv<ActiveTimestampTlv>()) != nullptr)
333 {
334 SuccessOrExit(error = tlv->AppendTo(*message));
335 }
336 else
337 {
338 ActiveTimestampTlv activeTimestamp;
339 activeTimestamp.Init();
340 SuccessOrExit(error = activeTimestamp.AppendTo(*message));
341 }
342
343 if ((tlv = dataset.GetTlv<ChannelMaskTlv>()) != nullptr)
344 {
345 SuccessOrExit(error = tlv->AppendTo(*message));
346 }
347 else
348 {
349 ChannelMaskBaseTlv channelMask;
350 channelMask.Init();
351 SuccessOrExit(error = channelMask.AppendTo(*message));
352 }
353
354 if ((tlv = dataset.GetTlv<PskcTlv>()) != nullptr)
355 {
356 SuccessOrExit(error = tlv->AppendTo(*message));
357 }
358 else
359 {
360 PskcTlv pskc;
361 pskc.Init();
362 SuccessOrExit(error = pskc.AppendTo(*message));
363 }
364
365 if ((tlv = dataset.GetTlv<SecurityPolicyTlv>()) != nullptr)
366 {
367 SuccessOrExit(error = tlv->AppendTo(*message));
368 }
369 else
370 {
371 SecurityPolicyTlv securityPolicy;
372 securityPolicy.Init();
373 SuccessOrExit(error = securityPolicy.AppendTo(*message));
374 }
375
376 SuccessOrExit(error = Tlv::Append<NetworkKeySequenceTlv>(*message, Get<KeyManager>().GetCurrentKeySequence()));
377
378 exit:
379 FreeAndNullMessageOnError(message, error);
380 return message;
381 }
382
HandleJoinerEntrustResponse(void * aContext,otMessage * aMessage,const otMessageInfo * aMessageInfo,Error aResult)383 void JoinerRouter::HandleJoinerEntrustResponse(void * aContext,
384 otMessage * aMessage,
385 const otMessageInfo *aMessageInfo,
386 Error aResult)
387 {
388 static_cast<JoinerRouter *>(aContext)->HandleJoinerEntrustResponse(AsCoapMessagePtr(aMessage),
389 AsCoreTypePtr(aMessageInfo), aResult);
390 }
391
HandleJoinerEntrustResponse(Coap::Message * aMessage,const Ip6::MessageInfo * aMessageInfo,Error aResult)392 void JoinerRouter::HandleJoinerEntrustResponse(Coap::Message * aMessage,
393 const Ip6::MessageInfo *aMessageInfo,
394 Error aResult)
395 {
396 OT_UNUSED_VARIABLE(aMessageInfo);
397
398 SendDelayedJoinerEntrust();
399
400 VerifyOrExit(aResult == kErrorNone && aMessage != nullptr);
401
402 VerifyOrExit(aMessage->GetCode() == Coap::kCodeChanged);
403
404 LogInfo("Receive joiner entrust response");
405 LogCert("[THCI] direction=recv | type=JOIN_ENT.rsp");
406
407 exit:
408 return;
409 }
410
ReadFrom(const Message & aMessage)411 void JoinerRouter::JoinerEntrustMetadata::ReadFrom(const Message &aMessage)
412 {
413 uint16_t length = aMessage.GetLength();
414
415 OT_ASSERT(length >= sizeof(*this));
416 IgnoreError(aMessage.Read(length - sizeof(*this), *this));
417 }
418
419 } // namespace MeshCoP
420 } // namespace ot
421
422 #endif // OPENTHREAD_FTD
423