mcs/class/System/Mono.Btls/MonoBtlsSsl.cs

   1 //
   2 // MonoBtlsSsl.cs
   3 //
   4 // Author:
   5 //       Martin Baulig <martin.baulig@xamarin.com>
   6 //
   7 // Copyright (c) 2015 Xamarin Inc. (http://www.xamarin.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining a copy
  10 // of this software and associated documentation files (the "Software"), to deal
  11 // in the Software without restriction, including without limitation the rights
  12 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13 // copies of the Software, and to permit persons to whom the Software is
  14 // furnished to do so, subject to the following conditions:
  15 //
  16 // The above copyright notice and this permission notice shall be included in
  17 // all copies or substantial portions of the Software.
  18 //
  19 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  25 // THE SOFTWARE.
  26 #if SECURITY_DEP && MONO_FEATURE_BTLS
  27 using System;
  28 using System.IO;
  29 using System.Text;
  30 using System.Runtime.InteropServices;
  31 using System.Runtime.CompilerServices;
  32
  33 #if MONOTOUCH
  34 using MonoTouch;
  35 #endif
  36
  37 namespace Mono.Btls
  38 {
  39         delegate int MonoBtlsVerifyCallback (MonoBtlsX509StoreCtx ctx);
  40         delegate int MonoBtlsSelectCallback ();
  41
  42         class MonoBtlsSsl : MonoBtlsObject
  43         {
  44                 internal class BoringSslHandle : MonoBtlsHandle
  45                 {
  46                         public BoringSslHandle (IntPtr handle)
  47                                 : base (handle, true)
  48                         {
  49                         }
  50
  51                         protected override bool ReleaseHandle ()
  52                         {
  53                                 mono_btls_ssl_destroy (handle);
  54                                 return true;
  55                         }
  56                 }
  57
  58                 [DllImport (BTLS_DYLIB)]
  59                 extern static void mono_btls_ssl_destroy (IntPtr handle);
  60
  61                 [DllImport (BTLS_DYLIB)]
  62                 extern static IntPtr mono_btls_ssl_new (IntPtr handle);
  63
  64                 [DllImport (BTLS_DYLIB)]
  65                 extern static int mono_btls_ssl_use_certificate (IntPtr handle, IntPtr x509);
  66
  67                 [DllImport (BTLS_DYLIB)]
  68                 extern static int mono_btls_ssl_use_private_key (IntPtr handle, IntPtr key);
  69
  70                 [DllImport (BTLS_DYLIB)]
  71                 extern static int mono_btls_ssl_add_chain_certificate (IntPtr handle, IntPtr x509);
  72
  73                 [DllImport (BTLS_DYLIB)]
  74                 extern static int mono_btls_ssl_accept (IntPtr handle);
  75
  76                 [DllImport (BTLS_DYLIB)]
  77                 extern static int mono_btls_ssl_connect (IntPtr handle);
  78
  79                 [DllImport (BTLS_DYLIB)]
  80                 extern static int mono_btls_ssl_handshake (IntPtr handle);
  81
  82                 [DllImport (BTLS_DYLIB)]
  83                 extern static void mono_btls_ssl_close (IntPtr handle);
  84
  85                 [DllImport (BTLS_DYLIB)]
  86                 extern static void mono_btls_ssl_set_bio (IntPtr handle, IntPtr bio);
  87
  88                 [DllImport (BTLS_DYLIB)]
  89                 extern static int mono_btls_ssl_read (IntPtr handle, IntPtr data, int len);
  90
  91                 [DllImport (BTLS_DYLIB)]
  92                 extern static int mono_btls_ssl_write (IntPtr handle, IntPtr data, int len);
  93
  94                 [DllImport (BTLS_DYLIB)]
  95                 extern static int mono_btls_ssl_get_error (IntPtr handle, int ret_code);
  96
  97                 [DllImport (BTLS_DYLIB)]
  98                 extern static int mono_btls_ssl_get_version (IntPtr handle);
  99
 100                 [DllImport (BTLS_DYLIB)]
 101                 extern static void mono_btls_ssl_set_min_version (IntPtr handle, int version);
 102
 103                 [DllImport (BTLS_DYLIB)]
 104                 extern static void mono_btls_ssl_set_max_version (IntPtr handle, int version);
 105
 106                 [DllImport (BTLS_DYLIB)]
 107                 extern static int mono_btls_ssl_get_cipher (IntPtr handle);
 108
 109                 [DllImport (BTLS_DYLIB)]
 110                 extern static int mono_btls_ssl_get_ciphers (IntPtr handle, out IntPtr data);
 111
 112                 [DllImport (BTLS_DYLIB)]
 113                 extern static IntPtr mono_btls_ssl_get_peer_certificate (IntPtr handle);
 114
 115                 [DllImport (BTLS_DYLIB)]
 116                 extern static int mono_btls_ssl_set_cipher_list (IntPtr handle, IntPtr str);
 117
 118                 [DllImport (BTLS_DYLIB)]
 119                 extern static void mono_btls_ssl_print_errors_cb (IntPtr func, IntPtr ctx);
 120
 121                 [DllImport (BTLS_DYLIB)]
 122                 extern static int mono_btls_ssl_set_verify_param (IntPtr handle, IntPtr param);
 123
 124                 [DllImport (BTLS_DYLIB)]
 125                 extern static int mono_btls_ssl_set_server_name (IntPtr handle, IntPtr name);
 126
 127                 [DllImport (BTLS_DYLIB)]
 128                 extern static IntPtr mono_btls_ssl_get_server_name (IntPtr handle);
 129
 130                 static BoringSslHandle Create_internal (MonoBtlsSslCtx ctx)
 131                 {
 132                         var handle = mono_btls_ssl_new (ctx.Handle.DangerousGetHandle ());
 133                         if (handle == IntPtr.Zero)
 134                                 throw new MonoBtlsException ();
 135                         return new BoringSslHandle (handle);
 136                 }
 137
 138                 PrintErrorsCallbackFunc printErrorsFunc;
 139                 IntPtr printErrorsFuncPtr;
 140
 141                 public MonoBtlsSsl (MonoBtlsSslCtx ctx)
 142                         : base (Create_internal (ctx))
 143                 {
 144                         printErrorsFunc = PrintErrorsCallback;
 145                         printErrorsFuncPtr = Marshal.GetFunctionPointerForDelegate (printErrorsFunc);
 146                 }
 147
 148                 new internal BoringSslHandle Handle {
 149                         get { return (BoringSslHandle)base.Handle; }
 150                 }
 151
 152                 public void SetBio (MonoBtlsBio bio)
 153                 {
 154                         CheckThrow ();
 155                         mono_btls_ssl_set_bio (
 156                                 Handle.DangerousGetHandle (),
 157                                 bio.Handle.DangerousGetHandle ());
 158                 }
 159
 160                 Exception ThrowError ([CallerMemberName] string callerName = null)
 161                 {
 162                         string errors;
 163                         try {
 164                                 if (callerName == null)
 165                                         callerName = GetType ().Name;
 166                                 errors = GetErrors ();
 167                         } catch {
 168                                 errors = null;
 169                         }
 170
 171                         if (errors != null) {
 172                                 Console.Error.WriteLine ("ERROR: {0} failed: {1}", callerName, errors);
 173                                 throw new MonoBtlsException ("{0} failed: {1}.", callerName, errors);
 174                         } else {
 175                                 Console.Error.WriteLine ("ERROR: {0} failed.", callerName);
 176                                 throw new MonoBtlsException ("{0} failed.", callerName);
 177                         }
 178                 }
 179
 180                 MonoBtlsSslError GetError (int ret_code)
 181                 {
 182                         CheckThrow ();
 183                         var error = mono_btls_ssl_get_error (
 184                                 Handle.DangerousGetHandle (), ret_code);
 185                         return (MonoBtlsSslError)error;
 186                 }
 187
 188                 public void SetCertificate (MonoBtlsX509 x509)
 189                 {
 190                         CheckThrow ();
 191
 192                         var ret = mono_btls_ssl_use_certificate (
 193                                 Handle.DangerousGetHandle (),
 194                                 x509.Handle.DangerousGetHandle ());
 195                         if (ret <= 0)
 196                                 throw ThrowError ();
 197                 }
 198
 199                 public void SetPrivateKey (MonoBtlsKey key)
 200                 {
 201                         CheckThrow ();
 202
 203                         var ret = mono_btls_ssl_use_private_key (
 204                                 Handle.DangerousGetHandle (),
 205                                 key.Handle.DangerousGetHandle ());
 206                         if (ret <= 0)
 207                                 throw ThrowError ();
 208                 }
 209
 210                 public void AddIntermediateCertificate (MonoBtlsX509 x509)
 211                 {
 212                         CheckThrow ();
 213
 214                         var ret = mono_btls_ssl_add_chain_certificate (
 215                                 Handle.DangerousGetHandle (),
 216                                 x509.Handle.DangerousGetHandle ());
 217                         if (ret <= 0)
 218                                 throw ThrowError ();
 219                 }
 220
 221                 public MonoBtlsSslError Accept ()
 222                 {
 223                         CheckThrow ();
 224
 225                         var ret = mono_btls_ssl_accept (Handle.DangerousGetHandle ());
 226
 227                         var error = GetError (ret);
 228                         return error;
 229                 }
 230
 231                 public MonoBtlsSslError Connect ()
 232                 {
 233                         CheckThrow ();
 234
 235                         var ret = mono_btls_ssl_connect (Handle.DangerousGetHandle ());
 236
 237                         var error = GetError (ret);
 238                         return error;
 239                 }
 240
 241                 public MonoBtlsSslError Handshake ()
 242                 {
 243                         CheckThrow ();
 244
 245                         var ret = mono_btls_ssl_handshake (Handle.DangerousGetHandle ());
 246
 247                         var error = GetError (ret);
 248                         return error;
 249                 }
 250
 251                 delegate int PrintErrorsCallbackFunc (IntPtr str, IntPtr len, IntPtr ctx);
 252
 253 #if MONOTOUCH
 254                 [MonoPInvokeCallback (typeof (PrintErrorsCallbackFunc))]
 255 #endif
 256                 static int PrintErrorsCallback (IntPtr str, IntPtr len, IntPtr ctx)
 257                 {
 258                         var sb = (StringBuilder)GCHandle.FromIntPtr (ctx).Target;
 259                         try {
 260                                 var text = Marshal.PtrToStringAnsi (str, (int)len);
 261                                 sb.Append (text);
 262                                 return 1;
 263                         } catch {
 264                                 return 0;
 265                         }
 266                 }
 267
 268                 public string GetErrors ()
 269                 {
 270                         var text = new StringBuilder ();
 271                         var handle = GCHandle.Alloc (text);
 272
 273                         try {
 274                                 mono_btls_ssl_print_errors_cb (printErrorsFuncPtr, GCHandle.ToIntPtr (handle));
 275                                 return text.ToString ();
 276                         } finally {
 277                                 if (handle.IsAllocated)
 278                                         handle.Free ();
 279                         }
 280                 }
 281
 282                 public void PrintErrors ()
 283                 {
 284                         var errors = GetErrors ();
 285                         if (string.IsNullOrEmpty (errors))
 286                                 return;
 287                         Console.Error.WriteLine (errors);
 288                 }
 289
 290                 public MonoBtlsSslError Read (IntPtr data, ref int dataSize)
 291                 {
 292                         CheckThrow ();
 293                         var ret = mono_btls_ssl_read (
 294                                 Handle.DangerousGetHandle (), data, dataSize);
 295
 296                         if (ret >= 0) {
 297                                 dataSize = ret;
 298                                 return MonoBtlsSslError.None;
 299                         }
 300
 301                         var error = mono_btls_ssl_get_error (
 302                                 Handle.DangerousGetHandle (), ret);
 303                         dataSize = 0;
 304                         return (MonoBtlsSslError)error;
 305                 }
 306
 307                 public MonoBtlsSslError Write (IntPtr data, ref int dataSize)
 308                 {
 309                         CheckThrow ();
 310                         var ret = mono_btls_ssl_write (
 311                                 Handle.DangerousGetHandle (), data, dataSize);
 312
 313                         if (ret >= 0) {
 314                                 dataSize = ret;
 315                                 return MonoBtlsSslError.None;
 316                         }
 317
 318                         var error = mono_btls_ssl_get_error (
 319                                 Handle.DangerousGetHandle (), ret);
 320                         dataSize = 0;
 321                         return (MonoBtlsSslError)error;
 322                 }
 323
 324                 public int GetVersion ()
 325                 {
 326                         CheckThrow ();
 327                         return mono_btls_ssl_get_version (Handle.DangerousGetHandle ());
 328                 }
 329
 330                 public void SetMinVersion (int version)
 331                 {
 332                         CheckThrow ();
 333                         mono_btls_ssl_set_min_version (Handle.DangerousGetHandle (), version);
 334                 }
 335
 336                 public void SetMaxVersion (int version)
 337                 {
 338                         CheckThrow ();
 339                         mono_btls_ssl_set_max_version (Handle.DangerousGetHandle (), version);
 340                 }
 341
 342                 public int GetCipher ()
 343                 {
 344                         CheckThrow ();
 345                         var cipher = mono_btls_ssl_get_cipher (Handle.DangerousGetHandle ());
 346                         CheckError (cipher > 0);
 347                         return cipher;
 348                 }
 349
 350                 public short[] GetCiphers ()
 351                 {
 352                         CheckThrow ();
 353                         IntPtr data;
 354                         var count = mono_btls_ssl_get_ciphers (
 355                                 Handle.DangerousGetHandle (), out data);
 356                         CheckError (count > 0);
 357                         try {
 358                                 short[] ciphers = new short[count];
 359                                 Marshal.Copy (data, ciphers, 0, count);
 360                                 return ciphers;
 361                         } finally {
 362                                 FreeDataPtr (data);
 363                         }
 364                 }
 365
 366                 public void SetCipherList (string str)
 367                 {
 368                         CheckThrow ();
 369                         IntPtr strPtr = IntPtr.Zero;
 370                         try {
 371                                 strPtr = Marshal.StringToHGlobalAnsi (str);
 372                                 var ret = mono_btls_ssl_set_cipher_list (
 373                                         Handle.DangerousGetHandle (), strPtr);
 374                                 CheckError (ret);
 375                         } finally {
 376                                 if (strPtr != IntPtr.Zero)
 377                                         Marshal.FreeHGlobal (strPtr);
 378                         }
 379                 }
 380
 381                 public MonoBtlsX509 GetPeerCertificate ()
 382                 {
 383                         CheckThrow ();
 384                         var x509 = mono_btls_ssl_get_peer_certificate (
 385                                 Handle.DangerousGetHandle ());
 386                         if (x509 == IntPtr.Zero)
 387                                 return null;
 388                         return new MonoBtlsX509 (new MonoBtlsX509.BoringX509Handle (x509));
 389                 }
 390
 391                 public void SetVerifyParam (MonoBtlsX509VerifyParam param)
 392                 {
 393                         CheckThrow ();
 394                         var ret = mono_btls_ssl_set_verify_param (
 395                                 Handle.DangerousGetHandle (),
 396                                 param.Handle.DangerousGetHandle ());
 397                         CheckError (ret);
 398                 }
 399
 400                 public void SetServerName (string name)
 401                 {
 402                         CheckThrow ();
 403                         IntPtr namePtr = IntPtr.Zero;
 404                         try {
 405                                 namePtr = Marshal.StringToHGlobalAnsi (name);
 406                                 var ret = mono_btls_ssl_set_server_name (
 407                                         Handle.DangerousGetHandle (), namePtr);
 408                                 CheckError (ret);
 409                         } finally {
 410                                 if (namePtr != IntPtr.Zero)
 411                                         Marshal.FreeHGlobal (namePtr);
 412                         }
 413                 }
 414
 415                 public string GetServerName ()
 416                 {
 417                         CheckThrow ();
 418                         var namePtr = mono_btls_ssl_get_server_name (
 419                                 Handle.DangerousGetHandle ());
 420                         if (namePtr == IntPtr.Zero)
 421                                 return null;
 422                         return Marshal.PtrToStringAnsi (namePtr);
 423                 }
 424
 425                 protected override void Close ()
 426                 {
 427                         mono_btls_ssl_close (Handle.DangerousGetHandle ());
 428                 }
 429         }
 430 }
 431 #endif