luna - wolfssl/wrapper/CSharp/wolfSSL

   1/* wolfSSL.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
  22
  23using System;
  24using System.Runtime.InteropServices;
  25using System.Text;
  26using System.Threading;
  27using System.IO;
  28using System.Net;
  29using System.Net.Sockets;
  30
  31namespace wolfSSL.CSharp
  32{
  33    public class wolfssl
  34    {
  35        private const string wolfssl_dll = "wolfssl.dll";
  36
  37        /* wait for 6 seconds default on TCP socket state poll if timeout not set */
  38        private const int WC_WAIT = 6000000;
  39
  40        /********************************
  41         * Utility String Conversion functions
  42         */
  43#if WindowsCE
  44        /// <summary>
  45        /// Convert MBCS (8-bit single/multi byte) to Wide Char/Unicode (16-bit) character set
  46        /// </summary>
  47        public static string MultiByteToWideChar(string msg)
  48        {
  49            if (msg == null)
  50                return null;
  51            /* Convert to Byte Array */
  52            byte[] bytes = Encoding.Unicode.GetBytes((string)msg.ToString());
  53            /* Convert to String */
  54            string ret = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
  55            /* Remove possible extra null terminator */
  56            int len = 0;
  57            while (len < ret.Length && ret[len] != 0) len++;
  58            return ret.Substring(0, len);
  59        }
  60
  61        /// <summary>
  62        /// Convert Unicode/Wide Char (16-bit) to MBCS (8-bit single/multi byte) character set
  63        /// </summary>
  64        public static string WideCharToMultiByte(string msg)
  65        {
  66            if (msg == null)
  67                return null;
  68            /* Get length and round up to even for multibyte / unicode */
  69            int msgLen = msg.Length;
  70            msgLen = ((msgLen + 1) & ~1);
  71            byte[] bytes = new byte[msgLen];
  72            /* Convert to Byte Array */
  73            byte[] msgBytes = Encoding.ASCII.GetBytes((string)msg.ToString());
  74            msgBytes.CopyTo(bytes, 0);
  75            /* Convert to String */
  76            return Encoding.Unicode.GetString(bytes, 0, bytes.Length);
  77        }
  78
  79        /// <summary>
  80        /// WinCE version of Marshal for Multi-byte pointer to ASCII string
  81        /// Similar conversion used in MultiByteToWideChar, but input is IntPtr
  82        /// </summary>
  83        public static string PtrToStringAnsi(IntPtr ptr)
  84        {
  85            if (ptr == IntPtr.Zero)
  86                return null;
  87
  88            /* Estimate string length */
  89            int len = 0;
  90            while (Marshal.ReadByte(ptr, len) != 0) len++;
  91
  92            if (len == 0)
  93                return string.Empty;
  94
  95            byte[] buffer = new byte[len];
  96            Marshal.Copy(ptr, buffer, 0, len);
  97
  98            return Encoding.ASCII.GetString(buffer, 0, len);
  99        }
 100#else
 101        public static string PtrToStringAnsi(IntPtr ptr)
 102        {
 103            return Marshal.PtrToStringAnsi(ptr);
 104        }
 105#endif
 106
 107
 108        /********************************
 109         * Class for DTLS connections
 110         */
 111        /// <summary>
 112        /// Contains information regarding a DTLS connection having UdpClient udp and IPEndPoint ep.
 113        /// Used to keep memory alive.
 114        /// </summary>
 115        public class DTLS_con
 116        {
 117            public UdpClient udp;
 118            public IPEndPoint ep;
 119        }
 120
 121
 122        /********************************
 123         * Class for keeping ctx handles alive
 124         */
 125        [StructLayout(LayoutKind.Sequential)]
 126        private class ctx_handle
 127        {
 128            private GCHandle rec_cb;
 129            private GCHandle snd_cb;
 130            private GCHandle psk_cb;
 131            private GCHandle sni_cb;
 132            private GCHandle sni_arg;
 133            private GCHandle vrf_cb;
 134            private IntPtr ctx;
 135
 136            public void set_receive(GCHandle input)
 137            {
 138                this.rec_cb = input;
 139            }
 140            public GCHandle get_receive()
 141            {
 142                return this.rec_cb;
 143            }
 144
 145            public void set_send(GCHandle input)
 146            {
 147                this.snd_cb = input;
 148            }
 149            public GCHandle get_send()
 150            {
 151                return this.snd_cb;
 152            }
 153
 154            public void set_psk(GCHandle input)
 155            {
 156                this.psk_cb = input;
 157            }
 158            public GCHandle get_psk()
 159            {
 160                return this.psk_cb;
 161            }
 162
 163            public void set_sni(GCHandle input) {
 164                this.sni_cb = input;
 165            }
 166
 167            public GCHandle get_sni(GCHandle input) {
 168                return this.sni_cb;
 169            }
 170
 171            public void set_arg(GCHandle input) {
 172                this.sni_arg= input;
 173            }
 174
 175            public GCHandle get_arg(GCHandle input) {
 176                return this.sni_arg;
 177            }
 178
 179            public void set_vrf(GCHandle input)
 180            {
 181                if (!Object.Equals(this.vrf_cb, default(GCHandle)))
 182                {
 183                    this.vrf_cb.Free();
 184                }
 185                this.vrf_cb = input;
 186            }
 187            public GCHandle get_vrf()
 188            {
 189                return this.vrf_cb;
 190            }
 191
 192            public void set_ctx(IntPtr input)
 193            {
 194                this.ctx = input;
 195            }
 196            public IntPtr get_ctx()
 197            {
 198                return this.ctx;
 199            }
 200
 201            /// <summary>
 202            /// Called to free the pointers keeping handles alive
 203            /// </summary>
 204            public void free()
 205            {
 206                log(INFO_LOG, "freeing ctx handle");
 207                if (!Object.Equals(this.rec_cb, default(GCHandle)))
 208                {
 209                    this.rec_cb.Free();
 210                }
 211                if (!Object.Equals(this.snd_cb, default(GCHandle)))
 212                {
 213                    this.snd_cb.Free();
 214                }
 215                if (!Object.Equals(this.psk_cb, default(GCHandle)))
 216                {
 217                    this.psk_cb.Free();
 218                }
 219                if (!Object.Equals(this.sni_cb, default(GCHandle)))
 220                {
 221                    this.sni_cb.Free();
 222                }
 223                if (!Object.Equals(this.vrf_cb, default(GCHandle)))
 224                {
 225                    this.vrf_cb.Free();
 226                }
 227            }
 228        }
 229
 230        /********************************
 231         * Class for keeping ssl handle alive
 232         */
 233        [StructLayout(LayoutKind.Sequential)]
 234        private class ssl_handle
 235        {
 236            private GCHandle fd_pin;
 237            private GCHandle psk_cb;
 238            private GCHandle sni_cb;
 239            private GCHandle vrf_cb;
 240            private IntPtr ssl;
 241
 242            public void set_fd(GCHandle input)
 243            {
 244                this.fd_pin = input;
 245            }
 246            public GCHandle get_fd()
 247            {
 248                return this.fd_pin;
 249            }
 250
 251            public void set_psk(GCHandle input)
 252            {
 253                this.psk_cb = input;
 254            }
 255            public GCHandle get_psk()
 256            {
 257                return this.psk_cb;
 258            }
 259
 260            public void set_vrf(GCHandle input)
 261            {
 262                if (!Object.Equals(this.vrf_cb, default(GCHandle)))
 263                {
 264                    this.vrf_cb.Free();
 265                }
 266                this.vrf_cb = input;
 267            }
 268            public GCHandle get_vrf()
 269            {
 270                return this.vrf_cb;
 271            }
 272
 273            public void set_ssl(IntPtr input)
 274            {
 275                this.ssl = input;
 276            }
 277            public IntPtr get_ssl()
 278            {
 279                return this.ssl;
 280            }
 281            public void free()
 282            {
 283                log(INFO_LOG, "freeing ssl handle");
 284
 285                if (!Object.Equals(this.fd_pin, default(GCHandle)))
 286                {
 287                    this.fd_pin.Free();
 288                }
 289                if (!Object.Equals(this.psk_cb, default(GCHandle)))
 290                {
 291                    this.psk_cb.Free();
 292                }
 293                if (!Object.Equals(this.sni_cb, default(GCHandle)))
 294                {
 295                    this.sni_cb.Free();
 296                }
 297                if (!Object.Equals(this.vrf_cb, default(GCHandle)))
 298                {
 299                    this.vrf_cb.Free();
 300                }
 301            }
 302        }
 303
 304
 305        /********************************
 306         * Init wolfSSL library
 307         */
 308#if WindowsCE
 309        [DllImport(wolfssl_dll)]
 310        private extern static int wolfSSL_Init();
 311        [DllImport(wolfssl_dll)]
 312        private extern static int wolfSSL_Cleanup();
 313#else
 314        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 315        private extern static int wolfSSL_Init();
 316        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 317        private extern static int wolfSSL_Cleanup();
 318#endif
 319
 320        /********************************
 321         * Methods of connection
 322         */
 323#if WindowsCE
 324        [DllImport(wolfssl_dll)]
 325        private extern static IntPtr wolfTLSv1_2_server_method();
 326        [DllImport(wolfssl_dll)]
 327        private extern static IntPtr wolfTLSv1_3_server_method();
 328        [DllImport(wolfssl_dll)]
 329        private extern static IntPtr wolfSSLv23_server_method();
 330        [DllImport(wolfssl_dll)]
 331        private extern static IntPtr wolfTLSv1_2_client_method();
 332        [DllImport(wolfssl_dll)]
 333        private extern static IntPtr wolfTLSv1_3_client_method();
 334        [DllImport(wolfssl_dll)]
 335        private extern static IntPtr wolfSSLv23_client_method();
 336        [DllImport(wolfssl_dll)]
 337        private extern static IntPtr wolfDTLSv1_2_server_method();
 338        [DllImport(wolfssl_dll)]
 339        private extern static IntPtr wolfDTLSv1_2_client_method();
 340#else
 341        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 342        private extern static IntPtr wolfTLSv1_2_server_method();
 343        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 344        private extern static IntPtr wolfTLSv1_3_server_method();
 345        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 346        private extern static IntPtr wolfSSLv23_server_method();
 347        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 348        private extern static IntPtr wolfTLSv1_2_client_method();
 349        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 350        private extern static IntPtr wolfTLSv1_3_client_method();
 351        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 352        private extern static IntPtr wolfSSLv23_client_method();
 353        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 354        private extern static IntPtr wolfDTLSv1_2_server_method();
 355        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 356        private extern static IntPtr wolfDTLSv1_2_client_method();
 357#endif
 358
 359
 360        /********************************
 361         * Callbacks
 362         */
 363#if WindowsCE
 364        public delegate int CallbackIORecv_delegate(IntPtr ssl, IntPtr buf, int sz, IntPtr ctx);
 365        [DllImport(wolfssl_dll)]
 366        private extern static int wolfSSL_CTX_SetIORecv(IntPtr ctx, CallbackIORecv_delegate recv);
 367        [DllImport(wolfssl_dll)]
 368        private extern static int wolfSSL_SetIOReadCtx(IntPtr ssl, IntPtr rctx);
 369        [DllImport(wolfssl_dll)]
 370        private extern static IntPtr wolfSSL_GetIOReadCtx(IntPtr ssl);
 371        public delegate int CallbackIOSend_delegate(IntPtr ssl, IntPtr buf, int sz, IntPtr ctx);
 372        [DllImport(wolfssl_dll)]
 373        private extern static int wolfSSL_CTX_SetIOSend(IntPtr ctx, CallbackIOSend_delegate send);
 374        [DllImport(wolfssl_dll)]
 375        private extern static int wolfSSL_SetIOWriteCtx(IntPtr ssl, IntPtr wctx);
 376        [DllImport(wolfssl_dll)]
 377        private extern static IntPtr wolfSSL_GetIOWriteCtx(IntPtr ssl);
 378#else
 379        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 380        public delegate int CallbackIORecv_delegate(IntPtr ssl, IntPtr buf, int sz, IntPtr ctx);
 381        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 382        private extern static int wolfSSL_CTX_SetIORecv(IntPtr ctx, CallbackIORecv_delegate recv);
 383        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 384        private extern static int wolfSSL_SetIOReadCtx(IntPtr ssl, IntPtr rctx);
 385        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 386        private extern static IntPtr wolfSSL_GetIOReadCtx(IntPtr ssl);
 387
 388        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 389        public delegate int CallbackIOSend_delegate(IntPtr ssl, IntPtr buf, int sz, IntPtr ctx);
 390        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 391        private extern static int wolfSSL_CTX_SetIOSend(IntPtr ctx, CallbackIOSend_delegate send);
 392        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 393        private extern static int wolfSSL_SetIOWriteCtx(IntPtr ssl, IntPtr wctx);
 394        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 395        private extern static IntPtr wolfSSL_GetIOWriteCtx(IntPtr ssl);
 396#endif
 397
 398
 399        /********************************
 400         * CTX structure
 401         */
 402#if WindowsCE
 403        [DllImport(wolfssl_dll)]
 404        private extern static IntPtr wolfSSL_CTX_new(IntPtr method);
 405        [DllImport(wolfssl_dll)]
 406        private extern static int wolfSSL_CTX_use_certificate_file(IntPtr ctx, string file, int type);
 407        [DllImport(wolfssl_dll)]
 408        private extern static int wolfSSL_CTX_load_verify_locations(IntPtr ctx, string file, string path);
 409        [DllImport(wolfssl_dll)]
 410        private extern static int wolfSSL_CTX_load_verify_locations_ex(IntPtr ctx, string file, string path, int flags);
 411        [DllImport(wolfssl_dll)]
 412        private extern static int wolfSSL_CTX_use_PrivateKey_file(IntPtr ctx, string file, int type);
 413        [DllImport(wolfssl_dll)]
 414        private extern static void wolfSSL_CTX_free(IntPtr ctx);
 415#else
 416        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 417        private extern static IntPtr wolfSSL_CTX_new(IntPtr method);
 418        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 419        private extern static int wolfSSL_CTX_use_certificate_file(IntPtr ctx, string file, int type);
 420        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 421        private extern static int wolfSSL_CTX_load_verify_locations(IntPtr ctx, string file, string path);
 422        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 423        private extern static int wolfSSL_CTX_load_verify_locations_ex(IntPtr ctx, string file, string path, int flags);
 424        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 425        private extern static int wolfSSL_CTX_use_PrivateKey_file(IntPtr ctx, string file, int type);
 426        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 427        private extern static void wolfSSL_CTX_free(IntPtr ctx);
 428#endif
 429
 430
 431        /********************************
 432         * PSK
 433         */
 434#if WindowsCE
 435        public delegate uint psk_delegate(IntPtr ssl, string identity, IntPtr key, uint max_sz);
 436        public delegate uint psk_client_delegate(IntPtr ssl, string hint, IntPtr identity, uint id_max_len, IntPtr key, uint max_sz);
 437        [DllImport(wolfssl_dll)]
 438        private extern static void wolfSSL_set_psk_server_callback(IntPtr ssl, psk_delegate psk_cb);
 439        [DllImport(wolfssl_dll)]
 440        private extern static void wolfSSL_CTX_set_psk_server_callback(IntPtr ctx, psk_delegate psk_cb);
 441        [DllImport(wolfssl_dll)]
 442        private extern static void wolfSSL_CTX_set_psk_client_callback(IntPtr ctx, psk_client_delegate psk_cb);
 443        [DllImport(wolfssl_dll)]
 444        private extern static int wolfSSL_CTX_use_psk_identity_hint(IntPtr ctx, string identity);
 445#else
 446        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 447        public delegate uint psk_delegate(IntPtr ssl, string identity, IntPtr key, uint max_sz);
 448        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 449        public delegate uint psk_client_delegate(IntPtr ssl, string hint, IntPtr identity, uint id_max_len, IntPtr key, uint max_sz);
 450        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 451        private extern static void wolfSSL_set_psk_server_callback(IntPtr ssl, psk_delegate psk_cb);
 452        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 453        private extern static void wolfSSL_CTX_set_psk_server_callback(IntPtr ctx, psk_delegate psk_cb);
 454        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 455        private extern static void wolfSSL_CTX_set_psk_client_callback(IntPtr ctx, psk_client_delegate psk_cb);
 456        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 457        private extern static int wolfSSL_CTX_use_psk_identity_hint(IntPtr ctx, StringBuilder identity);
 458#endif
 459
 460        /********************************
 461         * SNI
 462         */
 463#if WindowsCE
 464        public delegate int sni_delegate(IntPtr ssl, IntPtr ret, IntPtr exArg);
 465        [DllImport(wolfssl_dll)]
 466        private extern static void wolfSSL_CTX_set_servername_callback(IntPtr ctx, sni_delegate sni_cb);
 467        [DllImport(wolfssl_dll)]
 468        private extern static int wolfSSL_CTX_set_servername_arg(IntPtr ctx, IntPtr arg);
 469        [DllImport(wolfssl_dll)]
 470        private extern static int wolfSSL_CTX_UseSNI(IntPtr ctx, byte type, IntPtr data, ushort size);
 471        [DllImport(wolfssl_dll)]
 472        private extern static int wolfSSL_UseSNI(IntPtr ssl, byte type, IntPtr data, ushort size);
 473        [DllImport(wolfssl_dll)]
 474        private extern static ushort wolfSSL_SNI_GetRequest(IntPtr ssl, byte type, ref IntPtr data);
 475        [DllImport(wolfssl_dll)]
 476        private extern static int wolfSSL_SNI_GetFromBuffer(byte[] clientHello, uint helloSz, byte type, IntPtr sni, IntPtr inOutSz);
 477#else
 478        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 479        public delegate int sni_delegate(IntPtr ssl, IntPtr ret, IntPtr exArg);
 480        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 481        private extern static void wolfSSL_CTX_set_servername_callback(IntPtr ctx, sni_delegate sni_cb);
 482        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 483        private extern static int wolfSSL_CTX_set_servername_arg(IntPtr ctx, IntPtr arg);
 484        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 485        private extern static int wolfSSL_CTX_UseSNI(IntPtr ctx, byte type, IntPtr data, ushort size);
 486        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 487        private extern static int wolfSSL_UseSNI(IntPtr ssl, byte type, IntPtr data, ushort size);
 488        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 489        private extern static ushort wolfSSL_SNI_GetRequest(IntPtr ssl, byte type, ref IntPtr data);
 490        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 491        private extern static int wolfSSL_SNI_GetFromBuffer(byte[] clientHello, uint helloSz, byte type, IntPtr sni, IntPtr inOutSz);
 492#endif
 493
 494        /********************************
 495         * SSL Structure
 496         */
 497#if WindowsCE
 498        [DllImport(wolfssl_dll)]
 499        private extern static IntPtr wolfSSL_new(IntPtr ctx);
 500        [DllImport(wolfssl_dll)]
 501        private extern static int wolfSSL_accept(IntPtr ssl);
 502        [DllImport(wolfssl_dll)]
 503        private extern static int wolfSSL_connect(IntPtr ssl);
 504        [DllImport(wolfssl_dll)]
 505        private extern static int wolfSSL_read(IntPtr ssl, IntPtr buf, int sz);
 506        [DllImport(wolfssl_dll)]
 507        private extern static int wolfSSL_write(IntPtr ssl, IntPtr buf, int sz);
 508        [DllImport(wolfssl_dll)]
 509        private extern static int wolfSSL_shutdown(IntPtr ssl);
 510        [DllImport(wolfssl_dll)]
 511        private extern static void wolfSSL_free(IntPtr ssl);
 512        [DllImport(wolfssl_dll)]
 513        private static extern int wolfSSL_UseKeyShare(IntPtr ssl, ushort group);
 514#else
 515        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 516        private extern static IntPtr wolfSSL_new(IntPtr ctx);
 517        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 518        private extern static int wolfSSL_accept(IntPtr ssl);
 519        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 520        private extern static int wolfSSL_connect(IntPtr ssl);
 521        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 522        private extern static int wolfSSL_read(IntPtr ssl, IntPtr buf, int sz);
 523        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 524        private extern static int wolfSSL_write(IntPtr ssl, IntPtr buf, int sz);
 525        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 526        private extern static int wolfSSL_shutdown(IntPtr ssl);
 527        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 528        private extern static void wolfSSL_free(IntPtr ssl);
 529        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 530        private static extern int wolfSSL_UseKeyShare(IntPtr ssl, ushort group);
 531#endif
 532
 533        /********************************
 534         * Cipher lists
 535         */
 536#if WindowsCE
 537        /* only supports full name from cipher_name[] delimited by : */
 538        [DllImport(wolfssl_dll)]
 539        private extern static int wolfSSL_CTX_set_cipher_list(IntPtr ctx, string ciphers);
 540        [DllImport(wolfssl_dll)]
 541        private extern static int wolfSSL_set_cipher_list(IntPtr ssl, string ciphers);
 542        [DllImport(wolfssl_dll)]
 543        private extern static int wolfSSL_get_ciphers(string ciphers, int sz);
 544        [DllImport(wolfssl_dll)]
 545        private extern static IntPtr wolfSSL_get_cipher(IntPtr ssl);
 546        [DllImport(wolfssl_dll)]
 547        private extern static IntPtr wolfSSL_CIPHER_get_name(IntPtr cipher);
 548        [DllImport(wolfssl_dll)]
 549        private extern static IntPtr wolfSSL_get_current_cipher(IntPtr ssl);
 550        [DllImport(wolfssl_dll)]
 551        private extern static IntPtr wolfSSL_get_version(IntPtr ssl);
 552        [DllImport(wolfssl_dll)]
 553        private extern static IntPtr wolfSSL_get_cipher_list(IntPtr ssl);
 554#else
 555        /* only supports full name from cipher_name[] delimited by : */
 556        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 557        private extern static int wolfSSL_CTX_set_cipher_list(IntPtr ctx, StringBuilder ciphers);
 558        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 559        private extern static int wolfSSL_set_cipher_list(IntPtr ssl, StringBuilder ciphers);
 560        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 561        private extern static int wolfSSL_get_ciphers(StringBuilder ciphers, int sz);
 562        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 563        private extern static IntPtr wolfSSL_get_cipher(IntPtr ssl);
 564        [DllImport(wolfssl_dll, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
 565        private extern static IntPtr wolfSSL_CIPHER_get_name(IntPtr cipher);
 566        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 567        private extern static IntPtr wolfSSL_get_current_cipher(IntPtr ssl);
 568        [DllImport(wolfssl_dll, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
 569        private extern static IntPtr wolfSSL_get_version(IntPtr ssl);
 570        [DllImport(wolfssl_dll, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
 571        private extern static IntPtr wolfSSL_get_cipher_list(IntPtr ssl);
 572#endif
 573
 574        /********************************
 575         * Error logging
 576         */
 577#if WindowsCE
 578        [DllImport(wolfssl_dll)]
 579        private extern static IntPtr wolfSSL_ERR_reason_error_string(uint err);
 580        [DllImport(wolfssl_dll)]
 581        private extern static int wolfSSL_get_error(IntPtr ssl, int err);
 582        public delegate void loggingCb(int lvl, string msg);
 583        [DllImport(wolfssl_dll)]
 584        private extern static void wolfSSL_Debugging_ON();
 585        [DllImport(wolfssl_dll)]
 586        private extern static void wolfSSL_Debugging_OFF();
 587        [DllImport(wolfssl_dll)]
 588        private extern static int wolfSSL_SetLoggingCb(loggingCb vc);
 589#else
 590        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
 591        private extern static IntPtr wolfSSL_ERR_reason_error_string(uint err);
 592        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 593        private extern static int wolfSSL_get_error(IntPtr ssl, int err);
 594        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 595        public delegate void loggingCb(int lvl, StringBuilder msg);
 596        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 597        private extern static void wolfSSL_Debugging_ON();
 598        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 599        private extern static void wolfSSL_Debugging_OFF();
 600        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 601        private extern static int wolfSSL_SetLoggingCb(loggingCb vc);
 602#endif
 603        private static loggingCb internal_log;
 604
 605        /********************************
 606         * DH
 607         */
 608#if WindowsCE
 609        [DllImport(wolfssl_dll)]
 610        private extern static int wolfSSL_CTX_SetMinDhKey_Sz(IntPtr ctx, short size);
 611        [DllImport(wolfssl_dll)]
 612        private extern static int wolfSSL_SetTmpDH_file(IntPtr ssl, string dhParam, int type);
 613        [DllImport(wolfssl_dll)]
 614        private extern static int wolfSSL_CTX_SetTmpDH_file(IntPtr ctx, string dhParam, int type);
 615#else
 616        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 617        private extern static int wolfSSL_CTX_SetMinDhKey_Sz(IntPtr ctx, short size);
 618        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 619        private extern static int wolfSSL_SetTmpDH_file(IntPtr ssl, StringBuilder dhParam, int type);
 620        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 621        private extern static int wolfSSL_CTX_SetTmpDH_file(IntPtr ctx, StringBuilder dhParam, int type);
 622
 623#endif
 624
 625        /********************************
 626         * Verify Callback
 627         */
 628#if WindowsCE
 629        public delegate int CallbackVerify_delegate(int ret, IntPtr x509_ctx);
 630        [DllImport(wolfssl_dll)]
 631        private extern static void wolfSSL_CTX_set_verify(IntPtr ctx, int mode, CallbackVerify_delegate vc);
 632        [DllImport(wolfssl_dll)]
 633        private extern static void wolfSSL_set_verify(IntPtr ssl, int mode, CallbackVerify_delegate vc);
 634#else
 635        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 636        public delegate int CallbackVerify_delegate(int ret, IntPtr x509_ctx);
 637        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 638        private extern static void wolfSSL_CTX_set_verify(IntPtr ctx, int mode, CallbackVerify_delegate vc);
 639        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 640        private extern static void wolfSSL_set_verify(IntPtr ssl, int mode, CallbackVerify_delegate vc);
 641#endif
 642
 643
 644        /********************************
 645         * X509 Store
 646         */
 647#if WindowsCE
 648        [DllImport(wolfssl_dll)]
 649        private extern static IntPtr wolfSSL_X509_STORE_CTX_get_current_cert(IntPtr x509Ctx);
 650        [DllImport(wolfssl_dll)]
 651        private extern static int wolfSSL_X509_STORE_CTX_get_error(IntPtr sk);
 652        [DllImport(wolfssl_dll)]
 653        private extern static IntPtr wolfSSL_X509_STORE_GetCerts(IntPtr x509Ctx);
 654        [DllImport(wolfssl_dll)]
 655        private extern static int wolfSSL_sk_X509_num(IntPtr sk);
 656        [DllImport(wolfssl_dll)]
 657        private extern static void wolfSSL_sk_X509_free(IntPtr sk);
 658        [DllImport(wolfssl_dll)]
 659        private extern static IntPtr wolfSSL_sk_X509_pop(IntPtr sk);
 660#else
 661        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 662        private extern static IntPtr wolfSSL_X509_STORE_CTX_get_current_cert(IntPtr x509Ctx);
 663        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 664        private extern static int wolfSSL_X509_STORE_CTX_get_error(IntPtr sk);
 665        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 666        private extern static IntPtr wolfSSL_X509_STORE_GetCerts(IntPtr x509Ctx);
 667        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 668        private extern static int wolfSSL_sk_X509_num(IntPtr sk);
 669        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 670        private extern static void wolfSSL_sk_X509_free(IntPtr sk);
 671        [DllImport(wolfssl_dll, CallingConvention = CallingConvention.Cdecl)]
 672        private extern static IntPtr wolfSSL_sk_X509_pop(IntPtr sk);
 673#endif
 674
 675
 676        /********************************
 677         * Enum types from wolfSSL library
 678         */
 679        public static readonly int SSL_FILETYPE_PEM = 1;
 680        public static readonly int SSL_FILETYPE_ASN1 = 2;
 681        public static readonly int SSL_FILETYPE_RAW = 3;
 682
 683        public static readonly int SSL_VERIFY_NONE = 0;
 684        public static readonly int SSL_VERIFY_PEER = 1;
 685        public static readonly int SSL_VERIFY_FAIL_IF_NO_PEER_CERT = 2;
 686        public static readonly int SSL_VERIFY_CLIENT_ONCE = 4;
 687        public static readonly int SSL_VERIFY_POST_HANDSHAKE = 8;
 688        public static readonly int SSL_VERIFY_FAIL_EXCEPT_PSK = 16;
 689
 690        public static readonly int CBIO_ERR_GENERAL = -1;
 691        public static readonly int CBIO_ERR_WANT_READ = -2;
 692        public static readonly int CBIO_ERR_WANT_WRITE = -2;
 693        public static readonly int CBIO_ERR_CONN_RST = -3;
 694        public static readonly int CBIO_ERR_ISR = -4;
 695        public static readonly int CBIO_ERR_CONN_CLOSE = -5;
 696        public static readonly int CBIO_ERR_TIMEOUT = -6;
 697
 698        public static readonly int ERROR_LOG = 0;
 699        public static readonly int INFO_LOG = 1;
 700        public static readonly int ENTER_LOG = 2;
 701        public static readonly int LEAVE_LOG = 3;
 702        public static readonly int OTHER_LOG = 4;
 703
 704        public static readonly int SUCCESS = 1;
 705        public static readonly int FAILURE = 0;
 706        public static readonly int WOLFSSL_SNI_HOST_NAME = 0;
 707
 708        public static readonly int WOLFSSL_LOAD_FLAG_NONE                = 0x00000000;
 709        public static readonly int WOLFSSL_LOAD_FLAG_IGNORE_ERR          = 0x00000001;
 710        public static readonly int WOLFSSL_LOAD_FLAG_DATE_ERR_OKAY       = 0x00000002;
 711        public static readonly int WOLFSSL_LOAD_FLAG_PEM_CA_ONLY         = 0x00000004;
 712        public static readonly int WOLFSSL_LOAD_FLAG_IGNORE_BAD_PATH_ERR = 0x00000008;
 713        public static readonly int WOLFSSL_LOAD_FLAG_IGNORE_ZEROFILE     = 0x00000010;
 714        public static readonly int WOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS     = WOLFSSL_LOAD_FLAG_NONE;
 715
 716        /* from ssl.h */
 717        public enum NamedGroup
 718        {
 719            WOLFSSL_NAMED_GROUP_INVALID = 0,
 720
 721            WOLFSSL_ECC_SECP160K1 = 15,
 722            WOLFSSL_ECC_SECP160R1 = 16,
 723            WOLFSSL_ECC_SECP160R2 = 17,
 724            WOLFSSL_ECC_SECP192K1 = 18,
 725            WOLFSSL_ECC_SECP192R1 = 19,
 726            WOLFSSL_ECC_SECP224K1 = 20,
 727            WOLFSSL_ECC_SECP224R1 = 21,
 728            WOLFSSL_ECC_SECP256K1 = 22,
 729            WOLFSSL_ECC_SECP256R1 = 23,
 730            WOLFSSL_ECC_SECP384R1 = 24,
 731            WOLFSSL_ECC_SECP521R1 = 25,
 732            WOLFSSL_ECC_BRAINPOOLP256R1 = 26,
 733            WOLFSSL_ECC_BRAINPOOLP384R1 = 27,
 734            WOLFSSL_ECC_BRAINPOOLP512R1 = 28,
 735            WOLFSSL_ECC_X25519    = 29,
 736            WOLFSSL_ECC_X448      = 30,
 737            WOLFSSL_ECC_BRAINPOOLP256R1TLS13 = 31,
 738            WOLFSSL_ECC_BRAINPOOLP384R1TLS13 = 32,
 739            WOLFSSL_ECC_BRAINPOOLP512R1TLS13 = 33,
 740            WOLFSSL_ECC_SM2P256V1 = 41,
 741            WOLFSSL_ECC_MAX       = 41,
 742            WOLFSSL_ECC_MAX_AVAIL = 46,
 743            /* Update use of disabled curves when adding value greater than 46. */
 744
 745            WOLFSSL_FFDHE_START = 256,
 746            WOLFSSL_FFDHE_2048 = 256,
 747            WOLFSSL_FFDHE_3072 = 257,
 748            WOLFSSL_FFDHE_4096 = 258,
 749            WOLFSSL_FFDHE_6144 = 259,
 750            WOLFSSL_FFDHE_8192 = 260,
 751            WOLFSSL_FFDHE_END = 511,
 752
 753            /* Old code points to keep compatibility with MlKem Round 3.
 754             * Taken from OQS's openssl provider, see:
 755             * https://github.com/open-quantum-safe/oqs-provider/blob/main/oqs-template/
 756             *      oqs-kem-info.md
 757             */
 758            WOLFSSL_KYBER_LEVEL1          = 570, /* KYBER_512 */
 759            WOLFSSL_KYBER_LEVEL3          = 572, /* KYBER_768 */
 760            WOLFSSL_KYBER_LEVEL5          = 573, /* KYBER_1024 */
 761
 762            WOLFSSL_P256_KYBER_LEVEL1     = 12090,
 763            WOLFSSL_P384_KYBER_LEVEL3     = 12092,
 764            WOLFSSL_P521_KYBER_LEVEL5     = 12093,
 765            WOLFSSL_X25519_KYBER_LEVEL1   = 12089,
 766            WOLFSSL_X448_KYBER_LEVEL3     = 12176,
 767            WOLFSSL_X25519_KYBER_LEVEL3   = 25497,
 768            WOLFSSL_P256_KYBER_LEVEL3     = 25498,
 769
 770            /* Taken from draft-ietf-tls-mlkem, see:
 771             * https://datatracker.ietf.org/doc/draft-ietf-tls-mlkem/
 772             */
 773            WOLFSSL_ML_KEM_512 = 512,
 774            WOLFSSL_ML_KEM_768 = 513,
 775            WOLFSSL_ML_KEM_1024 = 514,
 776
 777            /* Taken from draft-ietf-tls-ecdhe-mlkem, see:
 778             * https://datatracker.ietf.org/doc/draft-ietf-tls-ecdhe-mlkem/
 779             */
 780            WOLFSSL_SECP256R1MLKEM768     = 4587,
 781            WOLFSSL_X25519MLKEM768        = 4588,
 782            WOLFSSL_SECP384R1MLKEM1024    = 4589,
 783
 784            /* Taken from OQS's openssl provider, see:
 785             * https://github.com/open-quantum-safe/oqs-provider/blob/main/oqs-template/
 786             *      oqs-kem-info.md
 787             */
 788            WOLFSSL_P256_ML_KEM_512_OLD   = 12103,
 789            WOLFSSL_P384_ML_KEM_768_OLD   = 12104,
 790            WOLFSSL_P521_ML_KEM_1024_OLD  = 12105,
 791
 792            WOLFSSL_SECP256R1MLKEM512     = 12107,
 793            WOLFSSL_SECP384R1MLKEM768     = 12108,
 794            WOLFSSL_SECP521R1MLKEM1024    = 12109,
 795            WOLFSSL_X25519MLKEM512        = 12214,
 796            WOLFSSL_X448MLKEM768          = 12215,
 797        }
 798
 799
 800
 801        private static IntPtr unwrap_ctx(IntPtr ctx)
 802        {
 803            try {
 804#if WindowsCE
 805                GCHandle gch = (GCHandle)ctx;
 806#else
 807                GCHandle gch = GCHandle.FromIntPtr(ctx);
 808#endif
 809                ctx_handle handles = (ctx_handle)gch.Target;
 810                return handles.get_ctx();
 811            } catch (Exception e)
 812            {
 813                log(ERROR_LOG, "wolfssl ctx pointer is incorrect " + e);
 814                return IntPtr.Zero;
 815            }
 816        }
 817        private static IntPtr unwrap_ssl(IntPtr ssl)
 818        {
 819            try {
 820#if WindowsCE
 821                GCHandle gch = (GCHandle)ssl;
 822#else
 823                GCHandle gch = GCHandle.FromIntPtr(ssl);
 824#endif
 825                ssl_handle handles = (ssl_handle)gch.Target;
 826                return handles.get_ssl();
 827            } catch (Exception e)
 828            {
 829                log(ERROR_LOG, "wolfssl pointer is incorrect " + e);
 830                return IntPtr.Zero;
 831            }
 832        }
 833
 834        /// <summary>
 835        /// Utility function used to access the certificates
 836        /// based on the platform.
 837        /// <returns>return the platform specific path to the certificate</returns>
 838        /// </summary>
 839        public static string setPath(string file) {
 840            PlatformID platform = Environment.OSVersion.Platform;
 841
 842#if !WindowsCE
 843            if (platform == PlatformID.Unix ||
 844                platform == PlatformID.MacOSX)
 845            {
 846                Console.WriteLine("Linux - " + file);
 847                return @"../../certs/" + file;
 848            }
 849            else
 850#endif
 851            if (platform == PlatformID.Win32NT ||
 852                platform == PlatformID.Win32Windows ||
 853                platform == PlatformID.Win32S ||
 854                platform == PlatformID.WinCE)
 855            {
 856                Console.WriteLine("Windows - " + file);
 857                return @"../../../../certs/" + file;
 858            } else
 859            {
 860                return "";
 861            }
 862        }
 863
 864
 865        /// <summary>
 866        /// Call back to allow receiving TLS information
 867        /// </summary>
 868        /// <param name="ssl">structure of ssl passed in</param>
 869        /// <param name="buf">buffer to contain received msg</param>
 870        /// <param name="sz">size of buffer</param>
 871        /// <param name="ctx">optional information passed in</param>
 872        /// <returns>size of message received</returns>
 873        private static int wolfSSLCbIORecv(IntPtr ssl, IntPtr buf, int sz, IntPtr ctx)
 874        {
 875            if (sz <= 0)
 876            {
 877                log(ERROR_LOG, "wolfssl receive error, size less than 0");
 878                return wolfssl.CBIO_ERR_GENERAL;
 879            }
 880
 881            int amtRecv = 0;
 882
 883            try
 884            {
 885#if WindowsCE
 886                GCHandle gch = (GCHandle)ctx;
 887#else
 888                GCHandle gch = GCHandle.FromIntPtr(ctx);
 889#endif
 890                Socket con = (System.Net.Sockets.Socket)gch.Target;
 891                Byte[] msg = new Byte[sz];
 892                amtRecv = con.Receive(msg, msg.Length, 0);
 893                if (amtRecv == 0)
 894                {
 895                    /* No data received so check for a response to see if connection is still open */
 896#if WindowsCE
 897                    if (con.Poll(WC_WAIT, SelectMode.SelectRead))
 898#else
 899                    if (con.Poll((con.ReceiveTimeout > 0) ? con.ReceiveTimeout : WC_WAIT, SelectMode.SelectRead))
 900#endif
 901                    {
 902                        log(ERROR_LOG, "socket connection issue, suspected connection termination.");
 903                        return wolfssl.CBIO_ERR_CONN_CLOSE;
 904                    }
 905                }
 906                Marshal.Copy(msg, 0, buf, sz);
 907            }
 908            catch (Exception e)
 909            {
 910                log(ERROR_LOG, "Error in receive " + e.ToString());
 911                return wolfssl.CBIO_ERR_CONN_CLOSE;
 912            }
 913
 914            return amtRecv;
 915        }
 916
 917
 918        /// <summary>
 919        /// Call back used for sending TLS information
 920        /// </summary>
 921        /// <param name="ssl">pointer to ssl struct</param>
 922        /// <param name="buf">buffer containing information to send</param>
 923        /// <param name="sz">size of buffer to send</param>
 924        /// <param name="ctx">optional information</param>
 925        /// <returns>amount of information sent</returns>
 926        private static int wolfSSLCbIOSend(IntPtr ssl, IntPtr buf, int sz, IntPtr ctx)
 927        {
 928            if (sz <= 0)
 929            {
 930                log(ERROR_LOG, "wolfssl send error, size less than 0");
 931                return wolfssl.CBIO_ERR_GENERAL;
 932            }
 933
 934            try
 935            {
 936#if WindowsCE
 937                GCHandle gch = (GCHandle)ctx;
 938#else
 939                GCHandle gch = GCHandle.FromIntPtr(ctx);
 940#endif
 941                Socket con = (System.Net.Sockets.Socket)gch.Target;
 942                Byte[] msg = new Byte[sz];
 943                Marshal.Copy(buf, msg, 0, sz);
 944                if (con.Send(msg, 0, msg.Length, SocketFlags.None) == 0 && sz != 0)
 945                {
 946                    /* no data sent and msg size is larger then 0, check for lost connection */
 947#if WindowsCE
 948                    if (con.Poll(WC_WAIT, SelectMode.SelectWrite))
 949#else
 950                    if (con.Poll((con.SendTimeout > 0) ? con.SendTimeout : WC_WAIT, SelectMode.SelectWrite))
 951#endif
 952                    {
 953                        log(ERROR_LOG, "socket connection issue, suspect connection termination");
 954                        return wolfssl.CBIO_ERR_CONN_CLOSE;
 955                    }
 956                }
 957                return sz;
 958            }
 959            catch (Exception e)
 960            {
 961                log(ERROR_LOG, "socket connection issue " + e.ToString());
 962                return wolfssl.CBIO_ERR_CONN_CLOSE;
 963            }
 964        }
 965
 966
 967        /// <summary>
 968        /// Call back used for sending DTLS information
 969        /// </summary>
 970        /// <param name="ssl">pointer to ssl struct</param>
 971        /// <param name="buf">buffer containing information to send</param>
 972        /// <param name="sz">size of buffer to send</param>
 973        /// <param name="ctx">optional information</param>
 974        /// <returns>amount of information sent</returns>
 975        private static int wolfSSL_dtlsCbIOSend(IntPtr ssl, IntPtr buf, int sz, IntPtr ctx)
 976        {
 977            if (sz <= 0)
 978            {
 979                log(ERROR_LOG, "wolfssl dtls send error, size less than 0");
 980                return wolfssl.CBIO_ERR_GENERAL;
 981            }
 982
 983            try
 984            {
 985#if WindowsCE
 986                GCHandle gch = (GCHandle)ctx;
 987#else
 988                GCHandle gch = GCHandle.FromIntPtr(ctx);
 989#endif
 990                DTLS_con con = (DTLS_con)gch.Target;
 991
 992                Byte[] msg = new Byte[sz];
 993                Marshal.Copy(buf, msg, 0, sz);
 994                con.udp.Send(msg, msg.Length, con.ep);
 995                return msg.Length;
 996            }
 997            catch (Exception e)
 998            {
 999                log(ERROR_LOG, "socket connection issue " + e.ToString());
1000                return wolfssl.CBIO_ERR_CONN_CLOSE;
1001            }
1002        }
1003
1004
1005        /// <summary>
1006        /// Call back to allow receiving DTLS information
1007        /// </summary>
1008        /// <param name="ssl">structure of ssl passed in</param>
1009        /// <param name="buf">buffer to contain received msg</param>
1010        /// <param name="sz">size of buffer</param>
1011        /// <param name="ctx">optional information passed in</param>
1012        /// <returns>size of message received</returns>
1013        private static int wolfSSL_dtlsCbIORecv(IntPtr ssl, IntPtr buf, int sz, IntPtr ctx)
1014        {
1015            if (sz <= 0)
1016            {
1017                log(ERROR_LOG, "wolfssl dtls receive error, size less than 0");
1018                return wolfssl.CBIO_ERR_GENERAL;
1019            }
1020
1021            try
1022            {
1023#if WindowsCE
1024                GCHandle gch = (GCHandle)ctx;
1025#else
1026                GCHandle gch = GCHandle.FromIntPtr(ctx);
1027#endif
1028                DTLS_con con = (DTLS_con)gch.Target;
1029
1030                Byte[] msg = con.udp.Receive(ref con.ep);
1031                if (msg.Length > sz)
1032                {
1033                    log(ERROR_LOG, "wolfssl DTLS packet received was larger than buffer");
1034                    return wolfssl.CBIO_ERR_GENERAL;
1035                }
1036
1037                Marshal.Copy(msg, 0, buf, msg.Length);
1038                return msg.Length;
1039            }
1040            catch (Exception e)
1041            {
1042                /* issue with receive or size of buffer */
1043                log(ERROR_LOG, "socket read issue " + e.ToString());
1044                return wolfssl.CBIO_ERR_CONN_CLOSE;
1045            }
1046        }
1047
1048
1049        /// <summary>
1050        /// Create a new ssl structure
1051        /// </summary>
1052        /// <param name="ctx">structure to create ssl structure from</param>
1053        /// <returns>pointer to ssl structure</returns>
1054        public static IntPtr new_ssl(IntPtr ctx)
1055        {
1056            if (ctx == IntPtr.Zero)
1057                return IntPtr.Zero;
1058
1059            try
1060            {
1061                ssl_handle io;
1062                IntPtr local_ctx = unwrap_ctx(ctx);
1063                if (local_ctx == IntPtr.Zero)
1064                {
1065                    log(ERROR_LOG, "new_ssl ctx unwrap error");
1066                    return IntPtr.Zero;
1067                }
1068
1069                io = new ssl_handle();
1070                io.set_ssl(wolfSSL_new(local_ctx));
1071
1072                /* check if null */
1073                if (io.get_ssl() == IntPtr.Zero)
1074                {
1075                    return IntPtr.Zero;
1076                }
1077
1078                /* keep memory pinned to be able to reference by address */
1079#if WindowsCE
1080                return (IntPtr)GCHandle.Alloc(io, GCHandleType.Pinned);
1081#else
1082                return GCHandle.ToIntPtr(GCHandle.Alloc(io, GCHandleType.Pinned));
1083#endif
1084            }
1085            catch (Exception e)
1086            {
1087                log(ERROR_LOG, e.ToString());
1088                return IntPtr.Zero;
1089            }
1090        }
1091
1092
1093        /// <summary>
1094        /// Used for a server to accept a connection
1095        /// </summary>
1096        /// <param name="ssl">structure containing info for connection</param>
1097        /// <returns>1 on success</returns>
1098        public static int accept(IntPtr ssl)
1099        {
1100            if (ssl == IntPtr.Zero)
1101                return FAILURE;
1102            try
1103            {
1104                IntPtr sslCtx = unwrap_ssl(ssl);
1105                if (sslCtx == IntPtr.Zero)
1106                {
1107                    log(ERROR_LOG, "accept ssl unwrap error");
1108                    return FAILURE;
1109                }
1110
1111                return wolfSSL_accept(sslCtx);
1112            }
1113            catch (Exception e)
1114            {
1115                log(ERROR_LOG, "accept error " + e.ToString());
1116                return FAILURE;
1117            }
1118        }
1119
1120
1121        /// <summary>
1122        /// Used for a client to connect
1123        /// </summary>
1124        /// <param name="ssl">structure containing connection info</param>
1125        /// <returns>1 on success</returns>
1126        public static int connect(IntPtr ssl)
1127        {
1128            if (ssl == IntPtr.Zero)
1129                return FAILURE;
1130            try
1131            {
1132                IntPtr sslCtx = unwrap_ssl(ssl);
1133                if (sslCtx == IntPtr.Zero)
1134                {
1135                    log(ERROR_LOG, "connect ssl unwrap error");
1136                    return FAILURE;
1137                }
1138
1139                return wolfSSL_connect(sslCtx);
1140            }
1141            catch (Exception e)
1142            {
1143                log(ERROR_LOG, "connect error " + e.ToString());
1144                return FAILURE;
1145            }
1146        }
1147
1148
1149        /// <summary>
1150        /// Read message from secure connection
1151        /// </summary>
1152        /// <param name="ssl">structure containing info about connection</param>
1153        /// <param name="buf">object to hold incoming message (Unicode format)</param>
1154        /// <param name="sz">size of available memory in buf</param>
1155        /// <returns>amount of data read on success</returns>
1156        public static int read(IntPtr ssl, StringBuilder buf, int sz)
1157        {
1158            if (ssl == IntPtr.Zero)
1159                return FAILURE;
1160            try
1161            {
1162                IntPtr sslCtx = unwrap_ssl(ssl);
1163                IntPtr data;
1164                int ret;
1165                byte[] msg;
1166
1167                /* Clear incoming buffer */
1168                buf.Length = 0;
1169
1170                if (sslCtx == IntPtr.Zero)
1171                {
1172                    log(ERROR_LOG, "read ssl unwrap error");
1173                    return FAILURE;
1174                }
1175                data = Marshal.AllocHGlobal(sz);
1176
1177                ret = wolfSSL_read(sslCtx, data, sz);
1178
1179                if (ret >= 0)
1180                {
1181                    /* Get data that was sent across and store it using a literal read of
1182                     * the conversion from bytes to character. Takes care of if
1183                     * a null terminator is part of the message read.
1184                     */
1185                    msg = new byte[ret];
1186                    Marshal.Copy(data, msg, 0, ret);
1187                    for (int i = 0; i < ret; i++)
1188                    {
1189                        buf.Append(@Convert.ToChar(msg[i]));
1190                    }
1191                }
1192                Marshal.FreeHGlobal(data);
1193
1194                return ret;
1195            }
1196            catch (Exception e)
1197            {
1198                log(ERROR_LOG, "wolfssl read error " + e.ToString());
1199                return FAILURE;
1200            }
1201        }
1202
1203
1204        /// <summary>
1205        /// Read message from secure connection using a byte array
1206        /// </summary>
1207        /// <param name="ssl">structure containing info about connection</param>
1208        /// <param name="buf">object to hold incoming message (raw bytes)</param>
1209        /// <param name="sz">size of available memory in buf</param>
1210        /// <returns>amount of data read on success</returns>
1211        public static int read(IntPtr ssl, byte[] buf, int sz)
1212        {
1213            if (ssl == IntPtr.Zero)
1214                return FAILURE;
1215            try
1216            {
1217                IntPtr sslCtx = unwrap_ssl(ssl);
1218                IntPtr data;
1219                int ret;
1220
1221                if (sslCtx == IntPtr.Zero)
1222                {
1223                    log(ERROR_LOG, "read ssl unwrap error");
1224                    return FAILURE;
1225                }
1226                data = Marshal.AllocHGlobal(sz);
1227
1228                ret = wolfSSL_read(sslCtx, data, sz);
1229
1230                if (ret >= 0)
1231                {
1232                    Marshal.Copy(data, buf, 0, ret);
1233                }
1234                Marshal.FreeHGlobal(data);
1235
1236                return ret;
1237            }
1238            catch (Exception e)
1239            {
1240                log(ERROR_LOG, "wolfssl read error " + e.ToString());
1241                return FAILURE;
1242            }
1243        }
1244
1245
1246
1247        /// <summary>
1248        /// Write message to secure connection
1249        /// </summary>
1250        /// <param name="ssl">structure containing connection info</param>
1251        /// <param name="buf">message to send</param>
1252        /// <param name="sz">size of the message</param>
1253        /// <returns>amount sent on success</returns>
1254        public static int write(IntPtr ssl, StringBuilder buf, int sz)
1255        {
1256            if (ssl == IntPtr.Zero)
1257                return FAILURE;
1258            try
1259            {
1260                IntPtr sslCtx = unwrap_ssl(ssl);
1261                IntPtr data;
1262                int ret;
1263
1264                if (sslCtx == IntPtr.Zero)
1265                {
1266                    log(ERROR_LOG, "write ssl unwrap error");
1267                    return FAILURE;
1268                }
1269
1270                data = Marshal.AllocHGlobal(sz);
1271                Marshal.Copy(System.Text.Encoding.Default.GetBytes(buf.ToString()), 0,
1272                       data, System.Text.Encoding.Default.GetByteCount(buf.ToString()));
1273                ret = wolfSSL_write(sslCtx, data, sz);
1274                Marshal.FreeHGlobal(data);
1275                return ret;
1276
1277            }
1278            catch (Exception e)
1279            {
1280                log(ERROR_LOG, "wolfssl write error " + e.ToString());
1281                return FAILURE;
1282            }
1283        }
1284
1285
1286        /// <summary>
1287        /// Write message to secure connection
1288        /// </summary>
1289        /// <param name="ssl">structure containing connection info</param>
1290        /// <param name="buf">message to send</param>
1291        /// <param name="sz">size of the message</param>
1292        /// <returns>amount sent on success</returns>
1293        public static int write(IntPtr ssl, byte[] buf, int sz)
1294        {
1295            if (ssl == IntPtr.Zero)
1296                return FAILURE;
1297            try
1298            {
1299                IntPtr sslCtx = unwrap_ssl(ssl);
1300                IntPtr data;
1301                int ret;
1302
1303                if (sslCtx == IntPtr.Zero)
1304                {
1305                    log(ERROR_LOG, "write ssl unwrap error");
1306                    return FAILURE;
1307                }
1308                data = Marshal.AllocHGlobal(sz);
1309                Marshal.Copy(buf, 0, data, sz);
1310                ret = wolfSSL_write(sslCtx, data, sz);
1311                Marshal.FreeHGlobal(data);
1312                return ret;
1313
1314            }
1315            catch (Exception e)
1316            {
1317                log(ERROR_LOG, "wolfssl write error " + e.ToString());
1318                return FAILURE;
1319            }
1320        }
1321
1322
1323        /// <summary>
1324        /// Free information stored in ssl struct
1325        /// </summary>
1326        /// <param name="ssl">pointer to ssl struct to free</param>
1327        public static void free(IntPtr ssl)
1328        {
1329            try
1330            {
1331                IntPtr sslCtx;
1332#if WindowsCE
1333                GCHandle gch = (GCHandle)ssl;
1334#else
1335                GCHandle gch = GCHandle.FromIntPtr(ssl);
1336#endif
1337                ssl_handle handles = (ssl_handle)gch.Target;
1338
1339                sslCtx = handles.get_ssl();
1340                wolfSSL_free(sslCtx);
1341                handles.free();
1342                gch.Free();
1343            }
1344            catch (Exception e)
1345            {
1346                log(ERROR_LOG, "wolfssl free error " + e.ToString());
1347            }
1348        }
1349
1350
1351        /// <summary>
1352        /// Shutdown a connection
1353        /// </summary>
1354        /// <param name="ssl">pointer to ssl struct to close connection of</param>
1355        /// <returns>1 on success</returns>
1356        public static int shutdown(IntPtr ssl)
1357        {
1358            if (ssl == IntPtr.Zero)
1359                return FAILURE;
1360            try
1361            {
1362                IntPtr sslCtx = unwrap_ssl(ssl);
1363                if (sslCtx == IntPtr.Zero)
1364                {
1365                    log(ERROR_LOG, "shutdown ssl unwrap error");
1366                    return FAILURE;
1367                }
1368
1369                return wolfSSL_shutdown(sslCtx);
1370            }
1371            catch (Exception e)
1372            {
1373                log(ERROR_LOG, "wolfssl shutdwon error " + e.ToString());
1374                return FAILURE;
1375            }
1376        }
1377
1378
1379        /// <summary>
1380        /// Creates a key share entry for the specified group on the given SSL/TLS connection.
1381        /// </summary>
1382        /// <param name="ssl">Pointer to the SSL structure to use.</param>
1383        /// <param name="group">The key exchange group identifier to use for key share (e.g., TLS supported group ID).</param>
1384        /// <returns>1 on success</returns>
1385        public static int UseKeyShare(IntPtr ssl, NamedGroup group)
1386        {
1387            if (ssl == IntPtr.Zero)
1388            {
1389                return FAILURE;
1390            }
1391            try
1392            {
1393                IntPtr sslCtx = unwrap_ssl(ssl);
1394                if (sslCtx == IntPtr.Zero)
1395                {
1396                    log(ERROR_LOG, "UseKeyShare ssl unwrap error");
1397                    return FAILURE;
1398                }
1399                return wolfSSL_UseKeyShare(sslCtx, (ushort)group);
1400            }
1401            catch (Exception e)
1402            {
1403                log(ERROR_LOG, "wolfSSL_UseKeyShare error " + e.ToString());
1404                return FAILURE;
1405            }
1406        }
1407
1408
1409        /// <summary>
1410        /// Optional, can be used to set a custom receive function
1411        /// </summary>
1412        /// <param name="ctx">structure to set receive function in</param>
1413        /// <param name="func">function to use when reading socket</param>
1414        public static void SetIORecv(IntPtr ctx, CallbackIORecv_delegate func)
1415        {
1416            try
1417            {
1418#if WindowsCE
1419                GCHandle gch = (GCHandle)ctx;
1420#else
1421                GCHandle gch = GCHandle.FromIntPtr(ctx);
1422#endif
1423                ctx_handle handles = (ctx_handle)gch.Target;
1424
1425                /* check if already stored handle needs freed */
1426                gch = handles.get_receive();
1427                if (!Object.Equals(gch, default(GCHandle)))
1428                {
1429                    gch.Free();
1430                }
1431
1432                /* keep new function alive */
1433                handles.set_receive(GCHandle.Alloc(func));
1434
1435                wolfSSL_CTX_SetIORecv(handles.get_ctx(), func);
1436            }
1437            catch (Exception e)
1438            {
1439                log(ERROR_LOG, "wolfssl setIORecv error " + e.ToString());
1440            }
1441        }
1442
1443
1444        /// <summary>
1445        /// Optional, can be used to set a custom send function
1446        /// </summary>
1447        /// <param name="ctx">structure to set function in</param>
1448        /// <param name="func">function to use when sending data</param>
1449        public static void SetIOSend(IntPtr ctx, CallbackIOSend_delegate func)
1450        {
1451            try
1452            {
1453#if WindowsCE
1454                GCHandle gch = (GCHandle)ctx;
1455#else
1456                GCHandle gch = GCHandle.FromIntPtr(ctx);
1457#endif
1458                ctx_handle handles = (ctx_handle)gch.Target;
1459
1460                /* check if already stored handle needs freed */
1461                gch = handles.get_send();
1462                if (!Object.Equals(gch, default(GCHandle)))
1463                {
1464                    gch.Free();
1465                }
1466
1467                /* keep new function alive */
1468                handles.set_send(GCHandle.Alloc(func));
1469
1470                wolfSSL_CTX_SetIOSend(handles.get_ctx(), func);
1471            }
1472            catch (Exception e)
1473            {
1474                log(ERROR_LOG, "wolfssl setIOSend error " + e.ToString());
1475            }
1476        }
1477
1478
1479        /// <summary>
1480        /// Create a new CTX structure
1481        /// </summary>
1482        /// <param name="method">method to use such as TLSv1.2</param>
1483        /// <returns>pointer to CTX structure</returns>
1484        public static IntPtr CTX_new(IntPtr method)
1485        {
1486            try
1487            {
1488                IntPtr ctx = wolfSSL_CTX_new(method);
1489                if (ctx == IntPtr.Zero)
1490                    return ctx;
1491
1492                ctx_handle io = new ctx_handle();
1493                io.set_ctx(ctx);
1494
1495                CallbackIORecv_delegate recv = new CallbackIORecv_delegate(wolfssl.wolfSSLCbIORecv);
1496                io.set_receive(GCHandle.Alloc(recv));
1497                wolfSSL_CTX_SetIORecv(ctx, recv);
1498
1499                CallbackIOSend_delegate send = new CallbackIOSend_delegate(wolfssl.wolfSSLCbIOSend);
1500                io.set_send(GCHandle.Alloc(send));
1501                wolfSSL_CTX_SetIOSend(ctx, send);
1502
1503                /* keep memory pinned */
1504#if WindowsCE
1505                return (IntPtr)GCHandle.Alloc(io, GCHandleType.Pinned);
1506#else
1507                return GCHandle.ToIntPtr(GCHandle.Alloc(io, GCHandleType.Pinned));
1508#endif
1509            }
1510            catch (Exception e)
1511            {
1512                log(ERROR_LOG, "ctx_new error " + e.ToString());
1513                return IntPtr.Zero;
1514            }
1515        }
1516
1517
1518        /// <summary>
1519        /// Create a new CTX structure for a DTLS connection
1520        /// </summary>
1521        /// <param name="method">Method to use in connection ie DTLSv1.2</param>
1522        /// <returns></returns>
1523        public static IntPtr CTX_dtls_new(IntPtr method)
1524        {
1525            try
1526            {
1527                IntPtr ctx = wolfSSL_CTX_new(method);
1528                if (ctx == IntPtr.Zero)
1529                    return ctx;
1530
1531                ctx_handle io = new ctx_handle();
1532                io.set_ctx(ctx);
1533
1534                CallbackIORecv_delegate recv = new CallbackIORecv_delegate(wolfssl.wolfSSL_dtlsCbIORecv);
1535                io.set_receive(GCHandle.Alloc(recv));
1536                wolfSSL_CTX_SetIORecv(ctx, recv);
1537
1538                CallbackIOSend_delegate send = new CallbackIOSend_delegate(wolfssl.wolfSSL_dtlsCbIOSend);
1539                io.set_send(GCHandle.Alloc(send));
1540                wolfSSL_CTX_SetIOSend(ctx, send);
1541
1542                /* keep memory pinned */
1543#if WindowsCE
1544                return (IntPtr)GCHandle.Alloc(io, GCHandleType.Pinned);
1545#else
1546                return GCHandle.ToIntPtr(GCHandle.Alloc(io, GCHandleType.Pinned));
1547#endif
1548            }
1549            catch (Exception e)
1550            {
1551                log(ERROR_LOG, "ctx_dtls_new error " + e.ToString());
1552                return IntPtr.Zero;
1553            }
1554        }
1555
1556
1557        /// <summary>
1558        /// Free information used in CTX structure
1559        /// </summary>
1560        /* <param name="ctx">structure to free</param>
1561         */
1562        public static void CTX_free(IntPtr ctx)
1563        {
1564            try
1565            {
1566#if WindowsCE
1567                GCHandle gch = (GCHandle)ctx;
1568#else
1569                GCHandle gch = GCHandle.FromIntPtr(ctx);
1570#endif
1571                ctx_handle handles = (ctx_handle)gch.Target;
1572                wolfSSL_CTX_free(handles.get_ctx());
1573                handles.free();
1574                gch.Free();
1575            }
1576            catch (Exception e)
1577            {
1578                log(ERROR_LOG, "wolfssl ctx free error " + e.ToString());
1579            }
1580        }
1581
1582        public static void CTX_set_servername_callback(IntPtr ctx, sni_delegate sni_cb)
1583        {
1584            try {
1585#if WindowsCE
1586                GCHandle gch = (GCHandle)ctx;
1587#else
1588                GCHandle gch = GCHandle.FromIntPtr(ctx);
1589#endif
1590                ctx_handle handles = (ctx_handle)gch.Target;
1591
1592                handles.set_sni(GCHandle.Alloc(sni_cb));
1593
1594                wolfSSL_CTX_set_servername_callback(handles.get_ctx(), sni_cb);
1595            } catch (Exception e) {
1596                log(ERROR_LOG, "wolfssl servername callback error: " + e.ToString());
1597            }
1598        }
1599
1600        public static int CTX_set_servername_arg(IntPtr ctx, IntPtr arg)
1601        {
1602            try {
1603#if WindowsCE
1604                GCHandle gch = (GCHandle)ctx;
1605#else
1606                GCHandle gch = GCHandle.FromIntPtr(ctx);
1607#endif
1608                ctx_handle handles = (ctx_handle)gch.Target;
1609
1610                handles.set_arg(GCHandle.Alloc(arg));
1611
1612                return wolfSSL_CTX_set_servername_arg(handles.get_ctx(), arg);
1613            } catch (Exception e) {
1614                log(ERROR_LOG, "wolfssl arg servername callback error: " + e.ToString());
1615                return FAILURE;
1616            }
1617        }
1618
1619        public static int CTX_UseSNI(IntPtr ctx, byte type, IntPtr data, ushort size)
1620        {
1621            try {
1622#if WindowsCE
1623                GCHandle gch = (GCHandle)ctx;
1624#else
1625                GCHandle gch = GCHandle.FromIntPtr(ctx);
1626#endif
1627                ctx_handle handles = (ctx_handle)gch.Target;
1628
1629                return  wolfSSL_CTX_UseSNI(handles.get_ctx(), type, data, size);
1630            } catch (Exception e) {
1631                log(ERROR_LOG, "wolfssl ctx use sni error: " + e.ToString());
1632                return FAILURE;
1633            }
1634        }
1635
1636        public static int UseSNI(IntPtr ssl, byte type, IntPtr data, ushort size)
1637        {
1638            try {
1639#if WindowsCE
1640                GCHandle gch = (GCHandle)ssl;
1641#else
1642                GCHandle gch = GCHandle.FromIntPtr(ssl);
1643#endif
1644                ssl_handle handles = (ssl_handle)gch.Target;
1645
1646                return  wolfSSL_UseSNI(handles.get_ssl(), type, data, size);
1647            } catch (Exception e) {
1648                log(ERROR_LOG, "wolfssl use sni error: " + e.ToString());
1649                return FAILURE;
1650            }
1651        }
1652
1653        public static ushort SNI_GetRequest(IntPtr ssl, byte type, ref IntPtr data)
1654        {
1655            try {
1656#if WindowsCE
1657                GCHandle gch = (GCHandle)ssl;
1658#else
1659                GCHandle gch = GCHandle.FromIntPtr(ssl);
1660#endif
1661                ssl_handle handles = (ssl_handle)gch.Target;
1662
1663                return  wolfSSL_SNI_GetRequest(handles.get_ssl(), type, ref data);
1664            } catch (Exception e) {
1665                log(ERROR_LOG, "wolfssl sni get request error: " + e.ToString());
1666                return ushort.MaxValue;
1667            }
1668        }
1669
1670        public static int SNI_GetFromBuffer(byte []clientHello, uint helloSz, byte type, IntPtr sni, IntPtr inOutSz)
1671        {
1672            try {
1673                return wolfSSL_SNI_GetFromBuffer(clientHello, helloSz, type, sni, inOutSz);
1674            } catch(Exception e) {
1675                log(ERROR_LOG, "wolfssl sni get from buffer error: " + e.ToString());
1676                return FAILURE;
1677            }
1678        }
1679
1680        /// <summary>
1681        /// Set identity hint to use
1682        /// </summary>
1683        /// <param name="ctx">pointer to structure of ctx to set hint in</param>
1684        /// <param name="hint">hint to use</param>
1685        /// <returns>1 on success</returns>
1686#if WindowsCE
1687        public static int CTX_use_psk_identity_hint(IntPtr ctx, string hint)
1688#else
1689        public static int CTX_use_psk_identity_hint(IntPtr ctx, StringBuilder hint)
1690#endif
1691        {
1692            try
1693            {
1694                IntPtr local_ctx = unwrap_ctx(ctx);
1695                if (local_ctx == IntPtr.Zero)
1696                {
1697                    log(ERROR_LOG, "CTX use psk identity hint unwrap error");
1698                    return FAILURE;
1699                }
1700
1701            #if WindowsCE
1702                return wolfSSL_CTX_use_psk_identity_hint(local_ctx, wolfssl.WideCharToMultiByte(hint));
1703            #else
1704                return wolfSSL_CTX_use_psk_identity_hint(local_ctx, hint);
1705            #endif
1706            }
1707            catch (Exception e)
1708            {
1709                log(ERROR_LOG, "wolfssl psk identity hint error " + e.ToString());
1710                return FAILURE;
1711            }
1712        }
1713
1714
1715        /// <summary>
1716        /// Set the function to use for PSK connections
1717        /// </summary>
1718        /// <param name="ctx">pointer to CTX that the function is set in</param>
1719        /// <param name="psk_cb">PSK function to use</param>
1720        public static void CTX_set_psk_server_callback(IntPtr ctx, psk_delegate psk_cb)
1721        {
1722            try
1723            {
1724#if WindowsCE
1725                GCHandle gch = (GCHandle)ctx;
1726#else
1727                GCHandle gch = GCHandle.FromIntPtr(ctx);
1728#endif
1729                ctx_handle handles = (ctx_handle)gch.Target;
1730
1731                handles.set_psk(GCHandle.Alloc(psk_cb));
1732                wolfSSL_CTX_set_psk_server_callback(handles.get_ctx(), psk_cb);
1733            }
1734            catch (Exception e)
1735            {
1736                log(ERROR_LOG, "wolfssl psk server callback error " + e.ToString());
1737            }
1738        }
1739
1740
1741        /// <summary>
1742        /// Set the function to use for PSK connections
1743        /// </summary>
1744        /// <param name="ctx">pointer to CTX that the function is set in</param>
1745        /// <param name="psk_cb">PSK function to use</param>
1746        public static void CTX_set_psk_client_callback(IntPtr ctx, psk_client_delegate psk_cb)
1747        {
1748            try
1749            {
1750#if WindowsCE
1751                GCHandle gch = (GCHandle)ctx;
1752#else
1753                GCHandle gch = GCHandle.FromIntPtr(ctx);
1754#endif
1755                ctx_handle handles = (ctx_handle)gch.Target;
1756
1757                handles.set_psk(GCHandle.Alloc(psk_cb));
1758                wolfSSL_CTX_set_psk_client_callback(handles.get_ctx(), psk_cb);
1759            }
1760            catch (Exception e)
1761            {
1762                log(ERROR_LOG, "wolfssl psk client callback error " + e.ToString());
1763            }
1764        }
1765
1766
1767        /// <summary>
1768        /// Set the function to use for PSK connections on a single TLS/DTLS connection
1769        /// </summary>
1770        /// <param name="ctx">pointer to SSL that the function is set in</param>
1771        /// <param name="psk_cb">PSK function to use</param>
1772        public static void set_psk_server_callback(IntPtr ssl, psk_delegate psk_cb)
1773        {
1774            try
1775            {
1776#if WindowsCE
1777                GCHandle gch = (GCHandle)ssl;
1778#else
1779                GCHandle gch = GCHandle.FromIntPtr(ssl);
1780#endif
1781                ssl_handle handles = (ssl_handle)gch.Target;
1782
1783                handles.set_psk(GCHandle.Alloc(psk_cb));
1784                wolfSSL_set_psk_server_callback(handles.get_ssl(), psk_cb);
1785            }
1786            catch (Exception e)
1787            {
1788                log(ERROR_LOG, "wolfssl psk server callback error " + e.ToString());
1789            }
1790        }
1791
1792
1793        /// <summary>
1794        /// Set Socket for TLS connection
1795        /// </summary>
1796        /// <param name="ssl">structure to set Socket in</param>
1797        /// <param name="fd">Socket to use</param>
1798        /// <returns>1 on success</returns>
1799        public static int set_fd(IntPtr ssl, Socket fd)
1800        {
1801            /* sanity check on inputs */
1802            if (ssl == IntPtr.Zero)
1803            {
1804                return FAILURE;
1805            }
1806
1807            try
1808            {
1809                if (!fd.Equals(null))
1810                {
1811#if WindowsCE
1812                    GCHandle gch = (GCHandle)ssl;
1813#else
1814                    GCHandle gch = GCHandle.FromIntPtr(ssl);
1815#endif
1816                    ssl_handle handles = (ssl_handle)gch.Target;
1817
1818                    IntPtr sslCtx = handles.get_ssl();
1819                    IntPtr ptr;
1820                    GCHandle fd_pin = GCHandle.Alloc(fd); // NOTE: Pinned only needed for buffers, not simple refs
1821
1822                    if (sslCtx == IntPtr.Zero)
1823                    {
1824                        log(ERROR_LOG, "wolfssl error setting up fd!!");
1825                        return FAILURE;
1826                    }
1827
1828                    handles.set_fd(fd_pin);
1829#if WindowsCE
1830                    ptr = (IntPtr)fd_pin;
1831#else
1832                    ptr = GCHandle.ToIntPtr(fd_pin);
1833#endif
1834
1835                    wolfSSL_SetIOWriteCtx(sslCtx, ptr); //pass along the socket for writing to
1836                    wolfSSL_SetIOReadCtx(sslCtx, ptr); //pass along the socket for reading from
1837
1838                    return SUCCESS;
1839                }
1840
1841                return FAILURE;
1842            }
1843            catch (Exception e)
1844            {
1845                log(ERROR_LOG, "Error setting up fd!! " + e.ToString());
1846                return FAILURE;
1847            }
1848        }
1849
1850
1851        /// <summary>
1852        /// Get socket of a TLS connection
1853        /// </summary>
1854        /// <param name="ssl">structure to get socket from</param>
1855        /// <returns>Socket object used for connection</returns>
1856        public static Socket get_fd(IntPtr ssl)
1857        {
1858            try
1859            {
1860                IntPtr ptr;
1861                IntPtr sslCtx = unwrap_ssl(ssl);
1862                if (sslCtx == IntPtr.Zero)
1863                {
1864                    log(ERROR_LOG, "wolfssl get_fd error");
1865                    return null;
1866                }
1867
1868                ptr = wolfSSL_GetIOReadCtx(sslCtx);
1869                if (ptr != IntPtr.Zero)
1870                {
1871#if WindowsCE
1872                    GCHandle gch = (GCHandle)ptr;
1873#else
1874                    GCHandle gch = GCHandle.FromIntPtr(ptr);
1875#endif
1876                    return (System.Net.Sockets.Socket)gch.Target;
1877                }
1878                return null;
1879            }
1880            catch (Exception e)
1881            {
1882                log(ERROR_LOG, "wolfssl get_fd error " + e.ToString());
1883                return null;
1884            }
1885        }
1886
1887
1888
1889        /// <summary>
1890        /// Set information needed to send and receive a DTLS connection
1891        /// </summary>
1892        /// <param name="ssl">structure to set information in</param>
1893        /// <param name="udp">UDP object to send and receive</param>
1894        /// <param name="ep">End point of connection</param>
1895        /// <returns>1 on success</returns>
1896        public static int set_dtls_fd(IntPtr ssl, UdpClient udp, IPEndPoint ep)
1897        {
1898            /* sanity check on inputs */
1899            if (ssl == IntPtr.Zero)
1900            {
1901                return FAILURE;
1902            }
1903
1904            try
1905            {
1906                if (!udp.Equals(null) && !ep.Equals(null))
1907                {
1908                    IntPtr ptr;
1909                    DTLS_con con;
1910#if WindowsCE
1911                    GCHandle gch = (GCHandle)ssl;
1912#else
1913                    GCHandle gch = GCHandle.FromIntPtr(ssl);
1914#endif
1915                    ssl_handle handles = (ssl_handle)gch.Target;
1916                    GCHandle fd_pin;
1917
1918                    con = new DTLS_con();
1919                    con.udp = udp;
1920                    con.ep = ep;
1921                    fd_pin = GCHandle.Alloc(con);
1922                    handles.set_fd(fd_pin);
1923#if WindowsCE
1924                    ptr = (IntPtr)fd_pin;
1925#else
1926                    ptr = GCHandle.ToIntPtr(fd_pin);
1927#endif
1928                    wolfSSL_SetIOWriteCtx(handles.get_ssl(), ptr); //pass along the socket for writing to
1929                    wolfSSL_SetIOReadCtx(handles.get_ssl(), ptr); //pass along the socket for reading from
1930
1931                    return SUCCESS;
1932                }
1933                return FAILURE;
1934            }
1935            catch (Exception e)
1936            {
1937                log(ERROR_LOG, "Error setting up fd!! " + e.ToString());
1938                return FAILURE;
1939            }
1940        }
1941
1942
1943        /// <summary>
1944        /// Get the pointer to DTLS_con class used for connection
1945        /// </summary>
1946        /// <param name="ssl">structure to get connection from</param>
1947        /// <returns>DTLS_con object</returns>
1948        public static DTLS_con get_dtls_fd(IntPtr ssl)
1949        {
1950            try
1951            {
1952                IntPtr ptr;
1953                IntPtr sslCtx = unwrap_ssl(ssl);
1954                if (sslCtx == IntPtr.Zero)
1955                {
1956                    log(ERROR_LOG, "wolfssl get_dtls_fd error");
1957                    return null;
1958                }
1959
1960                ptr = wolfSSL_GetIOReadCtx(sslCtx);
1961                if (ptr != IntPtr.Zero)
1962                {
1963#if WindowsCE
1964                    GCHandle gch = (GCHandle)ptr;
1965#else
1966                    GCHandle gch = GCHandle.FromIntPtr(ptr);
1967#endif
1968                    return (DTLS_con)gch.Target;
1969                }
1970                return null;
1971            }
1972            catch (Exception e)
1973            {
1974                log(ERROR_LOG, "wolfssl get_dtls_fd error " + e.ToString());
1975                return null;
1976            }
1977        }
1978
1979        public static string get_ciphers()
1980        {
1981            try
1982            {
1983            #if WindowsCE
1984                string ciphers = new string(' ', 4096);
1985            #else
1986                StringBuilder ciphers = new StringBuilder(new String(' ', 4096));
1987            #endif
1988                int ret = wolfSSL_get_ciphers(ciphers, ciphers.Length);
1989                if (ret != SUCCESS)
1990                    return null;
1991
1992        #if WindowsCE
1993                return wolfssl.MultiByteToWideChar(ciphers);
1994        #else
1995                return ciphers.ToString();
1996        #endif
1997            }
1998            catch (Exception e)
1999            {
2000                log(ERROR_LOG, "wolfssl get_ciphers error " + e.ToString());
2001                return null;
2002            }
2003        }
2004
2005        /// <summary>
2006        /// Get available cipher suites
2007        /// </summary>
2008        /// <param name="list">list to fill with cipher suite names</param>
2009        /// <param name="sz">size of list available to fill</param>
2010        /// <returns>1 on success</returns>
2011#if WindowsCE
2012        public static int get_ciphers(string list, int sz)
2013#else
2014        public static int get_ciphers(StringBuilder list, int sz)
2015#endif
2016        {
2017            try
2018            {
2019                return wolfSSL_get_ciphers(list, sz);
2020            }
2021            catch (Exception e)
2022            {
2023                log(ERROR_LOG, "wolfssl get_ciphers error " + e.ToString());
2024                return FAILURE;
2025            }
2026        }
2027
2028
2029        /// <summary>
2030        /// Initialize wolfSSL library
2031        /// </summary>
2032        /// <returns>1 on success</returns>
2033        public static int Init()
2034        {
2035            try
2036            {
2037                return wolfSSL_Init();
2038            }
2039            catch (Exception e)
2040            {
2041                log(ERROR_LOG, "wolfssl init error " + e.ToString());
2042                return FAILURE;
2043            }
2044        }
2045
2046
2047        /// <summary>
2048        /// Clean up wolfSSL library memory
2049        /// </summary>
2050        /// <returns>1 on success</returns>
2051        public static int Cleanup()
2052        {
2053            try
2054            {
2055                return wolfSSL_Cleanup();
2056            }
2057            catch (Exception e)
2058            {
2059                log(ERROR_LOG, "wolfssl cleanup error " + e.ToString());
2060                return FAILURE;
2061            }
2062        }
2063
2064
2065        /// <summary>
2066        /// Set up TLS version 1.2 method
2067        /// </summary>
2068        /// <returns>pointer to TLSv1.2 method</returns>
2069        public static IntPtr useTLSv1_2_server()
2070        {
2071            try
2072            {
2073                return wolfTLSv1_2_server_method();
2074            }
2075            catch (Exception e)
2076            {
2077                log(ERROR_LOG, "wolfssl error " + e.ToString());
2078                return IntPtr.Zero;
2079            }
2080        }
2081
2082        /// <summary>
2083        /// Set up TLS version 1.3 method
2084        /// </summary>
2085        /// <returns>pointer to TLSv1.3 method</returns>
2086        public static IntPtr useTLSv1_3_server()
2087        {
2088            try
2089            {
2090                return wolfTLSv1_3_server_method();
2091            }
2092            catch (Exception e)
2093            {
2094                log(ERROR_LOG, "wolfssl error " + e.ToString());
2095                return IntPtr.Zero;
2096            }
2097        }
2098
2099
2100        /// <summary>
2101        /// Use any TLS version
2102        /// </summary>
2103        /// <returns>pointer to method</returns>
2104        public static IntPtr usev23_server()
2105        {
2106            try
2107            {
2108                return wolfSSLv23_server_method();
2109            }
2110            catch (Exception e)
2111            {
2112                log(ERROR_LOG, "wolfssl error " + e.ToString());
2113                return IntPtr.Zero;
2114            }
2115        }
2116
2117
2118        /// <summary>
2119        /// Set up TLS version 1.2 method
2120        /// </summary>
2121        /// <returns>pointer to TLSv1.2 method</returns>
2122        public static IntPtr useTLSv1_2_client()
2123        {
2124            try
2125            {
2126                return wolfTLSv1_2_client_method();
2127            }
2128            catch (Exception e)
2129            {
2130                log(ERROR_LOG, "wolfssl error " + e.ToString());
2131                return IntPtr.Zero;
2132            }
2133        }
2134
2135        /// <summary>
2136        /// Set up TLS version 1.3 method
2137        /// </summary>
2138        /// <returns>pointer to TLSv1.3 method</returns>
2139        public static IntPtr useTLSv1_3_client()
2140        {
2141            try
2142            {
2143                return wolfTLSv1_3_client_method();
2144            }
2145            catch (Exception e)
2146            {
2147                log(ERROR_LOG, "wolfssl error " + e.ToString());
2148                return IntPtr.Zero;
2149            }
2150        }
2151
2152        /// <summary>
2153        /// Use any TLS version
2154        /// </summary>
2155        /// <returns>pointer to method</returns>
2156        public static IntPtr usev23_client()
2157        {
2158            try
2159            {
2160                return wolfSSLv23_client_method();
2161            }
2162            catch (Exception e)
2163            {
2164                log(ERROR_LOG, "wolfssl error " + e.ToString());
2165                return IntPtr.Zero;
2166            }
2167        }
2168
2169
2170        /// <summary>
2171        /// Set up DTLS version 1.2
2172        /// </summary>
2173        /// <returns>pointer to DTLSv1.2 method</returns>
2174        public static IntPtr useDTLSv1_2_server()
2175        {
2176            try
2177            {
2178                return wolfDTLSv1_2_server_method();
2179            }
2180            catch (Exception e)
2181            {
2182                log(ERROR_LOG, "wolfssl error " + e.ToString());
2183                return IntPtr.Zero;
2184            }
2185        }
2186
2187
2188        /// <summary>
2189        /// Set up DTLS version 1.2
2190        /// </summary>
2191        /// <returns>pointer to DTLSv1.2 method</returns>
2192        public static IntPtr useDTLSv1_2_client()
2193        {
2194            try
2195            {
2196                return wolfDTLSv1_2_client_method();
2197            }
2198            catch (Exception e)
2199            {
2200                log(ERROR_LOG, "wolfssl error " + e.ToString());
2201                return IntPtr.Zero;
2202            }
2203        }
2204
2205
2206        /// <summary>
2207        /// Gets the current cipher suite being used in connection
2208        /// </summary>
2209        /// <param name="ssl">SSL struct to get cipher suite from</param>
2210        /// <returns>string containing current cipher suite</returns>
2211        public static string get_current_cipher(IntPtr ssl)
2212        {
2213            if (ssl == IntPtr.Zero)
2214                return null;
2215            try
2216            {
2217                IntPtr ssl_cipher;
2218                IntPtr ssl_cipher_ptr;
2219                string ssl_cipher_str;
2220
2221                IntPtr sslCtx = unwrap_ssl(ssl);
2222                if (sslCtx == IntPtr.Zero)
2223                {
2224                    log(ERROR_LOG, "wolfssl get_current_cipher error");
2225                    return null;
2226                }
2227
2228                ssl_cipher = wolfSSL_get_current_cipher(sslCtx);
2229                ssl_cipher_ptr = wolfSSL_CIPHER_get_name(ssl_cipher);
2230                ssl_cipher_str = wolfssl.PtrToStringAnsi(ssl_cipher_ptr);
2231
2232                return ssl_cipher_str;
2233            }
2234            catch (Exception e)
2235            {
2236                log(ERROR_LOG, "wolfssl get current cipher error " + e.ToString());
2237                return null;
2238            }
2239        }
2240
2241
2242        /// <summary>
2243        /// Set available cipher suites for all ssl structs created from ctx
2244        /// </summary>
2245        /// <param name="ctx">CTX structure to set</param>
2246        /// <param name="list">List full of ciphers suites</param>
2247        /// <returns>1 on success</returns>
2248#if WindowsCE
2249        public static int CTX_set_cipher_list(IntPtr ctx, string list)
2250#else
2251        public static int CTX_set_cipher_list(IntPtr ctx, StringBuilder list)
2252#endif
2253        {
2254            try
2255            {
2256                IntPtr local_ctx = unwrap_ctx(ctx);
2257                if (local_ctx == IntPtr.Zero)
2258                {
2259                    log(ERROR_LOG, "CTX set cipher list error");
2260                    return FAILURE;
2261                }
2262
2263            #if WindowsCE
2264                return wolfSSL_CTX_set_cipher_list(local_ctx, wolfssl.WideCharToMultiByte(list));
2265            #else
2266                return wolfSSL_CTX_set_cipher_list(local_ctx, list);
2267            #endif
2268            }
2269            catch (Exception e)
2270            {
2271                log(ERROR_LOG, "wolfssl ctx set cipher list error " + e.ToString());
2272                return FAILURE;
2273            }
2274        }
2275
2276
2277        /// <summary>
2278        /// Set available cipher suite in local connection
2279        /// </summary>
2280        /// <param name="ssl">Structure to set cipher suite in</param>
2281        /// <param name="list">List of cipher suites</param>
2282        /// <returns>1 on success</returns>
2283#if WindowsCE
2284        public static int set_cipher_list(IntPtr ssl, string list)
2285#else
2286        public static int set_cipher_list(IntPtr ssl, StringBuilder list)
2287#endif
2288        {
2289            try
2290            {
2291                IntPtr sslCtx = unwrap_ssl(ssl);
2292                if (sslCtx == IntPtr.Zero)
2293                {
2294                    log(ERROR_LOG, "wolfssl set_cipher_list error");
2295                    return FAILURE;
2296                }
2297
2298            #if WindowsCE
2299                return wolfSSL_set_cipher_list(sslCtx, wolfssl.WideCharToMultiByte(list));
2300            #else
2301                return wolfSSL_set_cipher_list(sslCtx, list);
2302            #endif
2303            }
2304            catch (Exception e)
2305            {
2306                log(ERROR_LOG, "wolfssl set cipher error " + e.ToString());
2307                return FAILURE;
2308            }
2309        }
2310
2311
2312        /// <summary>
2313        /// Gets the version of the connection made ie TLSv1.2
2314        /// </summary>
2315        /// <param name="ssl">SSL struct to get version of</param>
2316        /// <returns>string containing version</returns>
2317        public static string get_version(IntPtr ssl)
2318        {
2319            if (ssl == IntPtr.Zero)
2320                return null;
2321
2322            try
2323            {
2324                IntPtr version_ptr;
2325                string version;
2326
2327                IntPtr sslCtx = unwrap_ssl(ssl);
2328                if (sslCtx == IntPtr.Zero)
2329                {
2330                    log(ERROR_LOG, "wolfssl get_version error");
2331                    return null;
2332                }
2333
2334                version_ptr = wolfSSL_get_version(sslCtx);
2335                version = wolfssl.PtrToStringAnsi(version_ptr);
2336                return version;
2337            }
2338            catch (Exception e)
2339            {
2340                log(ERROR_LOG, "wolfssl get version error " + e.ToString());
2341                return null;
2342            }
2343        }
2344
2345
2346        /// <summary>
2347        /// Get a string containing error value and reason
2348        /// </summary>
2349        /// <param name="ssl">SSL struct that had error</param>
2350        /// <returns>String containing error value and reason</returns>
2351        public static string get_error(IntPtr ssl)
2352        {
2353            if (ssl == IntPtr.Zero)
2354                return null;
2355
2356            try
2357            {
2358                IntPtr sslCtx = unwrap_ssl(ssl);
2359                if (sslCtx == IntPtr.Zero)
2360                {
2361                    log(ERROR_LOG, "wolfssl get_error error");
2362                    return null;
2363                }
2364
2365                int err = wolfSSL_get_error(sslCtx, 0);
2366                IntPtr err_ptr = wolfSSL_ERR_reason_error_string((uint)err);
2367                string err_str = wolfssl.PtrToStringAnsi(err_ptr);
2368                return "Error " + err + " " + err_str;
2369            }
2370            catch (Exception e)
2371            {
2372                log(ERROR_LOG, "wolfssl get error, error " + e.ToString());
2373                return null;
2374            }
2375        }
2376
2377
2378        /// <summary>
2379        /// Used to load in the certificate file
2380        /// </summary>
2381        /// <param name="ctx">CTX structure for TLS/SSL connections</param>
2382        /// <param name="fileCert">Name of the file to load including absolute path</param>
2383        /// <param name="type">Type of file ie PEM or DER</param>
2384        /// <returns>1 on success</returns>
2385        public static int CTX_use_certificate_file(IntPtr ctx, string fileCert, int type)
2386        {
2387            try
2388            {
2389                IntPtr local_ctx = unwrap_ctx(ctx);
2390                if (local_ctx == IntPtr.Zero)
2391                {
2392                    log(ERROR_LOG, "CTX use certificate file error");
2393                    return FAILURE;
2394                }
2395
2396            #if WindowsCE
2397                return wolfSSL_CTX_use_certificate_file(local_ctx, wolfssl.WideCharToMultiByte(fileCert), type);
2398            #else
2399                return wolfSSL_CTX_use_certificate_file(local_ctx, fileCert, type);
2400            #endif
2401            }
2402            catch (Exception e)
2403            {
2404                log(ERROR_LOG, "wolfssl ctx use cert file error " + e.ToString());
2405                return FAILURE;
2406            }
2407        }
2408
2409
2410        /// <summary>
2411        /// Used to load in the peer trusted root file
2412        /// </summary>
2413        /// <param name="ctx">CTX structure for TLS/SSL connections</param>
2414        /// <param name="fileCert">Name of the file to load including absolute path</param>
2415        /// <param name="type">path to multiple certificates (try to load all in path) </param>
2416        /// <returns>1 on success</returns>
2417        public static int CTX_load_verify_locations(IntPtr ctx, string fileCert, string path)
2418        {
2419            try
2420            {
2421                IntPtr local_ctx = unwrap_ctx(ctx);
2422                if (local_ctx == IntPtr.Zero)
2423                {
2424                    log(ERROR_LOG, "CTX load verify locations certificate file error");
2425                    return FAILURE;
2426                }
2427
2428            #if WindowsCE
2429                return wolfSSL_CTX_load_verify_locations(local_ctx, wolfssl.WideCharToMultiByte(fileCert), wolfssl.WideCharToMultiByte(path));
2430            #else
2431                return wolfSSL_CTX_load_verify_locations(local_ctx, fileCert, path);
2432            #endif
2433            }
2434            catch (Exception e)
2435            {
2436                log(ERROR_LOG, "wolfssl ctx load verify locations file error " + e.ToString());
2437                return FAILURE;
2438            }
2439        }
2440
2441        /// <summary>
2442        /// Used to load in the private key from a file
2443        /// </summary>
2444        /// <param name="ctx">CTX structure for TLS/SSL connections </param>
2445        /// <param name="fileKey">Name of the file, including absolute directory</param>
2446        /// <param name="type">Type of file ie PEM or DER</param>
2447        /// <returns>1 on success</returns>
2448        public static int CTX_use_PrivateKey_file(IntPtr ctx, string fileKey, int type)
2449        {
2450            try
2451            {
2452                IntPtr local_ctx = unwrap_ctx(ctx);
2453                if (local_ctx == IntPtr.Zero)
2454                {
2455                    log(ERROR_LOG, "CTX use PrivateKey file error");
2456                    return FAILURE;
2457                }
2458
2459            #if WindowsCE
2460                return wolfSSL_CTX_use_PrivateKey_file(local_ctx, wolfssl.WideCharToMultiByte(fileKey), type);
2461            #else
2462                return wolfSSL_CTX_use_PrivateKey_file(local_ctx, fileKey, type);
2463            #endif
2464            }
2465            catch (Exception e)
2466            {
2467                log(ERROR_LOG, "wolfssl ctx use key file error " + e.ToString());
2468                return FAILURE;
2469            }
2470        }
2471
2472
2473        /// <summary>
2474        /// Set temporary DH parameters
2475        /// </summary>
2476        /// <param name="ssl">Structure to set in</param>
2477        /// <param name="dhparam">file name</param>
2478        /// <param name="file_type">type of file ie PEM</param>
2479        /// <returns>1 on success</returns>
2480#if WindowsCE
2481        public static int SetTmpDH_file(IntPtr ssl, string dhparam, int file_type)
2482#else
2483        public static int SetTmpDH_file(IntPtr ssl, StringBuilder dhparam, int file_type)
2484#endif
2485        {
2486            try
2487            {
2488                IntPtr sslCtx = unwrap_ssl(ssl);
2489                if (sslCtx == IntPtr.Zero)
2490                {
2491                    log(ERROR_LOG, "SetTmpDH_file ssl unwrap error");
2492                    return FAILURE;
2493                }
2494
2495            #if WindowsCE
2496                return wolfSSL_SetTmpDH_file(sslCtx, wolfssl.WideCharToMultiByte(dhparam), file_type);
2497            #else
2498                return wolfSSL_SetTmpDH_file(sslCtx, dhparam, file_type);
2499            #endif
2500            }
2501            catch (Exception e)
2502            {
2503                log(ERROR_LOG, "SetTmpDH_file error " + e.ToString());
2504                return FAILURE;
2505            }
2506        }
2507
2508        /// <summary>
2509        /// Set temporary DH parameters
2510        /// </summary>
2511        /// <param name="ctx">Structure to set in</param>
2512        /// <param name="dhparam">file name</param>
2513        /// <param name="file_type">type of file ie PEM</param>
2514        /// <returns>1 on success</returns>
2515#if WindowsCE
2516        public static int CTX_SetTmpDH_file(IntPtr ctx, string dhparam, int file_type)
2517#else
2518        public static int CTX_SetTmpDH_file(IntPtr ctx, StringBuilder dhparam, int file_type)
2519#endif
2520        {
2521            try
2522            {
2523                IntPtr local_ctx = unwrap_ctx(ctx);
2524                if (local_ctx == IntPtr.Zero)
2525                {
2526                    log(ERROR_LOG, "CTX_SetTmpDH_file ctx unwrap error");
2527                    return FAILURE;
2528                }
2529
2530            #if WindowsCE
2531                return wolfSSL_CTX_SetTmpDH_file(local_ctx, wolfssl.WideCharToMultiByte(dhparam), file_type);
2532            #else
2533                return wolfSSL_CTX_SetTmpDH_file(local_ctx, dhparam, file_type);
2534            #endif
2535            }
2536            catch (Exception e)
2537            {
2538                log(ERROR_LOG, "CTX_SetTmpDH_file error " + e.ToString());
2539                return FAILURE;
2540            }
2541        }
2542
2543
2544        /// <summary>
2545        /// Used to set the minimum size of DH key
2546        /// </summary>
2547        /// <param name="ctx">Structure to store key size</param>
2548        /// <param name="minDhKey">Min key size </param>
2549        /// <returns>1 on success</returns>
2550        public static int CTX_SetMinDhKey_Sz(IntPtr ctx, short minDhKey)
2551        {
2552            try
2553            {
2554                IntPtr local_ctx = unwrap_ctx(ctx);
2555                if (local_ctx == IntPtr.Zero)
2556                {
2557                    log(ERROR_LOG, "CTX SetMinDhKey_Sz error");
2558                    return FAILURE;
2559                }
2560
2561                return wolfSSL_CTX_SetMinDhKey_Sz(local_ctx, minDhKey);
2562            }
2563            catch (Exception e)
2564            {
2565                log(ERROR_LOG, "wolfssl ctx set min dh key error " + e.ToString());
2566                return FAILURE;
2567            }
2568        }
2569
2570        /// <summary>
2571        /// Set the certificate verification mode and optional callback function
2572        /// </summary>
2573        /// <param name="ctx">pointer to CTX that the function is set in</param>
2574        /// <param name="mode">See SSL_VERIFY options</param>
2575        /// <param name="vc">Optional verify callback function to use</param>
2576        public static int CTX_set_verify(IntPtr ctx, int mode, CallbackVerify_delegate vc)
2577        {
2578            try
2579            {
2580                GCHandle   gch;
2581                ctx_handle handles;
2582                IntPtr     local_ctx = unwrap_ctx(ctx);
2583                if (local_ctx == IntPtr.Zero)
2584                {
2585                    log(ERROR_LOG, "CTX set_verify error");
2586                    return FAILURE;
2587                }
2588
2589                /* pin the verify callback to protect from garbage collection */
2590                if (!vc.Equals(null)) {
2591#if WindowsCE
2592                    gch = (GCHandle)ctx;
2593#else
2594                    gch = GCHandle.FromIntPtr(ctx);
2595#endif
2596                    handles = (ctx_handle)gch.Target;
2597                    handles.set_vrf(GCHandle.Alloc(vc));
2598                }
2599
2600                wolfSSL_CTX_set_verify(local_ctx, mode, vc);
2601                return SUCCESS;
2602            }
2603            catch (Exception e)
2604            {
2605                log(ERROR_LOG, "wolfssl ctx set verify error " + e.ToString());
2606                return FAILURE;
2607            }
2608        }
2609
2610        /// <summary>
2611        /// Set the certificate verification mode and optional callback function
2612        /// </summary>
2613        /// <param name="ctx">pointer to SSL object that the function is set in</param>
2614        /// <param name="mode">See SSL_VERIFY options</param>
2615        /// <param name="vc">Optional verify callback function to use</param>
2616        public static int set_verify(IntPtr ssl, int mode, CallbackVerify_delegate vc)
2617        {
2618            try
2619            {
2620                GCHandle   gch;
2621                ssl_handle handles;
2622                IntPtr     local_ssl = unwrap_ssl(ssl);
2623                if (local_ssl == IntPtr.Zero)
2624                {
2625                    log(ERROR_LOG, "set_verify error");
2626                    return FAILURE;
2627                }
2628
2629                /* pin the verify callback to protect from garbage collection */
2630                if (!vc.Equals(null)) {
2631#if WindowsCE
2632                    gch = (GCHandle)ssl;
2633#else
2634                    gch = GCHandle.FromIntPtr(ssl);
2635#endif
2636                    handles = (ssl_handle)gch.Target;
2637                    handles.set_vrf(GCHandle.Alloc(vc));
2638                }
2639
2640                wolfSSL_set_verify(local_ssl, mode, vc);
2641                return SUCCESS;
2642            }
2643            catch (Exception e)
2644            {
2645                log(ERROR_LOG, "wolfssl set verify error " + e.ToString());
2646                return FAILURE;
2647            }
2648        }
2649
2650
2651        /// <summary>
2652        /// Set the certificate verification mode and optional callback function
2653        /// </summary>
2654        /// <param name="ctx">pointer to SSL object that the function is set in</param>
2655        /// <param name="mode">See SSL_VERIFY options</param>
2656        /// <param name="vc">Optional verify callback function to use</param>
2657        public static X509 X509_STORE_CTX_get_current_cert(IntPtr x509Ctx)
2658        {
2659            X509 ret = null;
2660            try
2661            {
2662                if (x509Ctx == IntPtr.Zero)
2663                {
2664                    log(ERROR_LOG, "pointer passed in was not set");
2665                    return ret;
2666                }
2667                IntPtr x509 = wolfSSL_X509_STORE_CTX_get_current_cert(x509Ctx);
2668                if (x509 != IntPtr.Zero) {
2669                    return new X509(x509, false);
2670                }
2671                return ret;
2672            }
2673            catch (Exception e)
2674            {
2675                log(ERROR_LOG, "wolfssl WOLFSSL_X509_STORE_CTX error " + e.ToString());
2676                return ret;
2677            }
2678        }
2679
2680
2681        /// <summary>
2682        /// Gets all of the certificates from store
2683        /// </summary>
2684        /// <param name="x509Ctx">pointer to store to get certificates from</param>
2685        public static X509[] X509_STORE_CTX_get_certs(IntPtr x509Ctx)
2686        {
2687            X509[] ret = null;
2688            try
2689            {
2690                if (x509Ctx == IntPtr.Zero)
2691                {
2692                    log(ERROR_LOG, "pointer passed in was not set");
2693                    return ret;
2694                }
2695                IntPtr sk = wolfSSL_X509_STORE_GetCerts(x509Ctx);
2696                if (sk != IntPtr.Zero) {
2697                    int i;
2698                    int numCerts = wolfSSL_sk_X509_num(sk);
2699                    ret = new X509[numCerts];
2700
2701                    for (i = 0; i < numCerts; i++) {
2702                        IntPtr current = wolfSSL_sk_X509_pop(sk);
2703                        if (current != IntPtr.Zero)
2704                        {
2705                            ret[i] = new X509(current, true);
2706                        }
2707                    }
2708                    wolfSSL_sk_X509_free(sk);
2709                }
2710                return ret;
2711
2712            }
2713            catch (Exception e)
2714            {
2715                log(ERROR_LOG, "wolfssl WOLFSSL_X509_STORE_CTX error " + e.ToString());
2716                return ret;
2717            }
2718        }
2719
2720
2721        /// <summary>
2722        /// Get the current WOLFSSL_X509_STORE_CTX error value
2723        /// </summary>
2724        /// <param name="x509Ctx">pointer to store to get error from</param>
2725        public static int X509_STORE_CTX_get_error(IntPtr x509Ctx)
2726        {
2727            try
2728            {
2729                if (x509Ctx == IntPtr.Zero)
2730                {
2731                    log(ERROR_LOG, "pointer passed in was not set");
2732                    return -1;
2733                }
2734                return wolfSSL_X509_STORE_CTX_get_error(x509Ctx);
2735            }
2736            catch (Exception e)
2737            {
2738                log(ERROR_LOG, "wolfssl WOLFSSL_X509_STORE_CTX error " + e.ToString());
2739                return -1;
2740            }
2741        }
2742
2743        /// <summary>
2744        /// Print low level C library debug messages to stdout when compiled with macro DEBUG_WOLFSSL
2745        /// </summary>
2746        public static void Debugging_ON()
2747        {
2748            wolfSSL_Debugging_ON();
2749        }
2750
2751        /// <summary>
2752        /// Turn off low level C debug messages
2753        /// </summary>
2754        public static void Debugging_OFF()
2755        {
2756            wolfSSL_Debugging_OFF();
2757        }
2758
2759        /// <summary>
2760        /// Set the function to use for logging
2761        /// </summary>
2762        /// <param name="input">Function that conforms as to loggingCb</param>
2763        /// <returns>1 on success</returns>
2764        public static int SetLogging(loggingCb input)
2765        {
2766            internal_log = input;
2767
2768            wolfSSL_SetLoggingCb(input);
2769
2770            return SUCCESS;
2771        }
2772
2773
2774        /// <summary>
2775        /// Log a message to set logging function
2776        /// </summary>
2777        /// <param name="lvl">Level of log message</param>
2778        /// <param name="msg">Message to log</param>
2779        public static void log(int lvl, string msg)
2780        {
2781            /* if log is not set then print nothing */
2782            if (internal_log == null)
2783                return;
2784        #if WindowsCE
2785            internal_log(lvl, msg);
2786        #else
2787            StringBuilder msg_sb = new StringBuilder(msg);
2788            internal_log(lvl, msg_sb);
2789        #endif
2790        }
2791    }
2792}