dlls/bcrypt/macos.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  * Copyright 2018 Hans Leidekker for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  *
  19  */
  20
  21 #if 0
  22 #pragma makedep unix
  23 #endif
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <stdarg.h>
  29 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
  30 #include <AvailabilityMacros.h>
  31 #include <CommonCrypto/CommonCryptor.h>
  32 #endif
  33
  34 #include "ntstatus.h"
  35 #define WIN32_NO_STATUS
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "ntsecapi.h"
  39 #include "bcrypt.h"
  40
  41 #include "bcrypt_internal.h"
  42
  43 #include "wine/debug.h"
  44 #include "wine/unicode.h"
  45
  46 #if defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1080 && !defined(HAVE_GNUTLS_CIPHER_INIT)
  47 WINE_DEFAULT_DEBUG_CHANNEL(bcrypt);
  48
  49 struct key_data
  50 {
  51     CCCryptorRef   ref_encrypt;
  52     CCCryptorRef   ref_decrypt;
  53 };
  54 C_ASSERT( sizeof(struct key_data) <= sizeof(((struct key *)0)->private) );
  55
  56 static struct key_data *key_data( struct key *key )
  57 {
  58     return (struct key_data *)key->private;
  59 }
  60
  61 static NTSTATUS CDECL key_set_property( struct key *key, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
  62 {
  63     if (!strcmpW( prop, BCRYPT_CHAINING_MODE ))
  64     {
  65         if (!strcmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB ))
  66         {
  67             key->u.s.mode = MODE_ID_ECB;
  68             return STATUS_SUCCESS;
  69         }
  70         else if (!strcmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC ))
  71         {
  72             key->u.s.mode = MODE_ID_CBC;
  73             return STATUS_SUCCESS;
  74         }
  75         else
  76         {
  77             FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
  78             return STATUS_NOT_IMPLEMENTED;
  79         }
  80     }
  81
  82     FIXME( "unsupported key property %s\n", debugstr_w(prop) );
  83     return STATUS_NOT_IMPLEMENTED;
  84 }
  85
  86 static NTSTATUS CDECL key_symmetric_init( struct key *key )
  87 {
  88     switch (key->alg_id)
  89     {
  90     case ALG_ID_AES:
  91         switch (key->u.s.mode)
  92         {
  93         case MODE_ID_ECB:
  94         case MODE_ID_CBC:
  95             break;
  96         default:
  97             FIXME( "mode %u not supported\n", key->u.s.mode );
  98             return STATUS_NOT_SUPPORTED;
  99         }
 100         return STATUS_SUCCESS;
 101
 102     default:
 103         FIXME( "algorithm %u not supported\n", key->alg_id );
 104         return STATUS_NOT_SUPPORTED;
 105     }
 106 }
 107
 108 static CCMode get_cryptor_mode( struct key *key )
 109 {
 110     switch (key->u.s.mode)
 111     {
 112     case MODE_ID_ECB: return kCCModeECB;
 113     case MODE_ID_CBC: return kCCModeCBC;
 114     default:
 115         FIXME( "unsupported mode %u\n", key->u.s.mode );
 116         return 0;
 117     }
 118 }
 119
 120 static void CDECL key_symmetric_vector_reset( struct key *key )
 121 {
 122     if (!key_data(key)->ref_encrypt) return;
 123
 124     TRACE( "invalidating cryptor handles\n" );
 125     CCCryptorRelease( key_data(key)->ref_encrypt );
 126     key_data(key)->ref_encrypt = NULL;
 127
 128     CCCryptorRelease( key_data(key)->ref_decrypt );
 129     key_data(key)->ref_decrypt = NULL;
 130 }
 131
 132 static NTSTATUS init_cryptor_handles( struct key *key )
 133 {
 134     CCCryptorStatus status;
 135     CCMode mode;
 136
 137     if (key_data(key)->ref_encrypt) return STATUS_SUCCESS;
 138     if (!(mode = get_cryptor_mode( key ))) return STATUS_NOT_SUPPORTED;
 139
 140     if ((status = CCCryptorCreateWithMode( kCCEncrypt, mode, kCCAlgorithmAES128, ccNoPadding, key->u.s.vector,
 141                                            key->u.s.secret, key->u.s.secret_len, NULL, 0, 0, 0,
 142                                            &key_data(key)->ref_encrypt )) != kCCSuccess)
 143     {
 144         WARN( "CCCryptorCreateWithMode failed %d\n", status );
 145         return STATUS_INTERNAL_ERROR;
 146     }
 147     if ((status = CCCryptorCreateWithMode( kCCDecrypt, mode, kCCAlgorithmAES128, ccNoPadding, key->u.s.vector,
 148                                            key->u.s.secret, key->u.s.secret_len, NULL, 0, 0, 0,
 149                                            &key_data(key)->ref_decrypt )) != kCCSuccess)
 150     {
 151         WARN( "CCCryptorCreateWithMode failed %d\n", status );
 152         CCCryptorRelease( key_data(key)->ref_encrypt );
 153         key_data(key)->ref_encrypt = NULL;
 154         return STATUS_INTERNAL_ERROR;
 155     }
 156
 157     return STATUS_SUCCESS;
 158 }
 159
 160 static NTSTATUS CDECL key_symmetric_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len )
 161 {
 162     FIXME( "not implemented on Mac\n" );
 163     return STATUS_NOT_IMPLEMENTED;
 164 }
 165
 166 static NTSTATUS CDECL key_symmetric_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, ULONG output_len  )
 167 {
 168     CCCryptorStatus status;
 169     NTSTATUS ret;
 170
 171     if ((ret = init_cryptor_handles( key ))) return ret;
 172
 173     if ((status = CCCryptorUpdate( key_data(key)->ref_encrypt, input, input_len, output, output_len, NULL  )) != kCCSuccess)
 174     {
 175         WARN( "CCCryptorUpdate failed %d\n", status );
 176         return STATUS_INTERNAL_ERROR;
 177     }
 178     return STATUS_SUCCESS;
 179 }
 180
 181 static NTSTATUS CDECL key_symmetric_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, ULONG output_len )
 182 {
 183     CCCryptorStatus status;
 184     NTSTATUS ret;
 185
 186     if ((ret = init_cryptor_handles( key ))) return ret;
 187
 188     if ((status = CCCryptorUpdate( key_data(key)->ref_decrypt, input, input_len, output, output_len, NULL  )) != kCCSuccess)
 189     {
 190         WARN( "CCCryptorUpdate failed %d\n", status );
 191         return STATUS_INTERNAL_ERROR;
 192     }
 193     return STATUS_SUCCESS;
 194 }
 195
 196 static NTSTATUS CDECL key_symmetric_get_tag( struct key *key, UCHAR *tag, ULONG len )
 197 {
 198     FIXME( "not implemented on Mac\n" );
 199     return STATUS_NOT_IMPLEMENTED;
 200 }
 201
 202 static void CDECL key_symmetric_destroy( struct key *key )
 203 {
 204     if (key_data(key)->ref_encrypt) CCCryptorRelease( key_data(key)->ref_encrypt );
 205     if (key_data(key)->ref_decrypt) CCCryptorRelease( key_data(key)->ref_decrypt );
 206 }
 207
 208 static NTSTATUS CDECL key_asymmetric_init( struct key *key )
 209 {
 210     FIXME( "not implemented on Mac\n" );
 211     return STATUS_NOT_IMPLEMENTED;
 212 }
 213
 214 static NTSTATUS CDECL key_asymmetric_sign( struct key *key, void *padding, UCHAR *input, ULONG input_len, UCHAR *output,
 215                                            ULONG output_len, ULONG *ret_len, ULONG flags )
 216 {
 217     FIXME( "not implemented on Mac\n" );
 218     return STATUS_NOT_IMPLEMENTED;
 219 }
 220
 221 static NTSTATUS CDECL key_asymmetric_verify( struct key *key, void *padding, UCHAR *hash, ULONG hash_len,
 222                                              UCHAR *signature, ULONG signature_len, DWORD flags )
 223 {
 224     FIXME( "not implemented on Mac\n" );
 225     return STATUS_NOT_IMPLEMENTED;
 226 }
 227
 228 static NTSTATUS CDECL key_export_dsa_capi( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
 229 {
 230     FIXME( "not implemented on Mac\n" );
 231     return STATUS_NOT_IMPLEMENTED;
 232 }
 233
 234 static NTSTATUS CDECL key_export_ecc( struct key *key, UCHAR *output, ULONG len, ULONG *ret_len )
 235 {
 236     FIXME( "not implemented on Mac\n" );
 237     return STATUS_NOT_IMPLEMENTED;
 238 }
 239
 240 static NTSTATUS CDECL key_import_dsa_capi( struct key *key, UCHAR *buf, ULONG len )
 241 {
 242     FIXME( "not implemented on Mac\n" );
 243     return STATUS_NOT_IMPLEMENTED;
 244 }
 245
 246 static NTSTATUS CDECL key_import_ecc( struct key *key, UCHAR *input, ULONG len )
 247 {
 248     FIXME( "not implemented on Mac\n" );
 249     return STATUS_NOT_IMPLEMENTED;
 250 }
 251
 252 static NTSTATUS CDECL key_asymmetric_generate( struct key *key )
 253 {
 254     FIXME( "not implemented on Mac\n" );
 255     return STATUS_NOT_IMPLEMENTED;
 256 }
 257
 258 static void CDECL key_asymmetric_destroy( struct key *key )
 259 {
 260 }
 261
 262 static NTSTATUS CDECL key_asymmetric_duplicate( struct key *key_orig, struct key *key_copy )
 263 {
 264     FIXME( "not implemented on Mac\n" );
 265     return STATUS_NOT_IMPLEMENTED;
 266 }
 267
 268 static const struct key_funcs key_funcs =
 269 {
 270     key_set_property,
 271     key_symmetric_init,
 272     key_symmetric_vector_reset,
 273     key_symmetric_set_auth_data,
 274     key_symmetric_encrypt,
 275     key_symmetric_decrypt,
 276     key_symmetric_get_tag,
 277     key_symmetric_destroy,
 278     key_asymmetric_init,
 279     key_asymmetric_generate,
 280     key_asymmetric_duplicate,
 281     key_asymmetric_sign,
 282     key_asymmetric_verify,
 283     key_asymmetric_destroy,
 284     key_export_dsa_capi,
 285     key_export_ecc,
 286     key_import_dsa_capi,
 287     key_import_ecc
 288 };
 289
 290 NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
 291 {
 292     if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS;
 293     *(const struct key_funcs **)ptr_out = &key_funcs;
 294     return STATUS_SUCCESS;
 295 }
 296
 297 #endif