From fd34e22c84e56184e3e3c501c5811434812deb27 Mon Sep 17 00:00:00 2001 From: David Rupprecht Date: Fri, 15 Feb 2019 11:16:01 +0100 Subject: [PATCH] Started with local preference selection algorithm --- srsenb/hdr/upper/rrc.h | 1 + srsenb/src/upper/rrc.cc | 126 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 124 insertions(+), 3 deletions(-) diff --git a/srsenb/hdr/upper/rrc.h b/srsenb/hdr/upper/rrc.h index 21c702647..bc9f0a68a 100644 --- a/srsenb/hdr/upper/rrc.h +++ b/srsenb/hdr/upper/rrc.h @@ -245,6 +245,7 @@ public: void cqi_get(uint16_t* pmi_idx, uint16_t* n_pucch); int cqi_free(); + bool select_security_algorithms(); void send_dl_ccch(asn1::rrc::dl_ccch_msg_s* dl_ccch_msg); void send_dl_dcch(asn1::rrc::dl_dcch_msg_s* dl_dcch_msg, srslte::byte_buffer_t* pdu = NULL); diff --git a/srsenb/src/upper/rrc.cc b/srsenb/src/upper/rrc.cc index 2dec6bb9f..9f97b6945 100644 --- a/srsenb/src/upper/rrc.cc +++ b/srsenb/src/upper/rrc.cc @@ -1211,10 +1211,11 @@ void rrc::ue::set_security_key(uint8_t* key, uint32_t length) { memcpy(k_enb, key, length); parent->rrc_log->info_hex(k_enb, 32, "Key eNodeB (k_enb)"); - // Select algos (TODO: use security capabilities and config preferences) - cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA2; // FIXME: Should i keep this type??? - integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA1; + // Selects security algorithms (cipher_algo and integ_algo) based on capabilities and config preferences + select_security_algorithms(); + parent->rrc_log->info("Selected security algorithms EEA: EEA-%d EIA: EIA-%d\n", cipher_algo, integ_algo); + // Generate K_rrc_enc and K_rrc_int srslte::security_generate_k_rrc(k_enb, cipher_algo, integ_algo, k_rrc_enc, k_rrc_int); @@ -1902,6 +1903,125 @@ void rrc::ue::send_ue_cap_enquiry() /********************** HELPERS ***************************/ +bool rrc::ue::select_security_algorithms() +{ + srslte::CIPHERING_ALGORITHM_ID_ENUM + enc_algo_preference[srslte::CIPHERING_ALGORITHM_ID_N_ITEMS] = { + srslte::CIPHERING_ALGORITHM_ID_128_EEA2, + srslte::CIPHERING_ALGORITHM_ID_128_EEA1, + srslte::CIPHERING_ALGORITHM_ID_EEA0}; + + srslte::INTEGRITY_ALGORITHM_ID_ENUM + intgrity_algo_preference[srslte::INTEGRITY_ALGORITHM_ID_N_ITEMS] = { + srslte::INTEGRITY_ALGORITHM_ID_128_EIA2, + srslte::INTEGRITY_ALGORITHM_ID_128_EIA1, + srslte::INTEGRITY_ALGORITHM_ID_EIA0}; + + // Each position in the bitmap represents an encryption algorithm: + // “all bits equal to 0” – UE supports no other algorithm than EEA0, + // “first bit” – 128-EEA1, + // “second bit” – 128-EEA2, + // “third bit” – 128-EEA3, + // other bits reserved for future use. Value ‘1’ indicates support and value ‘0’ indicates no support of the algorithm. + // Algorithms are defined in TS 33.401 [15]. + // Note: information missing + + bool enc_algo_found = false; + bool integ_algo_found = false; + bool zero_vector = true; + int i = 0; + for (i = 0; i < srslte::CIPHERING_ALGORITHM_ID_N_ITEMS; i++) { + switch (enc_algo_preference[i]) { + case srslte::CIPHERING_ALGORITHM_ID_EEA0: + // “all bits equal to 0” – UE supports no other algorithm than EEA0, + zero_vector = true; + for (int j; j < LIBLTE_S1AP_ENCRYPTIONALGORITHMS_BIT_STRING_LEN; j++) { + if (security_capabilities.encryptionAlgorithms.buffer[j]) { + zero_vector = false; + } + } + if (zero_vector == true) { + cipher_algo = srslte::CIPHERING_ALGORITHM_ID_EEA0; + enc_algo_found = true; + break; + } + break; + case srslte::CIPHERING_ALGORITHM_ID_128_EEA1: + // “first bit” – 128-EEA1, + if (security_capabilities.encryptionAlgorithms + .buffer[srslte::CIPHERING_ALGORITHM_ID_128_EEA1 - 1]) { + cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA1; + enc_algo_found = true; + break; + } + break; + case srslte::CIPHERING_ALGORITHM_ID_128_EEA2: + // “second bit” – 128-EEA2, + if (security_capabilities.encryptionAlgorithms + .buffer[srslte::CIPHERING_ALGORITHM_ID_128_EEA2 - 1]) { + cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA2; + enc_algo_found = true; + break; + } + break; + default: + enc_algo_found = false; + break; + } + if (enc_algo_found == true) { + break; + } + } + + for (i = 0; i < srslte::INTEGRITY_ALGORITHM_ID_N_ITEMS; i++) { + switch (intgrity_algo_preference[i]) { + case srslte::INTEGRITY_ALGORITHM_ID_EIA0: + // “all bits equal to 0” – UE supports no other algorithm than EEA0, + zero_vector = true; + for (int j; j < LIBLTE_S1AP_INTEGRITYPROTECTIONALGORITHMS_BIT_STRING_LEN; + j++) { + if (security_capabilities.integrityProtectionAlgorithms.buffer[j]) { + zero_vector = false; + } + } + if (zero_vector == true) { + integ_algo = srslte::INTEGRITY_ALGORITHM_ID_EIA0; + integ_algo_found = true; + } + break; + case srslte::INTEGRITY_ALGORITHM_ID_128_EIA1: + // “first bit” – 128-EEA1, + if (security_capabilities.encryptionAlgorithms + .buffer[srslte::INTEGRITY_ALGORITHM_ID_128_EIA1 - 1]) { + integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA1; + integ_algo_found = true; + } + break; + case srslte::INTEGRITY_ALGORITHM_ID_128_EIA2: + // “second bit” – 128-EEA2, + if (security_capabilities.encryptionAlgorithms + .buffer[srslte::INTEGRITY_ALGORITHM_ID_128_EIA2 - 1]) { + integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA2; + integ_algo_found = true; + } + break; + default: + integ_algo_found = false; + break; + } + + if (integ_algo_found == true) { + break; + } + } + + if(integ_algo_found == false || enc_algo_found == false){ + // TODO: if no security algorithm found abort radio connection and issue + // cryption-and-or-integrity-protection-algorithms-not-supported message + return false; + } + return true; +} void rrc::ue::send_dl_ccch(dl_ccch_msg_s* dl_ccch_msg) { // Allocate a new PDU buffer, pack the message and send to PDCP