Skip to content

O
OpenXG-AMF
Commit 3e503cfb authored by Tien Thinh NGUYEN's avatar Tien Thinh NGUYEN
Browse files
Options

Update IMEISV Request and EPS NAS Security Alg

parent 2542778d
Hide whitespace changes
Inline Side-by-side
Showing with 238 additions and 63 deletions
src/nas/common/Ie_Const.hpp
View file @ 3e503cfb
......@@ -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
View file @ 3e503cfb
......@@ -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
View file @ 3e503cfb
......@@ -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
View file @ 3e503cfb
......@@ -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
View file @ 3e503cfb
......@@ -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
View file @ 3e503cfb
......@@ -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
View file @ 3e503cfb
......@@ -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
View file @ 3e503cfb
......@@ -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
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment