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
*******************************************************************************/ *******************************************************************************/

94
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 security_milenage_f1(uint8_t* k, uint8_t* op, uint8_t* rand, uint8_t* sqn, uint8_t* amf, uint8_t* mac_a);
uint8_t *op,
uint8_t *rand,
uint8_t *sqn,
uint8_t *amf,
uint8_t *mac_a);
uint8_t security_milenage_f1_star( 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 *sqn,
uint8_t *amf,
uint8_t *mac_s);
uint8_t security_milenage_f2345( uint8_t *k, uint8_t
uint8_t *op, 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 *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

54
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,36 +808,33 @@ 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 &&
mac != NULL)
{
msg_len_block_8 = (msg_len + 7) / 8; msg_len_block_8 = (msg_len + 7) / 8;
msg_len_block_32 = (msg_len + 31) / 32; msg_len_block_32 = (msg_len + 31) / 32;
@ -1047,25 +1044,17 @@ 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 &&
out != NULL)
{
msg_len_block_8 = (msg_len + 7) / 8; msg_len_block_8 = (msg_len + 7) / 8;
msg_len_block_32 = (msg_len + 31) / 32; msg_len_block_32 = (msg_len + 31) / 32;
@ -1093,7 +1082,7 @@ LIBLTE_ERROR_ENUM liblte_security_encryption_eea3(uint8 *key,
// Generate keystream // Generate keystream
ks = (uint32 *) calloc(msg_len_block_32, sizeof(uint32)); ks = (uint32*)calloc(msg_len_block_32, sizeof(uint32));
zuc_generate_keystream(&zuc_state, msg_len_block_32, ks); zuc_generate_keystream(&zuc_state, msg_len_block_32, ks);
// Generate output except last block // Generate output except last block
@ -1119,11 +1108,11 @@ LIBLTE_ERROR_ENUM liblte_security_encryption_eea3(uint8 *key,
err = LIBLTE_SUCCESS; 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,

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

@ -2,10 +2,6 @@
#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))
@ -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,7 +67,7 @@ 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;
@ -70,7 +81,9 @@ void LFSRWithInitialisationMode(zuc_state_t * state, u32 u)
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,9 +100,10 @@ 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;
@ -102,7 +116,9 @@ void LFSRWithWorkMode(zuc_state_t *state)
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,15 +150,16 @@ 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;
@ -150,6 +167,7 @@ u32 F(zuc_state_t *state)
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,9 +175,10 @@ 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]);
@ -177,6 +196,7 @@ 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;
@ -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]) {

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

@ -2015,8 +2015,7 @@ 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");

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

@ -713,7 +713,7 @@ 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],
@ -721,9 +721,9 @@ void nas::cipher_encrypt(byte_buffer_t* pdu)
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],
@ -731,9 +731,9 @@ void nas::cipher_encrypt(byte_buffer_t* pdu)
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");
@ -764,10 +764,10 @@ void nas::cipher_decrypt(byte_buffer_t* pdu)
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],
@ -775,10 +775,10 @@ void nas::cipher_decrypt(byte_buffer_t* pdu)
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");

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