Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2024-2026 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 <stdarg.h>
8 : #include <stddef.h>
9 : #include <setjmp.h>
10 : #include <stdint.h>
11 : #include <stdlib.h>
12 : #include <stdio.h>
13 : #include <assert.h>
14 : #include <string.h>
15 :
16 : #include <base.h>
17 : #include "library/memlib.h"
18 : #include "internal/libspdm_device_secret_lib.h"
19 : #include "internal/libspdm_common_lib.h"
20 :
21 : #if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY
22 146 : bool libspdm_read_responder_private_key(uint32_t base_asym_algo,
23 : void **data, size_t *size)
24 : {
25 : bool res;
26 : char *file;
27 :
28 146 : switch (base_asym_algo) {
29 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048:
30 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048:
31 0 : file = "rsa2048/end_responder.key";
32 0 : break;
33 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072:
34 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072:
35 0 : file = "rsa3072/end_responder.key";
36 0 : break;
37 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096:
38 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096:
39 0 : file = "rsa4096/end_responder.key";
40 0 : break;
41 146 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256:
42 146 : file = "ecp256/end_responder.key";
43 146 : break;
44 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384:
45 0 : file = "ecp384/end_responder.key";
46 0 : break;
47 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521:
48 0 : file = "ecp521/end_responder.key";
49 0 : break;
50 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256:
51 0 : file = "sm2/end_responder.key";
52 0 : break;
53 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519:
54 0 : file = "ed25519/end_responder.key";
55 0 : break;
56 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448:
57 0 : file = "ed448/end_responder.key";
58 0 : break;
59 0 : default:
60 0 : LIBSPDM_ASSERT(false);
61 0 : return false;
62 : }
63 146 : res = libspdm_read_input_file(file, data, size);
64 146 : return res;
65 : }
66 :
67 140 : bool libspdm_read_responder_private_key_ex(uint32_t base_asym_algo, uint8_t key_pair_id,
68 : void **data, size_t *size)
69 : {
70 : #if LIBSPDM_ENABLE_CAPABILITY_GET_KEY_PAIR_INFO_CAP
71 : bool res;
72 : char *file;
73 :
74 : /* slot 0 / slot 1 share the default leaf key; slot 4 uses a distinct leaf key
75 : * (end_responder4.key) to demonstrate multiple keys. The slot-4 key pair is the negotiated
76 : * algorithm's SECONDARY key pair; only it selects end_responder4.key. */
77 140 : if (key_pair_id != libspdm_get_key_pair_id_by_slot(base_asym_algo, 0, 4)) {
78 140 : return libspdm_read_responder_private_key(base_asym_algo, data, size);
79 : }
80 :
81 0 : switch (base_asym_algo) {
82 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048:
83 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048:
84 0 : file = "rsa2048/end_responder4.key";
85 0 : break;
86 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072:
87 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072:
88 0 : file = "rsa3072/end_responder4.key";
89 0 : break;
90 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096:
91 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096:
92 0 : file = "rsa4096/end_responder4.key";
93 0 : break;
94 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256:
95 0 : file = "ecp256/end_responder4.key";
96 0 : break;
97 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384:
98 0 : file = "ecp384/end_responder4.key";
99 0 : break;
100 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521:
101 0 : file = "ecp521/end_responder4.key";
102 0 : break;
103 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256:
104 0 : file = "sm2/end_responder4.key";
105 0 : break;
106 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519:
107 0 : file = "ed25519/end_responder4.key";
108 0 : break;
109 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448:
110 0 : file = "ed448/end_responder4.key";
111 0 : break;
112 0 : default:
113 0 : LIBSPDM_ASSERT(false);
114 0 : return false;
115 : }
116 0 : res = libspdm_read_input_file(file, data, size);
117 0 : return res;
118 : #else
119 : return libspdm_read_responder_private_key(base_asym_algo, data, size);
120 : #endif
121 : }
122 : #endif
123 :
124 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP)
125 35 : bool libspdm_read_requester_private_key(uint16_t req_base_asym_alg,
126 : void **data, size_t *size)
127 : {
128 : bool res;
129 : char *file;
130 :
131 35 : switch (req_base_asym_alg) {
132 35 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048:
133 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048:
134 35 : file = "rsa2048/end_requester.key";
135 35 : break;
136 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072:
137 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072:
138 0 : file = "rsa3072/end_requester.key";
139 0 : break;
140 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096:
141 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096:
142 0 : file = "rsa4096/end_requester.key";
143 0 : break;
144 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256:
145 0 : file = "ecp256/end_requester.key";
146 0 : break;
147 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384:
148 0 : file = "ecp384/end_requester.key";
149 0 : break;
150 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521:
151 0 : file = "ecp521/end_requester.key";
152 0 : break;
153 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256:
154 0 : file = "sm2/end_requester.key";
155 0 : break;
156 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519:
157 0 : file = "ed25519/end_requester.key";
158 0 : break;
159 0 : case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448:
160 0 : file = "ed448/end_requester.key";
161 0 : break;
162 0 : default:
163 0 : LIBSPDM_ASSERT(false);
164 0 : return false;
165 : }
166 35 : res = libspdm_read_input_file(file, data, size);
167 35 : return res;
168 : }
169 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */
|
