Merge remote-tracking branch 'origin/nr-pdcp-nea1' into integration_2024_w38b

CMakeLists.txt

@@ -1206,6 +1206,7 @@ set(NR_PDCP_SRC
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_sdu.c
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_timer_thread.c
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_security_nea2.c
+  ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_security_nea1.c
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_integrity_nia2.c
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_integrity_nia1.c
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/asn1_utils.c

ci-scripts/conf_files/gnb.sa.band77.162prb.usrpn310.2x2.conf

@@ -224,17 +224,17 @@ security = {
   # preferred ciphering algorithms
   # the first one of the list that an UE supports in chosen
   # valid values: nea0, nea1, nea2, nea3
-  ciphering_algorithms = ( "nea0" );
+  ciphering_algorithms = ( "nea1", "nea0" );
 
   # preferred integrity algorithms
   # the first one of the list that an UE supports in chosen
   # valid values: nia0, nia1, nia2, nia3
-  integrity_algorithms = ( "nia2", "nia0" );
+  integrity_algorithms = ( "nia1", "nia0" );
 
   # setting 'drb_ciphering' to "no" disables ciphering for DRBs, no matter
   # what 'ciphering_algorithms' configures; same thing for 'drb_integrity'
   drb_ciphering = "yes";
-  drb_integrity = "no";
+  drb_integrity = "yes";
 };
 
 log_config :

openair2/LAYER2/CMakeLists.txt

+#/*
+# * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+# * contributor license agreements.  See the NOTICE file distributed with
+# * this work for additional information regarding copyright ownership.
+# * The OpenAirInterface Software Alliance licenses this file to You under
+# * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+# * except in compliance with the License.
+# * You may obtain a copy of the License at
+# *
+# *      http://www.openairinterface.org/?page_id=698
+# *
+# * Unless required by applicable law or agreed to in writing, software
+# * distributed under the License is distributed on an "AS IS" BASIS,
+# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# * See the License for the specific language governing permissions and
+# * limitations under the License.
+# *-------------------------------------------------------------------------------
+# * For more information about the OpenAirInterface (OAI) Software Alliance:
+# *      contact@openairinterface.org
+# */
+
 add_subdirectory(nr_rlc)
+add_subdirectory(nr_pdcp)
 add_subdirectory(NR_MAC_UE)

openair2/LAYER2/nr_pdcp/CMakeLists.txt

+#/*
+# * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+# * contributor license agreements.  See the NOTICE file distributed with
+# * this work for additional information regarding copyright ownership.
+# * The OpenAirInterface Software Alliance licenses this file to You under
+# * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+# * except in compliance with the License.
+# * You may obtain a copy of the License at
+# *
+# *      http://www.openairinterface.org/?page_id=698
+# *
+# * Unless required by applicable law or agreed to in writing, software
+# * distributed under the License is distributed on an "AS IS" BASIS,
+# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# * See the License for the specific language governing permissions and
+# * limitations under the License.
+# *-------------------------------------------------------------------------------
+# * For more information about the OpenAirInterface (OAI) Software Alliance:
+# *      contact@openairinterface.org
+# */
+
+add_library(nr_pdcp_snow3g OBJECT
+            nr_pdcp_integrity_nia1.c
+            nr_pdcp_security_nea1.c)
+
+if (ENABLE_TESTS)
+  add_subdirectory(tests)
+endif ()

openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c

@@ -26,6 +26,7 @@
 #include <string.h>
 
 #include "nr_pdcp_security_nea2.h"
+#include "nr_pdcp_security_nea1.h"
 #include "nr_pdcp_integrity_nia2.h"
 #include "nr_pdcp_integrity_nia1.h"
 #include "nr_pdcp_sdu.h"
@@ -373,16 +374,21 @@ static void nr_pdcp_entity_set_security(struct nr_pdcp_entity_t *entity,
   }
 
   if (parameters->ciphering_algorithm != 0 && parameters->ciphering_algorithm != -1) {
-    if (parameters->ciphering_algorithm != 2) {
-      LOG_E(PDCP, "FATAL: only nea2 supported for the moment\n");
-      exit(1);
-    }
     entity->has_ciphering = 1;
     if (entity->free_security != NULL)
       entity->free_security(entity->security_context);
-    entity->security_context = nr_pdcp_security_nea2_init(entity->security_keys_and_algos.ciphering_key);
-    entity->cipher = nr_pdcp_security_nea2_cipher;
-    entity->free_security = nr_pdcp_security_nea2_free_security;
+    if (parameters->ciphering_algorithm == 2) {
+      entity->security_context = nr_pdcp_security_nea2_init(entity->security_keys_and_algos.ciphering_key);
+      entity->cipher = nr_pdcp_security_nea2_cipher;
+      entity->free_security = nr_pdcp_security_nea2_free_security;
+    } else if (parameters->ciphering_algorithm == 1) {
+      entity->security_context = nr_pdcp_security_nea1_init(entity->security_keys_and_algos.ciphering_key);
+      entity->cipher = nr_pdcp_security_nea1_cipher;
+      entity->free_security = nr_pdcp_security_nea1_free_security;
+    } else {
+      LOG_E(PDCP, "FATAL: only nea1 and nea2 supported for the moment\n");
+      exit(1);
+    }
   }
 }
 

openair2/LAYER2/nr_pdcp/nr_pdcp_security_nea1.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#include "nr_pdcp_security_nea1.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "assertions.h"
+
+stream_security_context_t *nr_pdcp_security_nea1_init(unsigned char *ciphering_key)
+{
+  nas_stream_cipher_t *ret;
+
+  ret = calloc(1, sizeof(*ret));
+  AssertFatal(ret != NULL, "out of memory\n");
+  ret->context = malloc(16);
+  AssertFatal(ret->context != NULL, "out of memory\n");
+  memcpy(ret->context, ciphering_key, 16);
+
+  return (stream_security_context_t *)ret;
+}
+
+void nr_pdcp_security_nea1_cipher(stream_security_context_t *security_context,
+                                  unsigned char *buffer,
+                                  int length,
+                                  int bearer,
+                                  int count,
+                                  int direction)
+{
+  nas_stream_cipher_t *ctx = (nas_stream_cipher_t *)security_context;
+
+  ctx->message = buffer;
+  ctx->count = count;
+  ctx->bearer = bearer - 1;
+  ctx->direction = direction;
+  ctx->blength = length * 8;
+
+  uint8_t out[length];
+
+  stream_compute_encrypt(EEA1_128_ALG_ID, ctx, out);
+
+  memcpy(buffer, out, length);
+}
+
+void nr_pdcp_security_nea1_free_security(stream_security_context_t *security_context)
+{
+  nas_stream_cipher_t *ctx = (nas_stream_cipher_t *)security_context;
+  free(ctx->context);
+  free(ctx);
+}

openair2/LAYER2/nr_pdcp/nr_pdcp_security_nea1.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#ifndef _NR_PDCP_SECURITY_NEA1_H_
+#define _NR_PDCP_SECURITY_NEA1_H_
+
+#include "openair3/SECU/secu_defs.h"
+
+stream_security_context_t *nr_pdcp_security_nea1_init(unsigned char *ciphering_key);
+
+void nr_pdcp_security_nea1_cipher(stream_security_context_t *security_context,
+                                  unsigned char *buffer,
+                                  int length,
+                                  int bearer,
+                                  int count,
+                                  int direction);
+
+void nr_pdcp_security_nea1_free_security(stream_security_context_t *security_context);
+
+#endif /* _NR_PDCP_SECURITY_NEA1_H_ */

openair2/LAYER2/nr_pdcp/tests/CMakeLists.txt

+#/*
+# * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+# * contributor license agreements.  See the NOTICE file distributed with
+# * this work for additional information regarding copyright ownership.
+# * The OpenAirInterface Software Alliance licenses this file to You under
+# * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+# * except in compliance with the License.
+# * You may obtain a copy of the License at
+# *
+# *      http://www.openairinterface.org/?page_id=698
+# *
+# * Unless required by applicable law or agreed to in writing, software
+# * distributed under the License is distributed on an "AS IS" BASIS,
+# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# * See the License for the specific language governing permissions and
+# * limitations under the License.
+# *-------------------------------------------------------------------------------
+# * For more information about the OpenAirInterface (OAI) Software Alliance:
+# *      contact@openairinterface.org
+# */
+
+add_executable(snow3g_tests snow3g_tests.c)
+target_link_libraries(snow3g_tests PRIVATE nr_pdcp_snow3g minimal_lib SECURITY)
+add_test(NAME snow3g_tests
+         COMMAND snow3g_tests)
+add_dependencies(tests snow3g_tests)

openair3/SECU/nas_stream_eea1.c

@@ -20,86 +20,22 @@
  */
 
 #include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
 #include <string.h>
 
 #include "assertions.h"
-#include "conversions.h"
 #include "nas_stream_eea1.h"
 #include "snow3g.h"
 
 void nas_stream_encrypt_eea1(nas_stream_cipher_t const *stream_cipher, uint8_t *out)
 {
-  snow_3g_context_t snow_3g_context;
-  int       n ;
-  int       i           = 0;
-  uint32_t  zero_bit    = 0;
-  //uint32_t  byte_length;
-  uint32_t *KS;
-  uint32_t  K[4],IV[4];
   uint8_t *key = (uint8_t *)stream_cipher->context;
-
-  DevAssert(stream_cipher != NULL);
-  DevAssert(out != NULL);
-
-  n = ( stream_cipher->blength + 31 ) / 32;
-  zero_bit = stream_cipher->blength & 0x7;
-  //byte_length = stream_cipher->blength >> 3;
-
-  memset(&snow_3g_context, 0, sizeof(snow_3g_context));
-  /*Initialisation*/
-  /* Load the confidentiality key for SNOW 3G initialization as in section 3.4. */
-  memcpy(K+3,key+0,4); /*K[3] = key[0]; we assume
-  K[3]=key[0]||key[1]||...||key[31] , with key[0] the
-  * most important bit of key*/
-  memcpy(K+2,key+4,4); /*K[2] = key[1];*/
-  memcpy(K+1,key+8,4); /*K[1] = key[2];*/
-  memcpy(K+0,key+12,4); /*K[0] = key[3]; we assume
-        * K[0]=key[96]||key[97]||...||key[127] , with key[127] the
-        * least important bit of key*/
-  K[3] = hton_int32(K[3]);
-  K[2] = hton_int32(K[2]);
-  K[1] = hton_int32(K[1]);
-  K[0] = hton_int32(K[0]);
-  /* Prepare the initialization vector (IV) for SNOW 3G initialization as in section 3.4. */
-  IV[3] = stream_cipher->count;
-  IV[2] = ((((uint32_t)stream_cipher->bearer) << 3) | ((((uint32_t)stream_cipher->direction) & 0x1) << 2)) << 24;
-  IV[1] = IV[3];
-  IV[0] = IV[2];
-
-  /* Run SNOW 3G algorithm to generate sequence of key stream bits KS*/
-  snow3g_initialize(K, IV, &snow_3g_context);
-  KS = (uint32_t *)malloc(4*n);
-  snow3g_generate_key_stream(n,(uint32_t*)KS, &snow_3g_context);
-
-  if (zero_bit > 0) {
-    KS[n - 1] = KS[n - 1] & (uint32_t)(0xFFFFFFFF << (8 - zero_bit));
-  }
-
-  for (i=0; i<n; i++) {
-    KS[i] = hton_int32(KS[i]);
-  }
-
-  /* Exclusive-OR the input data with keystream to generate the output bit
-  stream */
-  for (i=0; i<n*4; i++) {
-    stream_cipher->message[i] ^= *(((uint8_t*)KS)+i);
-  }
-
-  int ceil_index = 0;
-
-  if (zero_bit > 0) {
-    ceil_index = (stream_cipher->blength+7) >> 3;
-    stream_cipher->message[ceil_index - 1] = stream_cipher->message[ceil_index - 1] & (uint8_t)(0xFF << (8 - zero_bit));
-  }
-
-  free(KS);
-  memcpy(out, stream_cipher->message, n*4);
-
-  if (zero_bit > 0) {
-    out[ceil_index - 1] = stream_cipher->message[ceil_index - 1];
-  }
+  snow3g_ciphering(stream_cipher->count,
+                   stream_cipher->bearer,
+                   stream_cipher->direction,
+                   key,
+                   stream_cipher->blength / 8,
+                   stream_cipher->message,
+                   out);
 }
 
 stream_security_context_t *stream_ciphering_init_eea1(const uint8_t *ciphering_key)

openair3/SECU/nas_stream_eea1.h

@@ -24,9 +24,6 @@
 
 #include "secu_defs.h"
 
-#include <stdlib.h>
-#include <stdint.h>
-
 void nas_stream_encrypt_eea1(nas_stream_cipher_t const *stream_cipher, uint8_t *out);
 
 stream_security_context_t *stream_ciphering_init_eea1(const uint8_t *ciphering_key);

openair3/SECU/nas_stream_eia1.c

@@ -19,105 +19,12 @@
  *      contact@openairinterface.org
  */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
 #include <string.h>
-#include <math.h> // double ceil(double x);
 
 #include "nas_stream_eia1.h"
-
 #include "assertions.h"
-#include "conversions.h"
 #include "snow3g.h"
 
-#define SECU_DEBUG
-
-// see spec 3GPP Confidentiality and Integrity Algorithms UEA2&UIA2. Document 1: UEA2 and UIA2 Specification. Version 1.1
-
-/* MUL64x.
- * Input V: a 64-bit input.
- * Input c: a 64-bit input.
- * Output : a 64-bit output.
- * A 64-bit memory is allocated which is to be freed by the calling
- * function.
- * See section 4.3.2 for details.
- */
-static uint64_t MUL64x(uint64_t V, uint64_t c)
-{
-  if ( V & 0x8000000000000000 )
-    return (V << 1) ^ c;
-  else
-    return V << 1;
-}
-/* MUL64xPOW.
- * Input V: a 64-bit input.
- * Input i: a positive integer.
- * Input c: a 64-bit input.
- * Output : a 64-bit output.
- * A 64-bit memory is allocated which is to be freed by the calling
-function.
- * See section 4.3.3 for details.
- */
-static uint64_t MUL64xPOW(uint64_t V, uint32_t i, uint64_t c)
-{
-  if ( i == 0)
-    return V;
-  else
-    return MUL64x( MUL64xPOW(V,i-1,c) , c);
-}
-/* MUL64.
- * Input V: a 64-bit input.
- * Input P: a 64-bit input.
- * Input c: a 64-bit input.
- * Output : a 64-bit output.
- * A 64-bit memory is allocated which is to be freed by the calling
- * function.
- * See section 4.3.4 for details.
- */
-static uint64_t MUL64(uint64_t V, uint64_t P, uint64_t c)
-{
-  uint64_t result = 0;
-  int i = 0;
-
-  for ( i=0; i<64; i++) {
-    if( ( P>>i ) & 0x1 )
-      result ^= MUL64xPOW(V,i,c);
-  }
-
-  return result;
-}
-
-/* read a big endian uint64_t at given address (potentially not 64-bits aligned)
- * don't read more than 'available_bytes'
- * (use 0 if no byte to read)
- * (note: the compiler will optimize this, no need to do better)
- */
-static inline uint64_t U64(uint8_t *p, int available_bytes)
-{
-  uint64_t a = 0;
-  uint64_t b = 0;
-  uint64_t c = 0;
-  uint64_t d = 0;
-  uint64_t e = 0;
-  uint64_t f = 0;
-  uint64_t g = 0;
-  uint64_t h = 0;
-  switch (available_bytes) {
-    case 8: h = p[7]; /* falltrough */
-    case 7: g = p[6]; /* falltrough */
-    case 6: f = p[5]; /* falltrough */
-    case 5: e = p[4]; /* falltrough */
-    case 4: d = p[3]; /* falltrough */
-    case 3: c = p[2]; /* falltrough */
-    case 2: b = p[1]; /* falltrough */
-    case 1: a = p[0];
-  }
-
-  return (a << (32+24)) | (b << (32+16)) | (c << (32+8)) | (d << 32)
-         | (e << 24) | (f << 16) | (g << 8) | h;
-}
-
 /*!
  * @brief Create integrity cmac t for a given message.
  * @param[in] stream_cipher Structure containing various variables to setup encoding
@@ -125,98 +32,14 @@ static inline uint64_t U64(uint8_t *p, int available_bytes)
  */
 void nas_stream_encrypt_eia1(nas_stream_cipher_t const *stream_cipher, uint8_t out[4])
 {
-  snow_3g_context_t snow_3g_context;
-  uint32_t        K[4],IV[4], z[5];
-  int             i=0,D;
-  uint32_t        MAC_I = 0;
-  uint64_t        EVAL;
-  uint64_t        V;
-  uint64_t        P;
-  uint64_t        Q;
-  uint64_t        c;
-  uint64_t        M_D_2;
-  int             rem_bits;
-  uint8_t         *key = (uint8_t *)stream_cipher->context;
-
-  /* Load the Integrity Key for SNOW3G initialization as in section 4.4. */
-  memcpy(K+3,key+0,4); /*K[3] = key[0]; we assume
-    K[3]=key[0]||key[1]||...||key[31] , with key[0] the
-    * most important bit of key*/
-  memcpy(K+2,key+4,4); /*K[2] = key[1];*/
-  memcpy(K+1,key+8,4); /*K[1] = key[2];*/
-  memcpy(K+0,key+12,4); /*K[0] = key[3]; we assume
-    K[0]=key[96]||key[97]||...||key[127] , with key[127] the
-    * least important bit of key*/
-  K[3] = hton_int32(K[3]);
-  K[2] = hton_int32(K[2]);
-  K[1] = hton_int32(K[1]);
-  K[0] = hton_int32(K[0]);
-  /* Prepare the Initialization Vector (IV) for SNOW3G initialization as in
-    section 4.4. */
-  IV[3] = (uint32_t)stream_cipher->count;
-  IV[2] = ((((uint32_t)stream_cipher->bearer) & 0x0000001F) << 27);
-  IV[1] = (uint32_t)(stream_cipher->count) ^ ( (uint32_t)(stream_cipher->direction) << 31 ) ;
-  IV[0] = ((((uint32_t)stream_cipher->bearer) & 0x0000001F) << 27) ^ ((uint32_t)(stream_cipher->direction & 0x00000001) << 15);
-  //printf ("K:\n");
-  //hexprint(K, 16);
-  //printf ("K[0]:%08X\n",K[0]);
-  //printf ("K[1]:%08X\n",K[1]);
-  //printf ("K[2]:%08X\n",K[2]);
-  //printf ("K[3]:%08X\n",K[3]);
-
-  //printf ("IV:\n");
-  //hexprint(IV, 16);
-  //printf ("IV[0]:%08X\n",IV[0]);
-  //printf ("IV[1]:%08X\n",IV[1]);
-  //printf ("IV[2]:%08X\n",IV[2]);
-  //printf ("IV[3]:%08X\n",IV[3]);
-  z[0] = z[1] = z[2] = z[3] = z[4] = 0;
-  /* Run SNOW 3G to produce 5 keystream words z_1, z_2, z_3, z_4 and z_5. */
-  snow3g_initialize(K, IV, &snow_3g_context);
-  snow3g_generate_key_stream(5, z, &snow_3g_context);
-  //printf ("z[0]:%08X\n",z[0]);
-  //printf ("z[1]:%08X\n",z[1]);
-  //printf ("z[2]:%08X\n",z[2]);
-  //printf ("z[3]:%08X\n",z[3]);
-  //printf ("z[4]:%08X\n",z[4]);
-  P = ((uint64_t)z[0] << 32) | (uint64_t)z[1];
-  Q = ((uint64_t)z[2] << 32) | (uint64_t)z[3];
-  //printf ("P:%16lX\n",P);
-  //printf ("Q:%16lX\n",Q);
-  /* Calculation */
-  D = ceil( stream_cipher->blength / 64.0 ) + 1;
-  //printf ("D:%d\n",D);
-  EVAL = 0;
-  c = 0x1b;
-
-  AssertFatal(stream_cipher->blength % 8 == 0, "unsupported buffer length\n");
-
-  uint8_t *message = stream_cipher->message;
-
-  /* for 0 <= i <= D-3 */
-  for (i=0; i<D-2; i++) {
-    V = EVAL ^ U64(&message[4 * 2*i], 8);
-    EVAL = MUL64(V,P,c);
-  }
-
-  /* for D-2 */
-  rem_bits = stream_cipher->blength % 64;
-
-  if (rem_bits == 0)
-    rem_bits = 64;
-
-  M_D_2 = U64(&message[4 * (2*(D-2))], rem_bits/8);
-
-  V = EVAL ^ M_D_2;
-  EVAL = MUL64(V,P,c);
-  /* for D-1 */
-  EVAL ^= stream_cipher->blength;
-  /* Multiply by Q */
-  EVAL = MUL64(EVAL,Q,c);
-  MAC_I = (uint32_t)(EVAL >> 32) ^ z[4];
-  //printf ("MAC_I:%16X\n",MAC_I);
-  MAC_I = hton_int32(MAC_I);
-  memcpy(out, &MAC_I, 4);
+  uint8_t *key = (uint8_t *)stream_cipher->context;
+  snow3g_integrity(stream_cipher->count,
+                   stream_cipher->bearer,
+                   stream_cipher->direction,
+                   key,
+                   stream_cipher->blength / 8,
+                   stream_cipher->message,
+                   out);
 }
 
 stream_security_context_t *stream_integrity_init_eia1(const uint8_t *integrity_key)

openair3/SECU/snow3g.h

@@ -19,59 +19,24 @@
  *      contact@openairinterface.org
  */
 
-/*! \file snow3g.h
-* \brief
-* \author Open source Adapted from Specification of the 3GPP Confidentiality and
-*          Integrity Algorithms UEA2 & UIA2. Document 2: SNOW 3G Specification
-* \integrators  Kharbach Othmane, GAUTHIER Lionel.
-* \date 2014
-* \version
-* \note
-* \bug
-* \warning
-*/
-#ifndef SNOW3G_H_
-#define SNOW3G_H_
+#ifndef _SNOW3G_H_
+#define _SNOW3G_H_
 
-typedef struct snow_3g_context_s {
-  uint32_t LFSR_S0;
-  uint32_t LFSR_S1;
-  uint32_t LFSR_S2;
-  uint32_t LFSR_S3;
-  uint32_t LFSR_S4;
-  uint32_t LFSR_S5;
-  uint32_t LFSR_S6;
-  uint32_t LFSR_S7;
-  uint32_t LFSR_S8;
-  uint32_t LFSR_S9;
-  uint32_t LFSR_S10;
-  uint32_t LFSR_S11;
-  uint32_t LFSR_S12;
-  uint32_t LFSR_S13;
-  uint32_t LFSR_S14;
-  uint32_t LFSR_S15;
+#include <stdint.h>
 
-  /* FSM : The Finite State Machine has three 32-bit registers R1, R2 and R3.
-  */
-  uint32_t FSM_R1;
-  uint32_t FSM_R2;
-  uint32_t FSM_R3;
-} snow_3g_context_t;
+void snow3g_ciphering(uint32_t count,
+                      int bearer,
+                      int direction,
+                      const uint8_t *key,
+                      int length,
+                      const uint8_t *in,
+                      uint8_t *out);
+void snow3g_integrity(uint32_t count,
+                      int bearer,
+                      int direction,
+                      const uint8_t *key,
+                      int length,
+                      const uint8_t *in,
+                      uint8_t *out);
 
-/* Initialization.
-* Input k[4]: Four 32-bit words making up 128-bit key.
-* Input IV[4]: Four 32-bit words making 128-bit initialization variable.
-* Output: All the LFSRs and FSM are initialized for key generation.
-*/
-void snow3g_initialize(uint32_t k[4], uint32_t IV[4], snow_3g_context_t *snow_3g_context_pP);
-
-/* Generation of Keystream.
-* input n: number of 32-bit words of keystream.
-* input z: space for the generated keystream, assumes
-* memory is allocated already.
-* output: generated keystream which is filled in z
-*/
-
-void snow3g_generate_key_stream(uint32_t n, uint32_t *z, snow_3g_context_t *snow_3g_context_pP);
-
-#endif
+#endif /* _SNOW3G_H_ */