luna - wolfssl/wrapper/CSharp/wolfSSL

   1/* wolfCrypt.cs
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22using System;
  23using System.Collections.Generic;
  24#if !WindowsCE
  25using System.Collections.Concurrent;
  26#endif
  27using System.Runtime.InteropServices;
  28using System.Security.Cryptography;
  29using System.Text;
  30
  31namespace wolfSSL.CSharp
  32{
  33    public class wolfcrypt
  34    {
  35        private const string wolfssl_dll = "wolfssl.dll";
  36
  37        /********************************
  38         * Init wolfSSL library
  39         */
  40#if WindowsCE
  41        [DllImport(wolfssl_dll)]
  42        private extern static int wolfCrypt_Init();
  43        [DllImport(wolfssl_dll)]
  44        private extern static int wolfCrypt_Cleanup();
  45#else
  46        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
  47        private extern static int wolfCrypt_Init();
  48        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
  49        private extern static int wolfCrypt_Cleanup();
  50#endif
  51
  52
  53        /********************************
  54         * Random
  55         */
  56#if WindowsCE
  57        [DllImport(wolfssl_dll)]
  58        private extern static IntPtr wc_rng_new(IntPtr nonce, UInt32 nonceSz, IntPtr heap);
  59        [DllImport(wolfssl_dll)]
  60        private extern static void wc_rng_free(IntPtr rng);
  61        [DllImport(wolfssl_dll)]
  62        private extern static int wc_RNG_GenerateBlock(IntPtr rng, IntPtr output, UInt32 sz);
  63#else
  64        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
  65        private extern static IntPtr wc_rng_new(IntPtr nonce, UInt32 nonceSz, IntPtr heap);
  66        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
  67        private extern static void wc_rng_free(IntPtr rng);
  68        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
  69        private extern static int wc_RNG_GenerateBlock(IntPtr rng, IntPtr output, UInt32 sz);
  70#endif
  71
  72
  73        /********************************
  74         * ECC
  75         */
  76#if WindowsCE
  77        [DllImport(wolfssl_dll)]
  78        private extern static IntPtr wc_ecc_key_new(IntPtr heap);
  79        [DllImport(wolfssl_dll)]
  80        private extern static void wc_ecc_key_free(IntPtr key);
  81        [DllImport(wolfssl_dll)]
  82        private extern static int wc_ecc_set_rng(IntPtr key, IntPtr rng);
  83        [DllImport(wolfssl_dll)]
  84        private extern static int wc_ecc_make_key_ex(IntPtr rng, int keysize, IntPtr key, int curve_id);
  85        [DllImport(wolfssl_dll)]
  86        private extern static int wc_ecc_sign_hash(IntPtr hashPtr, uint hashlen, IntPtr sigPtr, IntPtr siglen, IntPtr rng, IntPtr key);
  87        [DllImport(wolfssl_dll)]
  88        private extern static int wc_ecc_verify_hash(IntPtr sigPtr, uint siglen, IntPtr hashPtr, uint hashlen, IntPtr res, IntPtr key);
  89
  90        /* ASN.1 DER format */
  91        [DllImport(wolfssl_dll)]
  92        private extern static int wc_EccPrivateKeyDecode(IntPtr keyBuf, IntPtr idx, IntPtr key, uint keyBufSz);
  93        [DllImport(wolfssl_dll)]
  94        private static extern int wc_EccPublicKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
  95        [DllImport(wolfssl_dll)]
  96        private static extern int wc_EccPrivateKeyToDer(IntPtr key, byte[] output, uint inLen);
  97        [DllImport(wolfssl_dll)]
  98        private static extern int wc_EccPublicKeyToDer(IntPtr key, byte[] output, uint inLen, int with_AlgCurve);
  99#else
 100        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 101        private extern static IntPtr wc_ecc_key_new(IntPtr heap);
 102        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 103        private extern static void wc_ecc_key_free(IntPtr key);
 104        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 105        private extern static int wc_ecc_set_rng(IntPtr key, IntPtr rng);
 106        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 107        private extern static int wc_ecc_make_key_ex(IntPtr rng, int keysize, IntPtr key, int curve_id);
 108        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 109        private extern static int wc_ecc_sign_hash(IntPtr hashPtr, uint hashlen, IntPtr sigPtr, IntPtr siglen, IntPtr rng, IntPtr key);
 110        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 111        private extern static int wc_ecc_verify_hash(IntPtr sigPtr, uint siglen, IntPtr hashPtr, uint hashlen, IntPtr res, IntPtr key);
 112
 113        /* ASN.1 DER format */
 114        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 115        private extern static int wc_EccPrivateKeyDecode(IntPtr keyBuf, IntPtr idx, IntPtr key, uint keyBufSz);
 116        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 117        private static extern int wc_EccPublicKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 118        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 119        private static extern int wc_EccPrivateKeyToDer(IntPtr key, byte[] output, uint inLen);
 120        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 121        private static extern int wc_EccPublicKeyToDer(IntPtr key, byte[] output, uint inLen, int with_AlgCurve);
 122#endif
 123
 124
 125        /********************************
 126         * ECIES
 127         */
 128#if WindowsCE
 129        [DllImport(wolfssl_dll)]
 130        private extern static IntPtr wc_ecc_ctx_new(int flags, IntPtr rng);
 131        [DllImport(wolfssl_dll)]
 132        private extern static IntPtr wc_ecc_ctx_new_ex(int flags, IntPtr rng, IntPtr heap);
 133        [DllImport(wolfssl_dll)]
 134        private extern static void wc_ecc_ctx_free(IntPtr ctx);
 135        [DllImport(wolfssl_dll)]
 136        private extern static int wc_ecc_ctx_reset(IntPtr ctx, IntPtr rng);
 137        [DllImport(wolfssl_dll)]
 138        private extern static int wc_ecc_ctx_set_algo(IntPtr ctx, byte encAlgo, byte kdfAlgo, byte macAlgo);
 139        [DllImport(wolfssl_dll)]
 140        private extern static IntPtr wc_ecc_ctx_get_own_salt(IntPtr ctx);
 141        [DllImport(wolfssl_dll)]
 142        private extern static int wc_ecc_ctx_set_peer_salt(IntPtr ctx, IntPtr salt);
 143        [DllImport(wolfssl_dll)]
 144        private extern static int wc_ecc_ctx_set_own_salt(IntPtr ctx, IntPtr salt, uint sz);
 145        [DllImport(wolfssl_dll)]
 146        private extern static int wc_ecc_ctx_set_kdf_salt(IntPtr ctx, IntPtr salt, uint sz);
 147        [DllImport(wolfssl_dll)]
 148        private extern static int wc_ecc_ctx_set_info(IntPtr ctx, IntPtr info, int sz);
 149        [DllImport(wolfssl_dll)]
 150        private extern static int wc_ecc_encrypt(IntPtr privKey, IntPtr pubKey, IntPtr msg, uint msgSz, IntPtr outBuffer, IntPtr outSz, IntPtr ctx);
 151        [DllImport(wolfssl_dll)]
 152        private extern static int wc_ecc_encrypt_ex(IntPtr privKey, IntPtr pubKey, IntPtr msg, uint msgSz, IntPtr outBuffer, IntPtr outSz, IntPtr ctx, int compressed);
 153        [DllImport(wolfssl_dll)]
 154        private extern static int wc_ecc_decrypt(IntPtr privKey, IntPtr pubKey, IntPtr msg, uint msgSz, IntPtr outBuffer, IntPtr outSz, IntPtr ctx);
 155#else
 156        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 157        private extern static IntPtr wc_ecc_ctx_new(int flags, IntPtr rng);
 158        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 159        private extern static IntPtr wc_ecc_ctx_new_ex(int flags, IntPtr rng, IntPtr heap);
 160        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 161        private extern static void wc_ecc_ctx_free(IntPtr ctx);
 162        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 163        private extern static int wc_ecc_ctx_reset(IntPtr ctx, IntPtr rng);
 164        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 165        private extern static int wc_ecc_ctx_set_algo(IntPtr ctx, byte encAlgo, byte kdfAlgo, byte macAlgo);
 166        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 167        private extern static IntPtr wc_ecc_ctx_get_own_salt(IntPtr ctx);
 168        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 169        private extern static int wc_ecc_ctx_set_peer_salt(IntPtr ctx, IntPtr salt);
 170        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 171        private extern static int wc_ecc_ctx_set_own_salt(IntPtr ctx, IntPtr salt, uint sz);
 172        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 173        private extern static int wc_ecc_ctx_set_kdf_salt(IntPtr ctx, IntPtr salt, uint sz);
 174        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 175        private extern static int wc_ecc_ctx_set_info(IntPtr ctx, IntPtr info, int sz);
 176        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 177        private extern static int wc_ecc_encrypt(IntPtr privKey, IntPtr pubKey, IntPtr msg, uint msgSz, IntPtr outBuffer, IntPtr outSz, IntPtr ctx);
 178        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 179        private extern static int wc_ecc_encrypt_ex(IntPtr privKey, IntPtr pubKey, IntPtr msg, uint msgSz, IntPtr outBuffer, IntPtr outSz, IntPtr ctx, int compressed);
 180        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 181        private extern static int wc_ecc_decrypt(IntPtr privKey, IntPtr pubKey, IntPtr msg, uint msgSz, IntPtr outBuffer, IntPtr outSz, IntPtr ctx);
 182#endif
 183
 184
 185
 186        /********************************
 187         * ECDHE
 188         */
 189#if WindowsCE
 190        [DllImport(wolfssl_dll)]
 191        private extern static int wc_ecc_shared_secret(IntPtr privateKey, IntPtr publicKey, byte[] outSharedSecret, ref int outlen);
 192#else
 193        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 194        private extern static int wc_ecc_shared_secret(IntPtr privateKey, IntPtr publicKey, byte[] outSharedSecret, ref int outlen);
 195#endif
 196
 197
 198        /********************************
 199         * RSA
 200         */
 201#if WindowsCE
 202        [DllImport(wolfssl_dll)]
 203        private static extern IntPtr wc_NewRsaKey(IntPtr heap, int devId, IntPtr result_code);
 204        [DllImport(wolfssl_dll)]
 205        private static extern int wc_DeleteRsaKey(IntPtr key, IntPtr key_p);
 206        [DllImport(wolfssl_dll)]
 207        private extern static int wc_InitRsaKey(IntPtr key, IntPtr heap);
 208        [DllImport(wolfssl_dll)]
 209        private extern static void wc_FreeRsaKey(IntPtr key);
 210        [DllImport(wolfssl_dll)]
 211        private extern static int wc_MakeRsaKey(IntPtr key, int keysize, Int32 exponent, IntPtr rng);
 212        [DllImport(wolfssl_dll)]
 213        private extern static int wc_RsaSSL_Sign(IntPtr hashPtr, int hashLen, IntPtr sigPtr, int sigLen, IntPtr key, IntPtr rng);
 214        [DllImport(wolfssl_dll)]
 215        private extern static int wc_RsaSSL_Verify(IntPtr sigPtr, int sigLen, IntPtr hashPtr, int hashLen, IntPtr key);
 216
 217        /* ASN.1 DER format */
 218        [DllImport(wolfssl_dll)]
 219        private extern static int wc_RsaPublicEncrypt(IntPtr inPtr, int inLen, IntPtr outPtr, int outLen, IntPtr key);
 220        [DllImport(wolfssl_dll)]
 221        private extern static int wc_RsaPrivateDecrypt(IntPtr inPtr, int inLen, IntPtr outPtr, int outLen, IntPtr key);
 222        [DllImport(wolfssl_dll)]
 223        private extern static int wc_RsaPrivateKeyDecode(IntPtr keyBuf, IntPtr idx, IntPtr key, uint keyBufSz);
 224        [DllImport(wolfssl_dll)]
 225        private extern static int wc_RsaPublicKeyDecode(IntPtr keyBuf, IntPtr idx, IntPtr key, uint keyBufSz);
 226
 227        [DllImport(wolfssl_dll)]
 228        private extern static int wc_RsaPSS_Sign(IntPtr hashPtr, int hashLen, IntPtr sigPtr, int sigLen, int hashType, IntPtr rng, IntPtr key);
 229        [DllImport(wolfssl_dll)]
 230        private extern static int wc_RsaPSS_Verify(IntPtr sigPtr, int sigLen, IntPtr hashPtr, int hashLen, int hashType, IntPtr key);
 231        [DllImport(wolfssl_dll)]
 232        private extern static int wc_RsaPSS_CheckPadding(IntPtr sigPtr, int sigLen, int hashType, IntPtr key);
 233#else
 234        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 235        private static extern IntPtr wc_NewRsaKey(IntPtr heap, int devId, IntPtr result_code);
 236        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 237        private static extern int wc_DeleteRsaKey(IntPtr key, IntPtr key_p);
 238        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 239        private extern static int wc_InitRsaKey(IntPtr key, IntPtr heap);
 240        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 241        private extern static void wc_FreeRsaKey(IntPtr key);
 242        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 243        private extern static int wc_MakeRsaKey(IntPtr key, int keysize, Int32 exponent, IntPtr rng);
 244        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 245        private extern static int wc_RsaSSL_Sign(IntPtr hashPtr, int hashLen, IntPtr sigPtr, int sigLen, IntPtr key, IntPtr rng);
 246        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 247        private extern static int wc_RsaSSL_Verify(IntPtr sigPtr, int sigLen, IntPtr hashPtr, int hashLen, IntPtr key);
 248
 249        /* ASN.1 DER format */
 250        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 251        private extern static int wc_RsaPublicEncrypt(IntPtr inPtr, int inLen, IntPtr outPtr, int outLen, IntPtr key);
 252        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 253        private extern static int wc_RsaPrivateDecrypt(IntPtr inPtr, int inLen, IntPtr outPtr, int outLen, IntPtr key);
 254        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 255        private extern static int wc_RsaPrivateKeyDecode(IntPtr keyBuf, IntPtr idx, IntPtr key, uint keyBufSz);
 256        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 257        private extern static int wc_RsaPublicKeyDecode(IntPtr keyBuf, IntPtr idx, IntPtr key, uint keyBufSz);
 258
 259        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 260        private extern static int wc_RsaPSS_Sign(IntPtr hashPtr, int hashLen, IntPtr sigPtr, int sigLen, int hashType, IntPtr rng, IntPtr key);
 261        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 262        private extern static int wc_RsaPSS_Verify(IntPtr sigPtr, int sigLen, IntPtr hashPtr, int hashLen, int hashType, IntPtr key);
 263        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 264        private extern static int wc_RsaPSS_CheckPadding(IntPtr sigPtr, int sigLen, int hashType, IntPtr key);
 265#endif
 266
 267
 268        /********************************
 269         * ED25519
 270         */
 271#if WindowsCE
 272        [DllImport(wolfssl_dll)]
 273        private static extern IntPtr wc_ed25519_new(IntPtr heap, int devId, IntPtr result_code);
 274        [DllImport(wolfssl_dll)]
 275        private static extern int wc_ed25519_delete(IntPtr key, IntPtr key_p);
 276        [DllImport(wolfssl_dll)]
 277        private static extern int wc_ed25519_init(IntPtr key);
 278        [DllImport(wolfssl_dll)]
 279        private static extern void wc_ed25519_free(IntPtr key);
 280        [DllImport(wolfssl_dll)]
 281        private static extern int wc_ed25519_make_key(IntPtr rng, int keysize, IntPtr key);
 282        [DllImport(wolfssl_dll)]
 283        private static extern int wc_ed25519_sign_msg(IntPtr inMsg, uint inlen, IntPtr outMsg, ref uint outlen, IntPtr key);
 284        [DllImport(wolfssl_dll)]
 285        private static extern int wc_ed25519_verify_msg(IntPtr sig, uint siglen, IntPtr msg, uint msgLen, ref int ret, IntPtr key);
 286
 287        /* ASN.1 DER format */
 288        [DllImport(wolfssl_dll)]
 289        private static extern int wc_Ed25519PrivateKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 290        [DllImport(wolfssl_dll)]
 291        private static extern int wc_Ed25519PublicKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 292        [DllImport(wolfssl_dll)]
 293        private static extern int wc_Ed25519KeyToDer(IntPtr key, byte[] output, uint inLen);
 294        [DllImport(wolfssl_dll)]
 295        private static extern int wc_Ed25519PrivateKeyToDer(IntPtr key, byte[] output, uint inLen);
 296        [DllImport(wolfssl_dll)]
 297        private static extern int wc_Ed25519PublicKeyToDer(IntPtr key, byte[] output, uint inLen, int withAlg);
 298
 299        /* RAW format */
 300        [DllImport(wolfssl_dll)]
 301        private static extern int wc_ed25519_make_public(IntPtr key, IntPtr pubKey, uint pubKeySz);
 302        [DllImport(wolfssl_dll)]
 303        private static extern int wc_ed25519_import_public(IntPtr inMsg, uint inLen, IntPtr key);
 304        [DllImport(wolfssl_dll)]
 305        private static extern int wc_ed25519_export_public(IntPtr key, IntPtr outMsg, ref uint outLen);
 306        [DllImport(wolfssl_dll)]
 307        private static extern int wc_ed25519_export_private(IntPtr key, IntPtr outMsg, ref uint outLen);
 308        [DllImport(wolfssl_dll)]
 309        private static extern int wc_ed25519_size(IntPtr key);
 310#else
 311        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 312        private static extern IntPtr wc_ed25519_new(IntPtr heap, int devId, IntPtr result_code);
 313        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 314        private static extern int wc_ed25519_delete(IntPtr key, IntPtr key_p);
 315        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 316        private static extern int wc_ed25519_init(IntPtr key);
 317        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 318        private static extern void wc_ed25519_free(IntPtr key);
 319        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 320        private static extern int wc_ed25519_make_key(IntPtr rng, int keysize, IntPtr key);
 321        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 322        private static extern int wc_ed25519_sign_msg(IntPtr inMsg, uint inlen, IntPtr outMsg, ref uint outlen, IntPtr key);
 323        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 324        private static extern int wc_ed25519_verify_msg(IntPtr sig, uint siglen, IntPtr msg, uint msgLen, ref int ret, IntPtr key);
 325
 326        /* ASN.1 DER format */
 327        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 328        private static extern int wc_Ed25519PrivateKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 329        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 330        private static extern int wc_Ed25519PublicKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 331        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 332        private static extern int wc_Ed25519KeyToDer(IntPtr key, byte[] output, uint inLen);
 333        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 334        private static extern int wc_Ed25519PrivateKeyToDer(IntPtr key, byte[] output, uint inLen);
 335        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 336        private static extern int wc_Ed25519PublicKeyToDer(IntPtr key, byte[] output, uint inLen, int withAlg);
 337
 338        /* RAW format */
 339        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 340        private static extern int wc_ed25519_make_public(IntPtr key, IntPtr pubKey, uint pubKeySz);
 341        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 342        private static extern int wc_ed25519_import_public(IntPtr inMsg, uint inLen, IntPtr key);
 343        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 344        private static extern int wc_ed25519_export_public(IntPtr key, IntPtr outMsg, ref uint outLen);
 345        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 346        private static extern int wc_ed25519_export_private(IntPtr key, IntPtr outMsg, ref uint outLen);
 347        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 348        private static extern int wc_ed25519_size(IntPtr key);
 349#endif
 350
 351
 352        /********************************
 353         * Curve25519
 354         */
 355#if WindowsCE
 356        [DllImport(wolfssl_dll)]
 357        private static extern IntPtr wc_curve25519_new(IntPtr heap, int devId, IntPtr result_code);
 358        [DllImport(wolfssl_dll)]
 359        private static extern int wc_curve25519_delete(IntPtr key, IntPtr key_p);
 360        [DllImport(wolfssl_dll)]
 361        private extern static int wc_curve25519_init(IntPtr key);
 362        [DllImport(wolfssl_dll)]
 363        private extern static void wc_curve25519_free(IntPtr key);
 364        [DllImport(wolfssl_dll)]
 365        private extern static int wc_curve25519_make_key(IntPtr rng, int keysize, IntPtr key);
 366        [DllImport(wolfssl_dll)]
 367        private extern static int wc_curve25519_shared_secret(IntPtr privateKey, IntPtr publicKey, byte[] outSharedSecret, ref int outlen);
 368        /* Only available when wolfSSL is built with WOLFSSL_CURVE25519_BLINDING.
 369         * Calls are wrapped in try/catch to tolerate builds without it. */
 370        [DllImport(wolfssl_dll)]
 371        private extern static int wc_curve25519_set_rng(IntPtr key, IntPtr rng);
 372
 373        /* ASN.1 DER format */
 374        [DllImport(wolfssl_dll)]
 375        private static extern int wc_Curve25519PrivateKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 376        [DllImport(wolfssl_dll)]
 377        private static extern int wc_Curve25519PublicKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 378        [DllImport(wolfssl_dll)]
 379        private static extern int wc_Curve25519PrivateKeyToDer(IntPtr key, byte[] output, uint inLen);
 380        [DllImport(wolfssl_dll)]
 381        private static extern int wc_Curve25519PublicKeyToDer(IntPtr key, byte[] output, uint inLen, int withAlg);
 382
 383        /* RAW format */
 384        [DllImport(wolfssl_dll)]
 385        private extern static int wc_curve25519_import_private(IntPtr privKey, int privKeySz, IntPtr key);
 386        [DllImport(wolfssl_dll)]
 387        private static extern int wc_curve25519_export_public(IntPtr key, byte[] outBuffer, ref uint outLen);
 388        [DllImport(wolfssl_dll)]
 389        private extern static int wc_curve25519_import_public(IntPtr pubKey, int pubKeySz, IntPtr key);
 390        [DllImport(wolfssl_dll)]
 391        private extern static int wc_curve25519_export_public(IntPtr key, IntPtr outPubKey, ref int outlen);
 392        [DllImport(wolfssl_dll)]
 393        private static extern int wc_curve25519_export_key_raw(IntPtr key, byte[] priv, ref uint privSz, byte[] pub, ref uint pubSz);
 394        [DllImport(wolfssl_dll)]
 395        private extern static int wc_curve25519_import_private_raw(IntPtr privKey, IntPtr pubKey, IntPtr key);
 396        [DllImport(wolfssl_dll)]
 397        private extern static int wc_curve25519_export_private_raw(IntPtr key, IntPtr outPrivKey, IntPtr outPubKey);
 398#else
 399        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 400        private static extern IntPtr wc_curve25519_new(IntPtr heap, int devId, IntPtr result_code);
 401        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 402        private static extern int wc_curve25519_delete(IntPtr key, IntPtr key_p);
 403        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 404        private extern static int wc_curve25519_init(IntPtr key);
 405        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 406        private extern static void wc_curve25519_free(IntPtr key);
 407        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 408        private extern static int wc_curve25519_make_key(IntPtr rng, int keysize, IntPtr key);
 409        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 410        private extern static int wc_curve25519_shared_secret(IntPtr privateKey, IntPtr publicKey, byte[] outSharedSecret, ref int outlen);
 411        /* Only available when wolfSSL is built with WOLFSSL_CURVE25519_BLINDING.
 412         * Calls are wrapped in try/catch to tolerate builds without it. */
 413        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 414        private extern static int wc_curve25519_set_rng(IntPtr key, IntPtr rng);
 415
 416        /* ASN.1 DER format */
 417        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 418        private static extern int wc_Curve25519PrivateKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 419        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 420        private static extern int wc_Curve25519PublicKeyDecode(byte[] input, ref uint inOutIdx, IntPtr key, uint inSz);
 421        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 422        private static extern int wc_Curve25519PrivateKeyToDer(IntPtr key, byte[] output, uint inLen);
 423        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 424        private static extern int wc_Curve25519PublicKeyToDer(IntPtr key, byte[] output, uint inLen, int withAlg);
 425
 426        /* RAW format */
 427        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 428        private extern static int wc_curve25519_import_private(IntPtr privKey, int privKeySz, IntPtr key);
 429        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 430        private static extern int wc_curve25519_export_public(IntPtr key, byte[] outBuffer, ref uint outLen);
 431        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 432        private extern static int wc_curve25519_import_public(IntPtr pubKey, int pubKeySz, IntPtr key);
 433        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 434        private extern static int wc_curve25519_export_public(IntPtr key, IntPtr outPubKey, ref int outlen);
 435        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 436        private static extern int wc_curve25519_export_key_raw(IntPtr key, byte[] priv, ref uint privSz, byte[] pub, ref uint pubSz);
 437        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 438        private extern static int wc_curve25519_import_private_raw(IntPtr privKey, IntPtr pubKey, IntPtr key);
 439        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 440        private extern static int wc_curve25519_export_private_raw(IntPtr key, IntPtr outPrivKey, IntPtr outPubKey);
 441#endif
 442
 443        /********************************
 444         * ML-KEM
 445         */
 446#if WindowsCE
 447        [DllImport(wolfssl_dll)]
 448        private static extern int wc_MlKemKey_CipherTextSize(IntPtr key, ref uint len);
 449        [DllImport(wolfssl_dll)]
 450        private static extern int wc_MlKemKey_SharedSecretSize(IntPtr key, ref uint len);
 451        [DllImport(wolfssl_dll)]
 452        private static extern int wc_MlKemKey_PrivateKeySize(IntPtr key, ref uint len);
 453        [DllImport(wolfssl_dll)]
 454        private static extern int wc_MlKemKey_PublicKeySize(IntPtr key, ref uint len);
 455        [DllImport(wolfssl_dll)]
 456        private static extern IntPtr wc_MlKemKey_New(int type, IntPtr heap, int devId);
 457        [DllImport(wolfssl_dll)]
 458        private static extern int wc_MlKemKey_Delete(IntPtr key, IntPtr key_p);
 459        [DllImport(wolfssl_dll)]
 460        private static extern int wc_MlKemKey_MakeKey(IntPtr key, IntPtr rng);
 461        [DllImport(wolfssl_dll)]
 462        private static extern int wc_MlKemKey_EncodePublicKey(IntPtr key, byte[] output, uint len);
 463        [DllImport(wolfssl_dll)]
 464        private static extern int wc_MlKemKey_DecodePublicKey(IntPtr key, byte[] input, uint len);
 465        [DllImport(wolfssl_dll)]
 466        private static extern int wc_MlKemKey_Encapsulate(IntPtr key, byte[] ct, byte[] ss, IntPtr rng);
 467        [DllImport(wolfssl_dll)]
 468        private static extern int wc_MlKemKey_Decapsulate(IntPtr key, byte[] ss, byte[] ct, uint len);
 469        [DllImport(wolfssl_dll)]
 470        private static extern int wc_MlKemKey_EncodePrivateKey(IntPtr key, byte[] output, uint len);
 471        [DllImport(wolfssl_dll)]
 472        private static extern int wc_MlKemKey_DecodePrivateKey(IntPtr key, byte[] input, uint len);
 473#else
 474        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 475        private static extern int wc_MlKemKey_CipherTextSize(IntPtr key, ref uint len);
 476        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 477        private static extern int wc_MlKemKey_SharedSecretSize(IntPtr key, ref uint len);
 478        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 479        private static extern int wc_MlKemKey_PrivateKeySize(IntPtr key, ref uint len);
 480        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 481        private static extern int wc_MlKemKey_PublicKeySize(IntPtr key, ref uint len);
 482        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 483        private static extern IntPtr wc_MlKemKey_New(int type, IntPtr heap, int devId);
 484        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 485        private static extern int wc_MlKemKey_Delete(IntPtr key, IntPtr key_p);
 486        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 487        private static extern int wc_MlKemKey_MakeKey(IntPtr key, IntPtr rng);
 488        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 489        private static extern int wc_MlKemKey_EncodePublicKey(IntPtr key, byte[] output, uint len);
 490        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 491        private static extern int wc_MlKemKey_DecodePublicKey(IntPtr key, byte[] input, uint len);
 492        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 493        private static extern int wc_MlKemKey_Encapsulate(IntPtr key, byte[] ct, byte[] ss, IntPtr rng);
 494        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 495        private static extern int wc_MlKemKey_Decapsulate(IntPtr key, byte[] ss, byte[] ct, uint len);
 496        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 497        private static extern int wc_MlKemKey_EncodePrivateKey(IntPtr key, byte[] output, uint len);
 498        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 499        private static extern int wc_MlKemKey_DecodePrivateKey(IntPtr key, byte[] input, uint len);
 500#endif
 501
 502        /********************************
 503         * ML-DSA
 504         */
 505#if WindowsCE
 506        [DllImport(wolfssl_dll)]
 507        private static extern IntPtr wc_dilithium_new(IntPtr heap, int devId);
 508        [DllImport(wolfssl_dll)]
 509        private static extern int wc_dilithium_delete(IntPtr key, IntPtr key_p);
 510        [DllImport(wolfssl_dll)]
 511        private static extern int wc_dilithium_set_level(IntPtr key, byte level);
 512        [DllImport(wolfssl_dll)]
 513        private static extern int wc_dilithium_make_key(IntPtr key, IntPtr rng);
 514        [DllImport(wolfssl_dll)]
 515        private static extern int wc_dilithium_export_private(IntPtr key, byte[] output, ref uint outLen);
 516        [DllImport(wolfssl_dll)]
 517        private static extern int wc_dilithium_import_private(byte[] priv, uint privSz, IntPtr key);
 518        [DllImport(wolfssl_dll)]
 519        private static extern int wc_dilithium_export_public(IntPtr key, byte[] output, ref uint outLen);
 520        [DllImport(wolfssl_dll)]
 521        private static extern int wc_dilithium_import_public(byte[] input, uint inputLen, IntPtr key);
 522        [DllImport(wolfssl_dll)]
 523        private static extern int wc_dilithium_sign_ctx_msg(byte[] ctx, byte ctxLen, byte[] msg, uint msgLen, byte[] sig, ref uint sigLen, IntPtr key, IntPtr rng);
 524        [DllImport(wolfssl_dll)]
 525        private static extern int wc_dilithium_verify_ctx_msg(byte[] sig, uint sigLen, byte[] ctx, byte ctxLen, byte[] msg, uint msgLen, ref int res, IntPtr key);
 526        [DllImport(wolfssl_dll)]
 527        private static extern int wc_MlDsaKey_GetPrivLen(IntPtr key, ref int len);
 528        [DllImport(wolfssl_dll)]
 529        private static extern int wc_MlDsaKey_GetPubLen(IntPtr key, ref int len);
 530        [DllImport(wolfssl_dll)]
 531        private static extern int wc_MlDsaKey_GetSigLen(IntPtr key, ref int len);
 532#else
 533        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 534        private static extern IntPtr wc_dilithium_new(IntPtr heap, int devId);
 535        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 536        private static extern int wc_dilithium_delete(IntPtr key, IntPtr key_p);
 537        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 538        private static extern int wc_dilithium_set_level(IntPtr key, byte level);
 539        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 540        private static extern int wc_dilithium_make_key(IntPtr key, IntPtr rng);
 541        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 542        private static extern int wc_dilithium_export_private(IntPtr key, byte[] output, ref uint outLen);
 543        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 544        private static extern int wc_dilithium_import_private(byte[] priv, uint privSz, IntPtr key);
 545        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 546        private static extern int wc_dilithium_export_public(IntPtr key, byte[] output, ref uint outLen);
 547        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 548        private static extern int wc_dilithium_import_public(byte[] input, uint inputLen, IntPtr key);
 549        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 550        private static extern int wc_dilithium_sign_ctx_msg(byte[] ctx, byte ctxLen, byte[] msg, uint msgLen, byte[] sig, ref uint sigLen, IntPtr key, IntPtr rng);
 551        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 552        private static extern int wc_dilithium_verify_ctx_msg(byte[] sig, uint sigLen, byte[] ctx, byte ctxLen, byte[] msg, uint msgLen, ref int res, IntPtr key);
 553        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 554        private static extern int wc_MlDsaKey_GetPrivLen(IntPtr key, ref int len);
 555        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 556        private static extern int wc_MlDsaKey_GetPubLen(IntPtr key, ref int len);
 557        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 558        private static extern int wc_MlDsaKey_GetSigLen(IntPtr key, ref int len);
 559#endif
 560
 561        /********************************
 562         * AES-GCM
 563         */
 564#if WindowsCE
 565        [DllImport(wolfssl_dll)]
 566        private extern static IntPtr wc_AesNew(IntPtr heap, int devId, IntPtr result_code);
 567        [DllImport(wolfssl_dll)]
 568        private extern static int wc_AesDelete(IntPtr aes, IntPtr aes_p);
 569        [DllImport(wolfssl_dll)]
 570        private extern static int wc_AesFree(IntPtr aes);
 571        [DllImport(wolfssl_dll)]
 572        private extern static int wc_AesInit(IntPtr aes, IntPtr heap, int devId);
 573        [DllImport(wolfssl_dll)]
 574        private extern static int wc_AesGcmInit(IntPtr aes, IntPtr key, uint len, IntPtr iv, uint ivSz);
 575        [DllImport(wolfssl_dll)]
 576        private extern static int wc_AesGcmSetKey(IntPtr aes, IntPtr key, uint len);
 577        [DllImport(wolfssl_dll)]
 578        private extern static int wc_AesGcmEncrypt(IntPtr aes, IntPtr output, IntPtr input, uint sz, IntPtr iv, uint ivSz, IntPtr authTag, uint authTagSz, IntPtr authIn, uint authInSz);
 579        [DllImport(wolfssl_dll)]
 580        private extern static int wc_AesGcmDecrypt(IntPtr aes, IntPtr output, IntPtr input, uint sz, IntPtr iv, uint ivSz, IntPtr authTag, uint authTagSz, IntPtr authIn, uint authInSz);
 581#else
 582        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 583        private extern static IntPtr wc_AesNew(IntPtr heap, int devId, IntPtr result_code);
 584        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 585        private extern static int wc_AesDelete(IntPtr aes, IntPtr aes_p);
 586        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 587        private extern static int wc_AesFree(IntPtr aes);
 588        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 589        private extern static int wc_AesInit(IntPtr aes, IntPtr heap, int devId);
 590        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 591        private extern static int wc_AesGcmInit(IntPtr aes, IntPtr key, uint len, IntPtr iv, uint ivSz);
 592        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 593        private extern static int wc_AesGcmSetKey(IntPtr aes, IntPtr key, uint len);
 594        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 595        private extern static int wc_AesGcmEncrypt(IntPtr aes, IntPtr output, IntPtr input, uint sz, IntPtr iv, uint ivSz, IntPtr authTag, uint authTagSz, IntPtr authIn, uint authInSz);
 596        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 597        private extern static int wc_AesGcmDecrypt(IntPtr aes, IntPtr output, IntPtr input, uint sz, IntPtr iv, uint ivSz, IntPtr authTag, uint authTagSz, IntPtr authIn, uint authInSz);
 598#endif
 599
 600
 601        /********************************
 602         * HPKE
 603         * Requires: HAVE_HPKE, HAVE_ECC (or HAVE_CURVE25519), HAVE_AESGCM
 604         */
 605#if WindowsCE
 606        [DllImport(wolfssl_dll)]
 607        private extern static int wc_HpkeInit(IntPtr hpke, int kem, int kdf, int aead, IntPtr heap);
 608        [DllImport(wolfssl_dll)]
 609        private extern static int wc_HpkeGenerateKeyPair(IntPtr hpke, ref IntPtr keypair, IntPtr rng);
 610        [DllImport(wolfssl_dll)]
 611        private extern static int wc_HpkeSerializePublicKey(IntPtr hpke, IntPtr key, byte[] outBuf, ref ushort outSz);
 612        [DllImport(wolfssl_dll)]
 613        private extern static int wc_HpkeDeserializePublicKey(IntPtr hpke, ref IntPtr key, byte[] inBuf, ushort inSz);
 614        [DllImport(wolfssl_dll)]
 615        private extern static void wc_HpkeFreeKey(IntPtr hpke, ushort kem, IntPtr keypair, IntPtr heap);
 616        [DllImport(wolfssl_dll)]
 617        private extern static int wc_HpkeSealBase(IntPtr hpke, IntPtr ephemeralKey, IntPtr receiverKey, byte[] info, uint infoSz, byte[] aad, uint aadSz, byte[] plaintext, uint ptSz, byte[] ciphertext);
 618        [DllImport(wolfssl_dll)]
 619        private extern static int wc_HpkeOpenBase(IntPtr hpke, IntPtr receiverKey, byte[] pubKey, ushort pubKeySz, byte[] info, uint infoSz, byte[] aad, uint aadSz, byte[] ciphertext, uint ctSz, byte[] plaintext);
 620#else
 621        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 622        private extern static int wc_HpkeInit(IntPtr hpke, int kem, int kdf, int aead, IntPtr heap);
 623        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 624        private extern static int wc_HpkeGenerateKeyPair(IntPtr hpke, ref IntPtr keypair, IntPtr rng);
 625        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 626        private extern static int wc_HpkeSerializePublicKey(IntPtr hpke, IntPtr key, byte[] outBuf, ref ushort outSz);
 627        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 628        private extern static int wc_HpkeDeserializePublicKey(IntPtr hpke, ref IntPtr key, byte[] inBuf, ushort inSz);
 629        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 630        private extern static void wc_HpkeFreeKey(IntPtr hpke, ushort kem, IntPtr keypair, IntPtr heap);
 631        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 632        private extern static int wc_HpkeSealBase(IntPtr hpke, IntPtr ephemeralKey, IntPtr receiverKey, byte[] info, uint infoSz, byte[] aad, uint aadSz, byte[] plaintext, uint ptSz, byte[] ciphertext);
 633        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 634        private extern static int wc_HpkeOpenBase(IntPtr hpke, IntPtr receiverKey, byte[] pubKey, ushort pubKeySz, byte[] info, uint infoSz, byte[] aad, uint aadSz, byte[] ciphertext, uint ctSz, byte[] plaintext);
 635#endif
 636
 637
 638        /********************************
 639         * HASH
 640         */
 641#if WindowsCE
 642        [DllImport(wolfssl_dll)]
 643        private extern static IntPtr wc_HashNew(uint hashType, IntPtr heap, int devId, IntPtr result_code);
 644        [DllImport(wolfssl_dll)]
 645        private extern static int wc_HashDelete(IntPtr hash, IntPtr hash_p);
 646        [DllImport(wolfssl_dll)]
 647        private extern static int wc_HashInit(IntPtr hash, uint hashType);
 648        [DllImport(wolfssl_dll)]
 649        private extern static int wc_HashUpdate(IntPtr hash, uint hashType, IntPtr data, uint dataSz);
 650        [DllImport(wolfssl_dll)]
 651        private extern static int wc_HashFinal(IntPtr hash, uint hashType, IntPtr output);
 652        [DllImport(wolfssl_dll)]
 653        private extern static int wc_HashFree(IntPtr hash, uint hashType);
 654        [DllImport(wolfssl_dll)]
 655        private extern static int wc_HashGetDigestSize(uint hashType);
 656#else
 657        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 658        private extern static IntPtr wc_HashNew(uint hashType, IntPtr heap, int devId, IntPtr result_code);
 659        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 660        private extern static int wc_HashDelete(IntPtr hash, IntPtr hash_p);
 661        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 662        private extern static int wc_HashInit(IntPtr hash, uint hashType);
 663        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 664        private extern static int wc_HashUpdate(IntPtr hash, uint hashType, IntPtr data, uint dataSz);
 665        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 666        private extern static int wc_HashFinal(IntPtr hash, uint hashType, IntPtr output);
 667        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 668        private extern static int wc_HashFree(IntPtr hash, uint hashType);
 669        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 670        private extern static int wc_HashGetDigestSize(uint hashType);
 671#endif
 672
 673
 674        /********************************
 675        * Logging
 676        */
 677#if WindowsCE
 678        [DllImport(wolfssl_dll)]
 679        private extern static IntPtr wc_GetErrorString(int error);
 680        public delegate void loggingCb(int lvl, string msg);
 681#else
 682        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 683        private extern static IntPtr wc_GetErrorString(int error);
 684        public delegate void loggingCb(int lvl, StringBuilder msg);
 685#endif
 686        private static loggingCb internal_log;
 687
 688        /// <summary>
 689        /// Log a message to set logging function
 690        /// </summary>
 691        /// <param name="lvl">Level of log message</param>
 692        /// <param name="msg">Message to log</param>
 693#if WindowsCE
 694        private static void log(int lvl, string msg)
 695        {
 696            /* if log is not set then print nothing */
 697            if (internal_log == null)
 698                return;
 699            internal_log(lvl, msg);
 700        }
 701#else
 702        private static void log(int lvl, string msg)
 703        {
 704            /* if log is not set then print nothing */
 705            if (internal_log == null)
 706                return;
 707            StringBuilder ptr = new StringBuilder(msg);
 708            internal_log(lvl, ptr);
 709        }
 710#endif
 711
 712
 713        /********************************
 714         * Enum types from wolfSSL library
 715         */
 716        /* Logging levels */
 717        public static readonly int ERROR_LOG = 0;
 718        public static readonly int INFO_LOG = 1;
 719        public static readonly int ENTER_LOG = 2;
 720        public static readonly int LEAVE_LOG = 3;
 721        public static readonly int OTHER_LOG = 4;
 722        public static readonly int INVALID_DEVID = -2;
 723        public static readonly int ECC_MAX_SIG_SIZE = 141;    /* ECC max sig size */
 724        public static readonly int ECC_KEY_SIZE = 32;         /* ECC key size */
 725        public static readonly int MAX_ECIES_TEST_SZ = 200;   /* ECIES max sig size */
 726        public static readonly int ED25519_SIG_SIZE = 64;     /* ED25519 pub + priv  */
 727        public static readonly int ED25519_KEY_SIZE = 32;     /* Private key only */
 728        public static readonly int ED25519_PUB_KEY_SIZE = 32; /* Compressed public */
 729        public static readonly int AES_128_KEY_SIZE = 16;     /* for 128 bit */
 730        public static readonly int AES_192_KEY_SIZE = 24;     /* for 192 bit */
 731        public static readonly int AES_256_KEY_SIZE = 32;     /* for 256 bit */
 732        public static readonly int AES_BLOCK_SIZE = 16;
 733
 734        /* Error codes */
 735        public static readonly int SUCCESS            = 0;
 736        public static readonly int EXCEPTION_E        = -1;
 737        public static readonly int MEMORY_E           = -125;  /* Out of memory error */
 738        public static readonly int BUFFER_E           = -131;  /* RSA buffer error, output too small/large */
 739        public static readonly int ASN_PARSE_E        = -140;  /* ASN parsing error, invalid input */
 740        public static readonly int ASN_VERSION_E      = -141;  /* ASN version error, invalid number */
 741        public static readonly int ASN_GETINT_E       = -142;  /* ASN get big int error, invalid data */
 742        public static readonly int ASN_RSA_KEY_E      = -143;  /* ASN key init error, invalid input */
 743        public static readonly int ASN_OBJECT_ID_E    = -144;  /* ASN object id error, invalid id */
 744        public static readonly int ASN_TAG_NULL_E     = -145;  /* ASN tag error, not null */
 745        public static readonly int ASN_EXPECT_0_E     = -146;  /* ASN expect error, not zero */
 746        public static readonly int ASN_BITSTR_E       = -147;  /* ASN bit string error, wrong id */
 747        public static readonly int ASN_UNKNOWN_OID_E  = -148;  /* ASN oid error, unknown sum id */
 748        public static readonly int ASN_DATE_SZ_E      = -149;  /* ASN date error, bad size */
 749        public static readonly int ASN_BEFORE_DATE_E  = -150;  /* ASN date error, current date before */
 750        public static readonly int ASN_AFTER_DATE_E   = -151;  /* ASN date error, current date after */
 751        public static readonly int ASN_SIG_OID_E      = -152;  /* ASN signature error, mismatched oid */
 752        public static readonly int ASN_TIME_E         = -153;  /* ASN time error, unknown time type */
 753        public static readonly int ASN_INPUT_E        = -154;  /* ASN input error, not enough data */
 754        public static readonly int ASN_SIG_CONFIRM_E  = -155;  /* ASN sig error, confirm failure */
 755        public static readonly int ASN_SIG_HASH_E     = -156;  /* ASN sig error, unsupported hash type */
 756        public static readonly int ASN_SIG_KEY_E      = -157;  /* ASN sig error, unsupported key type */
 757        public static readonly int BAD_FUNC_ARG       = -173;  /* Bad function argument */
 758        public static readonly int SIG_VERIFY_E       = -229;  /* wolfcrypt signature verify error */
 759
 760
 761        /***********************************************************************
 762         * Class Public Functions
 763         **********************************************************************/
 764
 765        /// <summary>
 766        /// Initialize wolfCrypt library
 767        /// </summary>
 768        /// <returns>0 on success</returns>
 769        public static int Init()
 770        {
 771            int ret;
 772            try
 773            {
 774                ret = wolfCrypt_Init();
 775            }
 776            catch (Exception e)
 777            {
 778                log(ERROR_LOG, "wolfCrypt init error " + e.ToString());
 779                ret = EXCEPTION_E;
 780            }
 781            return ret;
 782        }
 783
 784        /// <summary>
 785        /// Clean up wolfCrypt library memory
 786        /// </summary>
 787        /// <returns>0 on success</returns>
 788        public static int Cleanup()
 789        {
 790            int ret;
 791            try
 792            {
 793                ret = wolfCrypt_Cleanup();
 794            }
 795            catch (Exception e)
 796            {
 797                log(ERROR_LOG, "wolfCrypt cleanup error " + e.ToString());
 798                ret = EXCEPTION_E;
 799            }
 800            return ret;
 801        }
 802
 803
 804        /***********************************************************************
 805         * Random
 806         **********************************************************************/
 807
 808        /// <summary>
 809        /// Create new WC_RNG context
 810        /// </summary>
 811        /// <returns>Pointer to allocated WC_RNG or null</returns>
 812        public static IntPtr RandomNew()
 813        {
 814            IntPtr rng;
 815
 816            try
 817            {
 818                /* Allocate and init new WC_RNG structure */
 819                rng = wc_rng_new(
 820                    IntPtr.Zero, 0, /* Nonce (optional / used by FIPS only) */
 821                    IntPtr.Zero);   /* Heap hint for static memory only */
 822            }
 823            catch (Exception e)
 824            {
 825                log(ERROR_LOG, "random new exception " + e.ToString());
 826                rng = IntPtr.Zero;
 827            }
 828
 829            return rng;
 830        }
 831
 832        /// <summary>
 833        /// Free WC_RNG context
 834        /// </summary>
 835        /// <param name="rng">Pointer to allocated WC_RNG</param>
 836        public static void RandomFree(IntPtr rng)
 837        {
 838            if (rng != IntPtr.Zero)
 839            {
 840                /* Free WC_RNG structure */
 841                wc_rng_free(rng);
 842            }
 843        }
 844
 845        /// <summary>
 846        /// Generate random data (use existing WC_RNG context)
 847        /// </summary>
 848        /// <param name="rng">WC_RNG created from RandomNew()</param>
 849        /// <param name="buf">buffer to populate random data</param>
 850        /// <param name="sz">size of buffer</param>
 851        /// <returns>0=success or negative for error</returns>
 852        public static int Random(IntPtr rng, byte[] buf, int sz)
 853        {
 854            int ret;
 855            IntPtr data;
 856
 857            try
 858            {
 859                /* Allocate global buffer for wolfAPI random */
 860                data = Marshal.AllocHGlobal(sz);
 861                if (data != IntPtr.Zero)
 862                {
 863                    /* Generate random block */
 864                    ret = wc_RNG_GenerateBlock(rng, data, Convert.ToUInt32(sz));
 865                    if (ret == 0)
 866                    {
 867                        /* copy returned data */
 868                        Marshal.Copy(data, buf, 0, sz);
 869                    }
 870                    else
 871                    {
 872                        log(ERROR_LOG, "random generate block error " + ret + ": " + GetError(ret));
 873                    }
 874                    Marshal.FreeHGlobal(data);
 875                }
 876                else
 877                {
 878                    ret = MEMORY_E;
 879                }
 880            }
 881            catch (Exception e)
 882            {
 883                log(ERROR_LOG, "random generate block exception " + e.ToString());
 884                ret = EXCEPTION_E;
 885            }
 886
 887            return ret;
 888        }
 889
 890        /// <summary>
 891        /// Generate random data (single shot)
 892        /// </summary>
 893        /// <param name="buf">buffer to populate random data</param>
 894        /// <param name="sz">size of buffer</param>
 895        /// <returns>0=success or negative for error</returns>
 896        public static int Random(byte[] buf, int sz)
 897        {
 898            int ret;
 899            IntPtr rng = RandomNew();
 900            if (rng == IntPtr.Zero)
 901            {
 902                return MEMORY_E;
 903            }
 904            ret = Random(rng, buf, sz);
 905            RandomFree(rng);
 906            return ret;
 907        }
 908        /* END Random */
 909
 910
 911        /***********************************************************************
 912         * ECC
 913         **********************************************************************/
 914
 915        /// <summary>
 916        /// Generate a new ECC private / public key pair
 917        /// </summary>
 918        /// <param name="keysize">Key size in bytes (example: SECP256R1 = 32)</param>
 919        /// <returns>Allocated ECC key structure or null</returns>
 920        public static IntPtr EccMakeKey(int keysize, IntPtr rng)
 921        {
 922            int ret;
 923            IntPtr key = IntPtr.Zero;
 924
 925            try
 926            {
 927                /* Allocate and init new WC_RNG structure */
 928                key = wc_ecc_key_new(IntPtr.Zero);
 929                if (key != IntPtr.Zero)
 930                {
 931                    ret = wc_ecc_make_key_ex(rng, keysize, key, 0); /* 0=use default curve */
 932                    if (ret != 0)
 933                    {
 934                        EccFreeKey(key);
 935                        key = IntPtr.Zero;
 936                    }
 937                }
 938            }
 939            catch (Exception e)
 940            {
 941                log(ERROR_LOG, "ECC make key exception " + e.ToString());
 942
 943                EccFreeKey(key);
 944                key = IntPtr.Zero;
 945            }
 946
 947            return key;
 948        }
 949
 950        /// <summary>
 951        /// Sets the ECC rng structure
 952        /// </summary>
 953        /// <param name="key">Supplied key as a pointer</param>
 954        /// <param name="rng">rng context as a pointer</param>
 955        /// <returns>Returns 0 on success</returns>
 956        public static int EccSetRng(IntPtr key, IntPtr rng)
 957        {
 958            int ret = 0;
 959
 960            try
 961            {
 962                /* Check */
 963                if (key == IntPtr.Zero)
 964                {
 965                    log(ERROR_LOG, "Invalid key or rng pointer.");
 966                    return MEMORY_E;
 967                }
 968
 969                /* Set ECC rng */
 970                ret = wc_ecc_set_rng(key, rng);
 971                if (ret != 0)
 972                {
 973                    log(ERROR_LOG, "ECC set rng failed returned:" + ret);
 974                }
 975            }
 976            catch (Exception e)
 977            {
 978                log(ERROR_LOG, "ECC set rng exception " + e.ToString());
 979            }
 980
 981            return ret;
 982        }
 983
 984        /// <summary>
 985        /// Generate a new ECC private / public key pair
 986        /// </summary>
 987        /// <param name="keyASN1">ASN.1 private key buffer (see ecc_clikey_der_256)</param>
 988        /// <returns>Allocated ECC key structure or null</returns>
 989        public static IntPtr EccImportKey(byte[] keyASN1)
 990        {
 991            int ret;
 992            IntPtr key = IntPtr.Zero;
 993
 994            try
 995            {
 996                key = wc_ecc_key_new(IntPtr.Zero);
 997                if (key != IntPtr.Zero)
 998                {
 999                    IntPtr idx = Marshal.AllocHGlobal(sizeof(uint));
1000                    IntPtr keydata = Marshal.AllocHGlobal(keyASN1.Length);
1001                    Marshal.WriteInt32(idx, 0);
1002                    Marshal.Copy(keyASN1, 0, keydata, keyASN1.Length);
1003                    ret = wc_EccPrivateKeyDecode(keydata, idx, key, Convert.ToUInt32(keyASN1.Length));
1004                    if (ret != 0)
1005                    {
1006                        EccFreeKey(key);
1007                        key = IntPtr.Zero;
1008                    }
1009                    Marshal.FreeHGlobal(idx); /* not used */
1010                    Marshal.FreeHGlobal(keydata);
1011                }
1012            }
1013            catch (Exception e)
1014            {
1015                log(ERROR_LOG, "ECC import key exception " + e.ToString());
1016                EccFreeKey(key); /* make sure its free'd */
1017                key = IntPtr.Zero;
1018            }
1019
1020            return key;
1021        }
1022
1023        /// <summary>
1024        /// Sign a hash using ECC
1025        /// </summary>
1026        /// <param name="key">ECC key structure</param>
1027        /// <param name="hash">Hash to sign</param>
1028        /// <param name="signature">Buffer to receive the signature</param>
1029        /// <returns>Length of the signature on success, otherwise a negative error code</returns>
1030        public static int EccSign(IntPtr key, byte[] hash, byte[] signature)
1031        {
1032            int ret;
1033            int signedLength = 0;
1034            IntPtr hashPtr = IntPtr.Zero;
1035            IntPtr sigPtr = IntPtr.Zero;
1036            IntPtr sigLen = IntPtr.Zero;
1037            IntPtr rng = IntPtr.Zero;
1038
1039            try
1040            {
1041                rng = RandomNew();
1042                hashPtr = Marshal.AllocHGlobal(hash.Length);
1043                sigPtr = Marshal.AllocHGlobal(signature.Length);
1044                sigLen = Marshal.AllocHGlobal(sizeof(uint));
1045
1046                Marshal.WriteInt32(sigLen, signature.Length);
1047                Marshal.Copy(hash, 0, hashPtr, hash.Length);
1048                ret = wc_ecc_sign_hash(hashPtr, Convert.ToUInt32(hash.Length), sigPtr, sigLen, rng, key);
1049
1050                /* Output actual signature length */
1051                if (ret == 0)
1052                {
1053                    signedLength = Marshal.ReadInt32(sigLen);
1054                    if (signedLength <= signature.Length)
1055                    {
1056                        Marshal.Copy(sigPtr, signature, 0, signedLength);
1057                    }
1058                    else
1059                    {
1060                        ret = BUFFER_E;
1061                    }
1062                }
1063            }
1064            catch (Exception e)
1065            {
1066                log(ERROR_LOG, "ECC sign exception: " + e.ToString());
1067                ret = EXCEPTION_E;
1068            }
1069            finally
1070            {
1071                if (hashPtr != IntPtr.Zero) Marshal.FreeHGlobal(hashPtr);
1072                if (sigPtr != IntPtr.Zero) Marshal.FreeHGlobal(sigPtr);
1073                if (sigLen != IntPtr.Zero) Marshal.FreeHGlobal(sigLen);
1074                if (rng != IntPtr.Zero) RandomFree(rng);
1075            }
1076
1077            return ret == 0 ? signedLength : ret;
1078        }
1079
1080        /// <summary>
1081        /// Verify a signature using ECC
1082        /// </summary>
1083        /// <param name="key">ECC key structure</param>
1084        /// <param name="signature">Signature to verify</param>
1085        /// <param name="hash">Expected hash value</param>
1086        /// <returns>0 on success, otherwise an error code</returns>
1087        public static int EccVerify(IntPtr key, byte[] signature, byte[] hash)
1088        {
1089            int ret;
1090            IntPtr hashPtr = IntPtr.Zero;
1091            IntPtr sigPtr = IntPtr.Zero;
1092            IntPtr res = IntPtr.Zero;
1093
1094            try
1095            {
1096                hashPtr = Marshal.AllocHGlobal(hash.Length);
1097                sigPtr = Marshal.AllocHGlobal(signature.Length);
1098                res = Marshal.AllocHGlobal(sizeof(int));
1099
1100                Marshal.Copy(hash, 0, hashPtr, hash.Length);
1101                Marshal.Copy(signature, 0, sigPtr, signature.Length);
1102
1103                ret = wc_ecc_verify_hash(sigPtr, Convert.ToUInt32(signature.Length), hashPtr, Convert.ToUInt32(hash.Length), res, key);
1104
1105                if (ret == 0)
1106                {
1107                    int verifyResult = Marshal.ReadInt32(res);
1108                    ret = verifyResult == 1 ? 0 : EXCEPTION_E;
1109                }
1110            }
1111            catch (Exception e)
1112            {
1113                log(ERROR_LOG, "ECC verify exception " + e.ToString());
1114                ret = EXCEPTION_E;
1115            }
1116            finally
1117            {
1118                if (hashPtr != IntPtr.Zero) Marshal.FreeHGlobal(hashPtr);
1119                if (sigPtr != IntPtr.Zero) Marshal.FreeHGlobal(sigPtr);
1120                if (res != IntPtr.Zero) Marshal.FreeHGlobal(res);
1121            }
1122
1123            return ret;
1124        }
1125
1126        /// <summary>
1127        /// Export ECC Private Key to DER format
1128        /// </summary>
1129        /// <param name="key">ECC key structure</param>
1130        /// <returns>DER-encoded private key as byte array</returns>
1131        public static int EccExportPrivateKeyToDer(IntPtr key, out byte[] derKey)
1132        {
1133            int ret;
1134            derKey = null;
1135
1136            try
1137            {
1138                int bufferSize = wc_EccPrivateKeyToDer(key, null, 0);
1139                if (bufferSize < 0) {
1140                    log(ERROR_LOG, "ECC private key get size failed " + bufferSize.ToString());
1141                    return bufferSize;
1142                }
1143                derKey = new byte[bufferSize];
1144                ret = wc_EccPrivateKeyToDer(key, derKey, (uint)bufferSize);
1145                if (ret < 0)
1146                {
1147                    log(ERROR_LOG, "ECC private key to der failed " + ret.ToString());
1148                }
1149            }
1150            catch (Exception e)
1151            {
1152                log(ERROR_LOG, "ECC export private exception " + e.ToString());
1153                ret = EXCEPTION_E;
1154            }
1155
1156            return ret;
1157        }
1158
1159        /// <summary>
1160        /// Export ECC Public Key to DER format
1161        /// </summary>
1162        /// <param name="key">ECC key structure</param>
1163        /// <param name="includeCurve">Include algorithm curve in the output</param>
1164        /// <returns>DER-encoded public key as byte array</returns>
1165        public static int EccExportPublicKeyToDer(IntPtr key, out byte[] derKey, bool includeCurve)
1166        {
1167            int ret;
1168            derKey = null;
1169
1170            try
1171            {
1172                int bufferSize = wc_EccPublicKeyToDer(key, null, 0, includeCurve ? 1 : 0);
1173                if (bufferSize < 0) {
1174                    log(ERROR_LOG, "ECC public key get size failed " + bufferSize.ToString());
1175                    return bufferSize;
1176                }
1177                derKey = new byte[bufferSize];
1178                ret = wc_EccPublicKeyToDer(key, derKey, (uint)bufferSize, includeCurve ? 1 : 0);
1179                if (ret < 0)
1180                {
1181                    log(ERROR_LOG, "ECC public key to der failed " + ret.ToString());
1182                }
1183            }
1184            catch (Exception e)
1185            {
1186                log(ERROR_LOG, "ECC export public exception " + e.ToString());
1187                ret = EXCEPTION_E;
1188            }
1189
1190            return ret;
1191        }
1192
1193        /// <summary>
1194        /// Import ECC Public Key from DER format
1195        /// </summary>
1196        /// <param name="keyDer">DER-encoded public key</param>
1197        /// <returns>Allocated ECC key structure or null</returns>
1198        public static IntPtr EccImportPublicKeyFromDer(byte[] keyDer)
1199        {
1200            int ret;
1201            IntPtr key = IntPtr.Zero;
1202
1203            try
1204            {
1205                key = wc_ecc_key_new(IntPtr.Zero);
1206                if (key != IntPtr.Zero)
1207                {
1208                    uint idx = 0;
1209                    ret = wc_EccPublicKeyDecode(keyDer, ref idx, key, (uint)keyDer.Length);
1210                    if (ret != 0)
1211                    {
1212                        EccFreeKey(key);
1213                        key = IntPtr.Zero;
1214                    }
1215                }
1216            }
1217            catch (Exception e)
1218            {
1219                log(ERROR_LOG, "ECC import public key exception " + e.ToString());
1220                EccFreeKey(key);
1221                key = IntPtr.Zero;
1222            }
1223
1224            return key;
1225        }
1226
1227        /// <summary>
1228        /// Free an ECC key structure
1229        /// </summary>
1230        /// <param name="key">ECC key structure allocated using EccMakeKey() or EccImportKey()</param>
1231        public static void EccFreeKey(IntPtr key)
1232        {
1233            if (key != IntPtr.Zero)
1234            {
1235                wc_ecc_key_free(key);
1236            }
1237        }
1238        /* END ECC */
1239
1240
1241        /***********************************************************************
1242         * ECIES
1243         **********************************************************************/
1244
1245        /// <summary>
1246        /// Create a new ECIES context with flags, RNG, and custom heap.
1247        /// </summary>
1248        /// <param name="flags">Flags for the context initialization.</param>
1249        /// <param name="rng">Random Number Generator (RNG) pointer.</param>
1250        /// <param name="heap">Custom heap pointer for memory allocations.</param>
1251        /// <returns>Pointer to the newly created ECIES context or IntPtr.Zero on failure.</returns>
1252        public static IntPtr EciesNewCtx(int flags, IntPtr rng, IntPtr heap)
1253        {
1254            IntPtr ctx = IntPtr.Zero;
1255            heap = IntPtr.Zero;
1256
1257            try
1258            {
1259                ctx = wc_ecc_ctx_new_ex(flags, rng, heap);
1260                if (ctx == IntPtr.Zero)
1261                {
1262                    log(ERROR_LOG, "ECIES context creation with custom heap failed: returned IntPtr.Zero");
1263                }
1264            }
1265            catch (Exception e)
1266            {
1267                log(ERROR_LOG, "ECIES context creation with custom heap failed: " + e.ToString());
1268                return IntPtr.Zero;
1269            }
1270
1271            return ctx;
1272        }
1273
1274        /// <summary>
1275        /// Reset the ECIES context with a new RNG.
1276        /// </summary>
1277        /// <param name="ctx">Pointer to the ECIES context to reset.</param>
1278        /// <param name="rng">New RNG to set.</param>
1279        /// <returns>0 on success, or a negative error code on failure.</returns>
1280        public static int EciesCtxReset(IntPtr ctx, IntPtr rng)
1281        {
1282            int ret;
1283
1284            try
1285            {
1286                ret = wc_ecc_ctx_reset(ctx, rng);
1287            }
1288            catch (Exception e)
1289            {
1290                log(ERROR_LOG, "ECIES context reset exception: " + e.ToString());
1291                ret = EXCEPTION_E;
1292            }
1293
1294            return ret;
1295        }
1296
1297        /// <summary>
1298        /// Set encryption, KDF, and MAC algorithms for the ECIES context.
1299        /// </summary>
1300        /// <param name="ctx">Pointer to the ECIES context.</param>
1301        /// <param name="encAlgo">Encryption algorithm identifier.</param>
1302        /// <param name="kdfAlgo">Key Derivation Function (KDF) algorithm identifier.</param>
1303        /// <param name="macAlgo">MAC algorithm identifier.</param>
1304        /// <returns>0 on success, or a negative error code on failure.</returns>
1305        public static int EciesSetAlgo(IntPtr ctx, byte encAlgo, byte kdfAlgo, byte macAlgo)
1306        {
1307            int ret;
1308
1309            try
1310            {
1311                ret = wc_ecc_ctx_set_algo(ctx, encAlgo, kdfAlgo, macAlgo);
1312            }
1313            catch (Exception e)
1314            {
1315                log(ERROR_LOG, "ECIES set algorithm exception: " + e.ToString());
1316                ret = EXCEPTION_E;
1317            }
1318
1319            return ret;
1320        }
1321
1322        /// <summary>
1323        /// Get the ECIES own salt as a byte array.
1324        /// </summary>
1325        /// <param name="ctx">Pointer to the ECIES context.</param>
1326        /// <returns>Byte array representing the own salt, or null if there is an error.</returns>
1327        public static byte[] EciesGetOwnSalt(IntPtr ctx)
1328        {
1329            IntPtr saltPtr = IntPtr.Zero;
1330            byte[] salt = null;
1331
1332            try
1333            {
1334                /* Check ctx */
1335                if (ctx == IntPtr.Zero)
1336                {
1337                    log(ERROR_LOG, "Invalid ECIES context pointer.");
1338                    return null;
1339                }
1340
1341                /* Get own salt */
1342                saltPtr = wc_ecc_ctx_get_own_salt(ctx);
1343                if (saltPtr == IntPtr.Zero)
1344                {
1345                    log(ERROR_LOG, "Failed to get own salt.");
1346                    return null;
1347                }
1348
1349                /* Allocate salt size and copy to byte array */
1350                salt = new byte[(int)ecKeySize.EXCHANGE_SALT_SZ];
1351                Marshal.Copy(saltPtr, salt, 0, (int)ecKeySize.EXCHANGE_SALT_SZ);
1352            }
1353            catch (Exception e)
1354            {
1355                log(ERROR_LOG, "ECIES get own salt exception: " + e.ToString());
1356                return null;
1357            }
1358            finally
1359            {
1360                /* Cleanup */
1361                if (saltPtr != IntPtr.Zero) Marshal.FreeHGlobal(saltPtr);
1362            }
1363
1364            return salt;
1365        }
1366
1367        /// <summary>
1368        /// Set the peer salt for the ECIES context.
1369        /// </summary>
1370        /// <param name="ctx">Pointer to the ECIES context.</param>
1371        /// <param name="salt">Peer salt as a byte array.</param>
1372        /// <returns>0 on success, or a negative error code on failure.</returns>
1373        public static int EciesSetPeerSalt(IntPtr ctx, byte[] salt)
1374        {
1375            IntPtr saltPtr = IntPtr.Zero;
1376            int ret;
1377
1378            try
1379            {
1380                /* Allocate memory */
1381                saltPtr = Marshal.AllocHGlobal(salt.Length);
1382                Marshal.Copy(salt, 0, saltPtr, salt.Length);
1383
1384                /* Set the peer salt */
1385                ret = wc_ecc_ctx_set_peer_salt(ctx, saltPtr);
1386            }
1387            catch (Exception e)
1388            {
1389                log(ERROR_LOG, "ECIES set peer salt exception: " + e.ToString());
1390                ret = EXCEPTION_E;
1391            }
1392            finally
1393            {
1394                /* Cleanup */
1395                if (saltPtr != IntPtr.Zero) Marshal.FreeHGlobal(saltPtr);
1396            }
1397
1398            return ret;
1399        }
1400
1401        /// <summary>
1402        /// Set the own salt for the ECIES context.
1403        /// </summary>
1404        /// <param name="ctx">Pointer to the ECIES context.</param>
1405        /// <param name="salt">Own salt as a byte array.</param>
1406        /// <returns>0 on success, or a negative error code on failure.</returns>
1407        public static int EciesSetOwnSalt(IntPtr ctx, byte[] salt)
1408        {
1409            IntPtr saltPtr = IntPtr.Zero;
1410            uint saltSz;
1411            int ret;
1412
1413            try
1414            {
1415                /* Allocate memory */
1416                saltSz = (uint)salt.Length;
1417                saltPtr = Marshal.AllocHGlobal(salt.Length);
1418                Marshal.Copy(salt, 0, saltPtr, salt.Length);
1419
1420                /* Set the own salt */
1421                ret = wc_ecc_ctx_set_own_salt(ctx, saltPtr, saltSz);
1422            }
1423            catch (Exception e)
1424            {
1425                log(ERROR_LOG, "ECIES set own salt exception: " + e.ToString());
1426                ret = EXCEPTION_E;
1427            }
1428            finally
1429            {
1430                /* Cleanup */
1431                if (saltPtr != IntPtr.Zero) Marshal.FreeHGlobal(saltPtr);
1432            }
1433
1434            return ret;
1435        }
1436
1437        /// <summary>
1438        /// Set the KDF salt for the ECIES context.
1439        /// </summary>
1440        /// <param name="ctx">Pointer to the ECIES context.</param>
1441        /// <param name="salt">KDF salt as a byte array.</param>
1442        /// <returns>0 on success, or a negative error code on failure.</returns>
1443        public static int EciesSetKdfSalt(IntPtr ctx, byte[] salt)
1444        {
1445            IntPtr saltPtr = IntPtr.Zero;
1446            uint saltSz;
1447            int ret;
1448
1449            try
1450            {
1451                /* Allocate memory */
1452                saltSz = (uint)salt.Length;
1453                saltPtr = Marshal.AllocHGlobal(salt.Length);
1454                Marshal.Copy(salt, 0, saltPtr, salt.Length);
1455
1456                /* Set the KDF salt */
1457                ret = wc_ecc_ctx_set_kdf_salt(ctx, saltPtr, saltSz);
1458            }
1459            catch (Exception e)
1460            {
1461                log(ERROR_LOG, "ECIES set KDF salt exception: " + e.ToString());
1462                ret = EXCEPTION_E;
1463            }
1464            finally
1465            {
1466                /* Cleanup */
1467                if (saltPtr != IntPtr.Zero) Marshal.FreeHGlobal(saltPtr);
1468            }
1469
1470            return ret;
1471        }
1472
1473        /// <summary>
1474        /// Set the info for the ECIES context.
1475        /// </summary>
1476        /// <param name="ctx">Pointer to the ECIES context.</param>
1477        /// <param name="info">Info as a byte array.</param>
1478        /// <returns>0 on success, or a negative error code on failure.</returns>
1479        public static int EciesSetInfo(IntPtr ctx, byte[] info)
1480        {
1481            IntPtr infoPtr = IntPtr.Zero;
1482            int ret;
1483
1484            try
1485            {
1486                /* Allocate memory */
1487                infoPtr = Marshal.AllocHGlobal(info.Length);
1488                Marshal.Copy(info, 0, infoPtr, info.Length);
1489
1490                /* Set the info */
1491                ret = wc_ecc_ctx_set_info(ctx, infoPtr, info.Length);
1492            }
1493            catch (Exception e)
1494            {
1495                log(ERROR_LOG, "ECIES set info exception: " + e.ToString());
1496                ret = EXCEPTION_E;
1497            }
1498            finally
1499            {
1500                /* Cleanup */
1501                if (infoPtr != IntPtr.Zero) Marshal.FreeHGlobal(infoPtr);
1502            }
1503
1504            return ret;
1505        }
1506
1507        /// <summary>
1508        /// Encrypt a message using ECIES.
1509        /// </summary>
1510        /// <param name="privKey">Private key.</param>
1511        /// <param name="pubKey">Public key.</param>
1512        /// <param name="msg">Message to encrypt.</param>
1513        /// <param name="msgSz">Message size.</param>
1514        /// <param name="outBuffer">Output buffer.</param>
1515        /// <param name="ctx">ECIES context.</param>
1516        /// <returns>0 on success, or a negative error code on failure.</returns>
1517        public static int EciesEncrypt(IntPtr privKey, IntPtr pubKey, byte[] msg, uint msgSz, byte[] outBuffer, IntPtr ctx)
1518        {
1519            int ret;
1520            int outBufferLength = 0;
1521            IntPtr msgPtr = IntPtr.Zero;
1522            IntPtr outBufferPtr = IntPtr.Zero;
1523            IntPtr outSz = IntPtr.Zero;
1524
1525            try
1526            {
1527                /* Allocate memory */
1528                msgPtr = Marshal.AllocHGlobal(msg.Length);
1529                outBufferPtr = Marshal.AllocHGlobal(outBuffer.Length);
1530                outSz = Marshal.AllocHGlobal(sizeof(uint));
1531
1532                Marshal.WriteInt32(outSz, outBuffer.Length);
1533                Marshal.Copy(msg, 0, msgPtr, msg.Length);
1534
1535                /* Encrypt */
1536                ret = wc_ecc_encrypt(privKey, pubKey, msgPtr, msgSz, outBufferPtr, outSz, ctx);
1537                if (ret < 0)
1538                {
1539                    log(ERROR_LOG, "Failed to encrypt message using ECIES. Error code: " + ret);
1540                }
1541                /* Output actual output buffer length */
1542                if (ret == 0)
1543                {
1544                    outBufferLength = Marshal.ReadInt32(outSz);
1545                    if (outBufferLength <= outBuffer.Length)
1546                    {
1547                        Marshal.Copy(outBufferPtr, outBuffer, 0, outBufferLength);
1548                    }
1549                    else
1550                    {
1551                        ret = BUFFER_E;
1552                    }
1553                }
1554            }
1555            catch (Exception e)
1556            {
1557                log(ERROR_LOG, "ECIES encryption exception: " + e.ToString());
1558                ret = EXCEPTION_E;
1559            }
1560            finally
1561            {
1562                /* Cleanup */
1563                if (msgPtr != IntPtr.Zero) Marshal.FreeHGlobal(msgPtr);
1564                if (outBufferPtr != IntPtr.Zero) Marshal.FreeHGlobal(outBufferPtr);
1565                if (outSz != IntPtr.Zero) Marshal.FreeHGlobal(outSz);
1566            }
1567
1568            return ret == 0 ? outBufferLength : ret;
1569        }
1570
1571        /// <summary>
1572        /// Decrypt a message using ECIES.
1573        /// </summary>
1574        /// <param name="privKey">Private key.</param>
1575        /// <param name="pubKey">Public key.</param>
1576        /// <param name="msg">Encrypted message.</param>
1577        /// <param name="msgSz">Message size.</param>
1578        /// <param name="outBuffer">Output buffer for the decrypted message.</param>
1579        /// <param name="ctx">ECIES context.</param>
1580        /// <returns>0 on success, or a negative error code on failure.</returns>
1581        public static int EciesDecrypt(IntPtr privKey, IntPtr pubKey, byte[] msg, uint msgSz, byte[] outBuffer, IntPtr ctx)
1582        {
1583            int ret;
1584            int outBufferLength = 0;
1585            IntPtr msgPtr = IntPtr.Zero;
1586            IntPtr outBufferPtr = IntPtr.Zero;
1587            IntPtr outSz = IntPtr.Zero;
1588
1589            try
1590            {
1591                /* Allocate memory */
1592                msgPtr = Marshal.AllocHGlobal(msg.Length);
1593                outBufferPtr = Marshal.AllocHGlobal(outBuffer.Length);
1594                outSz = Marshal.AllocHGlobal(sizeof(uint));
1595
1596                Marshal.WriteInt32(outSz, outBuffer.Length);
1597                Marshal.Copy(msg, 0, msgPtr, msg.Length);
1598
1599                /* Decrypt */
1600                ret = wc_ecc_decrypt(privKey, pubKey, msgPtr, msgSz, outBufferPtr, outSz, ctx);
1601                if (ret < 0)
1602                {
1603                    log(ERROR_LOG, "Failed to decrypt message using ECIES. Error code: " + ret);
1604                }
1605                /* Output actual output buffer length */
1606                if (ret == 0)
1607                {
1608                    outBufferLength = Marshal.ReadInt32(outSz);
1609                    if (outBufferLength <= outBuffer.Length)
1610                    {
1611                        Marshal.Copy(outBufferPtr, outBuffer, 0, outBufferLength);
1612                    }
1613                    else
1614                    {
1615                        ret = BUFFER_E;
1616                    }
1617                }
1618            }
1619            catch (Exception e)
1620            {
1621                log(ERROR_LOG, "ECIES decryption exception: " + e.ToString());
1622                return EXCEPTION_E;
1623            }
1624            finally
1625            {
1626                /* Cleanup */
1627                if (msgPtr != IntPtr.Zero) Marshal.FreeHGlobal(msgPtr);
1628                if (outBufferPtr != IntPtr.Zero) Marshal.FreeHGlobal(outBufferPtr);
1629                if (outSz != IntPtr.Zero) Marshal.FreeHGlobal(outSz);
1630            }
1631
1632            return ret == 0 ? outBufferLength : ret;
1633        }
1634
1635        /// <summary>
1636        /// Free the ECIES context.
1637        /// </summary>
1638        /// <param name="ctx">Pointer to the ECIES context to free.</param>
1639        public static void EciesFreeCtx(IntPtr ctx)
1640        {
1641            if (ctx != IntPtr.Zero)
1642            {
1643                wc_ecc_ctx_free(ctx);
1644            }
1645        }
1646
1647        /********************************
1648         * ENUMS
1649         */
1650        public enum ecEncAlgo {
1651            ecAES_128_CBC = 1,  /* default */
1652            ecAES_256_CBC = 2,
1653            ecAES_128_CTR = 3,
1654            ecAES_256_CTR = 4
1655        }
1656
1657        public enum ecKdfAlgo {
1658            ecHKDF_SHA256      = 1,  /* default */
1659            ecHKDF_SHA1        = 2,
1660            ecKDF_X963_SHA1    = 3,
1661            ecKDF_X963_SHA256  = 4,
1662            ecKDF_SHA1         = 5,
1663            ecKDF_SHA256       = 6
1664        }
1665
1666        public enum ecMacAlgo {
1667            ecHMAC_SHA256 = 1,  /* default */
1668            ecHMAC_SHA1   = 2
1669        }
1670
1671        public enum ecKeySize {
1672            KEY_SIZE_128     = 16,
1673            KEY_SIZE_256     = 32,
1674            IV_SIZE_64       =  8,
1675            IV_SIZE_128      = 16,
1676            ECC_MAX_IV_SIZE  = 16,
1677            EXCHANGE_SALT_SZ = 16,
1678            EXCHANGE_INFO_SZ = 23
1679        }
1680
1681        public enum ecFlags {
1682            REQ_RESP_CLIENT = 1,
1683            REQ_RESP_SERVER = 2
1684        }
1685        /* END ECIES */
1686
1687
1688        /***********************************************************************
1689         * ECDHE
1690         **********************************************************************/
1691
1692        /// <summary>
1693        /// Generate a shared secret using ECC
1694        /// </summary>
1695        /// <param name="privateKey">ECC private key</param>
1696        /// <param name="publicKey">ECC public key</param>
1697        /// <param name="secret">Buffer to receive the shared secret</param>
1698        /// <returns>0 on success, otherwise an error code</returns>
1699        public static int EcdheSharedSecret(IntPtr privateKey, IntPtr publicKey, byte[] secret, IntPtr rng)
1700        {
1701            int ret;
1702            int secretLength = secret.Length;
1703
1704            try
1705            {
1706                /* set RNG for Public Key */
1707                ret = EccSetRng(privateKey, rng);
1708                if (ret != 0)
1709                {
1710                    throw new Exception("Failed to set Public Key RNG Error code: " + ret);
1711                }
1712
1713                /* set RNG for Private Key */
1714                ret = EccSetRng(publicKey, rng);
1715                if (ret != 0)
1716                {
1717                    throw new Exception("Failed to set Private Key RNG. Error code: " + ret);
1718                }
1719
1720                /* Generate shared secret */
1721                if (privateKey != IntPtr.Zero || publicKey != IntPtr.Zero)
1722                {
1723                    ret = wc_ecc_shared_secret(privateKey, publicKey, secret, ref secretLength);
1724                    if (ret != 0)
1725                    {
1726                        throw new Exception("Failed to compute ECC shared secret. Error code: " + ret);
1727                    }
1728                }
1729            }
1730            catch (Exception e)
1731            {
1732                log(ERROR_LOG, "ECC shared secret exception " + e.ToString());
1733                ret = EXCEPTION_E;
1734            }
1735
1736            return ret;
1737        }
1738        /* END ECDHE */
1739
1740
1741        /***********************************************************************
1742         * RSA
1743         **********************************************************************/
1744
1745        /// <summary>
1746        /// Generate a new RSA private/public key pair
1747        /// </summary>
1748        /// <param name="heap">Pointer to the heap for memory allocation
1749        /// (use IntPtr.Zero if not applicable)</param>
1750        /// <param name="devId">Device ID (if applicable, otherwise use 0)</param>
1751        /// <param name="keysize">Key size in bits (example: 2048)</param>
1752        /// <param name="exponent">Exponent for RSA key generation (default is 65537)</param>
1753        /// <returns>Allocated RSA key structure or null on failure</returns>
1754        public static IntPtr RsaMakeKey(IntPtr heap, int devId, int keysize, Int32 exponent)
1755        {
1756            int ret;
1757            IntPtr key = IntPtr.Zero;
1758            IntPtr rng = IntPtr.Zero;
1759
1760            try
1761            {
1762                /* Allocate and init new RSA key structure */
1763                key = wc_NewRsaKey(heap, devId, IntPtr.Zero);
1764                if (key != IntPtr.Zero)
1765                {
1766                    rng = RandomNew();
1767                    if (rng == IntPtr.Zero)
1768                    {
1769                        throw new Exception("Failed to create rng.");
1770                    }
1771
1772                    ret = wc_MakeRsaKey(key, keysize, exponent, rng);
1773                    if (ret != 0)
1774                    {
1775                        RsaFreeKey(key);
1776                        key = IntPtr.Zero;
1777                    }
1778
1779                    RandomFree(rng);
1780                    rng = IntPtr.Zero;
1781                }
1782            }
1783            catch (Exception e)
1784            {
1785                log(ERROR_LOG, "RSA make key exception " + e.ToString());
1786                if (rng != IntPtr.Zero) RandomFree(rng);
1787                if (key != IntPtr.Zero) RsaFreeKey(key);
1788                key = IntPtr.Zero;
1789            }
1790
1791            return key;
1792        }
1793
1794        public static IntPtr RsaMakeKey(IntPtr heap, int devId, int keysize)
1795        {
1796            return RsaMakeKey(heap, devId, keysize, 65537);
1797        }
1798
1799        /// <summary>
1800        /// Import an RSA private key from ASN.1 buffer
1801        /// </summary>
1802        /// <param name="keyASN1">ASN.1 private key buffer</param>
1803        /// <returns>Allocated RSA key structure or null</returns>
1804        public static IntPtr RsaImportKey(byte[] keyASN1)
1805        {
1806            int ret;
1807            IntPtr key = IntPtr.Zero;
1808
1809            try
1810            {
1811                key = wc_NewRsaKey(IntPtr.Zero, INVALID_DEVID, IntPtr.Zero);
1812                if (key != IntPtr.Zero)
1813                {
1814                    IntPtr idx = Marshal.AllocHGlobal(sizeof(uint));
1815                    IntPtr keydata = Marshal.AllocHGlobal(keyASN1.Length);
1816                    Marshal.WriteInt32(idx, 0);
1817                    Marshal.Copy(keyASN1, 0, keydata, keyASN1.Length);
1818                    ret = wc_RsaPrivateKeyDecode(keydata, idx, key, Convert.ToUInt32(keyASN1.Length));
1819                    if (ret != 0)
1820                    {
1821                        RsaFreeKey(key);
1822                        key = IntPtr.Zero;
1823                    }
1824                    Marshal.FreeHGlobal(idx); /* not used */
1825                    Marshal.FreeHGlobal(keydata);
1826                }
1827            }
1828            catch (Exception e)
1829            {
1830                log(ERROR_LOG, "RSA make key exception " + e.ToString());
1831                RsaFreeKey(key); /* make sure its free'd */
1832                key = IntPtr.Zero;
1833            }
1834
1835            return key;
1836        }
1837
1838        /// <summary>
1839        /// Sign a hash using RSA and SSL-style padding
1840        /// </summary>
1841        /// <param name="key">RSA key structure</param>
1842        /// <param name="hash">Hash to sign</param>
1843        /// <param name="signature">Buffer to receive the signature</param>
1844        /// <returns>Length of the signature on success, otherwise an error code</returns>
1845        public static int RsaSignSSL(IntPtr key, byte[] hash, byte[] signature)
1846        {
1847            IntPtr hashPtr = Marshal.AllocHGlobal(hash.Length);
1848            IntPtr sigPtr = Marshal.AllocHGlobal(signature.Length);
1849            IntPtr rng = IntPtr.Zero;
1850            int ret;
1851
1852            try
1853            {
1854                rng = RandomNew();
1855                if (rng == IntPtr.Zero)
1856                {
1857                    throw new Exception("Failed to create RNG.");
1858                }
1859
1860                Marshal.Copy(hash, 0, hashPtr, hash.Length);
1861
1862                ret = wc_RsaSSL_Sign(hashPtr, hash.Length, sigPtr, signature.Length, key, rng);
1863                if (ret >= 0) /* `wc_RsaSSL_Sign` returns the signature length on success */
1864                {
1865                    Marshal.Copy(sigPtr, signature, 0, ret);
1866                }
1867            }
1868            finally
1869            {
1870                if (hashPtr != IntPtr.Zero) Marshal.FreeHGlobal(hashPtr);
1871                if (sigPtr != IntPtr.Zero) Marshal.FreeHGlobal(sigPtr);
1872                if (rng != IntPtr.Zero) RandomFree(rng);
1873            }
1874
1875            return ret;
1876        }
1877
1878        /// <summary>
1879        /// Verify a signature using RSA and SSL-style padding
1880        /// </summary>
1881        /// <param name="key">RSA key structure</param>
1882        /// <param name="signature">Signature to verify</param>
1883        /// <param name="hash">Expected hash value</param>
1884        /// <returns>0 on success, otherwise an error code</returns>
1885        public static int RsaVerifySSL(IntPtr key, byte[] signature, byte[] hash)
1886        {
1887            IntPtr hashPtr = IntPtr.Zero;
1888            IntPtr sigPtr = IntPtr.Zero;
1889            int ret;
1890
1891            try
1892            {
1893                hashPtr = Marshal.AllocHGlobal(hash.Length);
1894                sigPtr = Marshal.AllocHGlobal(signature.Length);
1895
1896                Marshal.Copy(signature, 0, sigPtr, signature.Length);
1897
1898                ret = wc_RsaSSL_Verify(sigPtr, signature.Length, hashPtr, hash.Length, key);
1899
1900                if (ret == hash.Length)
1901                {
1902                    byte[] verifiedHash = new byte[hash.Length];
1903                    Marshal.Copy(hashPtr, verifiedHash, 0, hash.Length);
1904
1905                    if (ByteArrayVerify(verifiedHash, hash))
1906                    {
1907                        ret = 0;
1908                    }
1909                    else
1910                    {
1911                        ret = SIG_VERIFY_E;
1912                    }
1913                }
1914            }
1915            catch (Exception e)
1916            {
1917                log(ERROR_LOG, "RSA verify exception: " + e.ToString());
1918                ret = EXCEPTION_E;
1919            }
1920            finally
1921            {
1922                if (hashPtr != IntPtr.Zero) Marshal.FreeHGlobal(hashPtr);
1923                if (sigPtr != IntPtr.Zero) Marshal.FreeHGlobal(sigPtr);
1924            }
1925
1926            return ret;
1927        }
1928
1929        /// <summary>
1930        /// Encrypt data using RSA public key encryption
1931        /// </summary>
1932        /// <param name="key">RSA key structure</param>
1933        /// <param name="input">Data to encrypt</param>
1934        /// <param name="output">Buffer to receive the encrypted data</param>
1935        /// <returns>0 on success, otherwise an error code</returns>
1936        public static int RsaPublicEncrypt(IntPtr key, byte[] input, byte[] output)
1937        {
1938            IntPtr inPtr = Marshal.AllocHGlobal(input.Length);
1939            IntPtr outPtr = Marshal.AllocHGlobal(output.Length);
1940            Marshal.Copy(input, 0, inPtr, input.Length);
1941
1942            int ret = wc_RsaPublicEncrypt(inPtr, input.Length, outPtr, output.Length, key);
1943
1944            if (ret > 0)
1945            {
1946                Marshal.Copy(outPtr, output, 0, ret);
1947            }
1948
1949            Marshal.FreeHGlobal(inPtr);
1950            Marshal.FreeHGlobal(outPtr);
1951
1952            return ret > 0 ? 0 : ret;
1953        }
1954
1955        /// <summary>
1956        /// Decrypt data using RSA private key decryption
1957        /// </summary>
1958        /// <param name="key">RSA key structure</param>
1959        /// <param name="input">Encrypted data</param>
1960        /// <param name="output">Buffer to receive the decrypted data</param>
1961        /// <returns>0 on success, otherwise an error code</returns>
1962        public static int RsaPrivateDecrypt(IntPtr key, byte[] input, byte[] output)
1963        {
1964            IntPtr inPtr = Marshal.AllocHGlobal(input.Length);
1965            IntPtr outPtr = Marshal.AllocHGlobal(output.Length);
1966            Marshal.Copy(input, 0, inPtr, input.Length);
1967
1968            int ret = wc_RsaPrivateDecrypt(inPtr, input.Length, outPtr, output.Length, key);
1969
1970            if (ret > 0)
1971            {
1972                Marshal.Copy(outPtr, output, 0, ret);
1973            }
1974
1975            Marshal.FreeHGlobal(inPtr);
1976            Marshal.FreeHGlobal(outPtr);
1977
1978            return ret > 0 ? 0 : ret;
1979        }
1980
1981        /// <summary>
1982        /// Free an RSA key structure
1983        /// </summary>
1984        /// <param name="key">RSA key structure allocated using RsaMakeKey() or RsaImportKey()</param>
1985        public static void RsaFreeKey(IntPtr key)
1986        {
1987            if (key != IntPtr.Zero)
1988            {
1989                wc_DeleteRsaKey(key, IntPtr.Zero);
1990                key = IntPtr.Zero;
1991            }
1992        }
1993        /* END RSA */
1994
1995
1996        /***********************************************************************
1997         * ED25519
1998         **********************************************************************/
1999
2000        /// <summary>
2001        /// Generate a new ED25519 key pair with a specified heap, device ID, and internally managed RNG.
2002        /// </summary>
2003        /// <param name="heap">Heap to use for memory allocations (can be IntPtr.Zero).</param>
2004        /// <param name="devId">Device ID for hardware-based keys (can be 0 for software).</param>
2005        /// <returns>0 on success, or an error code on failure.</returns>
2006        public static IntPtr Ed25519MakeKey(IntPtr heap, int devId)
2007        {
2008            int ret = 0;
2009            IntPtr rng = IntPtr.Zero;
2010            IntPtr key = IntPtr.Zero;
2011
2012            try
2013            {
2014                rng = RandomNew();
2015                if (rng == IntPtr.Zero)
2016                {
2017                    throw new Exception("Failed to create RNG.");
2018                }
2019
2020                key = wc_ed25519_new(heap, devId, IntPtr.Zero);
2021                if (key != IntPtr.Zero)
2022                {
2023                    ret = wc_ed25519_make_key(rng, 32, key);
2024                }
2025            }
2026            catch (Exception e)
2027            {
2028                log(ERROR_LOG, "ED25519 make key exception: " + e.ToString());
2029                ret = EXCEPTION_E;
2030            }
2031            finally
2032            {
2033                /* Cleanup */
2034                if (rng != IntPtr.Zero) RandomFree(rng);
2035                if (ret != 0)
2036                {
2037                    wc_ed25519_delete(key, IntPtr.Zero);
2038                    key = IntPtr.Zero;
2039                }
2040            }
2041
2042            return key;
2043        }
2044
2045        /// <summary>
2046        /// Sign a message with an ED25519 private key.
2047        /// </summary>
2048        /// <param name="inMsg">Message to be signed</param>
2049        /// <param name="outMsg">Buffer to receive the signature</param>
2050        /// <param name="key">Private key used for signing</param>
2051        /// <returns>0 on success, otherwise an error code</returns>
2052        public static int Ed25519SignMsg(byte[] inMsg, out byte[] outMsg, IntPtr key)
2053        {
2054            int ret;
2055            IntPtr inMsgPtr = Marshal.AllocHGlobal(inMsg.Length);
2056            IntPtr outMsgPtr = Marshal.AllocHGlobal(ED25519_SIG_SIZE);
2057            outMsg = null;
2058
2059            try
2060            {
2061                Marshal.Copy(inMsg, 0, inMsgPtr, inMsg.Length);
2062                uint outMsgSize = (uint)ED25519_SIG_SIZE;
2063                ret = wc_ed25519_sign_msg(inMsgPtr, (uint)inMsg.Length, outMsgPtr, ref outMsgSize, key);
2064                if (ret == 0)
2065                {
2066                    outMsg = new byte[outMsgSize];
2067                    Marshal.Copy(outMsgPtr, outMsg, 0, (int)outMsgSize);
2068                }
2069            }
2070            finally
2071            {
2072                /* Cleanup */
2073                if (inMsgPtr != IntPtr.Zero) Marshal.FreeHGlobal(inMsgPtr);
2074                if (outMsgPtr != IntPtr.Zero) Marshal.FreeHGlobal(outMsgPtr);
2075            }
2076
2077            return ret;
2078        }
2079
2080        /// <summary>
2081        /// Verify a signature of a message with an ED25519 public key.
2082        /// </summary>
2083        /// <param name="sig">Signature to verify</param>
2084        /// <param name="msg">Message that was signed</param>
2085        /// <param name="key">Public key used for verification</param>
2086        /// <returns>0 if the verification succeeds, otherwise an error code</returns>
2087        public static int Ed25519VerifyMsg(byte[] sig, byte[] msg, IntPtr key)
2088        {
2089            IntPtr sigPtr = IntPtr.Zero;
2090            IntPtr msgPtr = IntPtr.Zero;
2091            int ret = 0;
2092
2093            try
2094            {
2095                /* Allocate memory */
2096                sigPtr = Marshal.AllocHGlobal(sig.Length);
2097                msgPtr = Marshal.AllocHGlobal(msg.Length);
2098
2099                Marshal.Copy(sig, 0, sigPtr, sig.Length);
2100                Marshal.Copy(msg, 0, msgPtr, msg.Length);
2101
2102                int verify = 0;
2103                ret = wc_ed25519_verify_msg(sigPtr, (uint)sig.Length, msgPtr, (uint)msg.Length, ref verify, key);
2104
2105                if (ret == 0 && verify == 1)
2106                {
2107                    ret = 0;
2108                }
2109                else
2110                {
2111                    ret = SIG_VERIFY_E;
2112                }
2113            }
2114            catch (Exception e)
2115            {
2116                log(ERROR_LOG, "ED25519 verify exception: " + e.ToString());
2117                ret = EXCEPTION_E;
2118            }
2119            finally
2120            {
2121                /* Cleanup */
2122                if (sigPtr != IntPtr.Zero) Marshal.FreeHGlobal(sigPtr);
2123                if (msgPtr != IntPtr.Zero) Marshal.FreeHGlobal(msgPtr);
2124            }
2125
2126            return ret;
2127        }
2128
2129        /// <summary>
2130        /// Decode an ED25519 private key from DER format.
2131        /// </summary>
2132        /// <param name="input">DER-encoded private key as byte array.</param>
2133        /// <returns>Allocated ED25519 key structure or IntPtr.Zero on failure.</returns>
2134        public static IntPtr Ed25519PrivateKeyDecode(byte[] input)
2135        {
2136            IntPtr key = IntPtr.Zero;
2137            uint idx = 0;
2138            int ret;
2139
2140            try
2141            {
2142                key = wc_ed25519_new(IntPtr.Zero, INVALID_DEVID, IntPtr.Zero);
2143                if (key != IntPtr.Zero)
2144                {
2145                    ret = wc_Ed25519PrivateKeyDecode(input, ref idx, key, (uint)input.Length);
2146                    if (ret != 0)
2147                    {
2148                        Ed25519FreeKey(key);
2149                        key = IntPtr.Zero;
2150                    }
2151                }
2152            }
2153            catch (Exception e)
2154            {
2155                log(ERROR_LOG, "ED25519 private key decode exception: " + e.ToString());
2156                if (key != IntPtr.Zero) Ed25519FreeKey(key);
2157                key = IntPtr.Zero;
2158            }
2159
2160            return key;
2161        }
2162
2163        /// <summary>
2164        /// Decode an ED25519 public key from DER format.
2165        /// </summary>
2166        /// <param name="input">DER-encoded public key as byte array.</param>
2167        /// <returns>Allocated ED25519 key structure or IntPtr.Zero on failure.</returns>
2168        public static IntPtr Ed25519PublicKeyDecode(byte[] input)
2169        {
2170            IntPtr key = IntPtr.Zero;
2171            uint idx = 0;
2172            int ret;
2173
2174            try
2175            {
2176                key = wc_ed25519_new(IntPtr.Zero, INVALID_DEVID, IntPtr.Zero);
2177                if (key != IntPtr.Zero)
2178                {
2179                    ret = wc_Ed25519PublicKeyDecode(input, ref idx, key, (uint)input.Length);
2180                    if (ret != 0)
2181                    {
2182                        Ed25519FreeKey(key);
2183                        key = IntPtr.Zero;
2184                    }
2185                }
2186            }
2187            catch (Exception e)
2188            {
2189                log(ERROR_LOG, "ED25519 public key decode exception: " + e.ToString());
2190                if (key != IntPtr.Zero) Ed25519FreeKey(key);
2191                key = IntPtr.Zero;
2192            }
2193
2194            return key;
2195        }
2196
2197        /// <summary>
2198        /// Export an ED25519 key to DER format.
2199        /// </summary>
2200        /// <param name="key">ED25519 key structure.</param>
2201        /// <param name="privKey">DER-encoded public key as byte array.</param>
2202        /// <returns>DER-encoded key as byte array.</returns>
2203        public static int Ed25519ExportKeyToDer(IntPtr key, out byte[] privKey)
2204        {
2205            int ret;
2206            privKey = null;
2207
2208            try
2209            {
2210                /* Get length */
2211                int len = wc_Ed25519KeyToDer(key, null, 0);
2212                if (len < 0)
2213                {
2214                    log(ERROR_LOG, "Failed to determine length. Error code: " + len);
2215                    return len;
2216                }
2217
2218                privKey = new byte[len];
2219                ret = wc_Ed25519KeyToDer(key, privKey, (uint)privKey.Length);
2220
2221                if (ret < 0)
2222                {
2223                    log(ERROR_LOG, "Failed to export ED25519 private key to DER format. Error code: " + ret);
2224                    return ret;
2225                }
2226            }
2227            catch(Exception e)
2228            {
2229                log(ERROR_LOG, "ED25519 export private key to DER exception: " + e.ToString());
2230                return EXCEPTION_E;
2231            }
2232
2233            return ret;
2234        }
2235
2236        /// <summary>
2237        /// Export an ED25519 private key to DER format.
2238        /// </summary>
2239        /// <param name="key">ED25519 private key structure.</param>
2240        /// <param name="derKey">DER-encoded private key as byte array.</param>
2241        /// <returns>DER-encoded private key as byte array.</returns>
2242        public static int Ed25519ExportPrivateKeyToDer(IntPtr key, out byte[] derKey)
2243        {
2244            int ret;
2245            derKey = null;
2246
2247            try
2248            {
2249                /* Determine length */
2250                int len = wc_Ed25519PrivateKeyToDer(key, null, 0);
2251                if (len < 0)
2252                {
2253                    log(ERROR_LOG, "Failed to determine length. Error code: " + len);
2254                    return len;
2255                }
2256
2257                derKey = new byte[len];
2258                ret = wc_Ed25519PrivateKeyToDer(key, derKey, (uint)derKey.Length);
2259
2260                if (ret < 0)
2261                {
2262                    log(ERROR_LOG, "Failed to export ED25519 private key to DER format. Error code: " + ret);
2263                    return ret;
2264                }
2265            }
2266            catch (Exception e)
2267            {
2268                log(ERROR_LOG, "ED25519 export private key to DER exception: " + e.ToString());
2269                return EXCEPTION_E;
2270            }
2271
2272            return ret;
2273        }
2274
2275        /// <summary>
2276        /// Export an ED25519 public key to DER format.
2277        /// </summary>
2278        /// <param name="key">ED25519 public key structure.</param>
2279        /// <param name="includeAlg">Whether to include the algorithm identifier in the output.</param>
2280        /// <param name="pubKey">DER-encoded public key as byte array.</param>
2281        /// <returns>An error code indicating success (0) or failure (negative value).</returns>
2282        public static int Ed25519ExportPublicKeyToDer(IntPtr key, out byte[] pubKey, bool includeAlg)
2283        {
2284            int ret;
2285            pubKey = null;
2286
2287            try
2288            {
2289                /* Determine length */
2290                int len = wc_Ed25519PublicKeyToDer(key, null, 0, 1);
2291                if (len < 0)
2292                {
2293                    log(ERROR_LOG, "Failed to determine length. Error code: " + len);
2294                    return len;
2295                }
2296
2297                pubKey = new byte[len];
2298                ret = wc_Ed25519PublicKeyToDer(key, pubKey, (uint)pubKey.Length, includeAlg ? 1 : 0);
2299                if (ret < 0)
2300                {
2301                    log(ERROR_LOG, "Failed to export ED25519 public key to DER format. Error code: " + ret);
2302                    return ret;
2303                }
2304            }
2305            catch (Exception e)
2306            {
2307                log(ERROR_LOG, "ED25519 export public key to DER exception: " + e.ToString());
2308                return EXCEPTION_E;
2309            }
2310
2311            return ret;
2312        }
2313
2314        /// <summary>
2315        /// Free an ED25519 key.
2316        /// </summary>
2317        /// <param name="key">Key to be freed</param>
2318        public static void Ed25519FreeKey(IntPtr key)
2319        {
2320            wc_ed25519_delete(key, IntPtr.Zero);
2321            key = IntPtr.Zero;
2322        }
2323        /* END ED25519 */
2324
2325
2326        /***********************************************************************
2327         * RAW ED25519
2328         **********************************************************************/
2329
2330        /// <summary>
2331        /// Initialize an ED25519 key.
2332        /// </summary>
2333        /// <param name="key">Buffer to receive the initialized key</param>
2334        /// <returns>0 on success, otherwise an error code</returns>
2335        public static int Ed25519InitKey(out IntPtr key)
2336        {
2337            key = IntPtr.Zero;
2338            try
2339            {
2340                key = Marshal.AllocHGlobal(ED25519_SIG_SIZE);
2341                int ret = wc_ed25519_init(key);
2342
2343                if (ret != 0)
2344                {
2345                    Marshal.FreeHGlobal(key);
2346                    key = IntPtr.Zero;
2347                }
2348
2349                return ret;
2350            }
2351            catch
2352            {
2353                /* Cleanup */
2354                Marshal.FreeHGlobal(key);
2355                key = IntPtr.Zero;
2356                throw;
2357            }
2358        }
2359
2360        /// <summary>
2361        /// Import a public key into an ED25519 key structure.
2362        /// </summary>
2363        /// <param name="inMsg">Public key to import</param>
2364        /// <param name="inLen">Length of the public key</param>
2365        /// <param name="key">Buffer to receive the imported key</param>
2366        /// <returns>0 on success, otherwise an error code</returns>
2367        public static int Ed25519ImportPublic(byte[] inMsg, uint inLen, out IntPtr key)
2368        {
2369            int ret;
2370            key = IntPtr.Zero;
2371            IntPtr inMsgPtr = IntPtr.Zero;
2372
2373            try
2374            {
2375                /* Allocate memory */
2376                key = wc_ed25519_new(IntPtr.Zero, INVALID_DEVID, IntPtr.Zero);
2377                if (key == IntPtr.Zero)
2378                {
2379                    throw new OutOfMemoryException("Failed to allocate memory for the key.");
2380                }
2381
2382                inMsgPtr = Marshal.AllocHGlobal(inMsg.Length);
2383                if (inMsgPtr == IntPtr.Zero)
2384                {
2385                    throw new OutOfMemoryException("Failed to allocate memory for the input message.");
2386                }
2387                Marshal.Copy(inMsg, 0, inMsgPtr, inMsg.Length);
2388
2389                ret = wc_ed25519_import_public(inMsgPtr, inLen, key);
2390                if (ret != 0)
2391                {
2392                    if (key != IntPtr.Zero) {
2393                        wc_ed25519_delete(key, IntPtr.Zero);
2394                        key = IntPtr.Zero;
2395                    }
2396                    return ret;
2397                }
2398            }
2399            catch (Exception ex)
2400            {
2401                Console.WriteLine("Exception in EdImportPublic: " + ex.Message);
2402                if (key != IntPtr.Zero) {
2403                    wc_ed25519_delete(key, IntPtr.Zero);
2404                    key = IntPtr.Zero;
2405                }
2406                return EXCEPTION_E;
2407            }
2408            finally
2409            {
2410                /* Cleanup */
2411                if (inMsgPtr != IntPtr.Zero) Marshal.FreeHGlobal(inMsgPtr);
2412            }
2413
2414            return ret;
2415        }
2416
2417        /// <summary>
2418        /// Export a public key from an ED25519 key structure.
2419        /// </summary>
2420        /// <param name="key">ED25519 key structure</param>
2421        /// <param name="outMsg">Buffer to receive the exported public key</param>
2422        /// <param name="outLen">Length of the exported public key</param>
2423        /// <returns>0 on success, otherwise an error code</returns>
2424        public static int Ed25519ExportPublic(IntPtr key, byte[] outMsg, out uint outLen)
2425        {
2426            int ret;
2427            IntPtr outMsgPtr = IntPtr.Zero;
2428
2429            try
2430            {
2431                outMsgPtr = Marshal.AllocHGlobal(outMsg.Length);
2432                outLen = (uint)outMsg.Length;
2433                ret = wc_ed25519_export_public(key, outMsgPtr, ref outLen);
2434                if (ret == 0)
2435                {
2436                    Marshal.Copy(outMsgPtr, outMsg, 0, (int)outLen);
2437                }
2438                else
2439                {
2440                    outLen = 0;
2441                }
2442            }
2443            finally
2444            {
2445                /* Cleanup */
2446                if (outMsgPtr != IntPtr.Zero) Marshal.FreeHGlobal(outMsgPtr);
2447            }
2448
2449            return ret;
2450        }
2451
2452        /// <summary>
2453        /// Export a private key from an ED25519 key structure.
2454        /// </summary>
2455        /// <param name="key">ED25519 key structure</param>
2456        /// <param name="outMsg">Buffer to receive the exported private key</param>
2457        /// <param name="outLen">Length of the exported private key</param>
2458        /// <returns>0 on success, otherwise an error code</returns>
2459        public static int Ed25519ExportPrivate(IntPtr key, byte[] outMsg, out uint outLen)
2460        {
2461            int ret;
2462            IntPtr outMsgPtr = IntPtr.Zero;
2463
2464            try
2465            {
2466                outMsgPtr = Marshal.AllocHGlobal(outMsg.Length);
2467                outLen = (uint)outMsg.Length;
2468                ret = wc_ed25519_export_private(key, outMsgPtr, ref outLen);
2469                if (ret == 0)
2470                {
2471                    Marshal.Copy(outMsgPtr, outMsg, 0, (int)outLen);
2472                }
2473                else
2474                {
2475                    outLen = 0;
2476                }
2477            }
2478            finally
2479            {
2480                /* Cleanup */
2481                if (outMsgPtr != IntPtr.Zero) Marshal.FreeHGlobal(outMsgPtr);
2482            }
2483
2484            return ret;
2485        }
2486
2487        /// <summary>
2488        /// Generate a public key from a private key.
2489        /// </summary>
2490        /// <param name="key">The private key used to generate the public key</param>
2491        /// <param name="pubKey">Buffer to receive the public key</param>
2492        /// <param name="pubKeySz">Size of the public key buffer</param>
2493        /// <returns>0 on success, otherwise an error code</returns>
2494        public static int Ed25519MakePublic(IntPtr key, byte[] pubKey, out uint pubKeySz)
2495        {
2496            int ret;
2497            IntPtr pubKeyPtr = Marshal.AllocHGlobal(pubKey.Length);
2498
2499            try
2500            {
2501                pubKeySz = (uint)pubKey.Length;
2502                ret = wc_ed25519_make_public(key, pubKeyPtr, pubKeySz);
2503                if (ret == 0)
2504                {
2505                    Marshal.Copy(pubKeyPtr, pubKey, 0, (int)pubKeySz);
2506                }
2507            }
2508            finally
2509            {
2510                /* Cleanup */
2511                if (pubKeyPtr != IntPtr.Zero) Marshal.FreeHGlobal(pubKeyPtr);
2512            }
2513
2514            return ret;
2515        }
2516
2517        /// <summary>
2518        /// Get the size of the ED25519 key.
2519        /// </summary>
2520        /// <param name="key">ED25519 key structure</param>
2521        /// <returns>Size of the key, or an error code if failed</returns>
2522        public static int Ed25519GetKeySize(IntPtr key)
2523        {
2524            return wc_ed25519_size(key);
2525        }
2526        /* END RAW ED25519 */
2527
2528
2529        /***********************************************************************
2530         * Curve25519
2531         **********************************************************************/
2532
2533        /// <summary>
2534        /// Generate a new Curve25519 key pair with a specified heap, device ID, and internally managed RNG.
2535        /// </summary>
2536        /// <param name="heap">Heap to use for memory allocations (can be IntPtr.Zero).</param>
2537        /// <param name="devId">Device ID for hardware-based keys (can be 0 for software).</param>
2538        /// <returns>0 on success, or an error code on failure.</returns>
2539        public static IntPtr Curve25519MakeKey(IntPtr heap, int devId)
2540        {
2541            int ret = 0;
2542            IntPtr rng = IntPtr.Zero;
2543            IntPtr key = IntPtr.Zero;
2544
2545            try
2546            {
2547                rng = RandomNew();
2548                if (rng == IntPtr.Zero)
2549                {
2550                    throw new Exception("Failed to create RNG.");
2551                }
2552
2553                key = wc_curve25519_new(heap, devId, IntPtr.Zero);
2554                if (key != IntPtr.Zero)
2555                {
2556                    ret = wc_curve25519_make_key(rng, 32, key);
2557                }
2558            }
2559            catch (Exception e)
2560            {
2561                log(ERROR_LOG, "Curve25519 make key exception: " + e.ToString());
2562                ret = EXCEPTION_E;
2563            }
2564            finally
2565            {
2566                /* Cleanup */
2567                if (rng != IntPtr.Zero) RandomFree(rng);
2568                if (ret != 0)
2569                {
2570                    wc_curve25519_delete(key, IntPtr.Zero);
2571                    key = IntPtr.Zero;
2572                }
2573            }
2574
2575            return key;
2576        }
2577
2578        /// <summary>
2579        /// Decode an Curve25519 private key from DER format.
2580        /// </summary>
2581        /// <param name="input">DER-encoded private key as byte array.</param>
2582        /// <returns>Allocated Curve25519 key structure or IntPtr.Zero on failure.</returns>
2583        public static IntPtr Curve25519PrivateKeyDecode(byte[] input)
2584        {
2585            IntPtr key = IntPtr.Zero;
2586            uint idx = 0;
2587            int ret;
2588
2589            try
2590            {
2591                key = wc_curve25519_new(IntPtr.Zero, INVALID_DEVID, IntPtr.Zero);
2592                if (key != IntPtr.Zero)
2593                {
2594                    ret = wc_Ed25519PrivateKeyDecode(input, ref idx, key, (uint)input.Length);
2595                    if (ret != 0)
2596                    {
2597                        Curve25519FreeKey(key);
2598                        key = IntPtr.Zero;
2599                    }
2600                }
2601            }
2602            catch (Exception e)
2603            {
2604                log(ERROR_LOG, "Curve25519 private key decode exception: " + e.ToString());
2605                if (key != IntPtr.Zero) Curve25519FreeKey(key);
2606                key = IntPtr.Zero;
2607            }
2608
2609            return key;
2610        }
2611
2612        /// <summary>
2613        /// Decode an Curve25519 public key from DER format.
2614        /// </summary>
2615        /// <param name="input">DER-encoded public key as byte array.</param>
2616        /// <returns>Allocated Curve25519 key structure or IntPtr.Zero on failure.</returns>
2617        public static IntPtr Curve25519PublicKeyDecode(byte[] input)
2618        {
2619            IntPtr key = IntPtr.Zero;
2620            uint idx = 0;
2621            int ret;
2622
2623            try
2624            {
2625                key = wc_curve25519_new(IntPtr.Zero, INVALID_DEVID, IntPtr.Zero);
2626                if (key != IntPtr.Zero)
2627                {
2628                    ret = wc_Curve25519PublicKeyDecode(input, ref idx, key, (uint)input.Length);
2629                    if (ret != 0)
2630                    {
2631                        Curve25519FreeKey(key);
2632                        key = IntPtr.Zero;
2633                    }
2634                }
2635            }
2636            catch (Exception e)
2637            {
2638                log(ERROR_LOG, "Curve25519 public key decode exception: " + e.ToString());
2639                if (key != IntPtr.Zero) Curve25519FreeKey(key);
2640                key = IntPtr.Zero;
2641            }
2642
2643            return key;
2644        }
2645
2646        /// <summary>
2647        /// Export an Curve25519 key to DER format.
2648        /// </summary>
2649        /// <param name="key">Curve25519 key structure.</param>
2650        /// <param name="derKey">DER-encoded public key as byte array.</param>
2651        /// <returns>DER-encoded key as byte array.</returns>
2652        public static int Curve25519ExportPrivateKeyToDer(IntPtr key, out byte[] derKey)
2653        {
2654            int ret;
2655            derKey = null;
2656
2657            try
2658            {
2659                /* Determine length */
2660                int len = wc_Curve25519PrivateKeyToDer(key, null, 0);
2661                if (len < 0)
2662                {
2663                    log(ERROR_LOG, "Failed to determine length. Error code: " + len);
2664                    return len;
2665                }
2666
2667                derKey = new byte[len];
2668                ret = wc_Curve25519PrivateKeyToDer(key, derKey, (uint)derKey.Length);
2669
2670                if (ret < 0)
2671                {
2672                    log(ERROR_LOG, "Failed to export Curve25519 private key to DER format. Error code: " + ret);
2673                    return ret;
2674                }
2675            }
2676            catch (Exception e)
2677            {
2678                log(ERROR_LOG, "CURVE25519 export private key to DER exception: " + e.ToString());
2679                return EXCEPTION_E;
2680            }
2681
2682            return ret;
2683        }
2684
2685        /// <summary>
2686        /// Export an Curve25519 public key to DER format.
2687        /// </summary>
2688        /// <param name="key">Curve25519 public key structure.</param>
2689        /// <param name="includeAlg">Whether to include the algorithm identifier in the output.</param>
2690        /// <param name="derKey">DER-encoded public key as byte array.</param>
2691        /// <returns>An error code indicating success (0) or failure (negative value).</returns>
2692        public static int Curve25519ExportPublicKeyToDer(IntPtr key, out byte[] derKey, bool includeAlg)
2693        {
2694            int ret;
2695            derKey = null;
2696
2697            try
2698            {
2699                /* Determine length */
2700                int len = wc_Curve25519PublicKeyToDer(key, null, 0, 1);
2701                if (len < 0)
2702                {
2703                    log(ERROR_LOG, "Failed to determine length. Error code: " + len);
2704                    return len;
2705                }
2706
2707                derKey = new byte[len];
2708                ret = wc_Curve25519PublicKeyToDer(key, derKey, (uint)derKey.Length, includeAlg ? 1 : 0);
2709                if (ret < 0)
2710                {
2711                    log(ERROR_LOG, "Failed to export Curve25519 public key to DER format. Error code: " + ret);
2712                }
2713            }
2714            catch (Exception e)
2715            {
2716                log(ERROR_LOG, "Curve25519 export public key to DER exception: " + e.ToString());
2717                ret = EXCEPTION_E;
2718            }
2719
2720            return ret;
2721        }
2722
2723        /// <summary>
2724        /// Free an Curve25519 key.
2725        /// </summary>
2726        /// <param name="key">Key to be freed</param>
2727        public static void Curve25519FreeKey(IntPtr key)
2728        {
2729            wc_curve25519_delete(key, IntPtr.Zero);
2730            key = IntPtr.Zero;
2731        }
2732        /* END Curve25519 */
2733
2734
2735        /***********************************************************************
2736         * RAW Curve25519
2737         **********************************************************************/
2738
2739        /// <summary>
2740        /// Generate a shared secret using Curve25519
2741        /// </summary>
2742        /// <param name="privateKey">Curve25519 private key</param>
2743        /// <param name="publicKey">Curve25519 public key</param>
2744        /// <param name="secret">Buffer to receive the shared secret</param>
2745        /// <returns>0 on success, otherwise an error code</returns>
2746        public static int Curve25519SharedSecret(IntPtr privateKey, IntPtr publicKey, byte[] secret)
2747        {
2748            int ret;
2749            int secretLength = secret.Length;
2750
2751            try
2752            {
2753                ret = wc_curve25519_shared_secret(privateKey, publicKey, secret, ref secretLength);
2754                if (ret != 0)
2755                {
2756                    throw new Exception("Failed to compute Curve25519 shared secret. Error code: " + ret);
2757                }
2758            }
2759            catch (Exception e)
2760            {
2761                log(ERROR_LOG, "Curve25519 shared secret exception " + e.ToString());
2762                ret = EXCEPTION_E;
2763            }
2764
2765            return ret;
2766        }
2767
2768        /// <summary>
2769        /// Import a Curve25519 private key from a byte array
2770        /// </summary>
2771        /// <param name="privateKey">Private key byte array</param>
2772        /// <returns>Allocated Curve25519 key structure or null</returns>
2773        public static IntPtr Curve25519ImportPrivateKey(byte[] privateKey)
2774        {
2775            IntPtr key = IntPtr.Zero;
2776
2777            try
2778            {
2779                key = Marshal.AllocHGlobal(privateKey.Length);
2780                Marshal.Copy(privateKey, 0, key, privateKey.Length);
2781                int ret = wc_curve25519_import_private(key, privateKey.Length, key);
2782                if (ret != 0)
2783                {
2784                    Marshal.FreeHGlobal(key);
2785                    key = IntPtr.Zero;
2786                }
2787            }
2788            catch (Exception e)
2789            {
2790                log(ERROR_LOG, "Curve25519 import private key exception " + e.ToString());
2791                if (key != IntPtr.Zero) Marshal.FreeHGlobal(key);
2792                key = IntPtr.Zero;
2793            }
2794
2795            return key;
2796        }
2797
2798        /// <summary>
2799        /// Import a Curve25519 public key from a byte array
2800        /// </summary>
2801        /// <param name="publicKey">Public key byte array</param>
2802        /// <returns>Allocated Curve25519 key structure or null</returns>
2803        public static IntPtr Curve25519ImportPublicKey(byte[] publicKey)
2804        {
2805            IntPtr key = IntPtr.Zero;
2806
2807            try
2808            {
2809                key = Marshal.AllocHGlobal(publicKey.Length);
2810                Marshal.Copy(publicKey, 0, key, publicKey.Length);
2811                int ret = wc_curve25519_import_public(key, publicKey.Length, key);
2812                if (ret != 0)
2813                {
2814                    Marshal.FreeHGlobal(key);
2815                    key = IntPtr.Zero;
2816                }
2817            }
2818            catch (Exception e)
2819            {
2820                log(ERROR_LOG, "Curve25519 import public key exception " + e.ToString());
2821                if (key != IntPtr.Zero) Marshal.FreeHGlobal(key);
2822                key = IntPtr.Zero;
2823            }
2824
2825            return key;
2826        }
2827
2828        /// <summary>
2829        /// Export a Curve25519 private key to a byte array
2830        /// </summary>
2831        /// <param name="key">Curve25519 key structure</param>
2832        /// <returns>Private key as byte array</returns>
2833        public static byte[] Curve25519ExportPrivateKey(IntPtr key)
2834        {
2835            byte[] privateKey = new byte[ED25519_KEY_SIZE];
2836            uint privSize = (uint)privateKey.Length;
2837            int ret = wc_curve25519_export_public(key, privateKey, ref privSize);
2838            if (ret != 0)
2839            {
2840                throw new Exception("Failed to export Curve25519 private key. Error code: " + ret);
2841            }
2842            return privateKey;
2843        }
2844
2845        /// <summary>
2846        /// Export a Curve25519 public key to a byte array
2847        /// </summary>
2848        /// <param name="key">Curve25519 key structure</param>
2849        /// <returns>Public key as byte array</returns>
2850        public static byte[] Curve25519ExportPublicKey(IntPtr key)
2851        {
2852            byte[] publicKey = new byte[ED25519_PUB_KEY_SIZE];
2853            uint pubSize = (uint)publicKey.Length;
2854            int ret = wc_curve25519_export_public(key, publicKey, ref pubSize);
2855            if (ret != 0)
2856            {
2857                throw new Exception("Failed to export Curve25519 public key. Error code: " + ret);
2858            }
2859            return publicKey;
2860        }
2861
2862
2863        /// <summary>
2864        /// Export both private and public keys from a Curve25519 key structure
2865        /// </summary>
2866        /// <param name="key">Curve25519 key structure</param>
2867        /// <param name="privateKey">returned raw private key as byte array</param>
2868        /// <param name="publicKey">returned raw public key as byte array</param>
2869        public static void Curve25519ExportKeyRaw(IntPtr key, out byte[] privateKey, out byte[] publicKey)
2870        {
2871            privateKey = new byte[ED25519_KEY_SIZE];
2872            publicKey = new byte[ED25519_PUB_KEY_SIZE];
2873            uint privSize = (uint)privateKey.Length;
2874            uint pubSize = (uint)publicKey.Length;
2875            int ret = wc_curve25519_export_key_raw(key, privateKey, ref privSize, publicKey, ref pubSize);
2876            if (ret != 0)
2877            {
2878                throw new Exception("Failed to export Curve25519 keys. Error code: " + ret);
2879            }
2880            return;
2881        }
2882        /* END RAW Curve25519 */
2883
2884
2885        /***********************************************************************
2886         * ML-KEM
2887         **********************************************************************/
2888
2889        // These APIs work by adding several options to wolfCrypt.
2890        // Please refer to `../user_settings.h`.
2891
2892        /// <summary>
2893        /// Allocate and initialize a new ML-KEM key without generating key
2894        /// material. Use this when you intend to import or decode an existing
2895        /// key (e.g., before calling MlKemDecodePublicKey/MlKemDecodePrivateKey).
2896        /// </summary>
2897        /// <param name="type">ML-KEM parameter set type</param>
2898        /// <param name="heap">Heap pointer for memory allocation</param>
2899        /// <param name="devId">Device ID (if applicable)</param>
2900        /// <returns>Pointer to the MlKem key structure, or IntPtr.Zero on failure</returns>
2901        public static IntPtr MlKemNew(MlKemTypes type, IntPtr heap, int devId)
2902        {
2903            try
2904            {
2905                IntPtr key = wc_MlKemKey_New((int)type, heap, devId);
2906                if (key == IntPtr.Zero)
2907                {
2908                    log(ERROR_LOG, "Failed to allocate or initialize MlKem key.");
2909                }
2910                return key;
2911            }
2912            catch (Exception ex)
2913            {
2914                log(ERROR_LOG, "MlKem key allocation exception: " + ex.ToString());
2915                return IntPtr.Zero;
2916            }
2917        }
2918
2919        /// <summary>
2920        /// Create a new ML-KEM key pair and initialize it with random values
2921        /// </summary>
2922        /// <param name="type">ML-KEM parameter set type</param>
2923        /// <param name="heap">Heap pointer for memory allocation</param>
2924        /// <param name="devId">Device ID (if applicable)</param>
2925        /// <returns>Pointer to the MlKem key structure, or IntPtr.Zero on failure</returns>
2926        public static IntPtr MlKemMakeKey(MlKemTypes type, IntPtr heap, int devId)
2927        {
2928            int ret = 0;
2929            IntPtr key = IntPtr.Zero;
2930            IntPtr rng = IntPtr.Zero;
2931            bool success = false;
2932
2933            try
2934            {
2935                key = wc_MlKemKey_New((int)type, heap, devId);
2936                if (key == IntPtr.Zero)
2937                {
2938                    log(ERROR_LOG, "Failed to allocate or initialize MlKem key.");
2939                    return IntPtr.Zero;
2940                }
2941
2942                rng = RandomNew();
2943                if (rng == IntPtr.Zero)
2944                {
2945                    log(ERROR_LOG, "Failed to create RNG for MlKem key.");
2946                    return IntPtr.Zero;
2947                }
2948
2949                ret = wc_MlKemKey_MakeKey(key, rng);
2950                if (ret != 0)
2951                {
2952                    log(ERROR_LOG, "Failed to make MlKem key. Error code: " + ret);
2953                    return IntPtr.Zero;
2954                }
2955
2956                success = true;
2957                return key;
2958            }
2959            catch (Exception ex)
2960            {
2961                log(ERROR_LOG, "MlKem key creation exception: " + ex.ToString());
2962                return IntPtr.Zero;
2963            }
2964            finally
2965            {
2966                if (rng != IntPtr.Zero)
2967                {
2968                    RandomFree(rng);
2969                }
2970                if (!success && key != IntPtr.Zero)
2971                {
2972                    ret = MlKemFreeKey(ref key);
2973                    if (ret != 0)
2974                    {
2975                        log(ERROR_LOG, "Failed to free MlKem key. Error code: " + ret);
2976                    }
2977                }
2978            }
2979        }
2980
2981        /// <summary>
2982        /// Free a MlKem key structure and release its memory
2983        /// </summary>
2984        /// <param name="key">Pointer to the MlKem key structure</param>
2985        /// <returns>0 on success, negative value on error.</returns>
2986        public static int MlKemFreeKey(ref IntPtr key)
2987        {
2988            int ret;
2989
2990            if (key == IntPtr.Zero)
2991            {
2992                return BAD_FUNC_ARG;
2993            }
2994
2995            ret = wc_MlKemKey_Delete(key, IntPtr.Zero);
2996            key = IntPtr.Zero;
2997            return ret;
2998        }
2999
3000        /// <summary>
3001        /// Encode the ML-KEM public key to a byte array.
3002        /// </summary>
3003        /// <param name="key">Pointer to the MlKem key structure.</param>
3004        /// <param name="publicKey">Output byte array containing the encoded public key.</param>
3005        /// <returns>0 on success, negative value on error.</returns>
3006        public static int MlKemEncodePublicKey(IntPtr key, out byte[] publicKey)
3007        {
3008            publicKey = null;
3009            int ret = 0;
3010            uint pubLen = 0;
3011
3012            if (key == IntPtr.Zero)
3013            {
3014                return BAD_FUNC_ARG;
3015            }
3016
3017            try
3018            {
3019                ret = wc_MlKemKey_PublicKeySize(key, ref pubLen);
3020                if (ret != 0 || pubLen == 0)
3021                {
3022                    log(ERROR_LOG, "Failed to get MlKem public key length. Error code: " + ret);
3023                    return (ret != 0) ? ret : BAD_FUNC_ARG;
3024                }
3025                if (pubLen > int.MaxValue)
3026                {
3027                    log(ERROR_LOG, "MlKem public key length too large: " + pubLen);
3028                    return BAD_FUNC_ARG;
3029                }
3030                publicKey = new byte[checked((int)pubLen)];
3031
3032                ret = wc_MlKemKey_EncodePublicKey(key, publicKey, pubLen);
3033                if (ret != 0)
3034                {
3035                    log(ERROR_LOG, "Failed to encode MlKem public key. Error code: " + ret);
3036                    publicKey = null;
3037                    return ret;
3038                }
3039            }
3040            catch (Exception e)
3041            {
3042                log(ERROR_LOG, "MlKem encode public key exception: " + e.ToString());
3043                publicKey = null;
3044                return EXCEPTION_E;
3045            }
3046            return SUCCESS;
3047        }
3048
3049        /// <summary>
3050        /// Encode the ML-KEM private key to a byte array.
3051        /// </summary>
3052        /// <param name="key">Pointer to the MlKem key structure.</param>
3053        /// <param name="privateKey">Output byte array containing the encoded private key.</param>
3054        /// <returns>0 on success, negative value on error.</returns>
3055        public static int MlKemEncodePrivateKey(IntPtr key, out byte[] privateKey)
3056        {
3057            privateKey = null;
3058            int ret = 0;
3059            uint privLen = 0;
3060
3061            if (key == IntPtr.Zero)
3062            {
3063                return BAD_FUNC_ARG;
3064            }
3065
3066            try
3067            {
3068                ret = wc_MlKemKey_PrivateKeySize(key, ref privLen);
3069                if (ret != 0 || privLen == 0)
3070                {
3071                    log(ERROR_LOG, "Failed to get MlKem private key length. Error code: " + ret);
3072                    return (ret != 0) ? ret : BAD_FUNC_ARG;
3073                }
3074                if (privLen > int.MaxValue)
3075                {
3076                    log(ERROR_LOG, "MlKem private key length too large: " + privLen);
3077                    return BAD_FUNC_ARG;
3078                }
3079
3080                privateKey = new byte[checked((int)privLen)];
3081                ret = wc_MlKemKey_EncodePrivateKey(key, privateKey, privLen);
3082                if (ret != 0)
3083                {
3084                    log(ERROR_LOG, "Failed to encode MlKem private key. Error code: " + ret);
3085                    privateKey = null;
3086                    return ret;
3087                }
3088            }
3089            catch (Exception e)
3090            {
3091                log(ERROR_LOG, "MlKem encode private key exception: " + e.ToString());
3092                privateKey = null;
3093                return EXCEPTION_E;
3094            }
3095            return SUCCESS;
3096        }
3097
3098        /// <summary>
3099        /// Decode a ML-KEM public key from a byte array.
3100        /// </summary>
3101        /// <param name="key">Pointer to the MlKem key structure.</param>
3102        /// <param name="publicKey">Encoded public key as byte array.</param>
3103        /// <returns>0 on success, negative value on error.</returns>
3104        public static int MlKemDecodePublicKey(IntPtr key, byte[] publicKey)
3105        {
3106            int ret = 0;
3107            uint pubLen = 0;
3108
3109            if (key == IntPtr.Zero)
3110            {
3111                return BAD_FUNC_ARG;
3112            }
3113
3114            if (publicKey == null)
3115            {
3116                log(ERROR_LOG, "MlKem decode public key called with null publicKey buffer.");
3117                return BAD_FUNC_ARG;
3118            }
3119
3120            try
3121            {
3122                ret = wc_MlKemKey_PublicKeySize(key, ref pubLen);
3123                if (ret != 0 || pubLen == 0)
3124                {
3125                    log(ERROR_LOG, "Failed to get MlKem public key length. Error code: " + ret);
3126                    return (ret != 0) ? ret : BAD_FUNC_ARG;
3127                }
3128                if ((uint)publicKey.Length != pubLen)
3129                {
3130                    log(ERROR_LOG, "MlKem public key buffer length mismatch. Expected: " +
3131                        pubLen + ", actual: " + publicKey.Length);
3132                    return BUFFER_E;
3133                }
3134
3135                ret = wc_MlKemKey_DecodePublicKey(key, publicKey, pubLen);
3136                if (ret != 0)
3137                {
3138                    log(ERROR_LOG, "Failed to decode MlKem public key. Error code: " + ret);
3139                    return ret;
3140                }
3141            }
3142            catch (Exception ex)
3143            {
3144                log(ERROR_LOG, "MlKem decode public key exception: " + ex.ToString());
3145                return EXCEPTION_E;
3146            }
3147            return SUCCESS;
3148        }
3149
3150        /// <summary>
3151        /// Decode a ML-KEM private key from a byte array.
3152        /// </summary>
3153        /// <param name="key">Pointer to the MlKem key structure.</param>
3154        /// <param name="privateKey">Encoded private key as byte array.</param>
3155        /// <returns>0 on success, negative value on error.</returns>
3156        public static int MlKemDecodePrivateKey(IntPtr key, byte[] privateKey)
3157        {
3158            int ret = 0;
3159            uint privLen = 0;
3160
3161            if (key == IntPtr.Zero)
3162            {
3163                return BAD_FUNC_ARG;
3164            }
3165
3166            if (privateKey == null)
3167            {
3168                log(ERROR_LOG, "MlKem private key buffer is null.");
3169                return BAD_FUNC_ARG;
3170            }
3171
3172            try
3173            {
3174                ret = wc_MlKemKey_PrivateKeySize(key, ref privLen);
3175                if (ret != 0 || privLen == 0)
3176                {
3177                    log(ERROR_LOG, "Failed to get MlKem private key length. Error code: " + ret);
3178                    return (ret != 0) ? ret : BAD_FUNC_ARG;
3179                }
3180
3181                if ((uint)privateKey.Length != privLen)
3182                {
3183                    log(ERROR_LOG, "MlKem private key buffer length mismatch. Required: " + privLen +
3184                        ", provided: " + (uint)privateKey.Length);
3185                    return BUFFER_E;
3186                }
3187
3188                ret = wc_MlKemKey_DecodePrivateKey(key, privateKey, privLen);
3189                if (ret != 0)
3190                {
3191                    log(ERROR_LOG, "Failed to decode MlKem private key. Error code: " + ret);
3192                    return ret;
3193                }
3194            }
3195            catch (Exception ex)
3196            {
3197                log(ERROR_LOG, "MlKem decode private key exception: " + ex.ToString());
3198                return EXCEPTION_E;
3199            }
3200            return SUCCESS;
3201        }
3202
3203        /// <summary>
3204        /// Perform ML-KEM encapsulation to generate a ciphertext and shared secret
3205        /// </summary>
3206        /// <param name="key">Pointer to the MlKem key structure</param>
3207        /// <param name="ct">Output buffer for the ciphertext</param>
3208        /// <param name="ss">Output buffer for the shared secret</param>
3209        /// <returns>0 on success, otherwise an error code</returns>
3210        public static int MlKemEncapsulate(IntPtr key, out byte[] ct, out byte[] ss)
3211        {
3212            int ret;
3213            ct = null;
3214            ss = null;
3215            uint ctLen = 0;
3216            uint ssLen = 0;
3217            IntPtr rng = IntPtr.Zero;
3218
3219            if (key == IntPtr.Zero)
3220            {
3221                return BAD_FUNC_ARG;
3222            }
3223
3224            try
3225            {
3226                ret = wc_MlKemKey_CipherTextSize(key, ref ctLen);
3227                if (ret != 0)
3228                {
3229                    log(ERROR_LOG, "Failed to determine ciphertext length. Error code: " + ret);
3230                    return ret;
3231                }
3232                ret = wc_MlKemKey_SharedSecretSize(key, ref ssLen);
3233                if (ret != 0)
3234                {
3235                    log(ERROR_LOG, "Failed to determine shared secret length. Error code: " + ret);
3236                    return ret;
3237                }
3238
3239                if (ctLen > int.MaxValue || ssLen > int.MaxValue)
3240                {
3241                    log(ERROR_LOG, "MlKem sizes exceed maximum supported length.");
3242                    return BAD_FUNC_ARG;
3243                }
3244                ct = new byte[checked((int)ctLen)];
3245                ss = new byte[checked((int)ssLen)];
3246
3247                rng = RandomNew();
3248                if (rng == IntPtr.Zero)
3249                {
3250                    log(ERROR_LOG, "Failed to create RNG for MlKem encapsulate.");
3251                    return MEMORY_E;
3252                }
3253                ret = wc_MlKemKey_Encapsulate(key, ct, ss, rng);
3254                if (ret != 0)
3255                {
3256                    log(ERROR_LOG, "Failed to encapsulate MlKem key. Error code: " + ret);
3257                    return ret;
3258                }
3259            }
3260            catch (Exception e)
3261            {
3262                log(ERROR_LOG, "MlKem encapsulate exception: " + e.ToString());
3263                return EXCEPTION_E;
3264            }
3265            finally
3266            {
3267                if (rng != IntPtr.Zero)
3268                {
3269                    RandomFree(rng);
3270                    rng = IntPtr.Zero;
3271                }
3272            }
3273            return SUCCESS;
3274        }
3275
3276        /// <summary>
3277        /// Perform ML-KEM decapsulation to recover the shared secret from ciphertext
3278        /// </summary>
3279        /// <param name="key">Pointer to the MlKem key structure</param>
3280        /// <param name="ct">Ciphertext buffer</param>
3281        /// <param name="ss">Output buffer for the shared secret</param>
3282        /// <returns>0 on success, otherwise an error code</returns>
3283        public static int MlKemDecapsulate(IntPtr key, byte[] ct, out byte[] ss)
3284        {
3285            int ret;
3286            ss = null;
3287            uint ssLen = 0;
3288
3289            if (key == IntPtr.Zero || ct == null)
3290            {
3291                return BAD_FUNC_ARG;
3292            }
3293
3294            try
3295            {
3296                uint ctLen = 0;
3297                ret = wc_MlKemKey_CipherTextSize(key, ref ctLen);
3298                if (ret != 0)
3299                {
3300                    log(ERROR_LOG, "Failed to determine ciphertext length. Error code: " + ret);
3301                    return ret;
3302                }
3303                if ((uint)ct.Length != ctLen)
3304                {
3305                    log(ERROR_LOG, "Ciphertext length mismatch. Expected: " + ctLen + ", got: " + ct.Length);
3306                    return BUFFER_E;
3307                }
3308
3309                ret = wc_MlKemKey_SharedSecretSize(key, ref ssLen);
3310                if (ret != 0)
3311                {
3312                    log(ERROR_LOG, "Failed to determine shared secret length. Error code: " + ret);
3313                    return ret;
3314                }
3315                if (ssLen > int.MaxValue)
3316                {
3317                    log(ERROR_LOG, "Shared secret length too large. Length: " + ssLen);
3318                    return BAD_FUNC_ARG;
3319                }
3320
3321                ss = new byte[checked((int)ssLen)];
3322                ret = wc_MlKemKey_Decapsulate(key, ss, ct, (uint)ct.Length);
3323                if (ret != 0)
3324                {
3325                    log(ERROR_LOG, "Failed to decapsulate MlKem key. Error code: " + ret);
3326                    return ret;
3327                }
3328            }
3329            catch (Exception e)
3330            {
3331                log(ERROR_LOG, "MlKem decapsulate exception: " + e.ToString());
3332                return EXCEPTION_E;
3333            }
3334            return SUCCESS;
3335        }
3336
3337        /********************************
3338         * ENUMS
3339         */
3340        public enum MlKemTypes
3341        {
3342            ML_KEM_512 = 0,
3343            ML_KEM_768 = 1,
3344            ML_KEM_1024 = 2
3345        }
3346        /* END ML-KEM */
3347
3348
3349        /***********************************************************************
3350         * ML-DSA
3351         **********************************************************************/
3352
3353        // These APIs work by adding several options to wolfCrypt.
3354        // Please refer to `../user_settings.h`.
3355
3356        /// <summary>
3357        /// Allocate and initialize a new ML-DSA key (with level set) without
3358        /// generating key material. Use this when you intend to import an
3359        /// existing key (e.g., before calling MlDsaImportPublicKey or
3360        /// MlDsaImportPrivateKey).
3361        /// </summary>
3362        /// <param name="heap">Heap pointer for memory allocation</param>
3363        /// <param name="devId">Device ID (if applicable)</param>
3364        /// <param name="level">ML-DSA security level</param>
3365        /// <returns>Pointer to the ML-DSA key structure, or IntPtr.Zero on failure</returns>
3366        public static IntPtr MlDsaNew(IntPtr heap, int devId, MlDsaLevels level)
3367        {
3368            IntPtr key = IntPtr.Zero;
3369            bool success = false;
3370
3371            try
3372            {
3373                key = wc_dilithium_new(heap, devId);
3374                if (key == IntPtr.Zero)
3375                {
3376                    log(ERROR_LOG, "Failed to allocate and initialize ML-DSA key.");
3377                    return IntPtr.Zero;
3378                }
3379
3380                int ret = wc_dilithium_set_level(key, (byte)level);
3381                if (ret != 0)
3382                {
3383                    log(ERROR_LOG, "Failed to set ML-DSA level. Error code: " + ret);
3384                    return IntPtr.Zero;
3385                }
3386
3387                success = true;
3388                return key;
3389            }
3390            catch (Exception ex)
3391            {
3392                log(ERROR_LOG, "ML-DSA key allocation exception: " + ex.ToString());
3393                return IntPtr.Zero;
3394            }
3395            finally
3396            {
3397                if (!success && key != IntPtr.Zero)
3398                {
3399                    int ret = MlDsaFreeKey(ref key);
3400                    if (ret != 0)
3401                    {
3402                        log(ERROR_LOG, "Failed to free ML-DSA key. Error code: " + ret);
3403                    }
3404                }
3405            }
3406        }
3407
3408        /// <summary>
3409        /// Create a new ML-DSA key pair and initialize it with random values
3410        /// </summary>
3411        /// <param name="heap">Heap pointer for memory allocation</param>
3412        /// <param name="devId">Device ID (if applicable)</param>
3413        /// <param name="level">ML-DSA security level</param>
3414        /// <returns>Pointer to the ML-DSA key structure, or IntPtr.Zero on failure</returns>
3415        public static IntPtr MlDsaMakeKey(IntPtr heap, int devId, MlDsaLevels level)
3416        {
3417            IntPtr key = IntPtr.Zero;
3418            IntPtr rng = IntPtr.Zero;
3419            int ret;
3420            bool success = false;
3421
3422            try
3423            {
3424                key = wc_dilithium_new(heap, devId);
3425                if (key == IntPtr.Zero)
3426                {
3427                    log(ERROR_LOG, "Failed to allocate and initialize ML-DSA key.");
3428                    return IntPtr.Zero;
3429                }
3430
3431                ret = wc_dilithium_set_level(key, (byte)level);
3432                if (ret != 0)
3433                {
3434                    log(ERROR_LOG, "Failed to set ML-DSA level. Error code: " + ret);
3435                    return IntPtr.Zero;
3436                }
3437
3438                rng = RandomNew();
3439                if (rng == IntPtr.Zero)
3440                {
3441                    log(ERROR_LOG, "Failed to create RNG for ML-DSA key.");
3442                    return IntPtr.Zero;
3443                }
3444
3445                ret = wc_dilithium_make_key(key, rng);
3446                if (ret != 0)
3447                {
3448                    log(ERROR_LOG, "Failed to make ML-DSA key. Error code: " + ret);
3449                    return IntPtr.Zero;
3450                }
3451
3452                success = true;
3453                return key;
3454            }
3455            catch (Exception ex)
3456            {
3457                log(ERROR_LOG, "ML-DSA key creation exception: " + ex.ToString());
3458                return IntPtr.Zero;
3459            }
3460            finally
3461            {
3462                if (rng != IntPtr.Zero)
3463                {
3464                    RandomFree(rng);
3465                }
3466                if (!success && key != IntPtr.Zero)
3467                {
3468                    ret = MlDsaFreeKey(ref key);
3469                    if (ret != 0)
3470                    {
3471                        log(ERROR_LOG, "Failed to free ML-DSA key. Error code: " + ret);
3472                    }
3473                }
3474            }
3475        }
3476
3477        /// <summary>
3478        /// Free an ML-DSA key structure and release its memory
3479        /// </summary>
3480        /// <param name="key">Pointer to the ML-DSA key structure</param>
3481        /// <returns>0 on success, negative value on error.</returns>
3482        public static int MlDsaFreeKey(ref IntPtr key)
3483        {
3484            int ret;
3485
3486            if (key == IntPtr.Zero)
3487            {
3488                return BAD_FUNC_ARG;
3489            }
3490
3491            ret = wc_dilithium_delete(key, IntPtr.Zero);
3492            key = IntPtr.Zero;
3493            return ret;
3494        }
3495
3496        /// <summary>
3497        /// Import an ML-DSA public key from a byte array.
3498        /// </summary>
3499        /// <param name="publicKey">Byte array containing the serialized public key.</param>
3500        /// <param name="key">Pointer to the ML-DSA key structure (must be initialized).</param>
3501        /// <returns>0 on success, negative value on error.</returns>
3502        public static int MlDsaImportPublicKey(byte[] publicKey, IntPtr key)
3503        {
3504            if (publicKey == null || key == IntPtr.Zero)
3505            {
3506                return BAD_FUNC_ARG;
3507            }
3508
3509            try
3510            {
3511                return wc_dilithium_import_public(publicKey, (uint)publicKey.Length, key);
3512            }
3513            catch (Exception e)
3514            {
3515                log(ERROR_LOG, "ML-DSA import public key exception: " + e.ToString());
3516                return EXCEPTION_E;
3517            }
3518        }
3519
3520        /// <summary>
3521        /// Import an ML-DSA private key from a byte array.
3522        /// </summary>
3523        /// <param name="privateKey">Byte array containing the private key.</param>
3524        /// <param name="key">Pointer to the ML-DSA key structure (must be initialized and have level set).</param>
3525        /// <returns>0 on success, negative value on error.</returns>
3526        public static int MlDsaImportPrivateKey(byte[] privateKey, IntPtr key)
3527        {
3528            if (privateKey == null || key == IntPtr.Zero)
3529            {
3530                return BAD_FUNC_ARG;
3531            }
3532
3533            try
3534            {
3535                return wc_dilithium_import_private(privateKey, (uint)privateKey.Length, key);
3536            }
3537            catch (Exception e)
3538            {
3539                log(ERROR_LOG, "ML-DSA import private key exception: " + e.ToString());
3540                return EXCEPTION_E;
3541            }
3542        }
3543
3544        /// <summary>
3545        /// Export an ML-DSA private key to a byte array.
3546        /// </summary>
3547        /// <param name="key">Pointer to the ML-DSA key structure.</param>
3548        /// <param name="privateKey">Output byte array containing the private key.</param>
3549        /// <returns>0 on success, negative value on error.</returns>
3550        public static int MlDsaExportPrivateKey(IntPtr key, out byte[] privateKey)
3551        {
3552            privateKey = null;
3553            int ret = 0;
3554            int privLen = 0;
3555            uint outLen;
3556
3557            if (key == IntPtr.Zero)
3558            {
3559                return BAD_FUNC_ARG;
3560            }
3561
3562            try
3563            {
3564                ret = wc_MlDsaKey_GetPrivLen(key, ref privLen);
3565                if (ret != 0 || privLen <= 0)
3566                {
3567                    log(ERROR_LOG, "Failed to get ML-DSA private key length. Error code: " + ret);
3568                    return (ret != 0) ? ret : BAD_FUNC_ARG;
3569                }
3570
3571                privateKey = new byte[privLen];
3572                outLen = (uint)privLen;
3573                ret = wc_dilithium_export_private(key, privateKey, ref outLen);
3574                if (ret != 0)
3575                {
3576                    log(ERROR_LOG, "Failed to export ML-DSA private key. Error code: " + ret);
3577                    privateKey = null;
3578                    return ret;
3579                }
3580                if (outLen != (uint)privLen)
3581                {
3582                    Array.Resize(ref privateKey, (int)outLen);
3583                }
3584            }
3585            catch (Exception e)
3586            {
3587                log(ERROR_LOG, "ML-DSA export private key exception: " + e.ToString());
3588                privateKey = null;
3589                return EXCEPTION_E;
3590            }
3591            return SUCCESS;
3592        }
3593
3594        /// <summary>
3595        /// Export an ML-DSA public key to a byte array.
3596        /// </summary>
3597        /// <param name="key">Pointer to the ML-DSA key structure.</param>
3598        /// <param name="publicKey">Output byte array containing the public key.</param>
3599        /// <returns>0 on success, negative value on error.</returns>
3600        public static int MlDsaExportPublicKey(IntPtr key, out byte[] publicKey)
3601        {
3602            publicKey = null;
3603            int ret = 0;
3604            int pubLen = 0;
3605            uint outLen;
3606
3607            if (key == IntPtr.Zero)
3608            {
3609                return BAD_FUNC_ARG;
3610            }
3611
3612            try
3613            {
3614                ret = wc_MlDsaKey_GetPubLen(key, ref pubLen);
3615                if (ret != 0 || pubLen <= 0)
3616                {
3617                    log(ERROR_LOG, "Failed to get ML-DSA public key length. Error code: " + ret);
3618                    return (ret != 0) ? ret : BAD_FUNC_ARG;
3619                }
3620
3621                publicKey = new byte[pubLen];
3622                outLen = (uint)pubLen;
3623                ret = wc_dilithium_export_public(key, publicKey, ref outLen);
3624                if (ret != 0)
3625                {
3626                    log(ERROR_LOG, "Failed to export ML-DSA public key. Error code: " + ret);
3627                    publicKey = null;
3628                    return ret;
3629                }
3630                if (outLen != (uint)pubLen)
3631                {
3632                    Array.Resize(ref publicKey, (int)outLen);
3633                }
3634            }
3635            catch (Exception e)
3636            {
3637                log(ERROR_LOG, "ML-DSA export public key exception: " + e.ToString());
3638                publicKey = null;
3639                return EXCEPTION_E;
3640            }
3641            return SUCCESS;
3642        }
3643
3644        /// <summary>
3645        /// Sign a message using an ML-DSA private key
3646        /// </summary>
3647        /// <param name="key">Pointer to the ML-DSA key structure</param>
3648        /// <param name="msg">Message to sign</param>
3649        /// <param name="sig">Output byte array for the signature</param>
3650        /// <returns>0 on success, otherwise an error code</returns>
3651        public static int MlDsaSignMsg(IntPtr key, byte[] msg, out byte[] sig)
3652        {
3653            int ret;
3654            int sigLen = 0;
3655            uint outLen;
3656            sig = null;
3657            IntPtr rng = IntPtr.Zero;
3658
3659            if (key == IntPtr.Zero || msg == null)
3660            {
3661                return BAD_FUNC_ARG;
3662            }
3663
3664            try
3665            {
3666                ret = wc_MlDsaKey_GetSigLen(key, ref sigLen);
3667                if (ret != 0 || sigLen <= 0)
3668                {
3669                    log(ERROR_LOG, "Failed to get ML-DSA signature length. Error code: " + ret);
3670                    return (ret != 0) ? ret : BAD_FUNC_ARG;
3671                }
3672
3673                sig = new byte[sigLen];
3674                outLen = (uint)sigLen;
3675                rng = RandomNew();
3676                if (rng == IntPtr.Zero)
3677                {
3678                    log(ERROR_LOG, "Failed to create RNG for ML-DSA signing.");
3679                    return MEMORY_E;
3680                }
3681                /* FIPS 204 sign with empty context (ctx=null, ctxLen=0). */
3682                ret = wc_dilithium_sign_ctx_msg(null, 0, msg, (uint)msg.Length, sig, ref outLen, key, rng);
3683                if (ret != 0)
3684                {
3685                    log(ERROR_LOG, "Failed to sign message with ML-DSA key. Error code: " + ret);
3686                    return ret;
3687                }
3688                if (outLen != (uint)sigLen)
3689                {
3690                    Array.Resize(ref sig, (int)outLen);
3691                }
3692            }
3693            catch (Exception e)
3694            {
3695                log(ERROR_LOG, "ML-DSA sign message exception: " + e.ToString());
3696                return EXCEPTION_E;
3697            }
3698            finally
3699            {
3700                if (rng != IntPtr.Zero){
3701                    RandomFree(rng);
3702                }
3703            }
3704            return SUCCESS;
3705        }
3706
3707        /// <summary>
3708        /// Verify an ML-DSA signature
3709        /// </summary>
3710        /// <param name="key">Pointer to the ML-DSA key structure</param>
3711        /// <param name="msg">Message that was signed</param>
3712        /// <param name="sig">Signature to verify</param>
3713        /// <returns>0 if the signature is valid, otherwise an error code</returns>
3714        public static int MlDsaVerifyMsg(IntPtr key, byte[] msg, byte[] sig)
3715        {
3716            int ret;
3717            int res = 0;
3718
3719            if (key == IntPtr.Zero || msg == null || sig == null)
3720            {
3721                return BAD_FUNC_ARG;
3722            }
3723
3724            try
3725            {
3726                /* FIPS 204 verify with empty context (ctx=null, ctxLen=0). */
3727                ret = wc_dilithium_verify_ctx_msg(sig, (uint)sig.Length, null, 0, msg, (uint)msg.Length, ref res, key);
3728                if (ret != 0)
3729                {
3730                    log(ERROR_LOG, "Failed to verify message with ML-DSA key. Error code: " + ret);
3731                    return ret;
3732                }
3733                if (res != 1)
3734                {
3735                    log(ERROR_LOG, "ML-DSA signature verification failed (invalid signature).");
3736                    return SIG_VERIFY_E;
3737                }
3738            }
3739            catch (Exception e)
3740            {
3741                log(ERROR_LOG, "ML-DSA verify message exception: " + e.ToString());
3742                return EXCEPTION_E;
3743            }
3744            return SUCCESS;
3745        }
3746
3747        /********************************
3748         * ENUMS
3749         */
3750        public enum MlDsaLevels
3751        {
3752            ML_DSA_44 = 2,
3753            ML_DSA_65 = 3,
3754            ML_DSA_87 = 5
3755        }
3756        /* END ML-DSA */
3757
3758
3759        /***********************************************************************
3760         * AES-GCM
3761         **********************************************************************/
3762
3763        /// <summary>
3764        /// Creates a new AES context.
3765        /// </summary>
3766        /// <param name="heap">Pointer to a memory heap, or IntPtr.Zero to use the default heap.</param>
3767        /// <param name="devId">The device ID to associate with this AES context.</param>
3768        /// <returns>A pointer to the newly created AES context, or IntPtr.Zero on failure.</returns>
3769        public static IntPtr AesNew(IntPtr heap, int devId)
3770        {
3771            IntPtr aesPtr = IntPtr.Zero;
3772
3773            try
3774            {
3775                aesPtr = wc_AesNew(heap, devId, IntPtr.Zero);
3776
3777                if (aesPtr == IntPtr.Zero)
3778                {
3779                    throw new Exception("Failed to create AES context.");
3780                }
3781
3782            }
3783            catch (Exception ex)
3784            {
3785                Console.WriteLine("AES context creation failed: " + ex.Message);
3786            }
3787
3788            return aesPtr;
3789        }
3790
3791        /// <summary>
3792        /// Initialize and set the AES key for AES-GCM operations.
3793        /// </summary>
3794        /// <param name="aes">AES-GCM context pointer.</param>
3795        /// <param name="key">The AES key (either 128, 192, or 256 bits).</param>
3796        /// <returns>0 on success, otherwise an error code.</returns>
3797        public static int AesGcmSetKey(IntPtr aes, byte[] key)
3798        {
3799            IntPtr keyPtr = IntPtr.Zero;
3800            int ret;
3801
3802            try
3803            {
3804                /* Allocate memory */
3805                keyPtr = Marshal.AllocHGlobal(key.Length);
3806                Marshal.Copy(key, 0, keyPtr, key.Length);
3807
3808                ret = wc_AesGcmSetKey(aes, keyPtr, (uint)key.Length);
3809                if (ret != 0)
3810                {
3811                    throw new Exception("AES-GCM initialization failed with error code ret = " + ret.ToString());
3812                }
3813            }
3814            finally
3815            {
3816                /* Cleanup */
3817                if (keyPtr != IntPtr.Zero) Marshal.FreeHGlobal(keyPtr);
3818            }
3819
3820            return ret;
3821        }
3822
3823        /// <summary>
3824        /// Wrapper method to initialize the AES-GCM context with a given key and IV.
3825        /// </summary>
3826        /// <param name="aes">Pointer to the AES-GCM context that needs to be initialized.</param>
3827        /// <param name="key">Byte array containing the AES key.</param>
3828        /// <param name="iv">Byte array containing the initialization vector (IV).</param>
3829        public static int AesGcmInit(IntPtr aes, byte[] key, byte[] iv)
3830        {
3831            IntPtr keyPtr = IntPtr.Zero;
3832            IntPtr ivPtr = IntPtr.Zero;
3833            int ret;
3834
3835            try
3836            {
3837                /* Allocate memory for key and IV */
3838                keyPtr = Marshal.AllocHGlobal(key.Length);
3839                Marshal.Copy(key, 0, keyPtr, key.Length);
3840
3841                ivPtr = Marshal.AllocHGlobal(iv.Length);
3842                Marshal.Copy(iv, 0, ivPtr, iv.Length);
3843
3844                ret = wc_AesGcmInit(aes, keyPtr, (uint)key.Length, ivPtr, (uint)iv.Length);
3845                if (ret != 0)
3846                {
3847                    throw new Exception("AES-GCM initialization failed with error code ret = " + ret.ToString());
3848                }
3849            }
3850            finally
3851            {
3852                /* Cleanup */
3853                if (keyPtr != IntPtr.Zero) Marshal.FreeHGlobal(keyPtr);
3854                if (ivPtr != IntPtr.Zero) Marshal.FreeHGlobal(ivPtr);
3855            }
3856
3857            return ret;
3858        }
3859
3860        /// <summary>
3861        /// Encrypt data using AES-GCM
3862        /// </summary>
3863        /// <param name="aes">AES-GCM context pointer.</param>
3864        /// <param name="iv">Initialization Vector (IV)</param>
3865        /// <param name="plaintext">Data to encrypt</param>
3866        /// <param name="ciphertext">Buffer to receive the encrypted data</param>
3867        /// <param name="authTag">Buffer to receive the authentication tag</param>
3868        /// <returns>0 on success, otherwise an error code</returns>
3869        public static int AesGcmEncrypt(IntPtr aes, byte[] iv, byte[] plaintext,
3870            byte[] ciphertext, byte[] authTag, byte[] addAuth)
3871        {
3872            int ret;
3873            IntPtr ivPtr = IntPtr.Zero;
3874            IntPtr ciphertextPtr = IntPtr.Zero;
3875            IntPtr plaintextPtr = IntPtr.Zero;
3876            IntPtr authTagPtr = IntPtr.Zero;
3877            IntPtr addAuthPtr = IntPtr.Zero;
3878            uint addAuthSz = 0;
3879
3880            try
3881            {
3882                /* Allocate memory */
3883                ivPtr = Marshal.AllocHGlobal(iv.Length);
3884                ciphertextPtr = Marshal.AllocHGlobal(ciphertext.Length);
3885                plaintextPtr = Marshal.AllocHGlobal(plaintext.Length);
3886                authTagPtr = Marshal.AllocHGlobal(authTag.Length);
3887                if (addAuth != null) {
3888                    addAuthSz = (uint)addAuth.Length;
3889                    addAuthPtr = Marshal.AllocHGlobal(addAuth.Length);
3890                    Marshal.Copy(addAuth, 0, addAuthPtr, addAuth.Length);
3891                }
3892
3893                Marshal.Copy(iv, 0, ivPtr, iv.Length);
3894                Marshal.Copy(plaintext, 0, plaintextPtr, plaintext.Length);
3895
3896                /* Encrypt data */
3897                ret = wc_AesGcmEncrypt(aes, ciphertextPtr, plaintextPtr, (uint)plaintext.Length,
3898                    ivPtr, (uint)iv.Length, authTagPtr, (uint)authTag.Length, addAuthPtr, addAuthSz);
3899                if (ret < 0)
3900                {
3901                    log(ERROR_LOG, "Failed to Encrypt data using AES-GCM. Error code: " + ret);
3902                }
3903                else {
3904                    Marshal.Copy(ciphertextPtr, ciphertext, 0, ciphertext.Length);
3905                    Marshal.Copy(authTagPtr, authTag, 0, authTag.Length);
3906                    ret = 0;
3907                }
3908            }
3909            catch (Exception e)
3910            {
3911                log(ERROR_LOG, "AES-GCM Encryption failed: " + e.ToString());
3912                ret = EXCEPTION_E;
3913            }
3914            finally
3915            {
3916                /* Cleanup */
3917                if (ivPtr != IntPtr.Zero) Marshal.FreeHGlobal(ivPtr);
3918                if (ciphertextPtr != IntPtr.Zero) Marshal.FreeHGlobal(ciphertextPtr);
3919                if (plaintextPtr != IntPtr.Zero) Marshal.FreeHGlobal(plaintextPtr);
3920                if (authTagPtr != IntPtr.Zero) Marshal.FreeHGlobal(authTagPtr);
3921                if (addAuthPtr != IntPtr.Zero) Marshal.FreeHGlobal(addAuthPtr);
3922            }
3923
3924            return ret;
3925        }
3926        public static int AesGcmEncrypt(IntPtr aes, byte[] iv, byte[] plaintext,
3927            byte[] ciphertext, byte[] authTag)
3928        {
3929            return AesGcmEncrypt(aes, iv, plaintext, ciphertext, null);
3930        }
3931
3932        /// <summary>
3933        /// Decrypt data using AES-GCM
3934        /// </summary>
3935        /// <param name="aes">AES-GCM context pointer.</param>
3936        /// <param name="iv">Initialization Vector (IV)</param>
3937        /// <param name="ciphertext">Data to decrypt</param>
3938        /// <param name="plaintext">Buffer to receive the decrypted data</param>
3939        /// <param name="authTag">Authentication tag for verification</param>
3940        /// <returns>0 on success, otherwise an error code</returns>
3941        public static int AesGcmDecrypt(IntPtr aes, byte[] iv, byte[] ciphertext,
3942            byte[] plaintext, byte[] authTag, byte[] addAuth)
3943        {
3944            int ret;
3945            IntPtr ivPtr = IntPtr.Zero;
3946            IntPtr ciphertextPtr = IntPtr.Zero;
3947            IntPtr plaintextPtr = IntPtr.Zero;
3948            IntPtr authTagPtr = IntPtr.Zero;
3949            IntPtr addAuthPtr = IntPtr.Zero;
3950            uint addAuthSz = 0;
3951
3952            try
3953            {
3954                /* Allocate memory */
3955                ivPtr = Marshal.AllocHGlobal(iv.Length);
3956                ciphertextPtr = Marshal.AllocHGlobal(ciphertext.Length);
3957                plaintextPtr = Marshal.AllocHGlobal(plaintext.Length);
3958                authTagPtr = Marshal.AllocHGlobal(authTag.Length);
3959                if (addAuth != null) {
3960                    addAuthSz = (uint)addAuth.Length;
3961                    addAuthPtr = Marshal.AllocHGlobal(addAuth.Length);
3962                    Marshal.Copy(addAuth, 0, addAuthPtr, addAuth.Length);
3963                }
3964
3965                Marshal.Copy(iv, 0, ivPtr, iv.Length);
3966                Marshal.Copy(ciphertext, 0, ciphertextPtr, ciphertext.Length);
3967                Marshal.Copy(authTag, 0, authTagPtr, authTag.Length);
3968
3969                /* Decrypt data */
3970                ret = wc_AesGcmDecrypt(aes, plaintextPtr, ciphertextPtr, (uint)ciphertext.Length,
3971                    ivPtr, (uint)iv.Length, authTagPtr, (uint)authTag.Length, addAuthPtr, addAuthSz);
3972                if (ret < 0)
3973                {
3974                    log(ERROR_LOG, "Failed to Decrypt data using AES-GCM. Error code: " + ret);
3975                }
3976                else {
3977                    Marshal.Copy(plaintextPtr, plaintext, 0, plaintext.Length);
3978                    ret = 0;
3979                }
3980            }
3981            catch (Exception e)
3982            {
3983                log(ERROR_LOG, "AES-GCM Decryption failed: " + e.ToString());
3984                ret = EXCEPTION_E;
3985            }
3986            finally
3987            {
3988                /* Cleanup */
3989                if (ivPtr != IntPtr.Zero) Marshal.FreeHGlobal(ivPtr);
3990                if (ciphertextPtr != IntPtr.Zero) Marshal.FreeHGlobal(ciphertextPtr);
3991                if (plaintextPtr != IntPtr.Zero) Marshal.FreeHGlobal(plaintextPtr);
3992                if (authTagPtr != IntPtr.Zero) Marshal.FreeHGlobal(authTagPtr);
3993                if (addAuthPtr != IntPtr.Zero) Marshal.FreeHGlobal(addAuthPtr);
3994            }
3995
3996            return ret;
3997        }
3998        public static int AesGcmDecrypt(IntPtr aes, byte[] iv, byte[] ciphertext,
3999            byte[] plaintext, byte[] authTag)
4000        {
4001            return AesGcmDecrypt(aes, iv, ciphertext, plaintext, authTag, null);
4002        }
4003
4004        /// <summary>
4005        /// Free AES-GCM context
4006        /// </summary>
4007        /// <param name="aes">AES-GCM context</param>
4008        public static void AesGcmFree(IntPtr aes)
4009        {
4010            if (aes != IntPtr.Zero)
4011            {
4012                wc_AesDelete(aes, IntPtr.Zero);
4013                aes = IntPtr.Zero;
4014            }
4015        }
4016        /* END AES-GCM */
4017
4018
4019        /***********************************************************************
4020         * HASH
4021         **********************************************************************/
4022
4023        /// <summary>
4024        /// Allocate and set up a new hash context with proper error handling
4025        /// </summary>
4026        /// <param name="hashType">The type of hash (SHA-256, SHA-384, etc.)</param>
4027        /// <param name="heap">Pointer to the heap for memory allocation (use IntPtr.Zero if not applicable)</param>
4028        /// <param name="devId">Device ID (if applicable, otherwise use INVALID_DEVID)</param>
4029        /// <returns>Allocated hash context pointer or IntPtr.Zero on failure</returns>
4030        public static IntPtr HashNew(uint hashType, IntPtr heap, int devId)
4031        {
4032            IntPtr hash = IntPtr.Zero;
4033
4034            try
4035            {
4036                /* Allocate new hash */
4037                hash = wc_HashNew(hashType, heap, devId, IntPtr.Zero);
4038                if (hash == IntPtr.Zero)
4039                {
4040                    throw new Exception("Failed to allocate new hash context.");
4041                }
4042            }
4043            catch (Exception e)
4044            {
4045                log(ERROR_LOG, "HashNew Exception: " + e.ToString());
4046            }
4047
4048            return hash;
4049        }
4050
4051        /// <summary>
4052        /// Initialize the hash context for a specific hash type with proper error handling
4053        /// </summary>
4054        /// <param name="hash">Hash context pointer</param>
4055        /// <param name="hashType">The type of hash (SHA-256, SHA-384, etc.)</param>
4056        /// <returns>0 on success, otherwise an error code</returns>
4057        public static int InitHash(IntPtr hash, uint hashType)
4058        {
4059            int ret = 0;
4060
4061            try
4062            {
4063                /* Check hash */
4064                if (hash == IntPtr.Zero)
4065                    throw new Exception("Hash context is null.");
4066
4067                ret = wc_HashInit(hash, hashType);
4068                if (ret != 0)
4069                {
4070                    throw new Exception("Failed to initialize hash context. Error code: ret = " + ret.ToString());
4071                }
4072            }
4073            catch (Exception e)
4074            {
4075                /* Cleanup */
4076                log(ERROR_LOG, "InitHash Exception: " + e.ToString());
4077                if (hash != IntPtr.Zero) {
4078                    wc_HashDelete(hash, IntPtr.Zero);
4079                    hash = IntPtr.Zero;
4080                }
4081            }
4082
4083            return ret;
4084        }
4085
4086        /// <summary>
4087        /// Update the hash with data
4088        /// </summary>
4089        /// <param name="hash">Hash context pointer</param>
4090        /// <param name="hashType">The type of hash</param>
4091        /// <param name="data">Byte array of the data to hash</param>
4092        /// <returns>0 on success, otherwise an error code</returns>
4093        public static int HashUpdate(IntPtr hash, uint hashType, byte[] data)
4094        {
4095            int ret = 0;
4096            IntPtr dataPtr = IntPtr.Zero;
4097
4098            try
4099            {
4100                /* Check parameters */
4101                if (hash == IntPtr.Zero)
4102                    throw new Exception("Hash context is null.");
4103                if (data == null || data.Length == 0)
4104                    throw new Exception("Invalid data array.");
4105
4106                /* Allocate memory */
4107                dataPtr = Marshal.AllocHGlobal(data.Length);
4108                Marshal.Copy(data, 0, dataPtr, data.Length);
4109
4110                /* Update hash */
4111                ret = wc_HashUpdate(hash, hashType, dataPtr, (uint)data.Length);
4112                if (ret != 0)
4113                {
4114                    throw new Exception("Failed to update hash. Error code: ret = " + ret.ToString());
4115                }
4116            }
4117            catch (Exception e)
4118            {
4119                log(ERROR_LOG, "HashUpdate Exception: " + e.ToString());
4120            }
4121            finally
4122            {
4123                /* Cleanup */
4124                if (dataPtr != IntPtr.Zero) Marshal.FreeHGlobal(dataPtr);
4125            }
4126
4127            return ret;
4128        }
4129
4130        /// <summary>
4131        /// Finalize the hash and output the result
4132        /// </summary>
4133        /// <param name="hash">Hash context pointer</param>
4134        /// <param name="hashType">The type of hash</param>
4135        /// <param name="output">Byte array where the hash output will be stored</param>
4136        /// <returns>0 on success, otherwise an error code</returns>
4137        public static int HashFinal(IntPtr hash, uint hashType, out byte[] output)
4138        {
4139            int ret = 0;
4140            IntPtr outputPtr = IntPtr.Zero;
4141
4142            try
4143            {
4144                /* Get hash size and initialize */
4145                int hashSize = wc_HashGetDigestSize(hashType);
4146                output = new byte[hashSize];
4147
4148                /* Check hash */
4149                if (hash == IntPtr.Zero)
4150                    throw new Exception("Hash context is null.");
4151                if (hashSize <= 0)
4152                    throw new Exception("Invalid hash size.");
4153
4154                /* Allocate memory */
4155                outputPtr = Marshal.AllocHGlobal(hashSize);
4156
4157                ret = wc_HashFinal(hash, hashType, outputPtr);
4158                if (ret != 0)
4159                {
4160                    throw new Exception("Failed to finalize hash. Error code: ret = " + ret.ToString());
4161                }
4162
4163                Marshal.Copy(outputPtr, output, 0, hashSize);
4164            }
4165            catch (Exception e)
4166            {
4167                log(ERROR_LOG, "HashFinal Exception: " + e.ToString());
4168                output = null;
4169            }
4170            finally
4171            {
4172                /* Cleanup */
4173                if (outputPtr != IntPtr.Zero) Marshal.FreeHGlobal(outputPtr);
4174            }
4175
4176            return ret;
4177        }
4178
4179        /// <summary>
4180        /// Free the allocated hash context with proper error handling
4181        /// </summary>
4182        /// <param name="hash">Hash context pointer to be freed</param>
4183        /// <param name="hashType">The type of hash</param>
4184        /// <returns>0 on success, otherwise an error code</returns>
4185        public static int HashFree(IntPtr hash, uint hashType)
4186        {
4187            int ret = 0;
4188
4189            try
4190            {
4191                /* Check hash */
4192                if (hash == IntPtr.Zero)
4193                    throw new Exception("Hash context is null, cannot free.");
4194
4195                /* Free hash */
4196                ret = wc_HashDelete(hash, IntPtr.Zero);
4197                hash = IntPtr.Zero;
4198                if (ret != 0)
4199                {
4200                    throw new Exception("Failed to free hash context. Error code: ret = " + ret.ToString());
4201                }
4202            }
4203            catch (Exception e)
4204            {
4205                log(ERROR_LOG, "HashFree Exception: " + e.ToString());
4206            }
4207
4208            return ret;
4209        }
4210
4211        /// <summary>
4212        /// Hash type enum values
4213        /// </summary>
4214        public enum hashType
4215        {
4216            WC_HASH_TYPE_NONE     = 0,
4217            WC_HASH_TYPE_MD2      = 1,
4218            WC_HASH_TYPE_MD4      = 2,
4219            WC_HASH_TYPE_MD5      = 3,
4220            WC_HASH_TYPE_SHA      = 4, /* SHA-1 (not old SHA-0) */
4221            WC_HASH_TYPE_SHA224   = 5,
4222            WC_HASH_TYPE_SHA256   = 6,
4223            WC_HASH_TYPE_SHA384   = 7,
4224            WC_HASH_TYPE_SHA512   = 8,
4225            WC_HASH_TYPE_MD5_SHA  = 9,
4226            WC_HASH_TYPE_SHA3_224 = 10,
4227            WC_HASH_TYPE_SHA3_256 = 11,
4228            WC_HASH_TYPE_SHA3_384 = 12,
4229            WC_HASH_TYPE_SHA3_512 = 13,
4230            WC_HASH_TYPE_BLAKE2B  = 14,
4231            WC_HASH_TYPE_BLAKE2S  = 15,
4232        }
4233        /* END HASH */
4234
4235
4236        /***********************************************************************
4237         * HPKE (RFC 9180) - Base mode SingleShot
4238         * Requires: HAVE_HPKE, HAVE_ECC (or HAVE_CURVE25519), HAVE_AESGCM
4239         **********************************************************************/
4240
4241        /* BEGIN HPKE */
4242
4243        /* HPKE KEM IDs */
4244        public enum HpkeKem : ushort {
4245            DHKEM_P256_HKDF_SHA256  = 0x0010,
4246            DHKEM_P384_HKDF_SHA384  = 0x0011,
4247            DHKEM_P521_HKDF_SHA512  = 0x0012,
4248            DHKEM_X25519_HKDF_SHA256 = 0x0020,
4249            DHKEM_X448_HKDF_SHA512  = 0x0021,
4250        }
4251        /* HPKE KDF IDs */
4252        public enum HpkeKdf : ushort {
4253            HKDF_SHA256 = 0x0001,
4254            HKDF_SHA384 = 0x0002,
4255            HKDF_SHA512 = 0x0003,
4256        }
4257        /* HPKE AEAD IDs */
4258        public enum HpkeAead : ushort {
4259            AES_128_GCM = 0x0001,
4260            AES_256_GCM = 0x0002,
4261        }
4262
4263        /* HPKE Nt (GCM tag length) */
4264        private const int HPKE_Nt = 16;
4265
4266        /* HPKE max encoded public-key length (matches HPKE_Npk_MAX in hpke.h) */
4267        private const int HPKE_Npk_MAX = 133;
4268
4269        /* Hpke struct is ~80 bytes on 64-bit (see hpke.h). Allocate 512 bytes
4270         * (6x headroom) to accommodate platform alignment and future growth.
4271         * If the native struct ever exceeds this, wc_HpkeInit will write OOB —
4272         * keep in sync with hpke.h if the struct grows significantly. */
4273        private const int HPKE_STRUCT_SZ = 512;
4274
4275        /* Per-Hpke-context state owned by the C# wrapper.
4276         * The RNG must outlive any keypair created with this context: when
4277         * wolfSSL is built with WOLFSSL_CURVE25519_BLINDING, wc_curve25519_make_key
4278         * stores the rng pointer inside the keypair (via wc_curve25519_set_rng)
4279         * and reuses it for blinding during shared-secret operations. If the
4280         * wrapper freed the rng after key generation, that pointer would dangle
4281         * and the next seal/open would fail with RNG_FAILURE_E (-199). */
4282        private struct HpkeContextState
4283        {
4284            public IntPtr rng;
4285            public HpkeKem kem;
4286        }
4287
4288#if WindowsCE
4289        /* .NET Compact Framework / Windows CE does not provide
4290         * System.Collections.Concurrent, so fall back to a plain Dictionary
4291         * guarded by an explicit lock. */
4292        private static readonly Dictionary<IntPtr, HpkeContextState> hpkeContexts =
4293            new Dictionary<IntPtr, HpkeContextState>();
4294        private static readonly object hpkeContextsLock = new object();
4295
4296        private static void HpkeContextStore(IntPtr hpke, HpkeContextState state)
4297        {
4298            lock (hpkeContextsLock) { hpkeContexts[hpke] = state; }
4299        }
4300        private static bool HpkeContextTryGet(IntPtr hpke, out HpkeContextState state)
4301        {
4302            lock (hpkeContextsLock) { return hpkeContexts.TryGetValue(hpke, out state); }
4303        }
4304        private static bool HpkeContextTryRemove(IntPtr hpke, out HpkeContextState state)
4305        {
4306            lock (hpkeContextsLock)
4307            {
4308                if (hpkeContexts.TryGetValue(hpke, out state))
4309                {
4310                    hpkeContexts.Remove(hpke);
4311                    return true;
4312                }
4313                return false;
4314            }
4315        }
4316#else
4317        private static readonly ConcurrentDictionary<IntPtr, HpkeContextState> hpkeContexts =
4318            new ConcurrentDictionary<IntPtr, HpkeContextState>();
4319
4320        private static void HpkeContextStore(IntPtr hpke, HpkeContextState state)
4321        {
4322            hpkeContexts[hpke] = state;
4323        }
4324        private static bool HpkeContextTryGet(IntPtr hpke, out HpkeContextState state)
4325        {
4326            return hpkeContexts.TryGetValue(hpke, out state);
4327        }
4328        private static bool HpkeContextTryRemove(IntPtr hpke, out HpkeContextState state)
4329        {
4330            return hpkeContexts.TryRemove(hpke, out state);
4331        }
4332#endif
4333
4334        /// <summary>
4335        /// Get the enc (encapsulated key) length for a given KEM
4336        /// </summary>
4337        /// <param name="kem">KEM identifier</param>
4338        /// <returns>Length in bytes</returns>
4339        private static ushort HpkeEncLen(HpkeKem kem)
4340        {
4341            /* Values must match DHKEM_*_ENC_LEN macros in wolfssl/wolfcrypt/hpke.h.
4342             * Not P/Invoked because wc_HpkeKemGetEncLen is currently WOLFSSL_LOCAL. */
4343            switch (kem)
4344            {
4345                case HpkeKem.DHKEM_P256_HKDF_SHA256:   return 65;  /* DHKEM_P256_ENC_LEN */
4346                case HpkeKem.DHKEM_P384_HKDF_SHA384:   return 97;  /* DHKEM_P384_ENC_LEN */
4347                case HpkeKem.DHKEM_P521_HKDF_SHA512:   return 133; /* DHKEM_P521_ENC_LEN */
4348                case HpkeKem.DHKEM_X25519_HKDF_SHA256: return 32;  /* DHKEM_X25519_ENC_LEN */
4349                case HpkeKem.DHKEM_X448_HKDF_SHA512:   return 56;  /* DHKEM_X448_ENC_LEN */
4350                default: return 0;
4351            }
4352        }
4353
4354        /// <summary>
4355        /// Allocate and initialize an HPKE context
4356        /// </summary>
4357        /// <param name="kem">KEM algorithm identifier</param>
4358        /// <param name="kdf">KDF algorithm identifier</param>
4359        /// <param name="aead">AEAD algorithm identifier</param>
4360        /// <returns>Pointer to allocated Hpke context or IntPtr.Zero on failure</returns>
4361        public static IntPtr HpkeInit(HpkeKem kem, HpkeKdf kdf, HpkeAead aead)
4362        {
4363            IntPtr hpke = IntPtr.Zero;
4364            IntPtr rng = IntPtr.Zero;
4365
4366            try
4367            {
4368                hpke = Marshal.AllocHGlobal(HPKE_STRUCT_SZ);
4369                if (hpke == IntPtr.Zero)
4370                {
4371                    log(ERROR_LOG, "HPKE alloc failed");
4372                    return IntPtr.Zero;
4373                }
4374
4375                /* Zero the memory */
4376                Marshal.Copy(new byte[HPKE_STRUCT_SZ], 0, hpke, HPKE_STRUCT_SZ);
4377
4378                int ret = wc_HpkeInit(hpke, (int)kem, (int)kdf, (int)aead, IntPtr.Zero);
4379                if (ret != 0)
4380                {
4381                    log(ERROR_LOG, "HPKE init failed " + ret + ": " + GetError(ret));
4382                    Marshal.FreeHGlobal(hpke);
4383                    return IntPtr.Zero;
4384                }
4385
4386                /* Allocate a persistent RNG that lives as long as this context.
4387                 * Required so curve25519 keypairs (with blinding) retain a valid
4388                 * rng pointer for shared-secret operations. */
4389                rng = RandomNew();
4390                if (rng == IntPtr.Zero)
4391                {
4392                    log(ERROR_LOG, "HPKE init: RNG allocation failed");
4393                    Marshal.FreeHGlobal(hpke);
4394                    return IntPtr.Zero;
4395                }
4396
4397                HpkeContextStore(hpke, new HpkeContextState { rng = rng, kem = kem });
4398            }
4399            catch (Exception e)
4400            {
4401                log(ERROR_LOG, "HPKE init exception " + e.ToString());
4402                if (rng != IntPtr.Zero)
4403                {
4404                    RandomFree(rng);
4405                }
4406                if (hpke != IntPtr.Zero)
4407                {
4408                    Marshal.FreeHGlobal(hpke);
4409                }
4410                return IntPtr.Zero;
4411            }
4412
4413            return hpke;
4414        }
4415
4416        /// <summary>
4417        /// Generate a new HPKE keypair
4418        /// </summary>
4419        /// <param name="hpke">HPKE context from HpkeInit()</param>
4420        /// <returns>Pointer to keypair or IntPtr.Zero on failure</returns>
4421        public static IntPtr HpkeGenerateKeyPair(IntPtr hpke)
4422        {
4423            IntPtr keypair = IntPtr.Zero;
4424
4425            try
4426            {
4427                if (hpke == IntPtr.Zero)
4428                {
4429                    log(ERROR_LOG, "HPKE generate keypair: invalid context");
4430                    return IntPtr.Zero;
4431                }
4432
4433                HpkeContextState state;
4434                if (!HpkeContextTryGet(hpke, out state) || state.rng == IntPtr.Zero)
4435                {
4436                    log(ERROR_LOG, "HPKE generate keypair: no RNG associated with context");
4437                    return IntPtr.Zero;
4438                }
4439
4440                int ret = wc_HpkeGenerateKeyPair(hpke, ref keypair, state.rng);
4441                if (ret != 0)
4442                {
4443                    log(ERROR_LOG, "HPKE generate keypair failed " + ret + ": " + GetError(ret));
4444                    return IntPtr.Zero;
4445                }
4446
4447                /* For X25519, explicitly bind the persistent rng to the keypair.
4448                 * wc_curve25519_make_key already does this internally when wolfSSL
4449                 * is built with WOLFSSL_CURVE25519_BLINDING, but the explicit call
4450                 * here documents the lifetime requirement and is defensive against
4451                 * future changes. The function only exists when blinding is built
4452                 * in, so swallow EntryPointNotFoundException for builds without it. */
4453                if (state.kem == HpkeKem.DHKEM_X25519_HKDF_SHA256 && keypair != IntPtr.Zero)
4454                {
4455                    try
4456                    {
4457                        wc_curve25519_set_rng(keypair, state.rng);
4458                    }
4459                    catch (EntryPointNotFoundException)
4460                    {
4461                        /* wolfSSL built without WOLFSSL_CURVE25519_BLINDING; nothing to do */
4462                    }
4463                }
4464            }
4465            catch (Exception e)
4466            {
4467                log(ERROR_LOG, "HPKE generate keypair exception " + e.ToString());
4468                keypair = IntPtr.Zero;
4469            }
4470
4471            return keypair;
4472        }
4473
4474        /// <summary>
4475        /// Serialize the public key to bytes
4476        /// </summary>
4477        /// <param name="hpke">HPKE context from HpkeInit()</param>
4478        /// <param name="keypair">Keypair from HpkeGenerateKeyPair()</param>
4479        /// <returns>Serialized public key bytes or null on failure</returns>
4480        public static byte[] HpkeSerializePublicKey(IntPtr hpke, IntPtr keypair)
4481        {
4482            try
4483            {
4484                if (hpke == IntPtr.Zero || keypair == IntPtr.Zero)
4485                {
4486                    log(ERROR_LOG, "HPKE serialize public key: invalid parameter");
4487                    return null;
4488                }
4489
4490                ushort outSz = (ushort)HPKE_Npk_MAX;
4491                byte[] outBuf = new byte[outSz];
4492
4493                int ret = wc_HpkeSerializePublicKey(hpke, keypair, outBuf, ref outSz);
4494                if (ret != 0)
4495                {
4496                    log(ERROR_LOG, "HPKE serialize public key failed " + ret + ": " + GetError(ret));
4497                    return null;
4498                }
4499
4500                /* Trim to actual size */
4501                byte[] result = new byte[outSz];
4502                Array.Copy(outBuf, 0, result, 0, outSz);
4503                return result;
4504            }
4505            catch (Exception e)
4506            {
4507                log(ERROR_LOG, "HPKE serialize public key exception " + e.ToString());
4508                return null;
4509            }
4510        }
4511
4512        /// <summary>
4513        /// Deserialize a public key from bytes
4514        /// </summary>
4515        /// <param name="hpke">HPKE context from HpkeInit()</param>
4516        /// <param name="pubKeyBytes">Serialized public key bytes</param>
4517        /// <returns>Pointer to keypair or IntPtr.Zero on failure</returns>
4518        public static IntPtr HpkeDeserializePublicKey(IntPtr hpke, byte[] pubKeyBytes)
4519        {
4520            IntPtr key = IntPtr.Zero;
4521
4522            try
4523            {
4524                if (hpke == IntPtr.Zero || pubKeyBytes == null || pubKeyBytes.Length == 0)
4525                {
4526                    log(ERROR_LOG, "HPKE deserialize public key: invalid parameter");
4527                    return IntPtr.Zero;
4528                }
4529
4530                int ret = wc_HpkeDeserializePublicKey(hpke, ref key, pubKeyBytes, (ushort)pubKeyBytes.Length);
4531                if (ret != 0)
4532                {
4533                    log(ERROR_LOG, "HPKE deserialize public key failed " + ret + ": " + GetError(ret));
4534                    return IntPtr.Zero;
4535                }
4536            }
4537            catch (Exception e)
4538            {
4539                log(ERROR_LOG, "HPKE deserialize public key exception " + e.ToString());
4540                return IntPtr.Zero;
4541            }
4542
4543            return key;
4544        }
4545
4546        /// <summary>
4547        /// Free a keypair created by HpkeGenerateKeyPair or HpkeDeserializePublicKey
4548        /// </summary>
4549        /// <param name="hpke">HPKE context from HpkeInit()</param>
4550        /// <param name="keypair">Keypair to free</param>
4551        /// <param name="kem">KEM used when the keypair was created</param>
4552        public static void HpkeFreeKey(IntPtr hpke, IntPtr keypair, HpkeKem kem)
4553        {
4554            if (hpke != IntPtr.Zero && keypair != IntPtr.Zero)
4555            {
4556                wc_HpkeFreeKey(hpke, (ushort)kem, keypair, IntPtr.Zero);
4557            }
4558        }
4559
4560        /// <summary>
4561        /// Free an HPKE context allocated by HpkeInit
4562        /// </summary>
4563        /// <param name="hpke">HPKE context to free</param>
4564        public static void HpkeFree(IntPtr hpke)
4565        {
4566            if (hpke != IntPtr.Zero)
4567            {
4568                HpkeContextState state;
4569                if (HpkeContextTryRemove(hpke, out state) && state.rng != IntPtr.Zero)
4570                {
4571                    RandomFree(state.rng);
4572                }
4573                Marshal.FreeHGlobal(hpke);
4574            }
4575        }
4576
4577        /// <summary>
4578        /// SingleShot seal (encrypt) using HPKE Base mode.
4579        /// Returns enc||ciphertext as a single byte array.
4580        /// The enc length is determined by the KEM (e.g. 65 bytes for P-256).
4581        /// Ciphertext length = plaintext length + Nt (16-byte GCM tag).
4582        /// </summary>
4583        /// <param name="hpke">HPKE context from HpkeInit()</param>
4584        /// <param name="ephemeralKey">Ephemeral keypair for sender</param>
4585        /// <param name="receiverKey">Receiver public key</param>
4586        /// <param name="info">Info context bytes (can be null)</param>
4587        /// <param name="aad">Additional authenticated data (can be null)</param>
4588        /// <param name="plaintext">Plaintext to encrypt</param>
4589        /// <returns>enc||ciphertext byte array or null on failure</returns>
4590        public static byte[] HpkeSealBase(IntPtr hpke, IntPtr ephemeralKey, IntPtr receiverKey,
4591            byte[] info, byte[] aad, byte[] plaintext)
4592        {
4593            try
4594            {
4595                if (hpke == IntPtr.Zero || ephemeralKey == IntPtr.Zero || receiverKey == IntPtr.Zero)
4596                {
4597                    log(ERROR_LOG, "HPKE seal base: invalid parameter");
4598                    return null;
4599                }
4600                /* Native wc_HpkeSealBase only requires plaintext to be non-NULL;
4601                 * ptSz == 0 is valid (output is just the AEAD tag). */
4602                if (plaintext == null)
4603                {
4604                    log(ERROR_LOG, "HPKE seal base: invalid plaintext");
4605                    return null;
4606                }
4607
4608                /* Serialize the ephemeral public key (enc) */
4609                byte[] enc = HpkeSerializePublicKey(hpke, ephemeralKey);
4610                if (enc == null)
4611                {
4612                    log(ERROR_LOG, "HPKE seal base: failed to serialize ephemeral key");
4613                    return null;
4614                }
4615
4616                uint infoSz = (info != null) ? (uint)info.Length : 0;
4617                uint aadSz = (aad != null) ? (uint)aad.Length : 0;
4618                uint ptSz = (uint)plaintext.Length;
4619
4620                /* wc_HpkeSealBase outputs ptSz + Nt (GCM tag) bytes */
4621                int sealLen = (int)ptSz + HPKE_Nt;
4622                byte[] sealOut = new byte[sealLen];
4623
4624                int ret = wc_HpkeSealBase(hpke, ephemeralKey, receiverKey,
4625                    info, infoSz, aad, aadSz, plaintext, ptSz, sealOut);
4626                if (ret != 0)
4627                {
4628                    log(ERROR_LOG, "HPKE seal base failed " + ret + ": " + GetError(ret));
4629                    return null;
4630                }
4631
4632                /* Return enc || sealOut */
4633                byte[] result = new byte[enc.Length + sealLen];
4634                Array.Copy(enc, 0, result, 0, enc.Length);
4635                Array.Copy(sealOut, 0, result, enc.Length, sealLen);
4636                return result;
4637            }
4638            catch (Exception e)
4639            {
4640                log(ERROR_LOG, "HPKE seal base exception " + e.ToString());
4641                return null;
4642            }
4643        }
4644
4645        /// <summary>
4646        /// Convenience SingleShot seal (encrypt) using HPKE Base mode.
4647        /// Generates an ephemeral keypair internally so the caller does not
4648        /// need to manage one.
4649        /// Returns enc||ciphertext as a single byte array.
4650        /// </summary>
4651        /// <param name="hpke">HPKE context from HpkeInit()</param>
4652        /// <param name="receiverKey">Receiver public key</param>
4653        /// <param name="info">Info context bytes (can be null)</param>
4654        /// <param name="aad">Additional authenticated data (can be null)</param>
4655        /// <param name="plaintext">Plaintext to encrypt</param>
4656        /// <param name="kem">KEM used (needed to free the ephemeral key)</param>
4657        /// <returns>enc||ciphertext byte array or null on failure</returns>
4658        public static byte[] HpkeSealBase(IntPtr hpke, IntPtr receiverKey,
4659            byte[] info, byte[] aad, byte[] plaintext, HpkeKem kem)
4660        {
4661            IntPtr ephemeralKey = IntPtr.Zero;
4662
4663            try
4664            {
4665                ephemeralKey = HpkeGenerateKeyPair(hpke);
4666                if (ephemeralKey == IntPtr.Zero)
4667                {
4668                    log(ERROR_LOG, "HPKE seal base: ephemeral keygen failed");
4669                    return null;
4670                }
4671
4672                return HpkeSealBase(hpke, ephemeralKey, receiverKey,
4673                    info, aad, plaintext);
4674            }
4675            catch (Exception e)
4676            {
4677                log(ERROR_LOG, "HPKE seal base exception " + e.ToString());
4678                return null;
4679            }
4680            finally
4681            {
4682                if (ephemeralKey != IntPtr.Zero)
4683                    HpkeFreeKey(hpke, ephemeralKey, kem);
4684            }
4685        }
4686
4687        /// <summary>
4688        /// SingleShot open (decrypt) using HPKE Base mode.
4689        /// Takes the full enc||ciphertext blob returned by HpkeSealBase.
4690        /// </summary>
4691        /// <param name="hpke">HPKE context from HpkeInit()</param>
4692        /// <param name="receiverKey">Receiver private keypair</param>
4693        /// <param name="encCiphertext">enc||ciphertext blob from HpkeSealBase()</param>
4694        /// <param name="info">Info context bytes (can be null)</param>
4695        /// <param name="aad">Additional authenticated data (can be null)</param>
4696        /// <param name="ptLen">Expected plaintext length</param>
4697        /// <returns>Decrypted plaintext byte array or null on failure</returns>
4698        public static byte[] HpkeOpenBase(IntPtr hpke, IntPtr receiverKey,
4699            byte[] encCiphertext, byte[] info, byte[] aad, int ptLen)
4700        {
4701            try
4702            {
4703                if (hpke == IntPtr.Zero || receiverKey == IntPtr.Zero)
4704                {
4705                    log(ERROR_LOG, "HPKE open base: invalid parameter");
4706                    return null;
4707                }
4708                if (encCiphertext == null || encCiphertext.Length == 0)
4709                {
4710                    log(ERROR_LOG, "HPKE open base: invalid ciphertext");
4711                    return null;
4712                }
4713
4714                /* encCiphertext = enc || ciphertext || GCM tag
4715                 * where ciphertext is ptLen bytes, tag is Nt bytes */
4716                if (ptLen < 0 || ptLen > int.MaxValue - HPKE_Nt)
4717                {
4718                    log(ERROR_LOG, "HPKE open base: invalid ptLen");
4719                    return null;
4720                }
4721
4722                int sealLen = ptLen + HPKE_Nt;
4723                if (encCiphertext.Length < sealLen)
4724                {
4725                    log(ERROR_LOG, "HPKE open base: encCiphertext too short for given ptLen");
4726                    return null;
4727                }
4728
4729                int pubKeySzInt = encCiphertext.Length - sealLen;
4730                if (pubKeySzInt < 0 || pubKeySzInt > ushort.MaxValue)
4731                {
4732                    log(ERROR_LOG, "HPKE open base: invalid encapsulated public key size");
4733                    return null;
4734                }
4735                ushort pubKeySz = (ushort)pubKeySzInt;
4736
4737                /* Split enc and sealed data (ciphertext || tag) */
4738                byte[] pubKey = new byte[pubKeySz];
4739                byte[] ct = new byte[sealLen];
4740                Array.Copy(encCiphertext, 0, pubKey, 0, pubKeySz);
4741                Array.Copy(encCiphertext, pubKeySz, ct, 0, sealLen);
4742
4743                uint infoSz = (info != null) ? (uint)info.Length : 0;
4744                uint aadSz = (aad != null) ? (uint)aad.Length : 0;
4745
4746                byte[] plaintext = new byte[ptLen];
4747
4748                /* ctSz is just the ciphertext length (without tag);
4749                 * wc_HpkeOpenBase reads the tag from ct + ctSz */
4750                int ret = wc_HpkeOpenBase(hpke, receiverKey, pubKey, pubKeySz,
4751                    info, infoSz, aad, aadSz, ct, (uint)ptLen, plaintext);
4752                if (ret != 0)
4753                {
4754                    log(ERROR_LOG, "HPKE open base failed " + ret + ": " + GetError(ret));
4755                    return null;
4756                }
4757
4758                return plaintext;
4759            }
4760            catch (Exception e)
4761            {
4762                log(ERROR_LOG, "HPKE open base exception " + e.ToString());
4763                return null;
4764            }
4765        }
4766
4767        /// <summary>
4768        /// Convenience SingleShot open (decrypt) using HPKE Base mode.
4769        /// Derives the plaintext length from the KEM enc length, so the caller
4770        /// does not need to know ptLen.
4771        /// </summary>
4772        /// <param name="hpke">HPKE context from HpkeInit()</param>
4773        /// <param name="receiverKey">Receiver private keypair</param>
4774        /// <param name="encCiphertext">enc||ciphertext blob from HpkeSealBase()</param>
4775        /// <param name="info">Info context bytes (can be null)</param>
4776        /// <param name="aad">Additional authenticated data (can be null)</param>
4777        /// <param name="kem">KEM used (to derive enc length)</param>
4778        /// <returns>Decrypted plaintext byte array or null on failure</returns>
4779        public static byte[] HpkeOpenBase(IntPtr hpke, IntPtr receiverKey,
4780            byte[] encCiphertext, byte[] info, byte[] aad, HpkeKem kem)
4781        {
4782            ushort encLen = HpkeEncLen(kem);
4783            if (encLen == 0)
4784            {
4785                log(ERROR_LOG, "HPKE open base: unsupported KEM");
4786                return null;
4787            }
4788            if (encCiphertext == null || encCiphertext.Length < encLen + HPKE_Nt)
4789            {
4790                log(ERROR_LOG, "HPKE open base: encCiphertext too short");
4791                return null;
4792            }
4793            int ptLen = encCiphertext.Length - encLen - HPKE_Nt;
4794            return HpkeOpenBase(hpke, receiverKey, encCiphertext, info, aad, ptLen);
4795        }
4796        /* END HPKE */
4797
4798
4799        /***********************************************************************
4800        * Logging / Other
4801        **********************************************************************/
4802
4803        /// <summary>
4804        /// Set the function to use for logging
4805        /// </summary>
4806        /// <param name="input">Function that conforms as to loggingCb</param>
4807        /// <returns>0 on success</returns>
4808        public static int SetLogging(loggingCb input)
4809        {
4810            internal_log = input;
4811            return SUCCESS;
4812        }
4813
4814        /// <summary>
4815        /// Get error string for wolfCrypt error codes
4816        /// </summary>
4817        /// <param name="error">Negative error number from wolfCrypt API</param>
4818        /// <returns>Error string</returns>
4819        public static string GetError(int error)
4820        {
4821            try
4822            {
4823                IntPtr errStr = wc_GetErrorString(error);
4824                return wolfssl.PtrToStringAnsi(errStr);
4825            }
4826            catch (Exception e)
4827            {
4828                log(ERROR_LOG, "Get error exception " + e.ToString());
4829                return string.Empty;
4830            }
4831        }
4832
4833        /// <summary>
4834        /// Compares two byte arrays.
4835        /// </summary>
4836        /// <param name="array1">The first byte array to compare.</param>
4837        /// <param name="array2">The second byte array to compare.</param>
4838        /// <returns>True if both arrays are equal; otherwise, false.</returns>
4839        public static bool ByteArrayVerify(byte[] array1, byte[] array2)
4840        {
4841            if (ReferenceEquals(array1, array2)) return true;
4842            if (array1 == null || array2 == null) return false;
4843            if (array1.Length != array2.Length) return false;
4844
4845            for (int i = 0; i < array1.Length; i++)
4846            {
4847                if (array1[i] != array2[i]) return false;
4848            }
4849            return true;
4850        }
4851    }
4852}
4853
4854