nr pdcp: add support for nea1

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

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);
+    if (parameters->ciphering_algorithm == 2) {
-    entity->cipher = nr_pdcp_security_nea2_cipher;
+      entity->security_context = nr_pdcp_security_nea2_init(entity->security_keys_and_algos.ciphering_key);
-    entity->free_security = nr_pdcp_security_nea2_free_security;
+      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

@@ -0,0 +1,69 @@
+/*
+ * 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

@@ -0,0 +1,38 @@
+/*
+ * 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_ */