/* * Copyright 2013-2019 Software Radio Systems Limited * * This file is part of srsLTE. * * srsLTE is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as * published by the Free Software Foundation, either version 3 of * the License, or (at your option) any later version. * * srsLTE is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * A copy of the GNU Affero General Public License can be found in * the LICENSE file in the top-level directory of this distribution * and at http://www.gnu.org/licenses/. * */ #ifndef SRSUE_NAS_H #define SRSUE_NAS_H #include "srslte/common/buffer_pool.h" #include "srslte/common/log.h" #include "srslte/common/common.h" #include "srslte/interfaces/ue_interfaces.h" #include "srslte/common/security.h" #include "srslte/asn1/liblte_mme.h" #include "srslte/common/nas_pcap.h" using srslte::byte_buffer_t; namespace srsue { class nas_args_t { public: nas_args_t() : force_imsi_attach(false) {} std::string apn_name; std::string apn_protocol; std::string apn_user; std::string apn_pass; bool force_imsi_attach; std::string eia; std::string eea; }; // EMM states (3GPP 24.302 v10.0.0) typedef enum { EMM_STATE_NULL = 0, EMM_STATE_DEREGISTERED, EMM_STATE_REGISTERED, EMM_STATE_DEREGISTERED_INITIATED, EMM_STATE_TAU_INITIATED, EMM_STATE_N_ITEMS, } emm_state_t; static const char emm_state_text[EMM_STATE_N_ITEMS][100] = {"NULL", "DEREGISTERED", "REGISTERED", "DEREGISTERED INITIATED", "TRACKING AREA UPDATE INITIATED"}; class nas : public nas_interface_rrc, public nas_interface_ue, public nas_interface_gw { public: nas(); void init(usim_interface_nas* usim_, rrc_interface_nas* rrc_, gw_interface_nas* gw_, srslte::log* nas_log_, nas_args_t args_); void stop(); emm_state_t get_state(); // RRC interface void paging(asn1::rrc::s_tmsi_s* ue_identiy); void set_barring(barring_t barring); void write_pdu(uint32_t lcid, srslte::unique_byte_buffer pdu); uint32_t get_k_enb_count(); bool is_attached(); bool get_k_asme(uint8_t *k_asme_, uint32_t n); uint32_t get_ipv4_addr(); bool get_ipv6_addr(uint8_t *ipv6_addr); // UE interface bool attach_request(); bool detach_request(); // PCAP void start_pcap(srslte::nas_pcap *pcap_); private: srslte::byte_buffer_pool *pool; srslte::log *nas_log; rrc_interface_nas *rrc; usim_interface_nas *usim; gw_interface_nas *gw; nas_args_t cfg; emm_state_t state; nas_interface_rrc::barring_t current_barring; bool plmn_is_selected; asn1::rrc::plmn_id_s current_plmn; asn1::rrc::plmn_id_s home_plmn; std::vector known_plmns; LIBLTE_MME_EMM_INFORMATION_MSG_STRUCT emm_info; // Security context struct nas_sec_ctxt{ uint8_t ksi; uint8_t k_asme[32]; uint32_t tx_count; uint32_t rx_count; uint32_t k_enb_count; srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo; srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo; LIBLTE_MME_EPS_MOBILE_ID_GUTI_STRUCT guti; }; bool have_guti; bool have_ctxt; nas_sec_ctxt ctxt; bool auth_request; uint32_t ip_addr; uint8_t ipv6_if_id[8]; uint8_t eps_bearer_id; uint8_t chap_id; uint8_t transaction_id; // Security bool eia_caps[8]; bool eea_caps[8]; uint8_t k_nas_enc[32]; uint8_t k_nas_int[32]; // PCAP srslte::nas_pcap *pcap = NULL; bool running; bool rrc_connect(); void integrity_generate(uint8_t *key_128, uint32_t count, uint8_t direction, uint8_t *msg, uint32_t msg_len, uint8_t *mac); bool integrity_check(srslte::unique_byte_buffer& pdu); void cipher_encrypt(srslte::unique_byte_buffer& pdu); void cipher_decrypt(srslte::unique_byte_buffer& pdu); void set_k_enb_count(uint32_t count); bool check_cap_replay(LIBLTE_MME_UE_SECURITY_CAPABILITIES_STRUCT *caps); void select_plmn(); // Parsers void parse_attach_accept(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_attach_reject(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_authentication_request(uint32_t lcid, srslte::unique_byte_buffer pdu, const uint8_t sec_hdr_type); void parse_authentication_reject(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_identity_request(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_security_mode_command(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_service_reject(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_esm_information_request(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_emm_information(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_detach_request(uint32_t lcid, srslte::unique_byte_buffer pdu); void parse_emm_status(uint32_t lcid, srslte::unique_byte_buffer pdu); // Packet generators void gen_attach_request(srslte::unique_byte_buffer& msg); void gen_service_request(srslte::unique_byte_buffer& msg); // Senders void send_identity_response(uint32_t lcid, uint8 id_type); void send_service_request(); void send_esm_information_response(const uint8 proc_transaction_id); void send_authentication_response(const uint8_t* res, const size_t res_len, const uint8_t sec_hdr_type); void send_authentication_failure(const uint8_t cause, const uint8_t* auth_fail_param); void gen_pdn_connectivity_request(LIBLTE_BYTE_MSG_STRUCT *msg); void send_security_mode_reject(uint8_t cause); void send_detach_request(bool switch_off); void send_detach_accept(); // security context persistence file bool read_ctxt_file(nas_sec_ctxt *ctxt); bool write_ctxt_file(nas_sec_ctxt ctxt); // ctxt file helpers std::string hex_to_string(uint8_t *hex, int size); bool string_to_hex(std::string hex_str, uint8_t *hex, uint32_t len); std::string emm_info_str(LIBLTE_MME_EMM_INFORMATION_MSG_STRUCT *info); template bool readvar(std::istream &file, const char *key, T *var) { std::string line; size_t len = strlen(key); std::getline(file, line); if(line.substr(0,len).compare(key)) { return false; } *var = (T)atoi(line.substr(len).c_str()); return true; } bool readvar(std::istream &file, const char *key, uint8_t *var, int varlen) { std::string line; size_t len = strlen(key); std::getline(file, line); if(line.substr(0,len).compare(key)) { return false; } std::string tmp = line.substr(len); if(!string_to_hex(tmp, var, varlen)) { return false; } return true; } std::vector split_string(const std::string input) { std::vector list; std::stringstream ss(input); while (ss.good()) { std::string substr; getline(ss, substr, ','); if (not substr.empty()) { list.push_back(atoi(substr.c_str())); } } return list; } }; } // namespace srsue #endif // SRSUE_NAS_H