1 /*
2 * Copyright (c) 2026, Arm Limited. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 *
6 */
7
8 #include "sfcp_encryption.h"
9
sfcp_get_trusted_subnet_by_id(uint8_t trusted_subnet_id,struct sfcp_trusted_subnet_config_t ** trusted_subnet)10 enum sfcp_error_t sfcp_get_trusted_subnet_by_id(
11 uint8_t trusted_subnet_id,
12 struct sfcp_trusted_subnet_config_t **trusted_subnet)
13 {
14 (void)trusted_subnet_id;
15 (void)trusted_subnet;
16
17 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
18 }
19
sfcp_trusted_subnet_get_server(struct sfcp_trusted_subnet_config_t * trusted_subnet,sfcp_node_id_t * server_node)20 enum sfcp_error_t sfcp_trusted_subnet_get_server(
21 struct sfcp_trusted_subnet_config_t *trusted_subnet,
22 sfcp_node_id_t *server_node)
23 {
24 (void)trusted_subnet;
25 (void)server_node;
26
27 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
28 }
29
sfcp_trusted_subnet_state_init(void)30 enum sfcp_error_t sfcp_trusted_subnet_state_init(void)
31 {
32 return SFCP_ERROR_SUCCESS;
33 }
34
35 enum sfcp_error_t
sfcp_trusted_subnet_get_state(uint8_t trusted_subnet_id,enum sfcp_trusted_subnet_state_t * state)36 sfcp_trusted_subnet_get_state(uint8_t trusted_subnet_id,
37 enum sfcp_trusted_subnet_state_t *state)
38 {
39 (void)trusted_subnet_id;
40 (void)state;
41
42 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
43 }
44
45 enum sfcp_error_t
sfcp_trusted_subnet_set_state(uint8_t trusted_subnet_id,enum sfcp_trusted_subnet_state_t state)46 sfcp_trusted_subnet_set_state(uint8_t trusted_subnet_id,
47 enum sfcp_trusted_subnet_state_t state)
48 {
49 (void)trusted_subnet_id;
50 (void)state;
51
52 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
53 }
54
sfcp_get_number_trusted_subnets(size_t * num_trusted_subnets)55 enum sfcp_error_t sfcp_get_number_trusted_subnets(size_t *num_trusted_subnets)
56 {
57 (void)num_trusted_subnets;
58
59 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
60 }
61
sfcp_get_trusted_subnet_for_node(sfcp_node_id_t node,struct sfcp_trusted_subnet_config_t ** trusted_subnet)62 enum sfcp_error_t sfcp_get_trusted_subnet_for_node(
63 sfcp_node_id_t node,
64 struct sfcp_trusted_subnet_config_t **trusted_subnet)
65 {
66 (void)node;
67 (void)trusted_subnet;
68
69 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
70 }
71
sfcp_trusted_subnet_get_send_seq_num(struct sfcp_trusted_subnet_config_t * trusted_subnet,sfcp_node_id_t remote_node,uint16_t * seq_num)72 enum sfcp_error_t sfcp_trusted_subnet_get_send_seq_num(
73 struct sfcp_trusted_subnet_config_t *trusted_subnet,
74 sfcp_node_id_t remote_node, uint16_t *seq_num)
75 {
76 (void)trusted_subnet;
77 (void)remote_node;
78 (void)seq_num;
79
80 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
81 }
82
sfcp_trusted_subnet_state_requires_handshake_encryption(uint8_t trusted_subnet_id,bool * requires_handshake,bool * requires_encryption)83 enum sfcp_error_t sfcp_trusted_subnet_state_requires_handshake_encryption(
84 uint8_t trusted_subnet_id, bool *requires_handshake,
85 bool *requires_encryption)
86 {
87 (void)trusted_subnet_id;
88 (void)requires_handshake;
89 (void)requires_encryption;
90
91 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
92 }
93
sfcp_encryption_handshake_initiator(uint8_t trusted_subnet_id,bool block)94 enum sfcp_error_t sfcp_encryption_handshake_initiator(uint8_t trusted_subnet_id,
95 bool block)
96 {
97 (void)trusted_subnet_id;
98 (void)block;
99
100 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
101 }
102
sfcp_encryption_handshake_responder(struct sfcp_packet_t * packet,size_t packet_size,sfcp_node_id_t remote_node,uint8_t message_id,bool packet_encrypted,uint8_t * payload,size_t payload_size,bool * is_handshake_msg)103 enum sfcp_error_t sfcp_encryption_handshake_responder(
104 struct sfcp_packet_t *packet, size_t packet_size,
105 sfcp_node_id_t remote_node, uint8_t message_id, bool packet_encrypted,
106 uint8_t *payload, size_t payload_size, bool *is_handshake_msg)
107 {
108 (void)remote_node;
109 (void)message_id;
110 (void)payload;
111 (void)payload_size;
112 (void)packet_encrypted;
113
114 *is_handshake_msg = false;
115 return SFCP_ERROR_SUCCESS;
116 }
117
sfcp_encrypt_msg(struct sfcp_packet_t * msg,size_t packet_size,uint8_t trusted_subnet_id,sfcp_node_id_t remote_node)118 enum sfcp_error_t sfcp_encrypt_msg(struct sfcp_packet_t *msg,
119 size_t packet_size,
120 uint8_t trusted_subnet_id,
121 sfcp_node_id_t remote_node)
122 {
123 (void)msg;
124 (void)packet_size;
125 (void)trusted_subnet_id;
126 (void)remote_node;
127
128 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
129 }
130
sfcp_decrypt_msg(struct sfcp_packet_t * msg,size_t packet_size,sfcp_node_id_t remote_node)131 enum sfcp_error_t sfcp_decrypt_msg(struct sfcp_packet_t *msg,
132 size_t packet_size,
133 sfcp_node_id_t remote_node)
134 {
135 (void)msg;
136 (void)packet_size;
137 (void)remote_node;
138
139 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
140 }
141
sfcp_encrypt_reply(struct sfcp_packet_t * reply,size_t packet_size,uint8_t trusted_subnet_id,sfcp_node_id_t remote_node)142 enum sfcp_error_t sfcp_encrypt_reply(struct sfcp_packet_t *reply,
143 size_t packet_size,
144 uint8_t trusted_subnet_id,
145 sfcp_node_id_t remote_node)
146 {
147 (void)reply;
148 (void)packet_size;
149 (void)trusted_subnet_id;
150 (void)remote_node;
151
152 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
153 }
154
sfcp_decrypt_reply(struct sfcp_packet_t * reply,size_t packet_size,sfcp_node_id_t remote_node)155 enum sfcp_error_t sfcp_decrypt_reply(struct sfcp_packet_t *reply,
156 size_t packet_size,
157 sfcp_node_id_t remote_node)
158 {
159 (void)reply;
160 (void)packet_size;
161 (void)remote_node;
162
163 return SFCP_ERROR_CRYPTOGRAPHY_NOT_SUPPORTED;
164 }
165