22
33#include " HybridKeyObjectHandle.hpp"
44#include " Utils.hpp"
5+ #include " CFRGKeyPairType.hpp"
6+ #include < openssl/evp.h>
57
68namespace margelo ::nitro::crypto {
79
810std::shared_ptr<ArrayBuffer> HybridKeyObjectHandle::exportKey (std::optional<KFormatType> format, std::optional<KeyEncoding> type,
911 const std::optional<std::string>& cipher,
1012 const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
11- throw std::runtime_error (" Not yet implemented"
13+ auto keyType = data_.GetKeyType ();
14+
15+ // Handle secret keys
16+ if (keyType == KeyType::SECRET) {
17+ return data_.GetSymmetricKey ();
18+ }
19+
20+ // Handle asymmetric keys (public/private)
21+ if (keyType == KeyType::PUBLIC || keyType == KeyType::PRIVATE) {
22+ const auto & pkey = data_.GetAsymmetricKey ();
23+ if (!pkey) {
24+ throw std::runtime_error (" Invalid asymmetric key"
25+ }
26+
27+ int keyId = EVP_PKEY_id (pkey.get ());
28+
29+ // For curve keys (X25519, X448, Ed25519, Ed448), use raw format if no format specified
30+ bool isCurveKey = (keyId == EVP_PKEY_X25519 || keyId == EVP_PKEY_X448 ||
31+ keyId == EVP_PKEY_ED25519 || keyId == EVP_PKEY_ED448);
32+
33+ // If no format specified and it's a curve key, export as raw
34+ if (!format.has_value () && !type.has_value () && isCurveKey) {
35+ if (keyType == KeyType::PUBLIC) {
36+ auto rawData = pkey.rawPublicKey ();
37+ if (!rawData) {
38+ throw std::runtime_error (" Failed to get raw public key"
39+ }
40+ return ToNativeArrayBuffer (std::string (reinterpret_cast <const char *>(rawData.get ()), rawData.size ()));
41+ } else {
42+ auto rawData = pkey.rawPrivateKey ();
43+ if (!rawData) {
44+ throw std::runtime_error (" Failed to get raw private key"
45+ }
46+ return ToNativeArrayBuffer (std::string (reinterpret_cast <const char *>(rawData.get ()), rawData.size ()));
47+ }
48+ }
49+
50+ // Set default format and type if not provided
51+ auto exportFormat = format.value_or (KFormatType::DER);
52+ auto exportType = type.value_or (keyType == KeyType::PUBLIC ? KeyEncoding::SPKI : KeyEncoding::PKCS8);
53+
54+ // Create encoding config
55+ if (keyType == KeyType::PUBLIC) {
56+ ncrypto::EVPKeyPointer::PublicKeyEncodingConfig config (
57+ false ,
58+ static_cast <ncrypto::EVPKeyPointer::PKFormatType>(exportFormat),
59+ static_cast <ncrypto::EVPKeyPointer::PKEncodingType>(exportType)
60+ );
61+
62+ auto result = pkey.writePublicKey (config);
63+ if (!result) {
64+ throw std::runtime_error (" Failed to export public key"
65+ }
66+
67+ auto bio = std::move (result.value );
68+ BUF_MEM* bptr = bio;
69+ return ToNativeArrayBuffer (std::string (bptr->data , bptr->length ));
70+ } else {
71+ ncrypto::EVPKeyPointer::PrivateKeyEncodingConfig config (
72+ false ,
73+ static_cast <ncrypto::EVPKeyPointer::PKFormatType>(exportFormat),
74+ static_cast <ncrypto::EVPKeyPointer::PKEncodingType>(exportType)
75+ );
76+
77+ // Handle cipher and passphrase for encrypted private keys
78+ if (cipher.has_value ()) {
79+ const EVP_CIPHER* evp_cipher = EVP_get_cipherbyname (cipher.value ().c_str ());
80+ if (!evp_cipher) {
81+ throw std::runtime_error (" Unknown cipher: " value ());
82+ }
83+ config.cipher = evp_cipher;
84+ }
85+
86+ if (passphrase.has_value ()) {
87+ auto & passphrase_ptr = passphrase.value ();
88+ config.passphrase = std::make_optional (ncrypto::DataPointer (passphrase_ptr->data (), passphrase_ptr->size ()));
89+ }
90+
91+ auto result = pkey.writePrivateKey (config);
92+ if (!result) {
93+ throw std::runtime_error (" Failed to export private key"
94+ }
95+
96+ auto bio = std::move (result.value );
97+ BUF_MEM* bptr = bio;
98+ return ToNativeArrayBuffer (std::string (bptr->data , bptr->length ));
99+ }
100+ }
101+
102+ throw std::runtime_error (" Unsupported key type for export"
12103}
13104
14105JWK HybridKeyObjectHandle::exportJwk (const JWK& key, bool handleRsaPss) {
15106 throw std::runtime_error (" Not yet implemented"
16107}
17108
18109CFRGKeyPairType HybridKeyObjectHandle::getAsymmetricKeyType () {
19- throw std::runtime_error (" Not yet implemented"
110+ const auto & pkey = data_.GetAsymmetricKey ();
111+ if (!pkey) {
112+ throw std::runtime_error (" Key is not an asymmetric key"
113+ }
114+
115+ int keyType = EVP_PKEY_id (pkey.get ());
116+
117+ switch (keyType) {
118+ case EVP_PKEY_X25519:
119+ return CFRGKeyPairType::X25519;
120+ case EVP_PKEY_X448:
121+ return CFRGKeyPairType::X448;
122+ case EVP_PKEY_ED25519:
123+ return CFRGKeyPairType::ED25519;
124+ case EVP_PKEY_ED448:
125+ return CFRGKeyPairType::ED448;
126+ default :
127+ throw std::runtime_error (" Unsupported asymmetric key type"
128+ }
20129}
21130
22131bool HybridKeyObjectHandle::init (KeyType keyType,
const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& key,
@@ -30,6 +139,11 @@ bool HybridKeyObjectHandle::init(KeyType keyType, const std::variant<std::string
30139 ab = std::get<std::shared_ptr<ArrayBuffer>>(key);
31140 }
32141
142+ // Handle raw key material (when format and type are not provided)
143+ if (!format.has_value () && !type.has_value ()) {
144+ return initRawKey (keyType, ab);
145+ }
146+
33147 switch (keyType) {
34148 case KeyType::SECRET: {
35149 this ->data_ = KeyObjectData::CreateSecret (ab);
@@ -63,4 +177,43 @@ KeyDetail HybridKeyObjectHandle::keyDetail() {
63177 throw std::runtime_error (" Not yet implemented"
64178}
65179
180+ bool HybridKeyObjectHandle::initRawKey (KeyType keyType, std::shared_ptr<ArrayBuffer> keyData) {
181+ // For x25519/x448/ed25519/ed448 raw keys, we need to determine the curve type
182+ // Based on key size: x25519=32 bytes, x448=56 bytes, ed25519=32 bytes, ed448=57 bytes
183+ int curveId = -1 ;
184+ size_t keySize = keyData->size ();
185+
186+ if (keySize == 32 ) {
187+ // Could be x25519 or ed25519 - for now assume x25519 based on test context
188+ curveId = EVP_PKEY_X25519;
189+ } else if (keySize == 56 ) {
190+ curveId = EVP_PKEY_X448;
191+ } else if (keySize == 57 ) {
192+ curveId = EVP_PKEY_ED448;
193+ } else {
194+ return false ; // Unsupported key size
195+ }
196+
197+ ncrypto::Buffer<const unsigned char > buffer{
198+ .data = reinterpret_cast <const unsigned char *>(keyData->data ()),
199+ .len = keyData->size ()
200+ };
201+
202+ ncrypto::EVPKeyPointer pkey;
203+ if (keyType == KeyType::PRIVATE) {
204+ pkey = ncrypto::EVPKeyPointer::NewRawPrivate (curveId, buffer);
205+ } else if (keyType == KeyType::PUBLIC) {
206+ pkey = ncrypto::EVPKeyPointer::NewRawPublic (curveId, buffer);
207+ } else {
208+ return false ; // Raw keys are only for asymmetric keys
209+ }
210+
211+ if (!pkey) {
212+ return false ;
213+ }
214+
215+ this ->data_ = KeyObjectData::CreateAsymmetric (keyType, std::move (pkey));
216+ return true ;
217+ }
218+
66219} // namespace margelo::nitro::crypto
0 commit comments