Update IMEISV Request and EPS NAS Security Alg

src/nas/common/Ie_Const.hpp

@@ -89,10 +89,11 @@ constexpr uint8_t kIeiShortNameForNetwork                   = 0x45;
 constexpr uint8_t kIeiPayloadContainerType     = 0x08;  // Should be verified
 constexpr uint8_t kIeiNetworkSlicingIndication = 0x09;  // 9-(4 higher bits)
 
-constexpr uint8_t kIeiNssaiInclusionMode        = 0x0A;  // B-(4 higher bits)
+constexpr uint8_t kIeiNssaiInclusionMode        = 0x0A;  // A-(4 higher bits)
 constexpr uint8_t kIeiMicoIndication            = 0x0B;  // B-(4 higher bits)
 constexpr uint8_t kIeiNasKeySetIdentifier       = 0x0C;  // C-(4 higher bits)
-constexpr uint8_t kIeiNon3gppNwProvidedPolicies = 0x0D;  // C-(4 higher bits)
+constexpr uint8_t kIeiNon3gppNwProvidedPolicies = 0x0D;  // D-(4 higher bits)
+constexpr uint8_t kIeiImeisvRequest             = 0x0E;  // E-(4 higher bits)
 
 constexpr uint8_t kIei5gmmCapability              = 0x10;
 constexpr uint8_t kIeiUeUsageSetting              = 0x18;
@@ -108,7 +109,8 @@ constexpr uint8_t kIeiAuthenticationResponseParameter = 0x2D;
 constexpr uint8_t kIeiUeSecurityCapability = 0x2e;
 constexpr uint8_t kIeiUeNetworkCapability  = 0x17;
 
-constexpr uint8_t kIeiAbba = 0x38;
+constexpr uint8_t kIeiAdditional5gSecurityInformation = 0x36;
+constexpr uint8_t kIeiAbba                            = 0x38;
 
 constexpr uint8_t kIeiUplinkDataStatus = 0x40;
 
@@ -116,9 +118,10 @@ constexpr uint8_t kT3502Value = 0x16;
 
 constexpr uint8_t kEquivalentPlmns = 0x4A;
 
-constexpr uint8_t kIeiPduSessionStatus = 0x50;
-constexpr uint8_t kIei5gsUpdateType    = 0x53;
-constexpr uint8_t kT3346Value          = 0x5f;
+constexpr uint8_t kIeiPduSessionStatus         = 0x50;
+constexpr uint8_t kIei5gsUpdateType            = 0x53;
+constexpr uint8_t kIeiEpsNasSecurityAlgorithms = 0x57;
+constexpr uint8_t kT3346Value                  = 0x5f;
 
 constexpr uint8_t kIeiEpsBearerContextStatus = 0x60;
 constexpr uint8_t kIeiUeRadioCapabilityId    = 0x67;

src/nas/common/NasIeHeader.hpp

@@ -39,11 +39,11 @@
 #include "EapMessage.hpp"
 #include "EpsBearerContextStatus.hpp"
 #include "EPS_NAS_Message_Container.hpp"
-#include "EPS_NAS_Security_Algorithms.hpp"
+#include "EpsNasSecurityAlgorithms.hpp"
 #include "Extended_DRX_Parameters.hpp"
 #include "GprsTimer2.hpp"
 #include "GprsTimer3.hpp"
-#include "IMEISV_Request.hpp"
+#include "ImeisvRequest.hpp"
 #include "LADN_Indication.hpp"
 #include "MA_PDU_Session_Information.hpp"
 #include "NasMessageContainer.hpp"

src/nas/ies/EPS_NAS_Security_Algorithms.cpp → src/nas/ies/EpsNasSecurityAlgorithms.cpp

@@ -19,92 +19,114 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-#include "EPS_NAS_Security_Algorithms.hpp"
-
-#include <iostream>
+#include "EpsNasSecurityAlgorithms.hpp"
 
-#include "logger.hpp"
 using namespace nas;
-using namespace std;
 
 //------------------------------------------------------------------------------
-EPS_NAS_Security_Algorithms::EPS_NAS_Security_Algorithms() {}
+EpsNasSecurityAlgorithms::EpsNasSecurityAlgorithms()
+    : Type3NasIe(kIeiEpsNasSecurityAlgorithms),
+      type_of_ciphering_algorithm_(),
+      type_of_integrity_protection_algorithm_() {
+  SetIeName(kEpsNasSecurityAlgorithmsIeName);
+}
 
 //------------------------------------------------------------------------------
-EPS_NAS_Security_Algorithms::~EPS_NAS_Security_Algorithms() {}
+EpsNasSecurityAlgorithms::EpsNasSecurityAlgorithms(
+    uint8_t ciphering, uint8_t integrity_protection)
+    : Type3NasIe(kIeiEpsNasSecurityAlgorithms) {
+  type_of_ciphering_algorithm_            = ciphering & 0x07;
+  type_of_integrity_protection_algorithm_ = integrity_protection & 0x07;
+  SetIeName(kEpsNasSecurityAlgorithmsIeName);
+}
 
 //------------------------------------------------------------------------------
-EPS_NAS_Security_Algorithms::EPS_NAS_Security_Algorithms(
-    uint8_t iei, uint8_t ciphering, uint8_t integrity_protection) {
-  _iei                 = iei;
-  CIPHERING            = ciphering;
-  INTEGRITY_PROTECTION = integrity_protection;
-}
+EpsNasSecurityAlgorithms::~EpsNasSecurityAlgorithms() {}
 
 //------------------------------------------------------------------------------
-void EPS_NAS_Security_Algorithms::SetTypeOfCipheringAlgorithm(uint8_t value) {
-  CIPHERING = value;
+void EpsNasSecurityAlgorithms::SetTypeOfCipheringAlgorithm(uint8_t value) {
+  type_of_ciphering_algorithm_ = value & 0x07;
 }
 
 //------------------------------------------------------------------------------
-void EPS_NAS_Security_Algorithms::SetTypeOfIntegrityProtectionAlgorithm(
+void EpsNasSecurityAlgorithms::SetTypeOfIntegrityProtectionAlgorithm(
     uint8_t value) {
-  INTEGRITY_PROTECTION = value;
+  type_of_integrity_protection_algorithm_ = value & 0x07;
 }
 
 //------------------------------------------------------------------------------
-uint8_t EPS_NAS_Security_Algorithms::GetTypeOfCipheringAlgorithm() {
-  return CIPHERING;
+uint8_t EpsNasSecurityAlgorithms::GetTypeOfCipheringAlgorithm() const {
+  return type_of_ciphering_algorithm_;
 }
 
 //------------------------------------------------------------------------------
-uint8_t EPS_NAS_Security_Algorithms::GetTypeOfIntegrityProtectionAlgorithm() {
-  return INTEGRITY_PROTECTION;
+uint8_t EpsNasSecurityAlgorithms::GetTypeOfIntegrityProtectionAlgorithm()
+    const {
+  return type_of_integrity_protection_algorithm_;
 }
 
 //------------------------------------------------------------------------------
-int EPS_NAS_Security_Algorithms::Encode(uint8_t* buf, int len) {
-  Logger::nas_mm().debug(
-      "encoding EPS_NAS_Security_Algorithms iei(0x%x)", _iei);
-  int encoded_size = 0;
-  if (len < 2) {
-    Logger::nas_mm().error("len is less than 2");
-    return -1;
-  }
+void EpsNasSecurityAlgorithms::Set(
+    uint8_t ciphering, uint8_t integrity_protection) {
+  type_of_ciphering_algorithm_            = ciphering & 0x0f;
+  type_of_integrity_protection_algorithm_ = integrity_protection & 0x0f;
+}
+//------------------------------------------------------------------------------
+void EpsNasSecurityAlgorithms::Get(
+    uint8_t& ciphering, uint8_t& integrity_protection) const {
+  ciphering            = type_of_ciphering_algorithm_;
+  integrity_protection = type_of_integrity_protection_algorithm_;
+}
+
+//------------------------------------------------------------------------------
+int EpsNasSecurityAlgorithms::Encode(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
 
-  else {
-    *(buf + encoded_size) = _iei;
-    encoded_size++;
-    *(buf + encoded_size) =
-        ((CIPHERING & 0x07) << 4) | (INTEGRITY_PROTECTION & 0x07);
-    encoded_size++;
-    Logger::nas_mm().debug("encoded EPS_NAS_Security_Algorithms IE 0x%x", *buf);
+  if (len < kEpsNasSecurityAlgorithmsLength) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kEpsNasSecurityAlgorithmsLength);
+    return KEncodeDecodeError;
   }
+  int encoded_size = 0;
+
+  // IEI
+  encoded_size += Type3NasIe::Encode(buf + encoded_size, len);
+
+  uint8_t octet = 0;
+  octet         = ((type_of_ciphering_algorithm_ & 0x07) << 4) |
+          (type_of_integrity_protection_algorithm_ & 0x07);
+
+  ENCODE_U8(buf + encoded_size, octet, encoded_size);
+
+  Logger::nas_mm().debug(
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int EPS_NAS_Security_Algorithms::Decode(uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("decoding EPS_NAS_Security_Algorithms IE");
-  if (len < 2) {
-    Logger::nas_mm().error("len is less than 2");
-    return 0;
-  } else {
-    int decoded_size = 0;
-    decoded_size++;
-    CIPHERING            = (*(buf + decoded_size) & 0x70) >> 4;
-    INTEGRITY_PROTECTION = *(buf + decoded_size) & 0x07;
-    decoded_size++;
-    Logger::nas_mm().debug(
-        "decoded NAS_Security_Algorithms len 1 "
-        "octet,CIPHERING=0x%x,INTEGRITY_PROTECTION=0x%x",
-        CIPHERING, INTEGRITY_PROTECTION);
-    return decoded_size;
+int EpsNasSecurityAlgorithms::Decode(uint8_t* buf, int len, bool is_iei) {
+  Logger::nas_mm().debug("Decoding %s", GetIeName().c_str());
+
+  if (len < kEpsNasSecurityAlgorithmsLength) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kEpsNasSecurityAlgorithmsLength);
+    return KEncodeDecodeError;
   }
+
+  int decoded_size = 0;
+
+  // IEI and Length
+  decoded_size += Type3NasIe::Decode(buf + decoded_size, len, is_iei);
+
+  uint8_t octet = 0;
+  DECODE_U8(buf + decoded_size, octet, decoded_size);
+
+  type_of_ciphering_algorithm_            = (octet & 0x70) >> 4;
+  type_of_integrity_protection_algorithm_ = octet & 0x07;
+
+  Logger::nas_mm().debug(
+      "Decoded %s, len (%d)", GetIeName().c_str(), decoded_size);
+  return decoded_size;
 }

src/nas/ies/EPS_NAS_Security_Algorithms.hpp → src/nas/ies/EpsNasSecurityAlgorithms.hpp

@@ -19,37 +19,37 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
+#ifndef _EPS_NAS_SECURITY_ALGORITHS_H
+#define _EPS_NAS_SECURITY_ALGORITHS_H
 
-#ifndef __EPS_NAS_Security_Algorithms_H
-#define __EPS_NAS_Security_Algorithms_H
+#include "Type3NasIe.hpp"
 
-#include <stdint.h>
+constexpr uint8_t kEpsNasSecurityAlgorithmsLength = 2;
+constexpr auto kEpsNasSecurityAlgorithmsIeName = "EPS NAS Security Algorithms";
 
 namespace nas {
 
-class EPS_NAS_Security_Algorithms {
+class EpsNasSecurityAlgorithms : public Type3NasIe {
  public:
-  EPS_NAS_Security_Algorithms();
-  ~EPS_NAS_Security_Algorithms();
-  EPS_NAS_Security_Algorithms(
-      uint8_t iei, uint8_t ciphering, uint8_t integrity_protection);
+  EpsNasSecurityAlgorithms();
+  EpsNasSecurityAlgorithms(uint8_t ciphering, uint8_t integrity_protection);
+  ~EpsNasSecurityAlgorithms();
+
   void SetTypeOfCipheringAlgorithm(uint8_t value);
+  uint8_t GetTypeOfCipheringAlgorithm() const;
+
   void SetTypeOfIntegrityProtectionAlgorithm(uint8_t value);
-  uint8_t GetTypeOfCipheringAlgorithm();
-  uint8_t GetTypeOfIntegrityProtectionAlgorithm();
+  uint8_t GetTypeOfIntegrityProtectionAlgorithm() const;
+
+  void Set(uint8_t ciphering, uint8_t integrity_protection);
+  void Get(uint8_t& ciphering, uint8_t& integrity_protection) const;
+
   int Encode(uint8_t* buf, int len);
-  int Decode(uint8_t* buf, int len, bool is_option);
+  int Decode(uint8_t* buf, int len, bool is_iei);
 
  private:
-  uint8_t _iei;
-  uint8_t CIPHERING;
-  uint8_t INTEGRITY_PROTECTION;
+  uint8_t type_of_ciphering_algorithm_;
+  uint8_t type_of_integrity_protection_algorithm_;
 };
 
 }  // namespace nas

src/nas/ies/IMEISV_Request.cpp → src/nas/ies/ImeisvRequest.cpp

@@ -19,82 +19,32 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#include "IMEISV_Request.hpp"
+#include "ImeisvRequest.hpp"
 
 #include "logger.hpp"
 using namespace nas;
 
 //------------------------------------------------------------------------------
-IMEISV_Request::IMEISV_Request(uint8_t iei) {
-  _iei   = iei;
-  _value = 0;
-}
-
-//------------------------------------------------------------------------------
-IMEISV_Request::IMEISV_Request(const uint8_t iei, uint8_t value) {
-  _iei   = iei;
-  _value = value;
+ImeisvRequest::ImeisvRequest() : Type1NasIeFormatTv(kIeiImeisvRequest) {
+  SetIeName(kImeisvRequestIeName);
 }
 
 //------------------------------------------------------------------------------
-IMEISV_Request::IMEISV_Request() : _iei(), _value() {}
-
-//------------------------------------------------------------------------------
-IMEISV_Request::~IMEISV_Request() {}
-
-//------------------------------------------------------------------------------
-void IMEISV_Request::setValue(uint8_t value) {
-  _value = value;
+ImeisvRequest::ImeisvRequest(uint8_t value)
+    : Type1NasIeFormatTv(kIeiImeisvRequest) {
+  SetValue(value & 0x07);
+  SetIeName(kImeisvRequestIeName);
 }
 
 //------------------------------------------------------------------------------
-uint8_t IMEISV_Request::getValue() {
-  return _value;
-}
+ImeisvRequest::~ImeisvRequest() {}
 
 //------------------------------------------------------------------------------
-int IMEISV_Request::Encode(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("Encoding IMEISV_Request iei (0x%x)", _iei);
-  if (len < 1) {
-    Logger::nas_mm().error("Len is less than 1");
-    return 0;
-  }
-  uint8_t octet = 0;
-  if (!(_iei & 0x0f)) {
-    // octet = (0x0f) & ((tsc << 3) | key_id);
-    //*buf = octet;
-    // Logger::nas_mm().debug("encoded Payload_Container_Type IE(len(1/2
-    // octet))"); return 0;
-  } else {
-    octet = (_iei << 4) | (_value & 0x07);
-    *buf  = octet;
-    Logger::nas_mm().debug("Encoded IMEISV_Request IE (len - 1 octet)");
-    return 1;
-  }
-  return 1;
+void ImeisvRequest::Set(uint8_t value) {
+  SetValue(value & 0x07);
 }
 
 //------------------------------------------------------------------------------
-int IMEISV_Request::Decode(uint8_t* buf, int len, bool is_option) {
-  if (len < 1) {
-    Logger::nas_mm().error("Len is less than one");
-    return 0;
-  } else {
-    uint8_t octet = (*buf);
-    if (is_option) {
-      _iei = (octet & 0xf0) >> 4;
-    } else {
-      _iei = 0;
-    }
-    _value = octet & 0x07;
-    Logger::nas_mm().debug("Decoded IMEISV_Request value (0x%x)", _value);
-    return 1;
-  }
+uint8_t ImeisvRequest::Get() const {
+  return GetValue() & 0x07;
 }

src/nas/ies/IMEISV_Request.hpp → src/nas/ies/ImeisvRequest.hpp

@@ -19,34 +19,25 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
+#ifndef _IMEISV_REQUEST_H_
+#define _IMEISV_REQUEST_H_
 
-#ifndef __IMEISV_Request_H_
-#define __IMEISV_Request_H_
+#include "Type1NasIeFormatTv.hpp"
 
-#include <stdint.h>
+constexpr auto kImeisvRequestIeName = "IMEISV Request";
 
 namespace nas {
 
-class IMEISV_Request {
+class ImeisvRequest : public Type1NasIeFormatTv {
  public:
-  IMEISV_Request();
-  IMEISV_Request(uint8_t iei);
-  IMEISV_Request(const uint8_t iei, uint8_t value);
-  ~IMEISV_Request();
-  int Encode(uint8_t* buf, int len);
-  int Decode(uint8_t* buf, int len, bool is_option);
-  void setValue(uint8_t value);
-  uint8_t getValue();
+  ImeisvRequest();
+  ImeisvRequest(uint8_t value);
+  ~ImeisvRequest();
+
+  void Set(uint8_t value);
+  uint8_t Get() const;
 
  private:
-  uint8_t _iei;
-  uint8_t _value;
 };
 }  // namespace nas
 

src/nas/msgs/SecurityModeCommand.cpp

@@ -71,15 +71,14 @@ void SecurityModeCommand::setUE_Security_Capability(
 
 //------------------------------------------------------------------------------
 void SecurityModeCommand::setIMEISV_Request(uint8_t value) {
-  ie_imeisv_request = std::make_optional<IMEISV_Request>(0x0E, value);
+  ie_imeisv_request = std::make_optional<ImeisvRequest>(value);
 }
 
 //------------------------------------------------------------------------------
 void SecurityModeCommand::setEPS_NAS_Security_Algorithms(
     uint8_t ciphering, uint8_t integrity) {
   ie_eps_nas_security_algorithms =
-      std::make_optional<EPS_NAS_Security_Algorithms>(
-          0x57, ciphering, integrity);
+      std::make_optional<EpsNasSecurityAlgorithms>(ciphering, integrity);
 }
 
 //------------------------------------------------------------------------------
@@ -267,31 +266,31 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("First option IEI (0x%x)", octet);
   while ((octet != 0x0)) {
     switch ((octet & 0xf0) >> 4) {
-      case 0xE: {
-        Logger::nas_mm().debug("Decoding IEI (0xE)");
-        IMEISV_Request ie_imeisv_request_tmp = {};
+      case kIeiImeisvRequest: {
+        Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiImeisvRequest);
+        ImeisvRequest ie_imeisv_request_tmp = {};
         if ((decoded_result = ie_imeisv_request_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
             KEncodeDecodeError)
           return decoded_result;
         decoded_size += decoded_result;
-        ie_imeisv_request =
-            std::optional<IMEISV_Request>(ie_imeisv_request_tmp);
-        octet = *(buf + decoded_size);
+        ie_imeisv_request = std::optional<ImeisvRequest>(ie_imeisv_request_tmp);
+        octet             = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
     }
     switch (octet) {
-      case 0x57: {
-        Logger::nas_mm().debug("decoding IEI (0x57)");
-        EPS_NAS_Security_Algorithms ie_eps_nas_security_algorithms_tmp = {};
+      case kIeiEpsNasSecurityAlgorithms: {
+        Logger::nas_mm().debug(
+            "decoding IEI 0x%x", kIeiEpsNasSecurityAlgorithms);
+        EpsNasSecurityAlgorithms ie_eps_nas_security_algorithms_tmp = {};
         if ((decoded_result = ie_eps_nas_security_algorithms_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
             KEncodeDecodeError)
           return decoded_result;
         decoded_size += decoded_result;
         ie_eps_nas_security_algorithms =
-            std::optional<EPS_NAS_Security_Algorithms>(
+            std::optional<EpsNasSecurityAlgorithms>(
                 ie_eps_nas_security_algorithms_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);

src/nas/msgs/SecurityModeCommand.hpp

@@ -71,8 +71,8 @@ class SecurityModeCommand : public NasMmPlainHeader {
   NasKeySetIdentifier ie_ngKSI;                               // Mandatory
   UESecurityCapability ie_ue_security_capability;             // Mandatory
 
-  std::optional<IMEISV_Request> ie_imeisv_request;  // Optional
-  std::optional<EPS_NAS_Security_Algorithms>
+  std::optional<ImeisvRequest> ie_imeisv_request;  // Optional
+  std::optional<EpsNasSecurityAlgorithms>
       ie_eps_nas_security_algorithms;  // Optional
   std::optional<Additional_5G_Security_Information>
       ie_additional_5G_security_information;  // Optional