def test_identity_timer_3470_expiry(self):
""" T3470 expiry for Identity Request"""
# Ground work.
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
maxNasMsgRetransmission = 5
# 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_GUTI
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,
)
# Wait for last Timer T3470 Expiry
for i in range(maxNasMsgRetransmission):
print(
"*** Waiting for Identity Request Message (",
str(i + 1),
") ***",
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_IDENTITY_REQ_IND.value,
)
print(
"*** Identity Request Message Received (",
str(i + 1),
") ***",
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print("*** Received UE Context Release Indication ***")
def test_no_auth_response(self):
# Ground work.
self._s1ap_wrapper.configIpBlock()
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print(
"************************* Running attach no auth response \
timer expiry 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
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_ATTACH_REQUEST,
attach_req,
)
# Wait for timer expiry 5 times, until context is released
for i in range(5):
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value,
)
print("************************* Timeout", i + 1)
print("************************* Timeouts complete")
# Attach Reject
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_ATTACH_REJECT_IND.value,
)
# Context release
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print("************************* Context released")
def test_send_error_ind_for_dl_nas_with_auth_req(self):
"""Send error indication after receiving authentication request"""
self._s1ap_wrapper.configIpBlock()
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
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
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req,
)
print("************************* Sent attach request")
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value,
)
print("************************* Received authentication request")
# Send error indication
error_ind = s1ap_types.fwNbErrIndMsg_t()
# isUeAssoc flag to include optional MME_UE_S1AP_ID and eNB_UE_S1AP_ID
error_ind.isUeAssoc = True
error_ind.ue_Id = req.ue_id
error_ind.cause.pres = True
# Radio network causeType = 0
error_ind.cause.causeType = 0
# causeVal - Unknown-pair-ue-s1ap-id
error_ind.cause.causeVal = 15
print("*** Sending error indication ***")
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.ENB_ERR_IND_MSG, error_ind,
)
# Context release
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print("************************* Received UE_CTX_REL_IND")
def test_sctp_abort_after_smc(self):
""" testing Sctp Abort after Security Mode Command for a single UE """
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print(
"************************* Running Sctp Abort after Security"
" Mode Command for a single UE for UE id ",
req.ue_id,
)
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
print("Sending Attach Request ue-id", 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 ue-id", req.ue_id)
auth_res = s1ap_types.ueAuthResp_t()
auth_res.ue_Id = req.ue_id
sqn_recvd = s1ap_types.ueSqnRcvd_t()
sqn_recvd.pres = 0
auth_res.sqnRcvd = sqn_recvd
print("Sending Auth Response ue-id", req.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", req.ue_id)
print("send SCTP ABORT")
sctp_abort = s1ap_types.FwSctpAbortReq_t()
sctp_abort.cause = 3
self._s1ap_wrapper._s1_util.issue_cmd(s1ap_types.tfwCmd.SCTP_ABORT_REQ,
sctp_abort)
def test_security_mode_reject(self):
""" Testing of security mode reject procedure """
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
pdn_type = s1ap_types.pdn_Type()
pdn_type.pres = True
pdn_type.pdn_type = 1
attach_req.mIdType = id_type
attach_req.epsAttachType = eps_type
attach_req.useOldSecCtxt = sec_ctxt
attach_req.pdnType_pr = pdn_type
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)
sec_mode_reject = s1ap_types.ueSecModeReject_t()
sec_mode_reject.ue_Id = 1
sec_mode_reject.cause = s1ap_types.TFW_EMM_CAUSE_SEC_MOD_REJ_UNSP
print("Sending Security Mode Reject ue-id", sec_mode_reject.ue_Id)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SEC_MOD_REJECT, sec_mode_reject)
time.sleep(2)
def test_no_security_mode_complete(self):
# Ground work.
self._s1ap_wrapper.configIpBlock()
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print("************************* Running attach no security mode \
complete timer expiry 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
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
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)
# Wait for timer expiry 5 times, until context is released
for i in range(5):
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value)
print("************************* Timeout", i + 1)
print("************************* Timeouts complete")
# Context release
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value)
print("************************* Context released")
def test_attach_auth_failure(self):
""" Testing of sending authentication failure 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
pdn_type = s1ap_types.pdn_Type()
pdn_type.pres = True
pdn_type.pdn_type = 3
attach_req.mIdType = id_type
attach_req.epsAttachType = eps_type
attach_req.useOldSecCtxt = sec_ctxt
attach_req.pdnType_pr = pdn_type
print("Sending Attach Request for 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 Authentication Request message ")
auth_failure = s1ap_types.ueAuthFailure_t()
auth_failure.ue_Id = 1
auth_failure.cause = s1ap_types.TFW_EMM_CAUSE_SYNC_FAILURE
# sending random/zero auts value to simulate failure scenario
for idx1 in range(14):
auth_failure.auts[idx1] = 0
print("Sending Authentication Failure for ue-id", auth_failure.ue_Id)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_AUTH_FAILURE,
auth_failure,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertTrue(response, s1ap_types.tfwCmd.UE_AUTH_REJ_IND.value)
print("Received Authentication Reject message")
def test_sctp_shutdown_after_identity_req(self):
""" testing SCTP Shutdown after Identity Request for a single UE """
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print(
"************************* Running SCTP Shutdown after Identity"
" Request for single UE for UE id ",
req.ue_id,
)
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_GUTI
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", 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_IDENTITY_REQ_IND.value,
)
print(
"Received Identity req ind ",
s1ap_types.tfwCmd.UE_IDENTITY_REQ_IND.value,
)
print("send SCTP SHUTDOWN")
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.SCTP_SHUTDOWN_REQ,
None,
)
def exec_attach_req_step(self, ue_id):
attach_req = s1ap_types.ueAttachRequest_t()
attach_req.ue_Id = 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
# 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 ue-id", attach_req.ue_Id)
def test_sctp_abort_after_auth_req(self):
""" testing SCTP Abort after Auth Request for a single UE """
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print(
"************************* Running SCTP Abort after Auth "
"Request for a single UE for UE id ",
req.ue_id,
)
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
print("Sending Attach Request ue-id", 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 ", s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value,
)
print("send SCTP ABORT")
sctp_abort = s1ap_types.FwSctpAbortReq_t()
sctp_abort.cause = 3
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.SCTP_ABORT_REQ, sctp_abort,
)
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 attach(
self,
ue_id,
attach_type,
resp_type,
resp_msg_type,
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,
):
"""
Given a UE issue the attach request of specified type
Caches the assigned IP address, if any is assigned
Args:
ue_id: The eNB ue_id
attach_type: The type of attach e.g. UE_END_TO_END_ATTACH_REQUEST
resp_type: enum type of the expected response
sec_ctxt: Optional param allows for the reuse of the security
context, defaults to creating a new security context.
id_type: Optional param allows for changing up the ID type,
defaults to s1ap_types.TFW_MID_TYPE_IMSI.
eps_type: Optional param allows for variation in the EPS attach
type, defaults to s1ap_types.TFW_EPS_ATTACH_TYPE_EPS_ATTACH.
"""
attach_req = s1ap_types.ueAttachRequest_t()
attach_req.ue_Id = ue_id
attach_req.mIdType = id_type
attach_req.epsAttachType = eps_type
attach_req.useOldSecCtxt = sec_ctxt
assert self.issue_cmd(attach_type, attach_req) == 0
response = self.get_response()
# The MME actually sends INT_CTX_SETUP_IND and UE_ATTACH_ACCEPT_IND in
# one message, but the s1aptester splits it and sends the tests 2
# messages. Usually context setup comes before attach accept, but
# it's possible it may happen the other way
if s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value == response.msg_type:
response = self.get_response()
elif s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value == response.msg_type:
context_setup = self.get_response()
assert context_setup.msg_type == s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value
logging.debug(
"s1ap response expected, received: %d, %d",
resp_type.value,
response.msg_type,
)
assert resp_type.value == response.msg_type
msg = response.cast(resp_msg_type)
# We only support IPv4 right now, as max PDN address in S1AP tester is
# currently 13 bytes, which is too short for IPv6 (which requires 16)
if resp_msg_type == s1ap_types.ueAttachAccept_t:
pdn_type = msg.esmInfo.pAddr.pdnType
addr = msg.esmInfo.pAddr.addrInfo
if S1ApUtil.CM_ESM_PDN_IPV4 == pdn_type:
# Cast and cache the IPv4 address
ip = ipaddress.ip_address(bytes(addr[:4]))
with self._lock:
self._ue_ip_map[ue_id] = ip
else:
raise ValueError("PDN TYPE %s not supported" % pdn_type)
return msg
def test_no_smc_with_mme_restart_reattach(self):
""" Send attach req + receive security mode command + restart mme
+ mme does implicit detach + re-attach """
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print("************* Running attach")
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
print("************* Send Attach Req for ue", 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 for ue", req.ue_id)
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
print("************* Send Auth Rsp for ue", req.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 SMC for ue", req.ue_id)
print("************************* Restarting MME service on", "gateway")
self._s1ap_wrapper.magmad_util.restart_services(["mme"])
for j in range(30):
print("Waiting for", j, "seconds")
time.sleep(1)
# Wait for UE context release command
response = self._s1ap_wrapper.s1_util.get_response()
while response.msg_type == s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value:
print("Received SMC retx from previous run... Ignoring")
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print("****** Triggering end-end attach after mme restart *********")
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()
print("************* Running Detach for ue", req.ue_id)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
req.ue_id,
s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value,
False,
)
def test_attach_enb_rlf(self):
"""
Attach, after attach procedure is completed, eNB detects the RLF
i.e., releasing the context by sending UE context release request
with cause Radio Link Failure by that time we sending one more
attach request
"""
# Ground work.
self._s1ap_wrapper.configUEDevice(1)
# 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 = 1
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 = 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,
)
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 = 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,
)
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,
)
print("***Triggering Re-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 = 1
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,
)
# Send UE context release request with cause Radio Link Failure
ue_ctxt_rel_req = s1ap_types.ueCntxtRelReq_t()
ue_ctxt_rel_req.ue_Id = 1
ue_ctxt_rel_req.cause.causeVal = (
gpp_types.CauseRadioNetwork.RADIO_CONNECTION_WITH_UE_LOST.value)
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST,
ue_ctxt_rel_req,
)
time.sleep(1)
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_imei_restriction_wildcard_snr(self):
"""
This TC validates imei restriction scenario where only tac
part of imei is configured i.e snr is wildcarded:
1. Send security mode complete message with a blocked imeisv
where tac is same as the one configured in mme.conf.template
2. Verify that attach reject is received with cause(5)
IMEI_NOT_ACCEPTED
If this TC is executed individually run
test_modify_mme_config_for_sanity.py to add
{ IMEI_TAC="99333821"}
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 = 1
self._s1ap_wrapper.configUEDevice(num_ues)
req = self._s1ap_wrapper.ue_req
# 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 = 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,
)
print(
"********************** Sent attach req for UE 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 = 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,
)
print("********************** Sent auth rsp for UE id", req.ue_id)
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 = req.ue_id
sec_mode_complete.imeisv_pres = True
imeisv = "9933382135103723"
# Check if the len of imeisv exceeds 16
self.assertLessEqual(len(imeisv), 16)
for i in range(0, len(imeisv)):
sec_mode_complete.imeisv[i] = ctypes.c_ubyte(int(imeisv[i]))
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",
req.ue_id,
)
# 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" % (attach_rej.ue_Id, 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,
)
def test_nas_non_delivery_smc(self):
""" testing Nas Non Delivery for Security Mode Command message
for single UE """
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print(
"************************* Running Nas Non Delivery of Security"
"Mode Command message for a single UE with UE id",
req.ue_id,
)
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
print("Sending Attach Request ue-id", 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 ue-Id", req.ue_id)
""" The purpose of UE_SET_NAS_NON_DELIVERY command is to prepare
enbapp to send S1ap-nas non delivery message for next receiving
downlink nas message
For testing of nas non delivery of SMC, the NasNonDel flag is set at
enbApp, before sending Auth Response, to avoid race condition of SMC
receiving first and then setting NasNonDel flag """
nas_non_del = s1ap_types.UeNasNonDel()
nas_non_del.ue_Id = req.ue_id
nas_non_del.flag = 1
nas_non_del.causeType = (
s1ap_types.NasNonDelCauseType.TFW_CAUSE_RADIONW.value)
nas_non_del.causeVal = 3
print("Sending Set Nas Non Del to enbApp for ue-id", nas_non_del.ue_Id)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SET_NAS_NON_DELIVERY,
nas_non_del,
)
print("Send Auth Resp", req.ue_id)
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_CTX_REL_IND.value,
)
print("Received UE_CTX_REL_IND")
# Reset the nas non delivery flag
nas_non_del = s1ap_types.UeNasNonDel()
nas_non_del.ue_Id = req.ue_id
nas_non_del.flag = 0
nas_non_del.causeType = (
s1ap_types.NasNonDelCauseType.TFW_CAUSE_RADIONW.value)
nas_non_del.causeVal = 3
print("Sending Reset Nas Non Del ind to enb")
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SET_NAS_NON_DELIVERY,
nas_non_del,
)
def test_attach_restricted_plmn(self):
"""
If this TC is executed individually run
test_modify_mme_config_for_sanity.py to add
PLMN - { MCC="123" ; MNC="450";}
under the RESTRICTED_PLMN_LIST
in mme.conf.template.
This TC does the following:
1. Send attach request with IMSI containing the PLMN
configured in mme.conf.template
2. Verify that MME sends attach reject with cause(11) PLMN NOT ALLOWED
3. Attach a 2nd UE with an allowed PLMN by invoking attach utility
function
4. Detach the UE
After execution of this TC run test_restore_mme_config_after_sanity.py
to restore the old mme.conf.template.
"""
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
# Trigger Attach Request with restricted PLMN
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
# Generate IMSI with prefix IMSI12345
imsi = self._s1ap_wrapper._s1_util.generate_imsi(prefix="IMSI12345")
for i in range(0, 15):
attach_req.imsi[i] = ctypes.c_ubyte(int(imsi[4 + i]))
attach_req.imsi_len = 15
attach_req.epsAttachType = eps_type
attach_req.useOldSecCtxt = sec_ctxt
attach_req.pdnType_pr = pdn_type
print(
"************************* Sending attach for ",
"UE id ",
req.ue_id,
)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_ATTACH_REQUEST,
attach_req,
)
# 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 cause %d" % (req.ue_id, attach_rej.cause), )
# Verify cause
self.assertEqual(attach_rej.cause, s1ap_types.TFW_EMM_CAUSE_PLMN_NA)
# Context release
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print(
"************************* Received ue context release cmd for "
"UE id ",
req.ue_id,
)
# Attach the 2nd UE with allowed PLMN
self._s1ap_wrapper.configUEDevice(1)
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(2)
print("********************** Running UE detach for UE id ", req.ue_id)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
req.ue_id,
s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value,
)
def test_attach_detach_ics_failure(self):
""" Initial Context Setup Failure Test Case"""
# 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
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,
)
init_ctxt_setup_fail = s1ap_types.ueInitCtxtSetupFail()
init_ctxt_setup_fail.ue_Id = req.ue_id
init_ctxt_setup_fail.flag = 1
init_ctxt_setup_fail.causeType = 1
init_ctxt_setup_fail.causeType = 0
print("*** Setting Initial Context Setup Failure ***")
# 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,
)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SET_INIT_CTXT_SETUP_FAIL,
init_ctxt_setup_fail,
)
# 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,
)
print("*** Received Initial Context Setup Failure ***")
# 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 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_enb_partial_reset(self):
""" attach 32 UEs """
ue_ids = []
num_ues = 1
self._s1ap_wrapper.configUEDevice(num_ues)
for _ in range(num_ues):
req = self._s1ap_wrapper.ue_req
print(
"************************* Calling attach for UE id ",
req.ue_id,
)
# 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 = 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 with PND Type IPv4 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()
print("response message type for ATTTACH ACC", response.msg_type)
print("acc", s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value)
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value,
)
ue_ids.append(req.ue_id)
# Trigger eNB Reset
# Add delay to ensure S1APTester sends attach partial before sending
# eNB Reset Request
time.sleep(0.5)
print("************************* Sending eNB Partial Reset Request")
reset_req = s1ap_types.ResetReq()
reset_req.rstType = s1ap_types.resetType.PARTIAL_RESET.value
reset_req.cause = s1ap_types.ResetCause()
reset_req.cause.causeType = (
s1ap_types.NasNonDelCauseType.TFW_CAUSE_MISC.value)
# Set the cause to MISC.hardware-failure
reset_req.cause.causeVal = 3
reset_req.r = s1ap_types.R()
reset_req.r.partialRst = s1ap_types.PartialReset()
reset_req.r.partialRst.numOfConn = num_ues
reset_req.r.partialRst.ueS1apIdPairList = (
(s1ap_types.UeS1apIdPair) * reset_req.r.partialRst.numOfConn)()
for indx in range(reset_req.r.partialRst.numOfConn):
reset_req.r.partialRst.ueS1apIdPairList[indx].ueId = ue_ids[indx]
print(
"Reset_req.r.partialRst.ueS1apIdPairList[indx].ueId",
reset_req.r.partialRst.ueS1apIdPairList[indx].ueId,
indx,
)
print("ue_ids", ue_ids)
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.RESET_REQ,
reset_req,
)
response1 = self._s1ap_wrapper.s1_util.get_response()
print("response1 message type", response1.msg_type)
self.assertEqual(response1.msg_type, s1ap_types.tfwCmd.RESET_ACK.value)
# Trigger detach request
"""time.sleep(0.5)
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_attach_complete_after_ics_timer_expiry(self):
"""Simulating sending of attach complete msg after ICS timer expiry.
MME should discard attach complete message as it is already in the
process of implicit detach
### Do not add this TC to sanity suite ###
"""
# 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
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_ATTACH_REQUEST, attach_req,
)
print("****** Sent ATTACH_REQUEST")
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")
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 = 4500
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
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 UE_AUTH_RESP")
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")
# 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,
)
print("****** Sent UE_SEC_MOD_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")
print("****** Sleeping for 4 seconds. Waiting for ICS timer to expire")
time.sleep(4)
# 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,
)
print("****** Sent ATTACH_COMPLETE")
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print("****** Received UE_CTX_REL_IND")
def test_no_attach_complete_with_mme_restart(self):
"""
Step 1: UE sends Attach Request, receives Attach Accept and UE shall
not respond to mme
Step 2: After sending Attach Accept, mme runs 3450 timer, while timer
is running, mme restarts.
Step 3: On mme recovery, mme sends Detach Request with re-attach
required, S1ap shall send Detach Accept and release the UE
contexts
Step 4: Once again attach UE to network
"""
self._s1ap_wrapper.configIpBlock()
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print(
"************************* Running attach setup timer expiry 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
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()
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,
)
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,
)
print(
"************************* Restarting MME service on",
"gateway",
)
self._s1ap_wrapper.magmad_util.restart_services(["mme"])
for j in range(20):
print("Waiting for", j, "seconds")
time.sleep(1)
# Receive NW initiated detach request
response = self._s1ap_wrapper.s1_util.get_response()
while response.msg_type == s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value:
print(
"Received Attach Accept retransmission from before restart",
"Ignoring...",
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_NW_INIT_DETACH_REQUEST.value,
)
nw_init_detach_req = response.cast(s1ap_types.ueNwInitdetachReq_t)
print(
"**************** Received NW initiated Detach Req with detach "
"type set to ",
nw_init_detach_req.Type,
)
self.assertEqual(
nw_init_detach_req.Type,
s1ap_types.ueNwInitDetType_t.TFW_RE_ATTACH_REQUIRED.value,
)
print("**************** Sending Detach Accept")
# Send detach accept
detach_accept = s1ap_types.ueTrigDetachAcceptInd_t()
detach_accept.ue_Id = req.ue_id
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_TRIGGERED_DETACH_ACCEPT,
detach_accept,
)
# Wait for UE context release command
response = self._s1ap_wrapper.s1_util.get_response()
# Ignore retransmitted NW Initiated Detach Request messages.
# This test waits for a couple of seconds after the MME restart, but most
# of the time MME comes up early after the restart and retransmits multiple
# NW Initiated Detach Request messages on T3422 Timer expiry.
while (
response.msg_type
== s1ap_types.tfwCmd.UE_NW_INIT_DETACH_REQUEST.value
):
nw_init_detach_req = response.cast(s1ap_types.ueNwInitdetachReq_t)
print(
"**************** Received retransmitted NW Initiated Detach "
"Req with detach type set to",
nw_init_detach_req.Type,
"Ignoring...",
)
self.assertEqual(
nw_init_detach_req.Type,
s1ap_types.ueNwInitDetType_t.TFW_RE_ATTACH_REQUIRED.value,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print("****** Received Ue context release command *********")
print("****** Triggering end-end attach after mme restart *********")
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()
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
req.ue_id,
s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value,
wait_for_s1_ctxt_release=False,
)
def test_no_auth_response_with_mme_restart(self):
""" This test case is to test EPC behaviour by restarting mme
after authentication timer expires """
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print("********* Sending Attach Req for ue", req.ue_id)
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
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_ATTACH_REQUEST,
attach_req,
)
# Wait for timer expiry 5 times, until context is released
for i in range(5):
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_AUTH_REQ_IND.value,
)
print("************************* Timeout", i + 1)
print("********* Received Auth Req for ue", req.ue_id)
print("************************* Timeouts complete")
# Attach Reject
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_ATTACH_REJECT_IND.value,
)
print("********* Received Attach Reject for ue", req.ue_id)
# Context release
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print("********* Received UE_CTX_REL_IND for ue", req.ue_id)
print("************************* Restarting MME service on", "gateway")
self._s1ap_wrapper.magmad_util.restart_services(["mme"])
for j in range(30):
print("Waiting for", j, "seconds")
time.sleep(1)
print("****** Triggering attach after mme restart *********")
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,
)
time.sleep(0.5)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_EMM_INFORMATION.value,
)
print(
"******************* Running UE detach (switch-off) for ",
"UE id ",
req.ue_id,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
req.ue_id,
s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value,
False,
)
def test_imei_restriction_smc(self):
"""
This TC does the following:
1. Send security mode complete message with a blocked imeisv
which is same as the one configured in mme.conf.template
2. Verify that attach reject is received with cause(5)
IMEI_NOT_ACCEPTED
3. Attach a 2nd UE with an allowed IMEISV by invoking attach utility
function
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]
sec_mode_complete.imeisv_pres = True
imeisv = "9900048235103723"
# Check if the len of imeisv exceeds 16
self.assertLessEqual(len(imeisv), 16)
for i in range(0, len(imeisv)):
sec_mode_complete.imeisv[i] = ctypes.c_ubyte(int(imeisv[i]))
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],
)
# 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" % (attach_rej.ue_Id, 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
print(
"************ Running end-end attach for UE id ************",
ue_ids[1],
)
self._s1ap_wrapper._s1_util.attach(
ue_ids[1],
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("********************** Sleeping for 2 seconds")
time.sleep(2)
print("********************** Running UE detach for UE id ", ue_ids[1])
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_ids[1],
s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value,
)
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_ics_timer_expiry_ue_unregistered(self):
"""
Simulating ICS timer expiry by dropping ICS req during attach
i.e UE is in unregistered state.
Network sends UE context release cmd after ICS timer expires
"""
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
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("*** Sending indication to drop Initial Context Setup Req ***")
drop_init_ctxt_setup_req = s1ap_types.UeDropInitCtxtSetup()
drop_init_ctxt_setup_req.ue_Id = req.ue_id
drop_init_ctxt_setup_req.flag = 1
# Timer to release UE context at s1ap tester
drop_init_ctxt_setup_req.tmrVal = 2000
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SET_DROP_ICS, drop_init_ctxt_setup_req)
# 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)
# enbApp sends UE_ICS_DROPD_IND message to tfwApp after dropping
# ICS request
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_ICS_DROPD_IND.value)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value)
print(
"************************* Received UE_CTX_REL_IND for UE id ",
req.ue_id,
)
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_no_identity_rsp_with_mme_restart(self):
"""
Step 1: UE performs GUTI based attach
Step 2: MME sends identity request and start 3470 timer
Step 3: On mme recovery, mme implicitly detach the UE and release the
all UE contexts.
Step 4: Once again UE shall successfully attach to network
"""
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
print(
"************************* Running No Identity Response with MME ",
" restart for UE id ",
req.ue_id,
)
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_GUTI
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 for ue_id", 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_IDENTITY_REQ_IND.value,
)
print(
"Received Identity req ind ",
s1ap_types.tfwCmd.UE_IDENTITY_REQ_IND.value,
)
print("********************** Restarting MME service on gateway ***")
self._s1ap_wrapper.magmad_util.restart_services(["mme"])
for j in range(30):
print("Waiting for", j, "seconds")
time.sleep(1)
# Since UE has neither received Attach Reject nor Attach Accept,
# assuming that both T3410 and T3411 timer expires at UE
# and re-transmit the Attach Request with same IEs in UL nas message
# with previous mme_ue_s1ap_id
# But in response to second Attach Request, s1ap receives ue context
# release command because after AGW recovery, s1ap stack will not be
# aware of mme_ue_s1ap_id.So s1ap stack should clear the s1ap signaling
# contexts at eNB that were created before mme restarts
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_GUTI
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 for ue_id", req.ue_id)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_ATTACH_REQUEST,
attach_req,
)
# It has been observed that despite getting the restart command on
# time, MME sometimes restarts after a delay of around 6 seconds.
# Currently identity response timer T3470 is set to 6 seconds as
# part of configuraton file mme.conf.template. If MME restarts after
# expiry of identity response timer, it will send the re-transmitted
# identity request message
resp_count = 0
while True:
response = self._s1ap_wrapper.s1_util.get_response()
if (response.msg_type ==
s1ap_types.tfwCmd.UE_IDENTITY_REQ_IND.value):
resp_count += 1
print(
"******************** Ignoring re-transmitted (",
resp_count,
") Identity request indication",
)
else:
break
# Context release
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value,
)
print("********** UE Context released **********")
time.sleep(5)
print("****** re-attach UE after mme restart *********")
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()
print(
"******************* Running UE detach (switch-off) for ",
"ue_id ",
req.ue_id,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
req.ue_id,
s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value,
)
