Enhance security tests group (ff1a5e5c) · Commits · INT - Core Network and Interoperability Testing / 5G Core / NAS

ccsrc/Externals/LIB_NG_NAS_Functions_ext.cc

+21 −23

Original line number	Diff line number	Diff line
		@@ -106,7 +106,7 @@ namespace LIB__NG__NAS__Functions {
		} // End of 'for' statement
		OCTETSTRING os(8, static_cast<const unsigned char*>(&mac_a[0]));
		p_mac_a = oct2bit(os);
		loggers::get_instance().log_msg("fx__f1star: p_mac_a: ", os);
		loggers::get_instance().log_msg("fx__f1: p_mac_a: ", os);

		return 0;
		}
		@@ -174,8 +174,8 @@ namespace LIB__NG__NAS__Functions {
		}

		INTEGER fx__f2345(const BITSTRING& p_authK, const BITSTRING& p_rand, BITSTRING& p_res, BITSTRING& p_ck, BITSTRING& p_ik, BITSTRING& p_ak) {
		loggers::get_instance().log_msg(">>> fx_f2345: p_authK: ", p_authK);
		loggers::get_instance().log_msg(">>> fx_f2345: p_rand: ", p_rand);
		loggers::get_instance().log_msg(">>> fx__f2345: p_authK: ", bit2oct(p_authK));
		loggers::get_instance().log_msg(">>> fx__f2345: p_rand: ", bit2oct(p_rand));

		rijndael r;
		OCTETSTRING authK = bit2oct(p_authK);
		@@ -183,7 +183,7 @@ namespace LIB__NG__NAS__Functions {
		opc op(r, OP);
		uint8_t op_c[16] = { 0x00 };
		op.compute_opc(op_c);
		loggers::get_instance().log_to_hexa("fx_f2345: a entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", op_c, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: a entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", op_c, 16);

		OCTETSTRING rand = bit2oct(p_rand);
		uint8_t rijndael_input[16] = { 0x00 };
		@@ -192,18 +192,18 @@ namespace LIB__NG__NAS__Functions {
		} // End of 'for' statement
		uint8_t temp[16] = { 0x00 };
		r.rijndael_encrypt(rijndael_input, temp);
		loggers::get_instance().log_to_hexa("fx_f2345: Value after 1st encryption: ", temp, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: Value after 1st encryption: ", temp, 16);

		// To obtain output block OUT2: XOR OPc and TEMP, rotate by r2=0, and XOR on the constant c2 (which is all zeroes except that the last bit is 1)
		for (int i = 0; i < 16; i++) {
		rijndael_input[i] = temp[i] ^ op_c[i];
		} // End of 'for' statement
		rijndael_input[15] ^= 1;
		loggers::get_instance().log_to_hexa("fx_f2345: b entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", rijndael_input, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: b entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", rijndael_input, 16);

		uint8_t out[16] = { 0x00 };
		r.rijndael_encrypt(rijndael_input, out);
		loggers::get_instance().log_to_hexa("fx_f2345: f2/d entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", out, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: f2/d entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", out, 16);

		for (int i = 0; i < 16; i++) {
		out[i] ^= op_c[i];
		@@ -213,22 +213,22 @@ namespace LIB__NG__NAS__Functions {
		for (int i = 0; i < 8; i++) {
		res[i] = out[i + 8];
		} // End of 'for' statement
		loggers::get_instance().log_to_hexa("fx_f2345: f2/e entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", res, 8);
		loggers::get_instance().log_to_hexa("fx__f2345: f2/e entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", res, 8);

		uint8_t ak[6] = { 0x00 };
		for (int i = 0; i < 6; i++) {
		ak[i] = out[i];
		} // End of 'for' statement
		loggers::get_instance().log_to_hexa("fx_f2345: f5/e entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", ak, 6);
		loggers::get_instance().log_to_hexa("fx__f2345: f5/e entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", ak, 6);

		// To obtain output block OUT3: XOR OPc and TEMP, rotate by r3=32, and XOR on the constant c3 (which is all zeroes except that the next to last bit is 1)
		for (int i = 0; i < 16; i++) {
		rijndael_input[(i + 12) % 16] = temp[i] ^ op_c[i];
		} // End of 'for' statement
		rijndael_input[15] ^= 2;
		loggers::get_instance().log_to_hexa("fx_f2345: f3/c entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", out, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: f3/c entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", out, 16);
		r.rijndael_encrypt(rijndael_input, out);
		loggers::get_instance().log_to_hexa("fx_f2345: f3/d entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", out, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: f3/d entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", out, 16);

		for (int i = 0; i < 16; i++) {
		out[i] ^= op_c[i];
		@@ -238,16 +238,16 @@ namespace LIB__NG__NAS__Functions {
		for (int i = 0; i < 16; i++) {
		ck[i] = out[i];
		} // End of 'for' statement
		loggers::get_instance().log_to_hexa("fx_f2345: f3/e entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", ck, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: f3/e entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 5.x Test Set table: ", ck, 16);

		// To obtain output block OUT4: XOR OPc and TEMP, rotate by r4=64, and XOR on the constant c4 (which is all zeroes except that the 2nd from last bit is 1)
		for (int i = 0; i < 16; i++) {
		rijndael_input[(i+8) % 16] = temp[i] ^ op_c[i];
		} // End of 'for' statement
		rijndael_input[15] ^= 4;
		loggers::get_instance().log_to_hexa("fx_f2345: f4/c entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", rijndael_input, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: f4/c entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", rijndael_input, 16);
		r.rijndael_encrypt(rijndael_input, out);
		loggers::get_instance().log_to_hexa("fx_f2345: f4/d entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", out, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: f4/d entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", out, 16);

		for (int i = 0; i < 16; i++) {
		out[i] ^= op_c[i];
		@@ -257,7 +257,7 @@ namespace LIB__NG__NAS__Functions {
		for (int i = 0; i < 16; i++) {
		ik[i] = out[i];
		} // End of 'for' statement
		loggers::get_instance().log_to_hexa("fx_f2345: f4/e entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", ik, 16);
		loggers::get_instance().log_to_hexa("fx__f2345: f4/e entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", ik, 16);

		OCTETSTRING os(8, static_cast<const unsigned char*>(&res[0]));
		p_res = oct2bit(os);
		@@ -267,10 +267,10 @@ namespace LIB__NG__NAS__Functions {
		p_ik = oct2bit(os);
		os = OCTETSTRING(6, static_cast<const unsigned char*>(&ak[0]));
		p_ak = oct2bit(os);
		loggers::get_instance().log_msg("fx_f2345: p_res: ", bit2oct(p_res));
		loggers::get_instance().log_msg("fx_f2345: p_ck: ", bit2oct(p_ck));
		loggers::get_instance().log_msg("fx_f2345: p_ik: ", bit2oct(p_ik));
		loggers::get_instance().log_msg("fx_f2345: p_ak: ", bit2oct(p_ak));
		loggers::get_instance().log_msg("fx__f2345: p_res: ", bit2oct(p_res));
		loggers::get_instance().log_msg("fx__f2345: p_ck: ", bit2oct(p_ck));
		loggers::get_instance().log_msg("fx__f2345: p_ik: ", bit2oct(p_ik));
		loggers::get_instance().log_msg("fx__f2345: p_ak: ", bit2oct(p_ak));

		return 0;
		}
		@@ -287,14 +287,12 @@ namespace LIB__NG__NAS__Functions {
		op.compute_opc(op_c);
		loggers::get_instance().log_to_hexa("fx__f5star: a entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", op_c, 16);


		OCTETSTRING rand = bit2oct(p_rand);
		uint8_t rijndael_input[16] = { 0x00 };
		for (int i = 0; i < 16; i++) {
		rijndael_input[i] = rand[i].get_octet() ^ op_c[i];
		} // End of 'for' statement
		uint8_t temp[16] = { 0x00 };
		loggers::get_instance().log_to_hexa("fx__f5star: Before 1st encryption: ", rijndael_input, 16);
		r.rijndael_encrypt(rijndael_input, temp);

		// To obtain output block OUT5: XOR OPc and TEMP, rotate by r5=96, and XOR on the constant c5 (which is all zeroes except that the 3rd from last bit is 1)
		@@ -303,9 +301,9 @@ namespace LIB__NG__NAS__Functions {
		} // End of 'for' statement
		rijndael_input[15] ^= 8;
		uint8_t out[16] = { 0x00 };
		loggers::get_instance().log_to_hexa("fx__f5star: Before 2sd encryption: ", rijndael_input, 16);
		loggers::get_instance().log_to_hexa("fx__f5star: f5*/c entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", rijndael_input, 16);
		r.rijndael_encrypt(rijndael_input, out);
		loggers::get_instance().log_to_hexa("fx__f5star: After 2sd encryption: ", out, 16);
		loggers::get_instance().log_to_hexa("fx__f5star: f5*/d entry in ETSI TS 135 207 V16.0.0 (2020-08) Clause 6.x Test Set table: ", out, 16);
		for (int i = 0; i < 16; i++) {
		out[i] ^= op_c[i];
		} // End of 'for' statement

ccsrc/Externals/common_ext.cc

+118 −62

Original line number	Diff line number	Diff line
		@@ -9,6 +9,7 @@
		//#include "converter.hh"
		#include "loggers.hh"

		#include "sha256.hh"
		#include "hmac.hh"

		#ifndef M_PI
		@@ -29,17 +30,44 @@ namespace CommonDefs {
		BITSTRING fx__KeyDerivationFunction(const INTEGER& p__KDF, const BITSTRING& p__Key, const OCTETSTRING& p__String){
		loggers::get_instance().log_msg(">>> fx__KeyDerivationFunction: p__KDF: ", p__KDF);
		loggers::get_instance().log_msg(">>> fx__KeyDerivationFunction: p__Key: ", bit2oct(p__Key));
		loggers::get_instance().log_msg(">>> fx__KeyDerivationFunction: p__String: ", p__String);

		hmac h; // hash_algorithms::sha_256: p__KDF == 1 (tsc_KDF_HMAC_SHA_256 see CommonDefs.ttcn)
		if (p__KDF == 1) { // tsc_KDF_HMAC_SHA_256 see CommonDefs.ttcn
		hmac h;
		OCTETSTRING res;
		if (h.generate(p__String, bit2oct(p__Key), res) == -1) {
		if (h.generate(p__String, bit2oct(p__Key), res, false) == -1) {
		loggers::get_instance().error("fx__KeyDerivationFunction: Key derivation failed");
		return int2bit(0, 0);
		}

		loggers::get_instance().log_msg("<<< fx__KeyDerivationFunction: res: ", res);
		return oct2bit(res);
		} else {
		loggers::get_instance().error("fx__KeyDerivationFunction: Unsupported KDF: %d", p__KDF);
		return int2bit(0, 0);
		}
		}

		/**
		* @desc This external function compute the SHA 256 hash of a string
		* @param p__String The string to hash
		* @return The SHA 256 hash of the specified string
		* @see fx_sha256(in octetstring p_String) return B256_Type
		*/
		BITSTRING fx__sha256(const OCTETSTRING& p__String){
		loggers::get_instance().log_msg(">>> fx__sha256: p__String: ", p__String);

		sha256 sha;
		OCTETSTRING res;
		if (sha.generate(p__String, res) == -1) {
		loggers::get_instance().error("fx__sha256: Key derivation failed");
		return int2bit(0, 0);
		}

		loggers::get_instance().log_msg("<<< fx__sha256: res: ", res);
		return oct2bit(res);
		}

		/**
		* @desc This external function gets the current time since 01/01/1970 in UTC format
		* @return The current time since 01/01/1970 in UTC format in milliseconds
		@@ -56,7 +84,35 @@ void fx__GetSystemTime(CommonDefs::Struct__tm__Type& p__Struct__tm, INTEGER& p_
		}
		//void fx__CalculateFCS32(BITSTRING const&) {
		BITSTRING fx__CalculateFCS32(const BITSTRING& p__TMSI){
		loggers::get_instance().log_msg(">>> fx__CalculateFCS32: p__TMSI: ", p__TMSI);

		// Sanity checks
		if (p__TMSI.lengthof() == 0) {
		loggers::get_instance().error("fx__CalculateFCS32: Empty TMSI");
		return int2bit(0, 0);
		}

		OCTETSTRING os = bit2oct(p__TMSI);
		const unsigned char data = static_cast<const unsigned char >(os);
		if (data == NULL) {
		loggers::get_instance().error("fx__CalculateFCS32: Failed to get data buffer");
		return int2bit(0, 0);
		}
		unsigned int crc = 0xffffffff;
		for (size_t i = 0; i < os.lengthof(); i++) {
		unsigned int val = (crc ^ os[i].get_octet()) & 0xFF;
		for(size_t j = 0; j < 8; j++){
		val = val & 0x1 ? (val >> 1) ^ 0xEDB88320 : val >> 1; // 0xEDB88320 is the reverse of 0x04C11DB7
		} // End of 'for' statement
		crc = val ^ crc >> 8;
		} // End of 'for' statement
		crc ^= 0xffffffff;

		crc = ((crc & 0xFF) << 24) \| ((crc & 0xFF00) << 8) \| ((crc & 0xFF0000) >> 8) \| ((crc & 0xFF000000) >> 24); // Reverse the bits of the CRC value
		OCTETSTRING crc_os(4, (const unsigned char*)&crc);
		loggers::get_instance().log_msg("fx__CalculateFCS32: crc: ", crc_os);

		return oct2bit(crc_os);
		}

		} // namespace CommonDefs

etc/Ats_NG_NAS/AtsNGAP_AMF.cfg_

+51 −25

Original line number	Diff line number	Diff line
		@@ -10,9 +10,16 @@ LibNGAP_Pixits.PX_AMF_NAME := "Kontron5G-amf"
		LibNGAP_Pixits.PX_RAN_UE_NGAP_ID := 0
		LibNGAP_Pixits.PX_AMF_UE_NGAP_ID := 22
		LibNGAP_Pixits.PX_PLMN_IDENTITY := '00f110'O
		LibNGAP_Pixits.PX_GNB_ID := '0000000000000001001110'B

		Lib_NG_NAS_Pixits.PX_SUPI_FORMAT := '0000'B
		Lib_NG_NAS_Pixits.PX_SUPI_DIGITS := '00f110214300014444330302'O
		Lib_NG_NAS_Pixits.PX_USIM_OPERATOR_VARIANT_ALGORITHM_CONFIGURATION := '00000000000000000000000000000000'O
		Lib_NG_NAS_Pixits.PX_LONG_TERM_KEY := '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'B
		Lib_NG_NAS_Pixits.PX_PLMN := '000000'O;


		NAS_5GC_Parameters.px_NAS_5GC_XRES_Length := 8 # In ETSI TS 135 206 V16.0.0 (2020-08) Table Table 5. f2 output, RES length is 8 octets (64 bits)

		[LOGGING]
		# In this section you can specify the name of the log file and the classes of events
		@@ -59,30 +66,8 @@ system.N2_gNBaMF_P.params := "NGAP/SCTP_FILE/IP_OFFLINE/ETH(mac_src=8c554ac1eee0
		# In this section you can specify what parts of your test suite you want to execute.
		#AtsImsIot_TestControl.control

		#NG_NAS_TestCases.TC_5G_AKA_RIJNDAEL_FUNCTIONS_TEST_01_01
		#NG_NAS_TestCases.TC_5G_AKA_RIJNDAEL_FUNCTIONS_TEST_01_02
		#NG_NAS_TestCases.TC_5G_AKA_RIJNDAEL_FUNCTIONS_TEST_01_03
		#NG_NAS_TestCases.TC_5G_AKA_RIJNDAEL_FUNCTIONS_TEST_01_04

		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_02_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_02_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_02_03
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_03
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_04_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_04_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_04_03
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_05_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_05_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_05_03
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_06_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_07_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_08_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_09_01
		NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_10_01

		#NG_NAS_TestCases.TC_5GNAS_AMF_AUT_REQ_01
		#NG_NAS_TestCases.TC_5GNAS_AMF_AUT_REQ_02
		###########################NG_NAS_TestCases.TC_5GNAS_AMF_AUT_REQ_02
		#NG_NAS_TestCases.TC_5GNAS_AMF_AUT_REQ_03
		#NG_NAS_TestCases.TC_5GNAS_AMF_AUT_REQ_04
		#NG_NAS_TestCases.TC_5GNAS_AMF_AUT_REQ_05
		@@ -104,6 +89,47 @@ NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_10_01
		#NG_NAS_TestCases.TC_5GNAS_AMF_DRG_REQ_02
		#NG_NAS_TestCases.TC_5GNAS_AMF_DRG_REQ_03


		#NG_NAS_TestCases.TC_5G_AKA_RIJNDAEL_FUNCTIONS_TEST_01_01
		#NG_NAS_TestCases.TC_5G_AKA_RIJNDAEL_FUNCTIONS_TEST_01_02
		#NG_NAS_TestCases.TC_5G_AKA_RIJNDAEL_FUNCTIONS_TEST_01_03
		#NG_NAS_TestCases.TC_5G_AKA_RIJNDAEL_FUNCTIONS_TEST_01_04
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_02_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_02_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_02_03
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_03
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_04_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_04_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_04_03
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_05_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_05_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_05_03
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_06_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_06_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_07_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_07_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_08_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_08_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_09_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_09_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_10_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_10_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_11
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_12_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_12_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_13
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_14_01
		#G_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_14_02
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_15_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_16_01
		NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_17_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_17_02
		NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_17_03
		NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_18_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_19_01
		#NG_NAS_TestCases.TC_5G_AKA_CRYPTO_FUNCTIONS_TEST_20_01

		[GROUPS]
		# In this section you can specify groups of hosts. These groups can be used inside the
		# [COMPONENTS] section to restrict the creation of certain PTCs to a given set of hosts.

titan-test-system-framework @ f8843ac9

Original line number	Diff line number	Diff line
		Subproject commit 9ed59ebd3c0a769688262f2370f6d3c3507b2a5f
		Subproject commit f8843ac9740f8efe537f4938918920c8e8f8e692

ttcn/Ats_NG_NAS/NG_NAS_TCFunctions.ttcn

+46 −40

File changed.

Preview size limit exceeded, changes collapsed.