Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2024 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "library/spdm_transport_test_lib.h"
8 : #include "internal/libspdm_common_lib.h"
9 :
10 : /**
11 : * Get sequence number in an SPDM secure message.
12 : *
13 : * This value is transport layer specific.
14 : *
15 : * @param sequence_number The current sequence number used to encode or decode message.
16 : * @param sequence_number_buffer A buffer to hold the sequence number output used in the secured message.
17 : * The size in byte of the output buffer shall be 8.
18 : *
19 : * @return size in byte of the sequence_number_buffer.
20 : * It shall be no greater than 8.
21 : * 0 means no sequence number is required.
22 : **/
23 818 : uint8_t libspdm_test_get_sequence_number(uint64_t sequence_number,
24 : uint8_t *sequence_number_buffer)
25 : {
26 818 : libspdm_copy_mem(sequence_number_buffer, LIBSPDM_TEST_SEQUENCE_NUMBER_COUNT,
27 : &sequence_number, LIBSPDM_TEST_SEQUENCE_NUMBER_COUNT);
28 818 : return LIBSPDM_TEST_SEQUENCE_NUMBER_COUNT;
29 : }
30 :
31 : /**
32 : * Return max random number count in an SPDM secure message.
33 : *
34 : * This value is transport layer specific.
35 : *
36 : * @return Max random number count in an SPDM secured message.
37 : * 0 means no random number is required.
38 : **/
39 482 : uint32_t libspdm_test_get_max_random_number_count(void)
40 : {
41 482 : return LIBSPDM_TEST_MAX_RANDOM_NUMBER_COUNT;
42 : }
43 :
44 : /**
45 : * This function translates the negotiated secured_message_version to a DSP0277 version.
46 : *
47 : * @param secured_message_version The version specified in binding specification and
48 : * negotiated in KEY_EXCHANGE/KEY_EXCHANGE_RSP.
49 : *
50 : * @return The DSP0277 version specified in binding specification,
51 : * which is bound to secured_message_version.
52 : */
53 818 : spdm_version_number_t libspdm_test_get_secured_spdm_version(
54 : spdm_version_number_t secured_message_version)
55 : {
56 818 : return secured_message_version;
57 : }
58 :
59 : /**
60 : * Encode a normal message or secured message to a transport message.
61 : *
62 : * @param session_id Indicates if it is a secured message protected via SPDM session.
63 : * If session_id is NULL, it is a normal message.
64 : * If session_id is NOT NULL, it is a secured message.
65 : * @param message_size size in bytes of the message data buffer.
66 : * @param message A pointer to a source buffer to store the message.
67 : * @param transport_message_size size in bytes of the transport message data buffer.
68 : * @param transport_message A pointer to a destination buffer to store the transport message.
69 : **/
70 136856 : libspdm_return_t libspdm_test_encode_message(const uint32_t *session_id,
71 : bool need_alignment,
72 : size_t message_size,
73 : void *message,
74 : size_t *transport_message_size,
75 : void **transport_message)
76 : {
77 : size_t aligned_message_size;
78 : size_t alignment;
79 : uint32_t data32;
80 : libspdm_test_message_header_t *test_message_header;
81 :
82 136856 : if (need_alignment) {
83 136374 : alignment = LIBSPDM_TEST_ALIGNMENT;
84 : } else {
85 482 : alignment = 1;
86 : }
87 136856 : aligned_message_size =
88 136856 : (message_size + (alignment - 1)) & ~(alignment - 1);
89 :
90 136856 : LIBSPDM_ASSERT(*transport_message_size >=
91 : aligned_message_size + sizeof(libspdm_test_message_header_t));
92 136856 : if (*transport_message_size <
93 136856 : aligned_message_size + sizeof(libspdm_test_message_header_t)) {
94 0 : *transport_message_size = aligned_message_size +
95 : sizeof(libspdm_test_message_header_t);
96 0 : return LIBSPDM_STATUS_BUFFER_TOO_SMALL;
97 : }
98 :
99 136856 : *transport_message_size =
100 136856 : aligned_message_size + sizeof(libspdm_test_message_header_t);
101 136856 : *transport_message = (uint8_t *)message - sizeof(libspdm_test_message_header_t);
102 136856 : test_message_header = *transport_message;
103 136856 : if (session_id != NULL) {
104 482 : test_message_header->message_type =
105 : LIBSPDM_TEST_MESSAGE_TYPE_SECURED_TEST;
106 482 : data32 = libspdm_read_uint32((const uint8_t *)message);
107 482 : LIBSPDM_ASSERT(*session_id == data32);
108 482 : if (*session_id != data32) {
109 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
110 : }
111 : } else {
112 136374 : test_message_header->message_type = LIBSPDM_TEST_MESSAGE_TYPE_SPDM;
113 : }
114 136856 : libspdm_zero_mem((uint8_t *)message + message_size,
115 : aligned_message_size - message_size);
116 136856 : return LIBSPDM_STATUS_SUCCESS;
117 : }
118 :
119 : /**
120 : * Decode a transport message to a normal message or secured message.
121 : *
122 : * @param session_id Indicates if it is a secured message protected via SPDM session.
123 : * If *session_id is NULL, it is a normal message.
124 : * If *session_id is NOT NULL, it is a secured message.
125 : * @param transport_message_size size in bytes of the transport message data buffer.
126 : * @param transport_message A pointer to a source buffer to store the transport message.
127 : * @param message_size size in bytes of the message data buffer.
128 : * @param message A pointer to a destination buffer to store the message.
129 : **/
130 136520 : libspdm_return_t libspdm_test_decode_message(uint32_t **session_id,
131 : bool need_alignment,
132 : size_t transport_message_size,
133 : void *transport_message,
134 : size_t *message_size, void **message)
135 : {
136 : const libspdm_test_message_header_t *test_message_header;
137 :
138 136520 : LIBSPDM_ASSERT(transport_message_size > sizeof(libspdm_test_message_header_t));
139 136520 : if (transport_message_size <= sizeof(libspdm_test_message_header_t)) {
140 0 : return LIBSPDM_STATUS_INVALID_MSG_SIZE;
141 : }
142 :
143 136520 : test_message_header = transport_message;
144 :
145 136520 : switch (test_message_header->message_type) {
146 336 : case LIBSPDM_TEST_MESSAGE_TYPE_SECURED_TEST:
147 336 : LIBSPDM_ASSERT(session_id != NULL);
148 336 : if (session_id == NULL) {
149 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
150 : }
151 336 : if (transport_message_size <=
152 : sizeof(libspdm_test_message_header_t) + sizeof(uint32_t)) {
153 0 : return LIBSPDM_STATUS_INVALID_MSG_SIZE;
154 : }
155 336 : *session_id = (uint32_t *)((uint8_t *)transport_message +
156 : sizeof(libspdm_test_message_header_t));
157 336 : break;
158 136184 : case LIBSPDM_TEST_MESSAGE_TYPE_SPDM:
159 136184 : if (session_id != NULL) {
160 136184 : *session_id = NULL;
161 : }
162 136184 : break;
163 0 : default:
164 0 : return LIBSPDM_STATUS_UNSUPPORTED_CAP;
165 : }
166 :
167 136520 : if (need_alignment) {
168 136212 : LIBSPDM_ASSERT(((transport_message_size - sizeof(libspdm_test_message_header_t)) &
169 : (LIBSPDM_TEST_ALIGNMENT - 1)) == 0);
170 : }
171 :
172 136520 : *message_size = transport_message_size - sizeof(libspdm_test_message_header_t);
173 136520 : *message = (uint8_t *)transport_message + sizeof(libspdm_test_message_header_t);
174 136520 : return LIBSPDM_STATUS_SUCCESS;
175 : }
|
