5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Applied clang-format to zuc_support PR.

Browse Source
master
Pedro Alvarez 5 years ago committed by Andre Puschmann
parent 595185d4b5
commit 004db4a067
12 changed files with 329 additions and 409 deletions
Show Stats Download Patch File Download Diff File

1
lib/include/srslte/common/liblte_security.h
Unescape Escape View File

@ -38,7 +38,6 @@
#include "srslte/asn1/liblte_common.h" #include "srslte/asn1/liblte_common.h"
/******************************************************************************* /*******************************************************************************
DEFINES DEFINES
*******************************************************************************/ *******************************************************************************/

100
lib/include/srslte/common/security.h
Unescape Escape View File

@ -103,90 +103,40 @@ uint8_t security_generate_k_up( uint8_t *k_enb,
/****************************************************************************** /******************************************************************************
* Integrity Protection * Integrity Protection
*****************************************************************************/ *****************************************************************************/
uint8_t security_128_eia1( uint8_t *key, uint8_t security_128_eia1(
uint32_t count, uint8_t* key, uint32_t count, uint32_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* mac);
uint32_t bearer,
uint8_t direction,
uint8_t *msg,
uint32_t msg_len,
uint8_t *mac);
uint8_t security_128_eia2( uint8_t *key,
uint32_t count,
uint32_t bearer,
uint8_t direction,
uint8_t *msg,
uint32_t msg_len,
uint8_t *mac);
uint8_t security_128_eia3( uint8_t *key,
uint32_t count,
uint32_t bearer,
uint8_t direction,
uint8_t *msg,
uint32_t msg_len,
uint8_t *mac);
uint8_t security_md5(const uint8_t *input,
size_t len,
uint8_t *output);
uint8_t security_128_eia2(
uint8_t* key, uint32_t count, uint32_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* mac);
uint8_t security_128_eia3(
uint8_t* key, uint32_t count, uint32_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* mac);
uint8_t security_md5(const uint8_t* input, size_t len, uint8_t* output);
/****************************************************************************** /******************************************************************************
* Encryption / Decryption * Encryption / Decryption
*****************************************************************************/ *****************************************************************************/
uint8_t security_128_eea1( uint8_t *key, uint8_t security_128_eea1(
uint32_t count, uint8_t* key, uint32_t count, uint8_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* msg_out);
uint8_t bearer,
uint8_t direction, uint8_t security_128_eea2(
uint8_t *msg, uint8_t* key, uint32_t count, uint8_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* msg_out);
uint32_t msg_len,
uint8_t *msg_out); uint8_t security_128_eea3(
uint8_t* key, uint32_t count, uint8_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* msg_out);
uint8_t security_128_eea2(uint8_t *key,
uint32_t count,
uint8_t bearer,
uint8_t direction,
uint8_t *msg,
uint32_t msg_len,
uint8_t *msg_out);
uint8_t security_128_eea3(uint8_t *key,
uint32_t count,
uint8_t bearer,
uint8_t direction,
uint8_t *msg,
uint32_t msg_len,
uint8_t *msg_out);
/****************************************************************************** /******************************************************************************
* Authentication * Authentication
*****************************************************************************/ *****************************************************************************/
uint8_t compute_opc( uint8_t *k, uint8_t compute_opc(uint8_t* k, uint8_t* op, uint8_t* opc);
uint8_t *op,
uint8_t *opc); uint8_t security_milenage_f1(uint8_t* k, uint8_t* op, uint8_t* rand, uint8_t* sqn, uint8_t* amf, uint8_t* mac_a);
uint8_t security_milenage_f1( uint8_t *k, uint8_t security_milenage_f1_star(uint8_t* k, uint8_t* op, uint8_t* rand, uint8_t* sqn, uint8_t* amf, uint8_t* mac_s);
uint8_t *op,
uint8_t *rand, uint8_t
uint8_t *sqn, security_milenage_f2345(uint8_t* k, uint8_t* op, uint8_t* rand, uint8_t* res, uint8_t* ck, uint8_t* ik, uint8_t* ak);
uint8_t *amf,
uint8_t *mac_a);
uint8_t security_milenage_f1_star( uint8_t *k,
uint8_t *op,
uint8_t *rand,
uint8_t *sqn,
uint8_t *amf,
uint8_t *mac_s);
uint8_t security_milenage_f2345( uint8_t *k,
uint8_t *op,
uint8_t *rand,
uint8_t *res,
uint8_t *ck,
uint8_t *ik,
uint8_t *ak);
uint8_t security_milenage_f5_star( uint8_t *k, uint8_t security_milenage_f5_star( uint8_t *k,
uint8_t *op, uint8_t *op,

4
lib/include/srslte/common/zuc.h
Unescape Escape View File

@ -32,7 +32,7 @@ typedef struct {
u32 BRC_X3; u32 BRC_X3;
} zuc_state_t; } zuc_state_t;
void zuc_initialize(zuc_state_t *state, u8* k, u8* iv); void zuc_initialize(zuc_state_t* state, u8* k, u8* iv);
void zuc_generate_keystream(zuc_state_t *state, int key_stream_len, u32* p_keystream); void zuc_generate_keystream(zuc_state_t* state, int key_stream_len, u32* p_keystream);
#endif // SRSLTE_ZUC_H #endif // SRSLTE_ZUC_H

262
lib/src/common/liblte_security.cc
Unescape Escape View File

@ -35,9 +35,9 @@
*******************************************************************************/ *******************************************************************************/
#include "srslte/common/liblte_security.h" #include "srslte/common/liblte_security.h"
#include "srslte/common/zuc.h"
#include "math.h" #include "math.h"
#include "srslte/common/liblte_ssl.h" #include "srslte/common/liblte_ssl.h"
#include "srslte/common/zuc.h"
/******************************************************************************* /*******************************************************************************
DEFINES DEFINES
@ -808,89 +808,86 @@ LIBLTE_ERROR_ENUM liblte_security_128_eia2(
return (err); return (err);
} }
u32 GET_WORD(u32 * DATA, u32 i) u32 GET_WORD(u32* DATA, u32 i)
{ {
u32 WORD, ti; u32 WORD, ti;
ti = i % 32; ti = i % 32;
if (ti == 0) if (ti == 0)
WORD = DATA[i/32]; WORD = DATA[i / 32];
else else
WORD = (DATA[i/32]<<ti) | (DATA[i/32+1]>>(32-ti)); WORD = (DATA[i / 32] << ti) | (DATA[i / 32 + 1] >> (32 - ti));
return WORD; return WORD;
} }
u8 GET_BIT(uint8_t * DATA, u32 i) u8 GET_BIT(uint8_t* DATA, u32 i)
{ {
return (DATA[i/8] & (1<<(7-(i%8)))) ? 1 : 0; return (DATA[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
} }
LIBLTE_ERROR_ENUM liblte_security_128_eia3(uint8* key, uint32 count, uint8 bearer, uint8 direction, uint8* msg, LIBLTE_ERROR_ENUM liblte_security_128_eia3(
uint32 msg_len, uint8* mac) uint8* key, uint32 count, uint8 bearer, uint8 direction, uint8* msg, uint32 msg_len, uint8* mac)
{ {
LIBLTE_ERROR_ENUM err = LIBLTE_ERROR_INVALID_INPUTS; LIBLTE_ERROR_ENUM err = LIBLTE_ERROR_INVALID_INPUTS;
uint8_t iv[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t iv[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint32 *ks; uint32* ks;
uint32 msg_len_block_8, msg_len_block_32, m; uint32 msg_len_block_8, msg_len_block_32, m;
if(key != NULL && if (key != NULL && msg != NULL && mac != NULL) {
msg != NULL && msg_len_block_8 = (msg_len + 7) / 8;
mac != NULL) msg_len_block_32 = (msg_len + 31) / 32;
{
msg_len_block_8 = (msg_len + 7) / 8;
msg_len_block_32 = (msg_len + 31) / 32;
// Construct iv // Construct iv
iv[0] = (count >> 24) & 0xFF; iv[0] = (count >> 24) & 0xFF;
iv[1] = (count >> 16) & 0xFF; iv[1] = (count >> 16) & 0xFF;
iv[2] = (count >> 8) & 0xFF; iv[2] = (count >> 8) & 0xFF;
iv[3] = count & 0xFF; iv[3] = count & 0xFF;
iv[4] = (bearer << 3) & 0xF8; iv[4] = (bearer << 3) & 0xF8;
iv[5] = iv[6] = iv[7] = 0; iv[5] = iv[6] = iv[7] = 0;
iv[8] = ((count >> 24) & 0xFF) ^ ((direction & 1) << 7); iv[8] = ((count >> 24) & 0xFF) ^ ((direction & 1) << 7);
iv[9] = (count >> 16) & 0xFF; iv[9] = (count >> 16) & 0xFF;
iv[10] = (count >> 8) & 0xFF; iv[10] = (count >> 8) & 0xFF;
iv[11] = count & 0xFF; iv[11] = count & 0xFF;
iv[12] = iv[4]; iv[12] = iv[4];
iv[13] = iv[5]; iv[13] = iv[5];
iv[14] = iv[6] ^ ((direction & 1) << 7); iv[14] = iv[6] ^ ((direction & 1) << 7);
iv[15] = iv[7]; iv[15] = iv[7];
zuc_state_t zuc_state; zuc_state_t zuc_state;
// Initialize keystream // Initialize keystream
zuc_initialize(&zuc_state, key, iv); zuc_initialize(&zuc_state, key, iv);
// Generate keystream // Generate keystream
int N = msg_len + 64; int N = msg_len + 64;
int L = (N + 31) / 32; int L = (N + 31) / 32;
ks = (uint32*)calloc(L, sizeof(uint32)); ks = (uint32*)calloc(L, sizeof(uint32));
zuc_generate_keystream(&zuc_state, L, ks); zuc_generate_keystream(&zuc_state, L, ks);
uint32_t T = 0; uint32_t T = 0;
for (uint32_t i = 0; i < msg_len; i++) { for (uint32_t i = 0; i < msg_len; i++) {
if (GET_BIT(msg, i)) { if (GET_BIT(msg, i)) {
T ^= GET_WORD(ks, i); T ^= GET_WORD(ks, i);
} }
} }
T ^= GET_WORD(ks, msg_len); T ^= GET_WORD(ks, msg_len);
uint32_t mac_tmp = T ^ ks[L - 1]; uint32_t mac_tmp = T ^ ks[L - 1];
mac[0] = (mac_tmp >> 24) & 0xFF; mac[0] = (mac_tmp >> 24) & 0xFF;
mac[1] = (mac_tmp >> 16) & 0xFF; mac[1] = (mac_tmp >> 16) & 0xFF;
mac[2] = (mac_tmp >> 8) & 0xFF; mac[2] = (mac_tmp >> 8) & 0xFF;
mac[3] = mac_tmp & 0xFF; mac[3] = mac_tmp & 0xFF;
free(ks); free(ks);
} }
return (err); return (err);
} }
/********************************************************************* /*********************************************************************
@ -1047,83 +1044,75 @@ LIBLTE_ERROR_ENUM liblte_security_decryption_eea2(
Specification of the 3GPP Confidentiality and Specification of the 3GPP Confidentiality and
Integrity Algorithms UEA2 & UIA2 D1 v2.1 Integrity Algorithms UEA2 & UIA2 D1 v2.1
*********************************************************************/ *********************************************************************/
LIBLTE_ERROR_ENUM liblte_security_encryption_eea3(uint8 *key, LIBLTE_ERROR_ENUM liblte_security_encryption_eea3(
uint32 count, uint8* key, uint32 count, uint8 bearer, uint8 direction, uint8* msg, uint32 msg_len, uint8* out)
uint8 bearer,
uint8 direction,
uint8 *msg,
uint32 msg_len,
uint8 *out)
{ {
LIBLTE_ERROR_ENUM err = LIBLTE_ERROR_INVALID_INPUTS; LIBLTE_ERROR_ENUM err = LIBLTE_ERROR_INVALID_INPUTS;
uint8_t iv[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t iv[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint32 *ks; uint32* ks;
int32 i; int32 i;
uint32 msg_len_block_8, msg_len_block_32, m; uint32 msg_len_block_8, msg_len_block_32, m;
if (key != NULL && if (key != NULL && msg != NULL && out != NULL) {
msg != NULL && msg_len_block_8 = (msg_len + 7) / 8;
out != NULL) msg_len_block_32 = (msg_len + 31) / 32;
{
msg_len_block_8 = (msg_len + 7) / 8; // Construct iv
msg_len_block_32 = (msg_len + 31) / 32; iv[0] = (count >> 24) & 0xFF;
iv[1] = (count >> 16) & 0xFF;
// Construct iv iv[2] = (count >> 8) & 0xFF;
iv[0] = (count >> 24) & 0xFF; iv[3] = (count)&0xFF;
iv[1] = (count >> 16) & 0xFF; iv[4] = ((bearer & 0x1F) << 3) | ((direction & 0x01) << 2);
iv[2] = (count >> 8) & 0xFF; iv[5] = 0;
iv[3] = (count)&0xFF; iv[6] = 0;
iv[4] = ((bearer & 0x1F) << 3) | ((direction & 0x01) << 2); iv[7] = 0;
iv[5] = 0; iv[8] = iv[0];
iv[6] = 0; iv[9] = iv[1];
iv[7] = 0; iv[10] = iv[2];
iv[8] = iv[0]; iv[11] = iv[3];
iv[9] = iv[1]; iv[12] = iv[4];
iv[10] = iv[2]; iv[13] = iv[5];
iv[11] = iv[3]; iv[14] = iv[6];
iv[12] = iv[4]; iv[15] = iv[7];
iv[13] = iv[5];
iv[14] = iv[6]; zuc_state_t zuc_state;
iv[15] = iv[7]; // Initialize keystream
zuc_initialize(&zuc_state, key, iv);
zuc_state_t zuc_state;
// Initialize keystream // Generate keystream
zuc_initialize(&zuc_state, key, iv);
ks = (uint32*)calloc(msg_len_block_32, sizeof(uint32));
// Generate keystream zuc_generate_keystream(&zuc_state, msg_len_block_32, ks);
ks = (uint32 *) calloc(msg_len_block_32, sizeof(uint32)); // Generate output except last block
zuc_generate_keystream(&zuc_state, msg_len_block_32, ks); for (i = 0; i < (int32_t)msg_len_block_32 - 1; i++) {
out[4 * i + 0] = msg[4 * i + 0] ^ ((ks[i] >> 24) & 0xFF);
// Generate output except last block out[4 * i + 1] = msg[4 * i + 1] ^ ((ks[i] >> 16) & 0xFF);
for (i = 0; i < (int32_t)msg_len_block_32 - 1; i++) { out[4 * i + 2] = msg[4 * i + 2] ^ ((ks[i] >> 8) & 0xFF);
out[4 * i + 0] = msg[4 * i + 0] ^ ((ks[i] >> 24) & 0xFF); out[4 * i + 3] = msg[4 * i + 3] ^ ((ks[i] & 0xFF));
out[4 * i + 1] = msg[4 * i + 1] ^ ((ks[i] >> 16) & 0xFF); }
out[4 * i + 2] = msg[4 * i + 2] ^ ((ks[i] >> 8) & 0xFF);
out[4 * i + 3] = msg[4 * i + 3] ^ ((ks[i] & 0xFF)); // Process last bytes
} for (i = (msg_len_block_32 - 1) * 4; i < (int32_t)msg_len_block_8; i++) {
out[i] = msg[i] ^ ((ks[i / 4] >> ((3 - (i % 4)) * 8)) & 0xFF);
// Process last bytes }
for (i = (msg_len_block_32 - 1) * 4; i < (int32_t)msg_len_block_8; i++) {
out[i] = msg[i] ^ ((ks[i / 4] >> ((3 - (i % 4)) * 8)) & 0xFF); // Zero tailing bits
} zero_tailing_bits(out, msg_len);
// Zero tailing bits // Clean up
zero_tailing_bits(out, msg_len); free(ks);
// zuc_deinitialize(state_ptr);
// Clean up
free(ks); err = LIBLTE_SUCCESS;
// zuc_deinitialize(state_ptr); }
err = LIBLTE_SUCCESS; return (err);
}
return(err);
} }
LIBLTE_ERROR_ENUM liblte_security_decryption_eea3(uint8* key, uint32 count, uint8 bearer, uint8 direction, uint8* msg, LIBLTE_ERROR_ENUM liblte_security_decryption_eea3(
uint32 msg_len, uint8* out) uint8* key, uint32 count, uint8 bearer, uint8 direction, uint8* msg, uint32 msg_len, uint8* out)
{ {
return liblte_security_encryption_eea3(key, count, bearer, direction, msg, msg_len, out); return liblte_security_encryption_eea3(key, count, bearer, direction, msg, msg_len, out);
} }
@ -1857,6 +1846,3 @@ void s3g_generate_keystream(S3G_STATE* state, uint32 n, uint32* ks)
s3g_clock_lfsr(state, 0x0); s3g_clock_lfsr(state, 0x0);
} }
} }

59
lib/src/common/security.cc
Unescape Escape View File

@ -150,19 +150,19 @@ uint8_t security_128_eia1( uint8_t *key,
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
uint8_t security_128_eia2(uint8_t* key, uint32_t count, uint32_t bearer, uint8_t direction, uint8_t* msg, uint8_t security_128_eia2(
uint32_t msg_len, uint8_t* mac) uint8_t* key, uint32_t count, uint32_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* mac)
{ {
return liblte_security_128_eia2(key, count, bearer, direction, msg, msg_len, mac); return liblte_security_128_eia2(key, count, bearer, direction, msg, msg_len, mac);
} }
uint8_t security_128_eia3(uint8_t* key, uint32_t count, uint32_t bearer, uint8_t direction, uint8_t* msg, uint8_t security_128_eia3(
uint32_t msg_len, uint8_t* mac) uint8_t* key, uint32_t count, uint32_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* mac)
{ {
return liblte_security_128_eia3(key, count, bearer, direction, msg, msg_len * 8, mac); return liblte_security_128_eia3(key, count, bearer, direction, msg, msg_len * 8, mac);
} }
uint8_t security_md5(const uint8_t *input, size_t len, uint8_t *output) uint8_t security_md5(const uint8_t* input, size_t len, uint8_t* output)
{ {
memset(output, 0x00, 16); memset(output, 0x00, 16);
#ifdef HAVE_MBEDTLS #ifdef HAVE_MBEDTLS
@ -174,7 +174,6 @@ uint8_t security_md5(const uint8_t *input, size_t len, uint8_t *output)
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
/****************************************************************************** /******************************************************************************
* Encryption / Decryption * Encryption / Decryption
*****************************************************************************/ *****************************************************************************/
@ -197,54 +196,26 @@ uint8_t security_128_eea1(uint8_t *key,
} }
uint8_t security_128_eea2(
uint8_t* key, uint32_t count, uint8_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* msg_out)
{
uint8_t security_128_eea2(uint8_t *key, return liblte_security_encryption_eea2(key, count, bearer, direction, msg, msg_len * 8, msg_out);
uint32_t count,
uint8_t bearer,
uint8_t direction,
uint8_t *msg,
uint32_t msg_len,
uint8_t *msg_out){
return liblte_security_encryption_eea2(key,
count,
bearer,
direction,
msg,
msg_len * 8,
msg_out);
} }
uint8_t security_128_eea3(
uint8_t* key, uint32_t count, uint8_t bearer, uint8_t direction, uint8_t* msg, uint32_t msg_len, uint8_t* msg_out)
{
uint8_t security_128_eea3(uint8_t *key, return liblte_security_encryption_eea3(key, count, bearer, direction, msg, msg_len * 8, msg_out);
uint32_t count,
uint8_t bearer,
uint8_t direction,
uint8_t *msg,
uint32_t msg_len,
uint8_t *msg_out){
return liblte_security_encryption_eea3(key,
count,
bearer,
direction,
msg,
msg_len * 8,
msg_out);
} }
/****************************************************************************** /******************************************************************************
* Authentication * Authentication
*****************************************************************************/ *****************************************************************************/
uint8_t compute_opc( uint8_t *k, uint8_t compute_opc(uint8_t* k, uint8_t* op, uint8_t* opc)
uint8_t *op,
uint8_t *opc)
{ {
return liblte_compute_opc(k, return liblte_compute_opc(k, op, opc);
op,
opc);
} }
uint8_t security_milenage_f1( uint8_t *k, uint8_t security_milenage_f1( uint8_t *k,

120
lib/src/common/zuc.cc
Unescape Escape View File

@ -2,17 +2,13 @@
#include "srslte/common/zuc.h" #include "srslte/common/zuc.h"
/* ——————————————————————- */
/* the state registers of LFSR */
#define MAKEU32(a, b, c, d) (((u32)(a) << 24) | ((u32)(b) << 16) | ((u32)(c) << 8) | ((u32)(d))) #define MAKEU32(a, b, c, d) (((u32)(a) << 24) | ((u32)(b) << 16) | ((u32)(c) << 8) | ((u32)(d)))
#define MulByPow2(x, k) ((((x) << k) | ((x) >> (31 - k))) & 0x7FFFFFFF) #define MulByPow2(x, k) ((((x) << k) | ((x) >> (31 - k))) & 0x7FFFFFFF)
#define MAKEU31(a, b, c) (((u32)(a) << 23) | ((u32)(b) << 8) | (u32)(c)) #define MAKEU31(a, b, c) (((u32)(a) << 23) | ((u32)(b) << 8) | (u32)(c))
#define ROT(a, k) (((a) << k) | ((a) >> (32 - k))) #define ROT(a, k) (((a) << k) | ((a) >> (32 - k)))
/* the s-boxes */ /* the s-boxes */
u8 S0[256] = { u8 S0[256] = {
0x3e, 0x72, 0x5b, 0x47, 0xca, 0xe0, 0x00, 0x33, 0x04, 0xd1, 0x54, 0x98, 0x09, 0xb9, 0x6d, 0xcb, 0x7b, 0x1b, 0xf9, 0x3e, 0x72, 0x5b, 0x47, 0xca, 0xe0, 0x00, 0x33, 0x04, 0xd1, 0x54, 0x98, 0x09, 0xb9, 0x6d, 0xcb, 0x7b, 0x1b, 0xf9,
0x32, 0xaf, 0x9d, 0x6a, 0xa5, 0xb8, 0x2d, 0xfc, 0x1d, 0x08, 0x53, 0x03, 0x90, 0x4d, 0x4e, 0x84, 0x99, 0xe4, 0xce, 0x32, 0xaf, 0x9d, 0x6a, 0xa5, 0xb8, 0x2d, 0xfc, 0x1d, 0x08, 0x53, 0x03, 0x90, 0x4d, 0x4e, 0x84, 0x99, 0xe4, 0xce,
0xd9, 0x91, 0xdd, 0xb6, 0x85, 0x48, 0x8b, 0x29, 0x6e, 0xac, 0xcd, 0xc1, 0xf8, 0x1e, 0x73, 0x43, 0x69, 0xc6, 0xb5, 0xd9, 0x91, 0xdd, 0xb6, 0x85, 0x48, 0x8b, 0x29, 0x6e, 0xac, 0xcd, 0xc1, 0xf8, 0x1e, 0x73, 0x43, 0x69, 0xc6, 0xb5,
@ -27,6 +23,7 @@ u8 S0[256] = {
0xfa, 0x36, 0xd2, 0x50, 0x68, 0x9e, 0x62, 0x71, 0x15, 0x3d, 0xd6, 0x40, 0xc4, 0xe2, 0x0f, 0x8e, 0x83, 0x77, 0x6b, 0xfa, 0x36, 0xd2, 0x50, 0x68, 0x9e, 0x62, 0x71, 0x15, 0x3d, 0xd6, 0x40, 0xc4, 0xe2, 0x0f, 0x8e, 0x83, 0x77, 0x6b,
0x25, 0x05, 0x3f, 0x0c, 0x30, 0xea, 0x70, 0xb7, 0xa1, 0xe8, 0xa9, 0x65, 0x8d, 0x27, 0x1a, 0xdb, 0x81, 0xb3, 0xa0, 0x25, 0x05, 0x3f, 0x0c, 0x30, 0xea, 0x70, 0xb7, 0xa1, 0xe8, 0xa9, 0x65, 0x8d, 0x27, 0x1a, 0xdb, 0x81, 0xb3, 0xa0,
0xf4, 0x45, 0x7a, 0x19, 0xdf, 0xee, 0x78, 0x34, 0x60}; 0xf4, 0x45, 0x7a, 0x19, 0xdf, 0xee, 0x78, 0x34, 0x60};
u8 S1[256] = { u8 S1[256] = {
0x55, 0xc2, 0x63, 0x71, 0x3b, 0xc8, 0x47, 0x86, 0x9f, 0x3c, 0xda, 0x5b, 0x29, 0xaa, 0xfd, 0x77, 0x8c, 0xc5, 0x94, 0x55, 0xc2, 0x63, 0x71, 0x3b, 0xc8, 0x47, 0x86, 0x9f, 0x3c, 0xda, 0x5b, 0x29, 0xaa, 0xfd, 0x77, 0x8c, 0xc5, 0x94,
0x0c, 0xa6, 0x1a, 0x13, 0x00, 0xe3, 0xa8, 0x16, 0x72, 0x40, 0xf9, 0xf8, 0x42, 0x44, 0x26, 0x68, 0x96, 0x81, 0xd9, 0x0c, 0xa6, 0x1a, 0x13, 0x00, 0xe3, 0xa8, 0x16, 0x72, 0x40, 0xf9, 0xf8, 0x42, 0x44, 0x26, 0x68, 0x96, 0x81, 0xd9,
@ -41,14 +38,28 @@ u8 S1[256] = {
0xc3, 0xde, 0xa3, 0xef, 0xea, 0x51, 0xe6, 0x6b, 0x18, 0xec, 0x1b, 0x2c, 0x80, 0xf7, 0x74, 0xe7, 0xff, 0x21, 0x5a, 0xc3, 0xde, 0xa3, 0xef, 0xea, 0x51, 0xe6, 0x6b, 0x18, 0xec, 0x1b, 0x2c, 0x80, 0xf7, 0x74, 0xe7, 0xff, 0x21, 0x5a,
0x6a, 0x54, 0x1e, 0x41, 0x31, 0x92, 0x35, 0xc4, 0x33, 0x07, 0x0a, 0xba, 0x7e, 0x0e, 0x34, 0x88, 0xb1, 0x98, 0x7c, 0x6a, 0x54, 0x1e, 0x41, 0x31, 0x92, 0x35, 0xc4, 0x33, 0x07, 0x0a, 0xba, 0x7e, 0x0e, 0x34, 0x88, 0xb1, 0x98, 0x7c,
0xf3, 0x3d, 0x60, 0x6c, 0x7b, 0xca, 0xd3, 0x1f, 0x32, 0x65, 0x04, 0x28, 0x64, 0xbe, 0x85, 0x9b, 0x2f, 0x59, 0x8a, 0xf3, 0x3d, 0x60, 0x6c, 0x7b, 0xca, 0xd3, 0x1f, 0x32, 0x65, 0x04, 0x28, 0x64, 0xbe, 0x85, 0x9b, 0x2f, 0x59, 0x8a,
0xd7, 0xb0, 0x25, 0xac, 0xaf, 0x12, 0x03, 0xe2, 0xf2}; /* the constants D */ 0xd7, 0xb0, 0x25, 0xac, 0xaf, 0x12, 0x03, 0xe2, 0xf2};
u32 EK_d[16] = {0x44D7, 0x26BC, 0x626B, 0x135E, 0x5789, 0x35E2, 0x7135, 0x09AF, /* the constants D */
0x4D78, 0x2F13, 0x6BC4, 0x1AF1, 0x5E26, 0x3C4D, 0x789A, 0x47AC}; u32 EK_d[16] = {0x44D7,
0x26BC,
0x626B,
0x135E,
0x5789,
0x35E2,
0x7135,
0x09AF,
0x4D78,
0x2F13,
0x6BC4,
0x1AF1,
0x5E26,
0x3C4D,
0x789A,
0x47AC};
/* ——————————————————————- */ /* ——————————————————————- */
/* c = a + b mod (2^31 – 1) */ /* c = a + b mod (2^31 – 1) */
u32 AddM(u32 a, u32 b) u32 AddM(u32 a, u32 b)
{ {
u32 c = a + b; u32 c = a + b;
@ -56,21 +67,23 @@ u32 AddM(u32 a, u32 b)
} }
/* LFSR with initialization mode */ /* LFSR with initialization mode */
void LFSRWithInitialisationMode(zuc_state_t * state, u32 u) void LFSRWithInitialisationMode(zuc_state_t* state, u32 u)
{ {
u32 f, v; u32 f, v;
f = state->LFSR_S0; f = state->LFSR_S0;
v = MulByPow2(state->LFSR_S0, 8); v = MulByPow2(state->LFSR_S0, 8);
f = AddM(f, v); f = AddM(f, v);
v = MulByPow2(state->LFSR_S4, 20); v = MulByPow2(state->LFSR_S4, 20);
f = AddM(f, v); f = AddM(f, v);
v = MulByPow2(state->LFSR_S10, 21); v = MulByPow2(state->LFSR_S10, 21);
f = AddM(f, v); f = AddM(f, v);
v = MulByPow2(state->LFSR_S13, 17); v = MulByPow2(state->LFSR_S13, 17);
f = AddM(f, v); f = AddM(f, v);
v = MulByPow2(state->LFSR_S15, 15); v = MulByPow2(state->LFSR_S15, 15);
f = AddM(f, v); f = AddM(f, v);
f = AddM(f, u); /* update the state */ f = AddM(f, u);
/* update the state */
state->LFSR_S0 = state->LFSR_S1; state->LFSR_S0 = state->LFSR_S1;
state->LFSR_S1 = state->LFSR_S2; state->LFSR_S1 = state->LFSR_S2;
state->LFSR_S2 = state->LFSR_S3; state->LFSR_S2 = state->LFSR_S3;
@ -87,22 +100,25 @@ void LFSRWithInitialisationMode(zuc_state_t * state, u32 u)
state->LFSR_S13 = state->LFSR_S14; state->LFSR_S13 = state->LFSR_S14;
state->LFSR_S14 = state->LFSR_S15; state->LFSR_S14 = state->LFSR_S15;
state->LFSR_S15 = f; state->LFSR_S15 = f;
} /* LFSR with work mode */ }
void LFSRWithWorkMode(zuc_state_t *state) /* LFSR with work mode */
void LFSRWithWorkMode(zuc_state_t* state)
{ {
u32 f, v; u32 f, v;
f = state->LFSR_S0; f = state->LFSR_S0;
v = MulByPow2(state->LFSR_S0, 8); v = MulByPow2(state->LFSR_S0, 8);
f = AddM(f, v); f = AddM(f, v);
v = MulByPow2(state->LFSR_S4, 20); v = MulByPow2(state->LFSR_S4, 20);
f = AddM(f, v); f = AddM(f, v);
v = MulByPow2(state->LFSR_S10, 21); v = MulByPow2(state->LFSR_S10, 21);
f = AddM(f, v); f = AddM(f, v);
v = MulByPow2(state->LFSR_S13, 17); v = MulByPow2(state->LFSR_S13, 17);
f = AddM(f, v); f = AddM(f, v);
v = MulByPow2(state->LFSR_S15, 15); v = MulByPow2(state->LFSR_S15, 15);
f = AddM(f, v); /* update the state */ f = AddM(f, v);
/* update the state */
state->LFSR_S0 = state->LFSR_S1; state->LFSR_S0 = state->LFSR_S1;
state->LFSR_S1 = state->LFSR_S2; state->LFSR_S1 = state->LFSR_S2;
state->LFSR_S2 = state->LFSR_S3; state->LFSR_S2 = state->LFSR_S3;
@ -122,7 +138,7 @@ void LFSRWithWorkMode(zuc_state_t *state)
} }
/* BitReorganization */ /* BitReorganization */
void BitReorganization(zuc_state_t *state) void BitReorganization(zuc_state_t* state)
{ {
state->BRC_X0 = ((state->LFSR_S15 & 0x7FFF8000) << 1) | (state->LFSR_S14 & 0xFFFF); state->BRC_X0 = ((state->LFSR_S15 & 0x7FFF8000) << 1) | (state->LFSR_S14 & 0xFFFF);
state->BRC_X1 = ((state->LFSR_S11 & 0xFFFF) << 16) | (state->LFSR_S9 >> 15); state->BRC_X1 = ((state->LFSR_S11 & 0xFFFF) << 16) | (state->LFSR_S9 >> 15);
@ -134,22 +150,24 @@ void BitReorganization(zuc_state_t *state)
u32 L1(u32 X) u32 L1(u32 X)
{ {
return (X ^ ROT(X, 2) ^ ROT(X, 10) ^ ROT(X, 18) ^ ROT(X, 24)); return (X ^ ROT(X, 2) ^ ROT(X, 10) ^ ROT(X, 18) ^ ROT(X, 24));
} /* L2 */ }
/* L2 */
u32 L2(u32 X) u32 L2(u32 X)
{ {
return (X ^ ROT(X, 8) ^ ROT(X, 14) ^ ROT(X, 22) ^ ROT(X, 30)); return (X ^ ROT(X, 8) ^ ROT(X, 14) ^ ROT(X, 22) ^ ROT(X, 30));
} }
/* F */ /* F */
u32 F(zuc_state_t *state) u32 F(zuc_state_t* state)
{ {
u32 W, W1, W2, u, v; u32 W, W1, W2, u, v;
W = (state->BRC_X0 ^ state->F_R1) + state->F_R2; W = (state->BRC_X0 ^ state->F_R1) + state->F_R2;
W1 = state->F_R1 + state->BRC_X1; W1 = state->F_R1 + state->BRC_X1;
W2 = state->F_R2 ^ state->BRC_X2; W2 = state->F_R2 ^ state->BRC_X2;
u = L1((W1 << 16) | (W2 >> 16)); u = L1((W1 << 16) | (W2 >> 16));
v = L2((W2 << 16) | (W1 >> 16)); v = L2((W2 << 16) | (W1 >> 16));
state->F_R1 = MAKEU32(S0[u >> 24], S1[(u >> 16) & 0xFF], S0[(u >> 8) & 0xFF], S1[u & 0xFF]); state->F_R1 = MAKEU32(S0[u >> 24], S1[(u >> 16) & 0xFF], S0[(u >> 8) & 0xFF], S1[u & 0xFF]);
state->F_R2 = MAKEU32(S0[v >> 24], S1[(v >> 16) & 0xFF], S0[(v >> 8) & 0xFF], S1[v & 0xFF]); state->F_R2 = MAKEU32(S0[v >> 24], S1[(v >> 16) & 0xFF], S0[(v >> 8) & 0xFF], S1[v & 0xFF]);
return W; return W;
@ -157,10 +175,11 @@ u32 F(zuc_state_t *state)
/* initialize */ /* initialize */
void zuc_initialize(zuc_state_t *state, u8* k, u8* iv) void zuc_initialize(zuc_state_t* state, u8* k, u8* iv)
{ {
u32 w, nCount; u32 w, nCount;
/* expand key */
/* expand key */
state->LFSR_S0 = MAKEU31(k[0], EK_d[0], iv[0]); state->LFSR_S0 = MAKEU31(k[0], EK_d[0], iv[0]);
state->LFSR_S1 = MAKEU31(k[1], EK_d[1], iv[1]); state->LFSR_S1 = MAKEU31(k[1], EK_d[1], iv[1]);
state->LFSR_S2 = MAKEU31(k[2], EK_d[2], iv[2]); state->LFSR_S2 = MAKEU31(k[2], EK_d[2], iv[2]);
@ -177,10 +196,11 @@ void zuc_initialize(zuc_state_t *state, u8* k, u8* iv)
state->LFSR_S13 = MAKEU31(k[13], EK_d[13], iv[13]); state->LFSR_S13 = MAKEU31(k[13], EK_d[13], iv[13]);
state->LFSR_S14 = MAKEU31(k[14], EK_d[14], iv[14]); state->LFSR_S14 = MAKEU31(k[14], EK_d[14], iv[14]);
state->LFSR_S15 = MAKEU31(k[15], EK_d[15], iv[15]); state->LFSR_S15 = MAKEU31(k[15], EK_d[15], iv[15]);
/* set F_R1 and F_R2 to zero */ /* set F_R1 and F_R2 to zero */
state->F_R1 = 0; state->F_R1 = 0;
state->F_R2 = 0; state->F_R2 = 0;
nCount = 32; nCount = 32;
while (nCount > 0) { while (nCount > 0) {
BitReorganization(state); BitReorganization(state);
w = F(state); w = F(state);
@ -189,7 +209,7 @@ void zuc_initialize(zuc_state_t *state, u8* k, u8* iv)
} }
} }
void zuc_generate_keystream(zuc_state_t *state, int key_stream_len, u32* p_keystream) void zuc_generate_keystream(zuc_state_t* state, int key_stream_len, u32* p_keystream)
{ {
int i; int i;
{ {

6
lib/test/common/test_eea2.cc
Unescape Escape View File

@ -19,12 +19,12 @@
* *
*/ */
#include <stdlib.h>
#include <stdio.h>
#include <assert.h> #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "srslte/srslte.h"
#include "srslte/common/liblte_security.h" #include "srslte/common/liblte_security.h"
#include "srslte/srslte.h"
/* /*
* Prototypes * Prototypes

1
lib/test/common/test_eia3.cc
Unescape Escape View File

@ -99,7 +99,6 @@ void test_set_3()
liblte_security_128_eia3(key, count, bearer, direction, msg, len_bits, mac); liblte_security_128_eia3(key, count, bearer, direction, msg, len_bits, mac);
int i; int i;
bool failed = false; bool failed = false;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (mac[i] != expected_mac[i]) { if (mac[i] != expected_mac[i]) {

7
srsenb/src/stack/rrc/rrc.cc
Unescape Escape View File

@ -2015,9 +2015,8 @@ bool rrc::ue::select_security_algorithms()
break; break;
case srslte::CIPHERING_ALGORITHM_ID_128_EEA3: case srslte::CIPHERING_ALGORITHM_ID_128_EEA3:
// “third bit” – 128-EEA3, // “third bit” – 128-EEA3,
if (security_capabilities.encryptionAlgorithms if (security_capabilities.encryptionAlgorithms.buffer[srslte::CIPHERING_ALGORITHM_ID_128_EEA3 - 1]) {
.buffer[srslte::CIPHERING_ALGORITHM_ID_128_EEA3 - 1]) { cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA3;
cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA3;
enc_algo_found = true; enc_algo_found = true;
parent->rrc_log->info("Selected EEA3 as RRC encryption algorithm\n"); parent->rrc_log->info("Selected EEA3 as RRC encryption algorithm\n");
break; break;
@ -2063,7 +2062,7 @@ bool rrc::ue::select_security_algorithms()
case srslte::INTEGRITY_ALGORITHM_ID_128_EIA3: case srslte::INTEGRITY_ALGORITHM_ID_128_EIA3:
// “third bit” – 128-EIA3, // “third bit” – 128-EIA3,
if (security_capabilities.integrityProtectionAlgorithms.buffer[srslte::INTEGRITY_ALGORITHM_ID_128_EIA3 - 1]) { if (security_capabilities.integrityProtectionAlgorithms.buffer[srslte::INTEGRITY_ALGORITHM_ID_128_EIA3 - 1]) {
integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA3; integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA3;
integ_algo_found = true; integ_algo_found = true;
parent->rrc_log->info("Selected EIA3 as RRC integrity algorithm.\n"); parent->rrc_log->info("Selected EIA3 as RRC integrity algorithm.\n");
} else { } else {

12
srsue/src/stack/rrc/rrc.cc
Unescape Escape View File

@ -949,18 +949,18 @@ void rrc::send_con_restablish_request()
break; break;
case INTEGRITY_ALGORITHM_ID_128_EIA2: case INTEGRITY_ALGORITHM_ID_128_EIA2:
security_128_eia2(&k_rrc_int[16], security_128_eia2(&k_rrc_int[16],
0xffffffff, // 32-bit all to ones 0xffffffff, // 32-bit all to ones
0x1f, // 5-bit all to ones 0x1f, // 5-bit all to ones
1, // 1-bit to one 1, // 1-bit to one
varShortMAC_packed, varShortMAC_packed,
N_bytes, N_bytes,
mac_key); mac_key);
break; break;
case INTEGRITY_ALGORITHM_ID_128_EIA3: case INTEGRITY_ALGORITHM_ID_128_EIA3:
security_128_eia3(&k_rrc_int[16], security_128_eia3(&k_rrc_int[16],
0xffffffff, // 32-bit all to ones 0xffffffff, // 32-bit all to ones
0x1f, // 5-bit all to ones 0x1f, // 5-bit all to ones
1, // 1-bit to one 1, // 1-bit to one
varShortMAC_packed, varShortMAC_packed,
N_bytes, N_bytes,
mac_key); mac_key);

92
srsue/src/stack/upper/nas.cc
Unescape Escape View File

@ -639,7 +639,7 @@ void nas::integrity_generate(uint8_t *key_128,
case INTEGRITY_ALGORITHM_ID_128_EIA2: case INTEGRITY_ALGORITHM_ID_128_EIA2:
security_128_eia2(key_128, security_128_eia2(key_128,
count, count,
0, // Bearer always 0 for NAS 0, // Bearer always 0 for NAS
direction, direction,
msg, msg,
msg_len, msg_len,
@ -648,7 +648,7 @@ void nas::integrity_generate(uint8_t *key_128,
case INTEGRITY_ALGORITHM_ID_128_EIA3: case INTEGRITY_ALGORITHM_ID_128_EIA3:
security_128_eia3(key_128, security_128_eia3(key_128,
count, count,
0, // Bearer always 0 for NAS 0, // Bearer always 0 for NAS
direction, direction,
msg, msg,
msg_len, msg_len,
@ -713,31 +713,31 @@ void nas::cipher_encrypt(byte_buffer_t* pdu)
&pdu->msg[6], &pdu->msg[6],
pdu->N_bytes-6, pdu->N_bytes-6,
&pdu_tmp.msg[6]); &pdu_tmp.msg[6]);
memcpy(&pdu->msg[6], &pdu_tmp.msg[6], pdu->N_bytes-6); memcpy(&pdu->msg[6], &pdu_tmp.msg[6], pdu->N_bytes - 6);
break; break;
case CIPHERING_ALGORITHM_ID_128_EEA2: case CIPHERING_ALGORITHM_ID_128_EEA2:
security_128_eea2(&k_nas_enc[16], security_128_eea2(&k_nas_enc[16],
pdu->msg[5], pdu->msg[5],
0, // Bearer always 0 for NAS 0, // Bearer always 0 for NAS
SECURITY_DIRECTION_UPLINK, SECURITY_DIRECTION_UPLINK,
&pdu->msg[6], &pdu->msg[6],
pdu->N_bytes-6, pdu->N_bytes - 6,
&pdu_tmp.msg[6]); &pdu_tmp.msg[6]);
memcpy(&pdu->msg[6], &pdu_tmp.msg[6], pdu->N_bytes-6); memcpy(&pdu->msg[6], &pdu_tmp.msg[6], pdu->N_bytes - 6);
break; break;
case CIPHERING_ALGORITHM_ID_128_EEA3: case CIPHERING_ALGORITHM_ID_128_EEA3:
security_128_eea3(&k_nas_enc[16], security_128_eea3(&k_nas_enc[16],
pdu->msg[5], pdu->msg[5],
0, // Bearer always 0 for NAS 0, // Bearer always 0 for NAS
SECURITY_DIRECTION_UPLINK, SECURITY_DIRECTION_UPLINK,
&pdu->msg[6], &pdu->msg[6],
pdu->N_bytes-6, pdu->N_bytes - 6,
&pdu_tmp.msg[6]); &pdu_tmp.msg[6]);
memcpy(&pdu->msg[6], &pdu_tmp.msg[6], pdu->N_bytes-6); memcpy(&pdu->msg[6], &pdu_tmp.msg[6], pdu->N_bytes - 6);
break; break;
default: default:
nas_log->error("Ciphering algorithm not known\n"); nas_log->error("Ciphering algorithm not known\n");
break; break;
} }
} }
@ -759,30 +759,30 @@ void nas::cipher_decrypt(byte_buffer_t* pdu)
memcpy(&pdu->msg[6], &tmp_pdu.msg[6], pdu->N_bytes-6); memcpy(&pdu->msg[6], &tmp_pdu.msg[6], pdu->N_bytes-6);
break; break;
case CIPHERING_ALGORITHM_ID_128_EEA2: case CIPHERING_ALGORITHM_ID_128_EEA2:
security_128_eea2(&k_nas_enc[16], security_128_eea2(&k_nas_enc[16],
pdu->msg[5], pdu->msg[5],
0, // Bearer always 0 for NAS 0, // Bearer always 0 for NAS
SECURITY_DIRECTION_DOWNLINK, SECURITY_DIRECTION_DOWNLINK,
&pdu->msg[6], &pdu->msg[6],
pdu->N_bytes-6, pdu->N_bytes - 6,
&tmp_pdu.msg[6]); &tmp_pdu.msg[6]);
nas_log->debug_hex(tmp_pdu.msg, pdu->N_bytes, "Decrypted"); nas_log->debug_hex(tmp_pdu.msg, pdu->N_bytes, "Decrypted");
memcpy(&pdu->msg[6], &tmp_pdu.msg[6], pdu->N_bytes-6); memcpy(&pdu->msg[6], &tmp_pdu.msg[6], pdu->N_bytes - 6);
break; break;
case CIPHERING_ALGORITHM_ID_128_EEA3: case CIPHERING_ALGORITHM_ID_128_EEA3:
security_128_eea3(&k_nas_enc[16], security_128_eea3(&k_nas_enc[16],
pdu->msg[5], pdu->msg[5],
0, // Bearer always 0 for NAS 0, // Bearer always 0 for NAS
SECURITY_DIRECTION_DOWNLINK, SECURITY_DIRECTION_DOWNLINK,
&pdu->msg[6], &pdu->msg[6],
pdu->N_bytes-6, pdu->N_bytes - 6,
&tmp_pdu.msg[6]); &tmp_pdu.msg[6]);
nas_log->debug_hex(tmp_pdu.msg, pdu->N_bytes, "Decrypted"); nas_log->debug_hex(tmp_pdu.msg, pdu->N_bytes, "Decrypted");
memcpy(&pdu->msg[6], &tmp_pdu.msg[6], pdu->N_bytes-6); memcpy(&pdu->msg[6], &tmp_pdu.msg[6], pdu->N_bytes - 6);
break; break;
default: default:
nas_log->error("Ciphering algorithms not known\n"); nas_log->error("Ciphering algorithms not known\n");
break; break;
} }
} }

32
srsue/test/upper/nas_test.cc
Unescape Escape View File

@ -47,24 +47,20 @@ using namespace asn1::rrc;
} \ } \
} }
uint8_t auth_request_pdu[] = { 0x07, 0x52, 0x01, 0x0c, 0x63, 0xa8, 0x54, 0x13, 0xe6, 0xa4, uint8_t auth_request_pdu[] = {0x07, 0x52, 0x01, 0x0c, 0x63, 0xa8, 0x54, 0x13, 0xe6, 0xa4, 0xce, 0xd9,
0xce, 0xd9, 0x86, 0xfb, 0xe5, 0xce, 0x9b, 0x62, 0x5e, 0x10, 0x86, 0xfb, 0xe5, 0xce, 0x9b, 0x62, 0x5e, 0x10, 0x67, 0x57, 0xb3, 0xc2,
0x67, 0x57, 0xb3, 0xc2, 0xb9, 0x70, 0x90, 0x01, 0x0c, 0x72, 0xb9, 0x70, 0x90, 0x01, 0x0c, 0x72, 0x8a, 0x67, 0x57, 0x92, 0x52, 0xb8};
0x8a, 0x67, 0x57, 0x92, 0x52, 0xb8 };
uint8_t sec_mode_command_pdu[] = {0x37, 0x4e, 0xfd, 0x57, 0x11, 0x00, 0x07, 0x5d, 0x02, 0x01, 0x02, 0xf0, 0x70, 0xc1};
uint8_t sec_mode_command_pdu[] = { 0x37, 0x4e, 0xfd, 0x57, 0x11, 0x00, 0x07, 0x5d, 0x02, 0x01,
0x02, 0xf0, 0x70, 0xc1 }; uint8_t attach_accept_pdu[] = {0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x42, 0x01, 0x3e, 0x06, 0x00, 0x00,
0xf1, 0x10, 0x00, 0x01, 0x00, 0x2a, 0x52, 0x01, 0xc1, 0x01, 0x04, 0x1b, 0x07,
uint8_t attach_accept_pdu[] = { 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x42, 0x01, 0x3e, 0x74, 0x65, 0x73, 0x74, 0x31, 0x32, 0x33, 0x06, 0x6d, 0x6e, 0x63, 0x30, 0x30,
0x06, 0x00, 0x00, 0xf1, 0x10, 0x00, 0x01, 0x00, 0x2a, 0x52, 0x31, 0x06, 0x6d, 0x63, 0x63, 0x30, 0x30, 0x31, 0x04, 0x67, 0x70, 0x72, 0x73,
0x01, 0xc1, 0x01, 0x04, 0x1b, 0x07, 0x74, 0x65, 0x73, 0x74, 0x05, 0x01, 0xc0, 0xa8, 0x05, 0x02, 0x27, 0x01, 0x80, 0x50, 0x0b, 0xf6, 0x00,
0x31, 0x32, 0x33, 0x06, 0x6d, 0x6e, 0x63, 0x30, 0x30, 0x31, 0xf1, 0x10, 0x80, 0x01, 0x01, 0x35, 0x16, 0x6d, 0xbc, 0x64, 0x01, 0x00};
0x06, 0x6d, 0x63, 0x63, 0x30, 0x30, 0x31, 0x04, 0x67, 0x70,
0x72, 0x73, 0x05, 0x01, 0xc0, 0xa8, 0x05, 0x02, 0x27, 0x01, uint8_t esm_info_req_pdu[] = {0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x5a, 0xd9};
0x80, 0x50, 0x0b, 0xf6, 0x00, 0xf1, 0x10, 0x80, 0x01, 0x01,
0x35, 0x16, 0x6d, 0xbc, 0x64, 0x01, 0x00 };
uint8_t esm_info_req_pdu[] = { 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x5a, 0xd9 };
uint8_t activate_dedicated_eps_bearer_pdu[] = {0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x00, 0xc5, 0x05, uint8_t activate_dedicated_eps_bearer_pdu[] = {0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x00, 0xc5, 0x05,
0x01, 0x01, 0x07, 0x21, 0x31, 0x00, 0x03, 0x40, 0x08, 0xae, 0x01, 0x01, 0x07, 0x21, 0x31, 0x00, 0x03, 0x40, 0x08, 0xae,

Write Preview
Loading…
Cancel
Save