def test_attach_detach_no_ueContRelComp(self): """ Basic attach/detach test with a single UE - SCTP Abort""" self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id print("************************ Running End to End attach for ", "UE id ", ue_id) # Now actually complete the attach self._s1ap_wrapper._s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("************************* Running UE detach for ", "UE id", ue_id) # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = req.ue_id detach_req.ueDetType = s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req) response = self._s1ap_wrapper._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_DETACH_ACCEPT_IND.value == response.msg_type) time.sleep(0.1) # Send SCTP ABORT to MME sctp_abort = s1ap_types.FwSctpAbortReq_t() sctp_abort.cause = 0 self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.SCTP_ABORT_REQ, sctp_abort)
def send_ue_detach(self, ue_id): detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = ue_id detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req ) self.detach_req_sent_count += 1
def detach(self, ue_id, reason_type, wait_for_s1_ctxt_release=True): """ Given a UE issue a detach request """ detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = ue_id detach_req.ueDetType = reason_type assert self.issue_cmd(s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req) == 0 if reason_type == s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value: response = self.get_response() assert s1ap_types.tfwCmd.UE_DETACH_ACCEPT_IND.value == response.msg_type # Now wait for the context release response if wait_for_s1_ctxt_release: response = self.get_response() assert s1ap_types.tfwCmd.UE_CTX_REL_IND.value == response.msg_type with self._lock: del self._ue_ip_map[ue_id]
def test_attach_ipv4v6_pdn_type(self): """ Test Attach for the UEs that are dual IP stack IPv4v6 capable """ # Ground work. self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req # Trigger Attach Request with PDN_Type = IPv4v6 attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH pdn_type = s1ap_types.pdn_Type() pdn_type.pres = True # Set PDN TYPE to IPv4V6 i.e. 3. IPV4 is equal to 1 # IPV6 is equal to 2 in value pdn_type.pdn_type = 3 attach_req.ue_Id = req.ue_id attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt attach_req.pdnType_pr = pdn_type print("********Triggering Attach Request with PND Type IPv4v6 test") self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value) # Trigger Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = req.ue_id sqnRecvd = s1ap_types.ueSqnRcvd_t() sqnRecvd.pres = 0 auth_res.sqnRcvd = sqnRecvd self._s1ap_wrapper._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value) # Trigger Security Mode Complete sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("************************* Running UE detach") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = req.ue_id detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req) # Wait for UE context release command response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value)
def test_stateless_multi_ue_mixedstate_mme_restart(self): """ Testing of sending Esm Information procedure """ ue_ids = [] num_ues_idle = 10 num_ues_active = 10 num_attached_ues = num_ues_idle + num_ues_active # each list item can be a number in [1,3] and be repeated stateof_ues_in_attachproc_before_restart = [ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, ] num_ues_attaching = len(stateof_ues_in_attachproc_before_restart) attach_steps = [ self.exec_attach_req_step, self.exec_auth_resp_step, self.exec_sec_mode_complete_step, self.exec_esm_inf_req_step, ] num_of_steps = len(attach_steps) tot_num_ues = num_ues_idle + num_ues_active + num_ues_attaching self._s1ap_wrapper.configUEDevice(tot_num_ues) idle_session_ips = [] # Prep attached UEs for i in range(num_ues_idle + num_ues_active): req = self._s1ap_wrapper.ue_req print( "************************* sending Attach Request for " "UE id ", req.ue_id, ) attach = self._s1ap_wrapper._s1_util.attach( req.ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) addr = attach.esmInfo.pAddr.addrInfo default_ip = ipaddress.ip_address(bytes(addr[:4])) if i < num_ues_idle: idle_session_ips.append(default_ip) else: self.dl_flow_rules[default_ip] = [] # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() ue_ids.append(req.ue_id) # Move first num_ues_idle UEs to idle state for i in range(num_ues_idle): print( "************************* Sending UE context release request ", "for UE id ", ue_ids[i], ) # Send UE context release request to move UE to idle mode ue_cntxt_rel_req = s1ap_types.ueCntxtRelReq_t() ue_cntxt_rel_req.ue_Id = ue_ids[i] ue_cntxt_rel_req.cause.causeVal = ( gpp_types.CauseRadioNetwork.USER_INACTIVITY.value) self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, ue_cntxt_rel_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, ) tId = {} # start attach procedures for the remaining UEs for i in range(num_ues_attaching): req = self._s1ap_wrapper.ue_req print( "************************* Starting Attach procedure " "UE id ", req.ue_id, ) # bring each newly attaching UE to the desired point during # attach procedure before restarting mme service ue_ids.append(req.ue_id) for step in range(stateof_ues_in_attachproc_before_restart[i]): if attach_steps[step] == self.exec_sec_mode_complete_step: tId[req.ue_id] = attach_steps[step](req.ue_id) elif attach_steps[step] == self.exec_esm_inf_req_step: attach_steps[step](req.ue_id, tId[req.ue_id]) else: attach_steps[step](req.ue_id) # Restart mme self._s1ap_wrapper.magmad_util.restart_mme_and_wait() # Post restart, complete the attach procedures that were cut in between for i in range(num_ues_attaching): # resume attach for attaching UEs print( "************************* Resuming Attach procedure " "UE id ", ue_ids[i + num_attached_ues], ) for step in range(stateof_ues_in_attachproc_before_restart[i], num_of_steps): if attach_steps[step] == self.exec_sec_mode_complete_step: tId[ue_ids[i + num_attached_ues]] = attach_steps[step]( ue_ids[i + num_attached_ues]) elif attach_steps[step] == self.exec_esm_inf_req_step: attach_steps[step](ue_ids[i + num_attached_ues], tId[ue_ids[i + num_attached_ues]]) else: attach_steps[step](ue_ids[i + num_attached_ues]) # Verify steady state flows in Table-0 # Idle users will have paging rules installed # Active users will have tunnel rules # 1 UL flow is created per active bearer num_ul_flows = num_ues_active + num_ues_attaching # Verify if flow rules are created self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, self.dl_flow_rules, ) # Verify paging flow rules for idle sessions self._s1ap_wrapper.s1_util.verify_paging_flow_rules(idle_session_ips) # Try to bring idle mode users into active state for i in range(num_ues_idle): print( "************************* Sending Service Request ", "for UE id ", ue_ids[i], ) # Send service request to reconnect UE ser_req = s1ap_types.ueserviceReq_t() ser_req.ue_Id = ue_ids[i] ser_req.ueMtmsi = s1ap_types.ueMtmsi_t() ser_req.ueMtmsi.pres = False ser_req.rrcCause = s1ap_types.Rrc_Cause.TFW_MO_DATA.value self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SERVICE_REQUEST, ser_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) self.dl_flow_rules[idle_session_ips[i]] = [] # Verify default bearer rules self._s1ap_wrapper.s1_util.verify_flow_rules( tot_num_ues, self.dl_flow_rules, ) # detach everyone print("*** Starting Detach Procedure for all UEs ***") for ue in ue_ids: print( "************************* Detaching " "UE id ", ue, ) # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = ue detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, )
def test_attach_detach_duplicate_nas_resp_messages(self): """ Duplicate NAS Response Messages Test Case""" # Ground work. self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req maxNasMsgRetransmission = 4 # Trigger Attach Request attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.ue_Id = req.ue_id attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt print("*** Triggering Attach Request ***") self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req) # Waiting for Authentication Request # Wait for last Timer T3460 Expiry for i in range(maxNasMsgRetransmission): print( "*** Waiting for Authentication Request Message (", str(i + 1), ") ***", ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value) print( "*** Authentication Request Message Received (", str(i + 1), ") ***", ) # Trigger Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = req.ue_id sqnRecvd = s1ap_types.ueSqnRcvd_t() sqnRecvd.pres = 0 auth_res.sqnRcvd = sqnRecvd for i in range(maxNasMsgRetransmission): print( "*** Sending Authentication Response Message (", str(i + 1), ") ***", ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res) # Waiting for Security mode command # Wait for last Timer T3460 Expiry for i in range(maxNasMsgRetransmission): print( "*** Waiting for Security Mode Command Message (", str(i + 1), ") ***", ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value) print( "*** Security Mode Command Message Received (", str(i + 1), ") ***", ) # Trigger Security Mode Complete sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = req.ue_id for i in range(maxNasMsgRetransmission): print( "*** Sending Security Mode Complete Message (", str(i + 1), ") ***", ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete) # Waiting for Attach accept # Wait for last Timer T3450 Expiry for i in range(maxNasMsgRetransmission): print( "*** Waiting for Attach Accept Message (", str(i + 1), ") ***", ) # Attach accept will be sent in ICSR only for the first time # Re-transmitted Attach Accept will be sent in DL NAS transport if i < 1: response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value) print( "*** Attach Accept Message Received (", str(i + 1), ") ***", ) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = req.ue_id for i in range(maxNasMsgRetransmission): print( "*** Sending Attach Complete Message (", str(i + 1), ") ***", ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete) print("*** Running UE detach ***") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = req.ue_id detach_req.ueDetType = s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req)
def test_resync(self): """Attach logic where we bump up the seq number stored in UE SQN array in order to trigger authentication failure from UE to verify the re-sync of seq number logic in EPC""" # Ground work. self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req print("************************* Running sync failure test") attach_req = s1ap_types.ueAttachRequest_t() attach_req.ue_Id = req.ue_id sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt # Trigger Attach self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = req.ue_id sqn_recvd = s1ap_types.ueSqnRcvd_t() max_sqn_recvd = s1ap_types.ueSqnRcvd_t() # Use SQN received from EPC as is sqn_recvd.pres = False # Set UE side max SQN value to bigger than value received from EPC # This is to trigger auth failure with cause = Sync Failure max_sqn_recvd.pres = True max_sqn_recvd.sqn = (0, 0, 0, 0, 0, 96) auth_res.sqnRcvd = sqn_recvd auth_res.maxSqnRcvd = max_sqn_recvd self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) response = self._s1ap_wrapper.s1_util.get_response() # Verify that EPC re-sends Authentication Request self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) print("************************* Retrying authentication") # Use SQN received from EPC as is sqn_recvd.pres = False auth_res.sqnRcvd = sqn_recvd self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) # Trigger Security mode complete message sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) # Receive initial context setup and attach accept indication response = (self._s1ap_wrapper._s1_util. receive_initial_ctxt_setup_and_attach_accept()) attach_acc = response.cast(s1ap_types.ueAttachAccept_t) print( "********************** Received attach accept for UE Id:", attach_acc.ue_Id, ) # Trigger Attach complete message attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete, ) print("************************* UE Attach Complete") # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("************************* Running UE detach") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = req.ue_id detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, )
def test_esm_information(self): """ Testing of sending Esm Information procedure """ num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) print("************************* sending Attach Request for ue-id : 1") attach_req = s1ap_types.ueAttachRequest_t() attach_req.ue_Id = 1 sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt # enabling ESM Information transfer flag attach_req.eti.pres = 1 attach_req.eti.esm_info_transfer_flag = 1 print("Sending Attach Request ue-id", attach_req.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value) print("Received auth req ind ") auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = 1 sqn_recvd = s1ap_types.ueSqnRcvd_t() sqn_recvd.pres = 0 auth_res.sqnRcvd = sqn_recvd print("Sending Auth Response ue-id", auth_res.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value) print("Received Security Mode Command ue-id", auth_res.ue_Id) time.sleep(1) sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete) # Esm Information Request indication print("Received Esm Information Request ue-id", sec_mode_complete.ue_Id) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ESM_INFORMATION_REQ.value) esm_info_req = response.cast(s1ap_types.ueEsmInformationReq_t) # Sending Esm Information Response print("Sending Esm Information Response ue-id", sec_mode_complete.ue_Id) esm_info_response = s1ap_types.ueEsmInformationRsp_t() esm_info_response.ue_Id = 1 esm_info_response.tId = esm_info_req.tId esm_info_response.pdnAPN_pr.pres = 1 s = "magma.ipv4" esm_info_response.pdnAPN_pr.len = len(s) esm_info_response.pdnAPN_pr.pdn_apn = (ctypes.c_ubyte * 100)( *[ctypes.c_ubyte(ord(c)) for c in s[:100]]) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ESM_INFORMATION_RSP, esm_info_response) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("*** Running UE detach ***") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = 1 detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req) # Wait for UE context release command response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value)
def test_guti_attach_with_zero_mtmsi(self): """1. Perform IMSI attach 2. Move UE to idle mode 3. Send GUTI attach request for the same UE with M-TMSI value 0 4. Detach the UE """ num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) req = self._s1ap_wrapper.ue_req print( "************************* Running End to End attach for UE id:", req.ue_id, ) # Now actually complete the attach self._s1ap_wrapper._s1_util.attach( req.ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() time.sleep(0.5) # Send UE context release request to move UE to idle mode print( "************************* Sending UE context release request ", "for UE id ", req.ue_id, ) ureq = s1ap_types.ueCntxtRelReq_t() ureq.ue_Id = req.ue_id ureq.cause.causeVal = gpp_types.CauseRadioNetwork.USER_INACTIVITY.value self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, ureq, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, ) time.sleep(5) # Send GUTI attach request with M-TMSI value as 0 attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_GUTI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH pdn_type = s1ap_types.pdn_Type() pdn_type.pres = True pdn_type.pdn_type = 1 mcc = "001" mnc = "01" mcc_len = len(mcc) mnc_len = len(mnc) attach_req.ue_Id = req.ue_id attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt attach_req.pdnType_pr = pdn_type attach_req.guti_mi.pres = True for i in range(0, mcc_len): attach_req.guti_mi.guti.mcc[i] = ctypes.c_ubyte(int(mcc[i])) for i in range(0, mnc_len): attach_req.guti_mi.guti.mnc[i] = ctypes.c_ubyte(int(mnc[i])) attach_req.guti_mi.guti.mmeGrdId = 314 attach_req.guti_mi.guti.mmeCode = 30 attach_req.guti_mi.guti.mTmsi = 0 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) print( "********************** Sent attach req for UE id ", attach_req.ue_Id, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_IDENTITY_REQ_IND.value, ) id_req = response.cast(s1ap_types.ueIdentityReqInd_t) print( "********************** Received identity req for UE id", id_req.ue_Id, ) identity_resp = s1ap_types.ueIdentityResp_t() identity_resp.ue_Id = id_req.ue_Id identity_resp.idType = s1ap_types.TFW_MID_TYPE_IMSI self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_IDENTITY_RESP, identity_resp, ) print( "********************** Sent identity rsp for UE id", id_req.ue_Id, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) auth_req = response.cast(s1ap_types.ueAuthReqInd_t) print( "********************** Received auth req for UE id", auth_req.ue_Id, ) # Send Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = auth_req.ue_Id sqn_recvd = s1ap_types.ueSqnRcvd_t() sqn_recvd.pres = 0 auth_res.sqnRcvd = sqn_recvd self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) print("********************** Sent auth rsp for UE id", auth_req.ue_Id) response = self._s1ap_wrapper.s1_util.get_response() sec_mode_cmd = response.cast(s1ap_types.ueSecModeCmdInd_t) self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) print( "********************** Received security mode cmd for UE id", sec_mode_cmd.ue_Id, ) sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = sec_mode_cmd.ue_Id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) print( "********************** Sent security mode complete for UE id", sec_mode_cmd.ue_Id, ) # Receive initial context setup and attach accept indication response = (self._s1ap_wrapper._s1_util. receive_initial_ctxt_setup_and_attach_accept()) attach_acc = response.cast(s1ap_types.ueAttachAccept_t) print( "********************** Received attach accept for UE Id:", attach_acc.ue_Id, ) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = attach_acc.ue_Id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete, ) print( "********************** Sent attach complete for UE id", attach_complete.ue_Id, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print( "************************* Running UE detach for UE id ", attach_complete.ue_Id, ) # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = attach_complete.ue_Id detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) # Wait for UE context release command response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, )
def test_different_enb_s1ap_id_same_ue(self): """ Testing of sending different enb S1ap-ID for same UE """ num_ues = 1 self._s1ap_wrapper.configUEDevice_ues_same_imsi(num_ues) print("************************* sending Attach Request for ue-id : 1") attach_req = s1ap_types.ueAttachRequest_t() attach_req.ue_Id = 1 sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt print("Sending Attach Request ue-id", attach_req.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req) response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue(response, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value) print("Received auth req ind ") auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = 1 sqn_recvd = s1ap_types.ueSqnRcvd_t() sqn_recvd.pres = 0 auth_res.sqnRcvd = sqn_recvd print("Sending Auth Response ue-id", auth_res.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res) response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue(response, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value) print("Received Security Mode Command ue-id", auth_res.ue_Id) attach_req = s1ap_types.ueAttachRequest_t() attach_req.ue_Id = 2 sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt print("Sending Attach Request ue-id", attach_req.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req) time.sleep(1) sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete) response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue(response, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value) response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue(response, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("************************* Running UE detach for UE id:1 ") print("************************* Running UE detach") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = 1 detach_req.ueDetType = s1ap_types.ueDetachType_t.\ UE_SWITCHOFF_DETACH.value self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req) # Wait for UE context release command response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue(response, s1ap_types.tfwCmd.UE_CTX_REL_IND.value)
def test_attach_esm_information_with_apn_correction(self): """ Testing of sending wrong APN in Esm Information procedure and using APN correction feature to override it """ num_ues = 1 print('************************* restarting mme') self._s1ap_wrapper.magmad_util.restart_services(['mme']) for j in range(15): print("Waiting mme restart for", j, "seconds") time.sleep(1) self._s1ap_wrapper.configUEDevice_ues_same_imsi(num_ues) print("************************* sending Attach Request for ue-id : 1") attach_req = s1ap_types.ueAttachRequest_t() attach_req.ue_Id = 1 sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt # enabling ESM Information transfer flag attach_req.eti.pres = 1 attach_req.eti.esm_info_transfer_flag = 1 print("Sending Attach Request ue-id", attach_req.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) print("Received auth req ind ") auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = 1 sqn_recvd = s1ap_types.ueSqnRcvd_t() sqn_recvd.pres = 0 auth_res.sqnRcvd = sqn_recvd print("Sending Auth Response ue-id", auth_res.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) print("Received Security Mode Command ue-id", auth_res.ue_Id) time.sleep(1) sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) # Esm Information Request indication print( "Received Esm Information Request ue-id", sec_mode_complete.ue_Id, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ESM_INFORMATION_REQ.value, ) esm_info_req = response.cast(s1ap_types.ueEsmInformationReq_t) # Sending Esm Information Response print( "Sending Esm Information Response ue-id", sec_mode_complete.ue_Id, ) esm_info_response = s1ap_types.ueEsmInformationRsp_t() esm_info_response.ue_Id = 1 esm_info_response.tId = esm_info_req.tId esm_info_response.pdnAPN_pr.pres = 1 s = "oai" esm_info_response.pdnAPN_pr.len = len(s) esm_info_response.pdnAPN_pr.pdn_apn = (ctypes.c_ubyte * 100)( *[ctypes.c_ubyte(ord(c)) for c in s[:100]], ) print("Sending Esm Information with wrong APN ", s) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ESM_INFORMATION_RSP, esm_info_response, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value, ) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("*** Running UE detach ***") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = 1 detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) # Wait for UE context release command response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, ) # Disable APN Correction self._s1ap_wrapper.magmad_util.config_apn_correction( MagmadUtil.apn_correction_cmds.DISABLE, ) self._s1ap_wrapper.magmad_util.restart_services(['mme']) for j in range(10): print("Waiting mme restart for", j, "seconds") time.sleep(1)
def test_attach_delay_ue_ctxt_rel_cmp(self): """ Attach, Delay Ue context release complete """ # Ground work. self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req # Trigger Attach Request attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.ue_Id = req.ue_id attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt print("********Triggering Attach Request ") self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value) # Trigger Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = req.ue_id sqnRecvd = s1ap_types.ueSqnRcvd_t() sqnRecvd.pres = 0 auth_res.sqnRcvd = sqnRecvd self._s1ap_wrapper._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value) # Trigger Security Mode Complete sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value) delay_ue_ctxt_rel_cmp = s1ap_types.UeDelayUeCtxtRelCmp() delay_ue_ctxt_rel_cmp.ue_Id = req.ue_id delay_ue_ctxt_rel_cmp.flag = 1 delay_ue_ctxt_rel_cmp.tmrVal = 1000 print("*** Setting Delay for Ue context release complete ***") self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SET_DELAY_UE_CTXT_REL_CMP, delay_ue_ctxt_rel_cmp, ) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete) time.sleep(0.5) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_EMM_INFORMATION.value) time.sleep(0.5) # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = req.ue_id detach_req.ueDetType = s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req) response = self._s1ap_wrapper._s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_DETACH_ACCEPT_IND.value) print( "*** Sending UE context release request ", "for UE id ***", req.ue_id, ) # Send UE context release request to move UE to idle mode # ue_ctxt_rel_req = s1ap_types.ueCntxtRelReq_t() uectxtrel_req = s1ap_types.ueCntxtRelReq_t() uectxtrel_req.ue_Id = req.ue_id uectxtrel_req.cause.causeVal = ( gpp_types.CauseRadioNetwork.RELEASE_DUE_TO_EUTRAN_GENERATED_REASON. value) self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, uectxtrel_req) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value) time.sleep(10)
def test_imei_restriction_no_imeisv_in_smc(self): """ This TC does the following: UE 1: 1. Send security mode complete message without imeisv 2. Receive identity request with id type imeisv 3. Send identity rsp with blocked imeisv 4. Verify attach reject is received with cause(5) IMEI_NOT_ACCEPTED UE 2: 1. Send security mode complete message without imeisv 2. Receive identity request with id type imeisv 3. Send identity rsp with an allowed imeisv 4. Detach the UE If this TC is executed individually run test_modify_mme_config_for_sanity.py to add { IMEI="9900048235103723" } under the BLOCKED_IMEI_LIST in mme.conf.template. After execution of this TC run test_restore_mme_config_after_sanity.py to restore the old mme.conf.template. """ num_ues = 2 ue_ids = [] self._s1ap_wrapper.configUEDevice(num_ues) for _ in range(num_ues): req = self._s1ap_wrapper.ue_req ue_ids.append(req.ue_id) # Send Attach Request attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH pdn_type = s1ap_types.pdn_Type() pdn_type.pres = True pdn_type.pdn_type = 1 attach_req.ue_Id = ue_ids[0] attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt attach_req.pdnType_pr = pdn_type self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) print( "********************** Sent attach req for UE id ", ue_ids[0], ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) auth_req = response.cast(s1ap_types.ueAuthReqInd_t) print( "********************** Received auth req for UE id", auth_req.ue_Id, ) # Send Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = ue_ids[0] sqnRecvd = s1ap_types.ueSqnRcvd_t() sqnRecvd.pres = 0 auth_res.sqnRcvd = sqnRecvd self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) print("********************** Sent auth rsp for UE id", ue_ids[0]) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) sec_mod_cmd = response.cast(s1ap_types.ueSecModeCmdInd_t) print( "********************** Received security mode cmd for UE id", sec_mod_cmd.ue_Id, ) # Send Security Mode Complete sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = ue_ids[0] # Do not include imeisv sec_mode_complete.noImeisv = True self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) print( "********************** Sent security mode complete for UE id", ue_ids[0], ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_IDENTITY_REQ_IND.value, ) id_req = response.cast(s1ap_types.ueIdentityReqInd_t) print( "********************** Received identity req for UE id", id_req.ue_Id, ) # Mobile Identity types # IMSI=1, IMEI=2, IMEISV=3, TMSI=4, TMGI=5, GUTI=6 identity_resp = s1ap_types.ueIdentityResp_t() identity_resp.ue_Id = ue_ids[0] identity_resp.idType = 3 identity_resp.idValPres = True imeisv = "9900048235103723" # Check if the len of imeisv exceeds 16 self.assertLessEqual(len(imeisv), 16) for i in range(0, len(imeisv)): identity_resp.idVal[i] = ctypes.c_ubyte(int(imeisv[i])) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_IDENTITY_RESP, identity_resp, ) print("********************** Sent identity rsp for UE id", ue_ids[0]) # Receive Attach Reject response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_REJECT_IND.value, ) attach_rej = response.cast(s1ap_types.ueAttachRejInd_t) print( "********************** Received attach reject for UE id %d" " with emm cause %d" % (ue_ids[0], attach_rej.cause), ) # Verify cause self.assertEqual( attach_rej.cause, s1ap_types.TFW_EMM_CAUSE_IMEI_NOT_ACCEPTED, ) # UE Context release response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, ) ue_context_rel = response.cast(s1ap_types.ueCntxtRelReq_t) print( "********************** Received UE_CTX_REL_IND for UE id ", ue_context_rel.ue_Id, ) # Attach the 2nd UE attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH pdn_type = s1ap_types.pdn_Type() pdn_type.pres = True pdn_type.pdn_type = 1 attach_req.ue_Id = ue_ids[1] attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt attach_req.pdnType_pr = pdn_type self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) print( "********************** Sent attach req for UE id ", ue_ids[1], ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) auth_req = response.cast(s1ap_types.ueAuthReqInd_t) print( "********************** Received auth req for UE id", auth_req.ue_Id, ) # Send Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = ue_ids[1] sqnRecvd = s1ap_types.ueSqnRcvd_t() sqnRecvd.pres = 0 auth_res.sqnRcvd = sqnRecvd self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) print("********************** Sent auth rsp for UE id", ue_ids[1]) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) sec_mod_cmd = response.cast(s1ap_types.ueSecModeCmdInd_t) print( "********************** Received security mode cmd for UE id", sec_mod_cmd.ue_Id, ) # Send Security Mode Complete sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = ue_ids[1] # Do not include imeisv sec_mode_complete.noImeisv = True self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) print( "********************** Sent security mode complete for UE id", ue_ids[1], ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_IDENTITY_REQ_IND.value, ) id_req = response.cast(s1ap_types.ueIdentityReqInd_t) print( "********************** Received identity req for UE id", id_req.ue_Id, ) # Send Identity Request id_req = response.cast(s1ap_types.ueIdentityReqInd_t) identity_resp = s1ap_types.ueIdentityResp_t() identity_resp.ue_Id = id_req.ue_Id identity_resp.idType = id_req.idType self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_IDENTITY_RESP, identity_resp, ) print("********************** Sent identity rsp for UE id", ue_ids[1]) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value, ) attach_acc = response.cast(s1ap_types.ueAttachAccept_t) print( "********************** Received attach accept for UE id", attach_acc.ue_Id, ) # Send Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = ue_ids[1] self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete, ) print( "********************** Sent attach complete for UE id", ue_ids[1], ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_EMM_INFORMATION.value, ) print("********************** Sleeping for 0.5 seconds ") time.sleep(0.5) # Now detach the UE print("********************** Running UE detach for UE id ", ue_ids[1]) detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = ue_ids[1] detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) # Wait for UE context release command response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, ) ue_context_rel = response.cast(s1ap_types.ueCntxtRelReq_t) print( "********************** Received UE_CTX_REL_IND for UE id ", ue_context_rel.ue_Id, )
def _create_attach_ipv4v6_pdn_type_req(self, pdn_type_value): # Ground work. self._s1ap_wrapper.configUEDevice(1) ue_req = self._s1ap_wrapper.ue_req # Trigger Attach Request with PDN_Type = IPv4v6 attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH pdn_type = s1ap_types.pdn_Type() pdn_type.pres = True # Set PDN TYPE to IPv4V6 i.e. 3. IPV4 is equal to 1 # IPV6 is equal to 2 in value pdn_type.pdn_type = pdn_type_value attach_req.ue_Id = ue_req.ue_id attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt attach_req.pdnType_pr = pdn_type print( "********Triggering Attach Request with PDN Type IPv4v6 test, " "pdn_type_value", pdn_type_value, ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) # Trigger Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = ue_req.ue_id sqn_recvd = s1ap_types.ueSqnRcvd_t() sqn_recvd.pres = 0 auth_res.sqnRcvd = sqn_recvd self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) # Trigger Security Mode Complete sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = ue_req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) # Attach Reject will be sent since IPv6 PDN Type is not configured if pdn_type_value == 2: response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_REJECT_IND.value, ) return self._s1ap_wrapper.s1_util.get_response() # Receive initial context setup and attach accept indication response = (self._s1ap_wrapper._s1_util. receive_initial_ctxt_setup_and_attach_accept()) attach_acc = response.cast(s1ap_types.ueAttachAccept_t) print( "********************** Received attach accept for UE Id:", attach_acc.ue_Id, ) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = ue_req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("************************* Running UE detach") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = ue_req.ue_id detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) # Wait for UE context release command return self._s1ap_wrapper.s1_util.get_response()
def test_dedicated_bearer_activation_idle_mode_pag_tmr_exp(self): """ Test with a single UE attach + UE context release + dedicated bearer activation + page the UE + Paging timer expires + send dedicated bearer activation reject to SPGW""" self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id imsi = req.imsi # Add dedicated bearer for default bearer 5 # UL Flow description #1 ulFlow1 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5002, # TCP dest port "ip_proto": "TCP", # Protocol Type "direction": "UL", # Direction } # UL Flow description #2 ulFlow2 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5001, # TCP dest port "ip_proto": "TCP", # Protocol Type "direction": "UL", # Direction } # UL Flow description #3 ulFlow3 = { "ipv4_dst": "192.168.129.64", # IPv4 destination address "tcp_dst_port": 5003, # TCP dest port "ip_proto": "TCP", # Protocol Type "direction": "UL", # Direction } # UL Flow description #4 ulFlow4 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5004, # TCP dest port "ip_proto": "TCP", # Protocol Type "direction": "UL", # Direction } # DL Flow description #1 dlFlow1 = { "ipv4_src": "192.168.129.42", # IPv4 source address "tcp_src_port": 5001, # TCP source port "ip_proto": "TCP", # Protocol Type "direction": "DL", # Direction } # DL Flow description #2 dlFlow2 = { "ipv4_src": "192.168.129.64", # IPv4 source address "tcp_src_port": 5002, # TCP source port "ip_proto": "TCP", # Protocol Type "direction": "DL", # Direction } # DL Flow description #3 dlFlow3 = { "ipv4_src": "192.168.129.64", # IPv4 source address "tcp_src_port": 5003, # TCP source port "ip_proto": "TCP", # Protocol Type "direction": "DL", # Direction } # DL Flow description #4 dlFlow4 = { "ipv4_src": "192.168.129.42", # IPv4 source address "tcp_src_port": 5004, # TCP source port "ip_proto": "TCP", # Protocol Type "direction": "DL", # Direction } # Flow list to be configured flow_list = [ ulFlow1, ulFlow2, ulFlow3, ulFlow4, dlFlow1, dlFlow2, dlFlow3, dlFlow4, ] # QoS qos = { "qci": 1, # qci value [1 to 9] "priority": 1, # Range [0-255] "max_req_bw_ul": 10000000, # MAX bw Uplink "max_req_bw_dl": 15000000, # MAX bw Downlink "gbr_ul": 1000000, # GBR Uplink "gbr_dl": 2000000, # GBR Downlink "arp_prio": 1, # ARP priority "pre_cap": 1, # pre-emption capability "pre_vul": 1, # pre-emption vulnerability } policy_id = "internet" print("*********** Running End to End attach for UE id ", ue_id) attach = self._s1ap_wrapper._s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) addr = attach.esmInfo.pAddr.addrInfo default_ip = ipaddress.ip_address(bytes(addr[:4])) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() # Delay to ensure S1APTester sends attach complete before sending UE # context release print("*********** Sleeping for 5 seconds") time.sleep(5) print("*********** Moving UE to idle mode") print( "*********** Sending UE context release request ", "for UE id ", ue_id, ) # Send UE context release request to move UE to idle mode req = s1ap_types.ueCntxtRelReq_t() req.ue_Id = ue_id req.cause.causeVal = gpp_types.CauseRadioNetwork.USER_INACTIVITY.value self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, req ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value ) # Verify if paging flow rules are created ip_list = [default_ip] self._s1ap_wrapper.s1_util.verify_paging_flow_rules(ip_list) print("Sleeping for 5 seconds") time.sleep(5) print( "************* Adding dedicated bearer to magma.ipv4" " PDN in idle mode" ) print( "************* Sending RAR for IMSI", "".join([str(i) for i in imsi]), ) self._sessionManager_util.create_ReAuthRequest( "IMSI" + "".join([str(i) for i in imsi]), policy_id, flow_list, qos, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PAGING_IND.value ) print("*********** Received Paging for UE id ", ue_id) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PAGING_IND.value ) print("*********** Received second Paging for UE id ", ue_id) print("*********** Sleeping for 5 seconds") time.sleep(5) print("*********** Running UE detach for UE id ", ue_id) # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = ue_id detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req )
def test_attach_outoforder_attach_cmp_icsrsp(self): """ Attach, Out of order attach complete and initial context setup response """ """ Simulating this scenario by delaying ICS response message to change the order of attach complete and ics resp """ # Ground work. self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req # Trigger Attach Request attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH pdn_type = s1ap_types.pdn_Type() pdn_type.pres = True pdn_type.pdn_type = 3 attach_req.ue_Id = req.ue_id attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt attach_req.pdnType_pr = pdn_type self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) delay_init_ctxt_setup_resp = s1ap_types.UeDelayInitCtxtSetupRsp() delay_init_ctxt_setup_resp.ue_Id = req.ue_id delay_init_ctxt_setup_resp.flag = 1 delay_init_ctxt_setup_resp.tmrVal = 2000 print("*** Setting Initial Context Setup Resp Delay ***") self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SET_DELAY_ICS_RSP, delay_init_ctxt_setup_resp, ) # Trigger Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = req.ue_id sqnRecvd = s1ap_types.ueSqnRcvd_t() sqnRecvd.pres = 0 auth_res.sqnRcvd = sqnRecvd self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) # Trigger Security Mode Complete sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value, ) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print( "************************* Running UE detach for UE id ", req.ue_id, ) # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = req.ue_id detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) # Wait for UE context release command response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, ) time.sleep(1)
def test_attach_complete_with_ActvDfltBearCtxtRej(self): """ Test Attach test case for sending Activate Default EPS Bearer Reject along with Attach Complete message """ # Ground work. self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req # Trigger Attach Request attach_req = s1ap_types.ueAttachRequest_t() sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH pdn_type = s1ap_types.pdn_Type() pdn_type.pres = True pdn_type.pdn_type = 1 attach_req.ue_Id = req.ue_id attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt attach_req.pdnType_pr = pdn_type print("********Triggering Attach Request ") self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value) # Trigger Authentication Response auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = req.ue_id sqnRecvd = s1ap_types.ueSqnRcvd_t() sqnRecvd.pres = 0 auth_res.sqnRcvd = sqnRecvd self._s1ap_wrapper._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value) # Trigger Security Mode Complete sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value) msg = response.cast(s1ap_types.ueAttachAccept_t) bid = msg.esmInfo.epsBearerId # Trigger Attach Complete with # Activate Default EPS Bearer Context Reject time.sleep(0.2) act_rej = s1ap_types.ueActvDfltEpsBearerCtxtRej_t() act_rej.ue_Id = req.ue_id act_rej.bearerId = bid act_rej.esmCause = s1ap_types.TFW_EMM_CAUSE_REQ_REJ_UNSPECIFIED # Activate Default EPS Bearer Context Reject sent along with # Attach Complete message # Attach Complete + Activate Default EPS Bearer Context Reject self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ACTV_DEFAULT_EPS_BEARER_CNTXT_REJECT, act_rej) # Added delay to ensure S1APTester receives the emm information before # sending the detach request message time.sleep(0.5) print("************************* Running UE detach") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = req.ue_id detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req) time.sleep(0.5)
def test_attach_with_multiple_mme_restarts(self): num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) print("************************* Sending Attach Request for ue-id : 1") attach_req = s1ap_types.ueAttachRequest_t() attach_req.ue_Id = 1 sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) print("************************* Received UE_AUTH_REQ_IND") # Try consecutive mme restarts self._s1ap_wrapper.magmad_util.restart_mme_and_wait() self._s1ap_wrapper.magmad_util.restart_mme_and_wait() auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = 1 sqn_recvd = s1ap_types.ueSqnRcvd_t() sqn_recvd.pres = 0 auth_res.sqnRcvd = sqn_recvd print("************************* Sending Auth Response ue-id", auth_res.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) print("************************* Received UE_SEC_MOD_CMD_IND") self._s1ap_wrapper.magmad_util.restart_mme_and_wait() print("************************* Sending UE_SEC_MOD_COMPLETE") sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) print("************************* Received INT_CTX_SETUP_IND") response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value, ) print("************************* Received UE_ATTACH_ACCEPT_IND") self._s1ap_wrapper.magmad_util.restart_mme_and_wait() # Trigger Attach Complete print("************************* Sending UE_ATTACH_COMPLETE") attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("************************* Running UE detach") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = 1 detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) # Wait for UE context release command return self._s1ap_wrapper.s1_util.get_response()
def test_attach_esm_info_timerexpiration_max_retries(self): """Testing of sending Esm Information procedure""" num_ues = 1 # The maximum no. of allowed transmissions of ESM information request # as per 3gpp spec 24.301 is 3. Since MME does not send the PDN # connectivity reject message as of now after maximum number of # T3489 expires, test script does not receive any failure response and # has no provision to handle it as well. Therefore, test case gets # stuck waiting for response, if max_retries value is greater than 3 max_retries = 3 self._s1ap_wrapper.configUEDevice(num_ues) print("************************* sending Attach Request for ue-id : 1") attach_req = s1ap_types.ueAttachRequest_t() attach_req.ue_Id = 1 sec_ctxt = s1ap_types.TFW_CREATE_NEW_SECURITY_CONTEXT id_type = s1ap_types.TFW_MID_TYPE_IMSI eps_type = s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH attach_req.mIdType = id_type attach_req.epsAttachType = eps_type attach_req.useOldSecCtxt = sec_ctxt # enabling ESM Information transfer flag attach_req.eti.pres = 1 attach_req.eti.esm_info_transfer_flag = 1 print("Sending Attach Request ue-id", attach_req.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value, ) print("Received auth req ind ") auth_res = s1ap_types.ueAuthResp_t() auth_res.ue_Id = 1 sqn_recvd = s1ap_types.ueSqnRcvd_t() sqn_recvd.pres = 0 auth_res.sqnRcvd = sqn_recvd print("Sending Auth Response ue-id", auth_res.ue_Id) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_AUTH_RESP, auth_res, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value, ) print("Received Security Mode Command ue-id", auth_res.ue_Id) time.sleep(1) sec_mode_complete = s1ap_types.ueSecModeComplete_t() sec_mode_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE, sec_mode_complete, ) for i in range(max_retries): # Esm Information Request indication response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ESM_INFORMATION_REQ.value, ) print( "Received Esm Information Request (", i + 1, ") ue-id", sec_mode_complete.ue_Id, ) esm_info_req = response.cast(s1ap_types.ueEsmInformationReq_t) # Sleep for 5 seconds to trigger last max retry count timer expiry time.sleep(5) # Sending Esm Information Response print( "Sending Esm Information Response ue-id", sec_mode_complete.ue_Id, ) esm_info_response = s1ap_types.ueEsmInformationRsp_t() esm_info_response.ue_Id = 1 esm_info_response.tId = esm_info_req.tId esm_info_response.pdnAPN_pr.pres = 1 s = "magma.ipv4" esm_info_response.pdnAPN_pr.len = len(s) esm_info_response.pdnAPN_pr.pdn_apn = (ctypes.c_ubyte * 100)( *[ctypes.c_ubyte(ord(c)) for c in s[:100]], ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ESM_INFORMATION_RSP, esm_info_response, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value, ) # Trigger Attach Complete attach_complete = s1ap_types.ueAttachComplete_t() attach_complete.ue_Id = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ATTACH_COMPLETE, attach_complete, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print("*** Running UE detach ***") # Now detach the UE detach_req = s1ap_types.uedetachReq_t() detach_req.ue_Id = 1 detach_req.ueDetType = ( s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, )