libidav/crypto.c

   1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   3  *
   4  * Copyright 2018 Olaf Wintermann. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  *   1. Redistributions of source code must retain the above copyright
  10  *      notice, this list of conditions and the following disclaimer.
  11  *
  12  *   2. Redistributions in binary form must reproduce the above copyright
  13  *      notice, this list of conditions and the following disclaimer in the
  14  *      documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include "utils.h"
  35
  36 #include "crypto.h"
  37
  38 /* -------------------- OpenSSL Crypto Functions -------------------- */
  39 #ifdef DAV_USE_OPENSSL
  40
  41 #if OPENSSL_VERSION_NUMBER < 0x10000000L
  42
  43 static EVP_CIPHER_CTX* create_evp_cipher_ctx() {
  44     EVP_CIPHER_CTX *ctx = malloc(sizeof(EVP_CIPHER_CTX));
  45     EVP_CIPHER_CTX_init(ctx);
  46     return ctx;
  47 }
  48
  49 static void free_evp_cipher_ctx(EVP_CIPHER_CTX *ctx) {
  50     EVP_CIPHER_CTX_cleanup(ctx);
  51     free(ctx);
  52 }
  53
  54 #define EVP_CIPHER_CTX_new() create_evp_cipher_ctx()
  55 #define EVP_CIPHER_CTX_free(ctx) free_evp_cipher_ctx(ctx)
  56
  57 #endif
  58
  59 int dav_rand_bytes(unsigned char *buf, size_t len) {
  60     return !RAND_bytes(buf, len);
  61 }
  62
  63 AESDecrypter* aes_decrypter_new(DavKey *key, void *stream, dav_write_func write_func) {
  64     AESDecrypter *dec = calloc(1, sizeof(AESDecrypter));
  65     SHA256_Init(&dec->sha256);
  66     dec->stream = stream;
  67     dec->write = write_func;
  68     dec->key = key;
  69     dec->init = 0;
  70     dec->ivpos = 0;
  71
  72     return dec;
  73 }
  74
  75 void aes_decrypter_init(AESDecrypter *dec) {
  76     //EVP_CIPHER_CTX_init(&dec->ctx);
  77     dec->ctx = EVP_CIPHER_CTX_new();
  78     dec->init = 1;
  79     if(dec->key->type == DAV_KEY_AES128) {
  80         EVP_DecryptInit_ex(
  81                 dec->ctx,
  82                 EVP_aes_128_cbc(),
  83                 NULL,
  84                 dec->key->data,
  85                 dec->ivtmp);
  86     } else if(dec->key->type == DAV_KEY_AES256) {
  87         EVP_DecryptInit_ex(
  88                 dec->ctx,
  89                 EVP_aes_256_cbc(),
  90                 NULL,
  91                 dec->key->data,
  92                 dec->ivtmp);
  93     } else {
  94         fprintf(stderr, "unknown key type\n");
  95         exit(-1);
  96     }
  97 }
  98
  99 size_t aes_write(const void *buf, size_t s, size_t n, AESDecrypter *dec) {
 100     int len = s*n;
 101     if(!dec->init) {
 102         size_t n = 16 - dec->ivpos;
 103         size_t cp = n > len ? len : n;
 104         memcpy(dec->ivtmp + dec->ivpos, buf, cp);
 105         dec->ivpos += cp;
 106         if(dec->ivpos >= 16) {
 107             aes_decrypter_init(dec);
 108         }
 109         if(len == cp) {
 110             return len;
 111         } else {
 112             buf = (char*)buf + cp;
 113             len -= cp;
 114         }
 115     }
 116
 117     int outlen = len + 16;
 118     unsigned char *out = malloc(outlen);
 119     EVP_DecryptUpdate(dec->ctx, out, &outlen, buf, len);
 120     ssize_t wlen = dec->write(out, 1, outlen, dec->stream);
 121     SHA256_Update(&dec->sha256, out, wlen);
 122     free(out);
 123     return (s*n) / s;
 124 }
 125
 126 void aes_decrypter_shutdown(AESDecrypter *dec) {
 127     if(dec->init) {
 128         void *out = malloc(128);
 129         int len = 0;
 130         EVP_DecryptFinal_ex(dec->ctx, out, &len);
 131         dec->write(out, 1, len, dec->stream);
 132         SHA256_Update(&dec->sha256, out, len);
 133         free(out);
 134         //EVP_CIPHER_CTX_cleanup(&dec->ctx);
 135         EVP_CIPHER_CTX_free(dec->ctx);
 136     }
 137 }
 138
 139 void aes_decrypter_close(AESDecrypter *dec) {
 140     free(dec);
 141 }
 142
 143
 144 AESEncrypter* aes_encrypter_new(DavKey *key, void *stream, dav_read_func read_func, dav_seek_func seek_func) {
 145     unsigned char *iv = malloc(16);
 146     if(!RAND_bytes(iv, 16)) {
 147         free(iv);
 148         return NULL;
 149     }
 150
 151     AESEncrypter *enc = malloc(sizeof(AESEncrypter));
 152     SHA256_Init(&enc->sha256);
 153     enc->stream = stream;
 154     enc->read = read_func;
 155     enc->seek = seek_func;
 156     enc->tmp = NULL;
 157     enc->tmplen = 0;
 158     enc->tmpoff = 0;
 159     enc->end = 0;
 160     enc->iv = iv;
 161     enc->ivlen = 16;
 162
 163     //EVP_CIPHER_CTX_init(&enc->ctx);
 164     enc->ctx = EVP_CIPHER_CTX_new();
 165     if(key->type == DAV_KEY_AES128) {
 166         EVP_EncryptInit_ex(enc->ctx, EVP_aes_128_cbc(), NULL, key->data, enc->iv);
 167     } else if(key->type == DAV_KEY_AES256) {
 168         EVP_EncryptInit_ex(enc->ctx, EVP_aes_256_cbc(), NULL, key->data, enc->iv);
 169     } else {
 170         fprintf(stderr, "unknown key type\n");
 171         exit(-1);
 172     }
 173     return enc;
 174 }
 175
 176 size_t aes_read(void *buf, size_t s, size_t n, AESEncrypter *enc) {
 177     size_t len = s*n;
 178     if(enc->tmp) {
 179         size_t tmp_diff = enc->tmplen - enc->tmpoff;
 180         size_t cp_len = tmp_diff > len ? len : tmp_diff;
 181         memcpy(buf, enc->tmp + enc->tmpoff, cp_len);
 182         enc->tmpoff += cp_len;
 183         if(enc->tmpoff >= enc->tmplen) {
 184             free(enc->tmp);
 185             enc->tmp = NULL;
 186             enc->tmplen = 0;
 187             enc->tmpoff = 0;
 188         }
 189         return cp_len / s;
 190     }
 191
 192     if(enc->end) {
 193         return 0;
 194     }
 195
 196     void *in = malloc(len);
 197     size_t in_len = enc->read(in, 1, len, enc->stream);
 198
 199     SHA256_Update(&enc->sha256, in, in_len);
 200
 201     unsigned char *out = NULL;
 202     int outlen = 0;
 203     size_t ivl = enc->ivlen;
 204     if(in_len != 0) {
 205         outlen = len + 32;
 206         out = malloc(outlen + ivl);
 207         if(ivl > 0) {
 208             memcpy(out, enc->iv, ivl);
 209         }
 210         EVP_EncryptUpdate(enc->ctx, out + ivl, &outlen, in, in_len);
 211         if(in_len != len) {
 212             int newoutlen = 16;
 213             EVP_EncryptFinal_ex(enc->ctx, out + ivl + outlen, &newoutlen);
 214             outlen += newoutlen;
 215             enc->end = 1;
 216         }
 217     } else {
 218         out = malloc(16);
 219         EVP_EncryptFinal_ex(enc->ctx, out, &outlen);
 220         enc->end = 1;
 221     }
 222     enc->tmp = (char*)out;
 223     enc->tmplen = outlen + ivl;
 224     enc->tmpoff = 0;
 225
 226     if(enc->ivlen > 0) {
 227         enc->ivlen = 0;
 228     }
 229
 230     free(in);
 231
 232     return aes_read(buf, s, n, enc);
 233 }
 234
 235 void aes_encrypter_close(AESEncrypter *enc) {
 236     if(enc->tmp) {
 237         free(enc->tmp);
 238     }
 239     if(enc->iv) {
 240         free(enc->iv);
 241     }
 242     //EVP_CIPHER_CTX_cleanup(&enc->ctx);
 243     EVP_CIPHER_CTX_free(enc->ctx);
 244     free(enc);
 245 }
 246
 247 int aes_encrypter_reset(AESEncrypter  *enc, curl_off_t offset, int origin) {
 248     if(origin != SEEK_SET || offset != 0 || !enc->seek) {
 249         return CURL_SEEKFUNC_CANTSEEK;
 250     }
 251
 252     enc->ivlen = 16;
 253     if(enc->seek(enc->stream, 0, SEEK_SET) != 0) {
 254         return CURL_SEEKFUNC_FAIL;
 255     }
 256     return CURL_SEEKFUNC_OK;
 257 }
 258
 259
 260 char* aes_encrypt(const char *in, size_t len, DavKey *key) {
 261     unsigned char iv[16];
 262     if(!RAND_bytes(iv, 16)) {
 263         return NULL;
 264     }
 265
 266     //EVP_CIPHER_CTX ctx;
 267     //EVP_CIPHER_CTX_init(&ctx);
 268     EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
 269     if(key->type == DAV_KEY_AES128) {
 270         EVP_EncryptInit_ex(
 271                 ctx,
 272                 EVP_aes_128_cbc(),
 273                 NULL,
 274                 (unsigned char*)key->data,
 275                 iv);
 276     } else if(key->type == DAV_KEY_AES256) {
 277         EVP_EncryptInit_ex(
 278                 ctx,
 279                 EVP_aes_256_cbc(),
 280                 NULL,
 281                 (unsigned char*)key->data,
 282                 iv);
 283     } else {
 284         //EVP_CIPHER_CTX_cleanup(&ctx);
 285         EVP_CIPHER_CTX_free(ctx);
 286         return NULL;
 287     }
 288
 289     //int len = strlen(in);
 290     int buflen = len + 64;
 291     unsigned char *buf = calloc(1, buflen);
 292     memcpy(buf, iv, 16);
 293
 294     int l = buflen - 16;
 295     EVP_EncryptUpdate(ctx, buf + 16, &l, (unsigned char*)in, len);
 296
 297     int f = 0;
 298     EVP_EncryptFinal_ex(ctx, buf + 16 + l, &f);
 299     char *out = util_base64encode((char*)buf, 16 + l + f);
 300     free(buf);
 301     EVP_CIPHER_CTX_free(ctx);
 302     //EVP_CIPHER_CTX_cleanup(&ctx);
 303
 304     return out;
 305 }
 306
 307 char* aes_decrypt(const char *in, size_t *length, DavKey *key) {
 308     int len;
 309     unsigned char *buf = (unsigned char*)util_base64decode_len(in, &len);
 310
 311     //EVP_CIPHER_CTX ctx;
 312     //EVP_CIPHER_CTX_init(&ctx);
 313     EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
 314     if(key->type == DAV_KEY_AES128) {
 315         EVP_DecryptInit_ex(
 316                 ctx,
 317                 EVP_aes_128_cbc(),
 318                 NULL,
 319                 key->data,
 320                 buf);
 321     } else if(key->type == DAV_KEY_AES256) {
 322         EVP_DecryptInit_ex(
 323                 ctx,
 324                 EVP_aes_256_cbc(),
 325                 NULL,
 326                 key->data,
 327                 buf);
 328     } else {
 329         //EVP_CIPHER_CTX_cleanup(&ctx);
 330         EVP_CIPHER_CTX_free(ctx);
 331         return NULL;
 332     }
 333
 334     unsigned char *out = malloc(len + 1);
 335     int outlen = len;
 336     unsigned char *in_buf = buf + 16;
 337     int inlen = len - 16;
 338     int f = 0;
 339
 340     EVP_DecryptUpdate(ctx, out, &outlen, in_buf, inlen);
 341     EVP_DecryptFinal_ex(ctx, out + outlen, &f);
 342     out[outlen + f] = '\0';
 343     free(buf);
 344     //EVP_CIPHER_CTX_cleanup(&ctx);
 345     EVP_CIPHER_CTX_free(ctx);
 346
 347     *length = outlen + f;
 348     return (char*)out;
 349 }
 350
 351
 352 void dav_get_hash(DAV_SHA_CTX *sha256, unsigned char *buf){
 353     SHA256_Final((unsigned char*)buf, sha256);
 354 }
 355
 356 char* dav_create_hash(const char *data, size_t len) {
 357     unsigned char hash[DAV_SHA256_DIGEST_LENGTH];
 358     DAV_SHA_CTX ctx;
 359     SHA256_Init(&ctx);
 360     SHA256_Update(&ctx, data, len);
 361     SHA256_Final(hash, &ctx);
 362     return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
 363 }
 364
 365 DAV_SHA_CTX* dav_hash_init(void) {
 366     DAV_SHA_CTX *ctx = malloc(sizeof(DAV_SHA_CTX));
 367     SHA256_Init(ctx);
 368     return ctx;
 369 }
 370
 371 void dav_hash_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
 372     SHA256_Update(ctx, data, len);
 373 }
 374
 375 void dav_hash_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
 376     SHA256_Final(buf, ctx);
 377     free(ctx);
 378 }
 379
 380 #if OPENSSL_VERSION_NUMBER < 0x10100000L
 381 static int crypto_pw2key_error = 0;
 382 DavKey* dav_pw2key(const char *password, const unsigned char *salt, int saltlen, int pwfunc, int enc) {
 383     if(!crypto_pw2key_error) {
 384         fprintf(stderr, "Error: password key derivation not supported on this platform: openssl to old\n");
 385         crypto_pw2key_error = 1;
 386     }
 387     return 0;
 388 }
 389
 390 #else
 391 DavKey* dav_pw2key(const char *password, const unsigned char *salt, int saltlen, int pwfunc, int enc) {
 392     if(!password) {
 393         return NULL;
 394     }
 395     size_t len = strlen(password);
 396     if(len == 0) {
 397         return NULL;
 398     }
 399
 400     // setup key data and length
 401     unsigned char keydata[32];
 402     int keylen = 32;
 403     switch(enc) {
 404         case DAV_KEY_AES128: keylen = 16; break;
 405         case DAV_KEY_AES256: keylen = 32; break;
 406         default: return NULL;
 407     }
 408
 409     // generate key
 410     switch(pwfunc) {
 411         case DAV_PWFUNC_PBKDF2_SHA256: {
 412             PKCS5_PBKDF2_HMAC(
 413                     password,
 414                     len,
 415                     salt,
 416                     saltlen,
 417                     DAV_CRYPTO_ITERATION_COUNT,
 418                     EVP_sha256(),
 419                     keylen,
 420                     keydata);
 421             break;
 422         }
 423         case DAV_PWFUNC_PBKDF2_SHA512: {
 424             PKCS5_PBKDF2_HMAC(
 425                     password,
 426                     len,
 427                     salt,
 428                     saltlen,
 429                     DAV_CRYPTO_ITERATION_COUNT,
 430                     EVP_sha512(),
 431                     keylen,
 432                     keydata);
 433             break;
 434         }
 435         default: return NULL;
 436     }
 437
 438     // create DavKey with generated data
 439     DavKey *key = malloc(sizeof(DavKey));
 440     key->data = malloc(keylen);
 441     key->length = keylen;
 442     key->name = NULL;
 443     key->type = enc;
 444     memcpy(key->data, keydata, keylen);
 445     return key;
 446 }
 447 #endif
 448
 449 #endif
 450
 451
 452 /* -------------------- Apple Crypto Functions -------------------- */
 453 #ifdef DAV_CRYPTO_COMMON_CRYPTO
 454
 455 #define RANDOM_BUFFER_LENGTH 256
 456 static char randbuf[RANDOM_BUFFER_LENGTH];
 457 static int rbufpos = RANDOM_BUFFER_LENGTH;
 458
 459 int dav_rand_bytes(unsigned char *buf, size_t len) {
 460     if(len + rbufpos > RANDOM_BUFFER_LENGTH) {
 461         int devr = open("/dev/urandom", O_RDONLY);
 462         if(devr == -1) {
 463             return 1;
 464         }
 465
 466         if(read(devr, randbuf, RANDOM_BUFFER_LENGTH) < RANDOM_BUFFER_LENGTH) {
 467             close(devr);
 468             return 1;
 469         }
 470
 471         rbufpos = 0;
 472         if(len > RANDOM_BUFFER_LENGTH) {
 473             int err = 0;
 474             if(read(devr, buf, len) < len) {
 475                 err = 1;
 476             }
 477             close(devr);
 478             return err;
 479         }
 480
 481         close(devr);
 482     }
 483
 484     char *r = randbuf;
 485     memcpy(buf, r + rbufpos, len);
 486     rbufpos += len;
 487
 488     return 0;
 489 }
 490
 491 AESDecrypter* aes_decrypter_new(DavKey *key, void *stream, dav_write_func write_func) {
 492     AESDecrypter *dec = calloc(1, sizeof(AESDecrypter));
 493     CC_SHA256_Init(&dec->sha256);
 494     dec->stream = stream;
 495     dec->write = write_func;
 496     dec->key = key;
 497     dec->init = 0;
 498     dec->ivpos = 0;
 499
 500     return dec;
 501 }
 502
 503
 504 void aes_decrypter_init(AESDecrypter *dec) {
 505     //EVP_CIPHER_CTX_init(&dec->ctx);
 506     dec->init = 1;
 507
 508     CCCryptorRef cryptor;
 509     CCCryptorStatus status;
 510     if(dec->key->type == DAV_KEY_AES128) {
 511         status = CCCryptorCreate(kCCDecrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding, dec->key->data, dec->key->length, dec->ivtmp, &cryptor);
 512     } else if(dec->key->type == DAV_KEY_AES256) {
 513         status = CCCryptorCreate(kCCDecrypt, kCCAlgorithmAES, kCCOptionPKCS7Padding, dec->key->data, dec->key->length, dec->ivtmp, &cryptor);
 514     } else {
 515         fprintf(stderr, "unknown key type\n");
 516         exit(-1);
 517     }
 518     dec->ctx = cryptor;
 519 }
 520
 521 size_t aes_write(const void *buf, size_t s, size_t n, AESDecrypter *dec) {
 522     int len = s*n;
 523     if(!dec->init) {
 524         size_t n = 16 - dec->ivpos;
 525         size_t cp = n > len ? len : n;
 526         memcpy(dec->ivtmp + dec->ivpos, buf, cp);
 527         dec->ivpos += cp;
 528         if(dec->ivpos >= 16) {
 529             aes_decrypter_init(dec);
 530         }
 531         if(len == cp) {
 532             return len;
 533         } else {
 534             buf = (char*)buf + cp;
 535             len -= cp;
 536         }
 537     }
 538
 539     int outlen = len + 16;
 540     unsigned char *out = malloc(outlen);
 541
 542     CCCryptorStatus status;
 543     size_t avail = outlen;
 544     size_t moved = 0;
 545     status = CCCryptorUpdate(dec->ctx, buf, len, out, avail, &moved);
 546
 547     ssize_t wlen = dec->write(out, 1, moved, dec->stream);
 548     CC_SHA256_Update(&dec->sha256, out, wlen);
 549     free(out);
 550     return (s*n) / s;
 551 }
 552
 553 void aes_decrypter_shutdown(AESDecrypter *dec) {
 554     if(dec->init) {
 555         void *out = malloc(128);
 556         size_t len = 0;
 557         //EVP_DecryptFinal_ex(dec->ctx, out, &len);
 558         CCCryptorFinal(dec->ctx, out, 128, &len);
 559
 560
 561         dec->write(out, 1, len, dec->stream);
 562         CC_SHA256_Update(&dec->sha256, out, len);
 563         free(out);
 564         //EVP_CIPHER_CTX_cleanup(&dec->ctx);
 565         //EVP_CIPHER_CTX_free(dec->ctx);
 566     }
 567 }
 568
 569 void aes_decrypter_close(AESDecrypter *dec) {
 570
 571 }
 572
 573 AESEncrypter* aes_encrypter_new(DavKey *key, void *stream, dav_read_func read_func, dav_seek_func seek_func) {
 574     unsigned char *iv = malloc(16);
 575     if(dav_rand_bytes(iv, 16)) {
 576         return NULL;
 577     }
 578
 579     CCCryptorRef cryptor;
 580     CCCryptorStatus status;
 581     if(key->type == DAV_KEY_AES128) {
 582         status = CCCryptorCreate(kCCEncrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding, key->data, key->length, iv, &cryptor);
 583     } else if(key->type == DAV_KEY_AES256) {
 584         status = CCCryptorCreate(kCCEncrypt, kCCAlgorithmAES, kCCOptionPKCS7Padding, key->data, key->length, iv, &cryptor);
 585     } else {
 586         free(iv);
 587         return NULL;
 588     }
 589
 590     AESEncrypter *enc = malloc(sizeof(AESEncrypter));
 591     enc->ctx = cryptor;
 592     CC_SHA256_Init(&enc->sha256);
 593     enc->stream = stream;
 594     enc->read = read_func;
 595     enc->seek = seek_func;
 596     enc->tmp = NULL;
 597     enc->tmplen = 0;
 598     enc->tmpoff = 0;
 599     enc->end = 0;
 600     enc->iv = iv;
 601     enc->ivlen = 16;
 602
 603     return enc;
 604 }
 605
 606 size_t aes_read(void *buf, size_t s, size_t n, AESEncrypter *enc) {
 607     size_t len = s*n;
 608     if(enc->tmp) {
 609         size_t tmp_diff = enc->tmplen - enc->tmpoff;
 610         size_t cp_len = tmp_diff > len ? len : tmp_diff;
 611         memcpy(buf, enc->tmp + enc->tmpoff, cp_len);
 612         enc->tmpoff += cp_len;
 613         if(enc->tmpoff >= enc->tmplen) {
 614             free(enc->tmp);
 615             enc->tmp = NULL;
 616             enc->tmplen = 0;
 617             enc->tmpoff = 0;
 618         }
 619         return cp_len / s;
 620     }
 621
 622     if(enc->end) {
 623         return 0;
 624     }
 625
 626     void *in = malloc(len);
 627     size_t in_len = enc->read(in, 1, len, enc->stream);
 628
 629     CC_SHA256_Update(&enc->sha256, in, in_len);
 630
 631     unsigned char *out = NULL;
 632     size_t outlen = 0;
 633     size_t ivl = enc->ivlen;
 634     if(in_len != 0) {
 635         outlen = len + 32;
 636         out = malloc(outlen + ivl);
 637         if(ivl > 0) {
 638             memcpy(out, enc->iv, ivl);
 639         }
 640
 641         CCCryptorStatus status;
 642         size_t avail = outlen;
 643         status = CCCryptorUpdate(enc->ctx, in, in_len, out + ivl, avail, &outlen);
 644         if(in_len != len) {
 645             size_t newoutlen = 16;
 646             status = CCCryptorFinal(enc->ctx, out + ivl + outlen, 16, &newoutlen);
 647             outlen += newoutlen;
 648             enc->end = 1;
 649         }
 650     } else {
 651         out = malloc(32);
 652         CCCryptorStatus status;
 653         size_t avail = outlen;
 654         status = CCCryptorFinal(enc->ctx, out, 32, &outlen);
 655         enc->end = 1;
 656     }
 657     enc->tmp = (char*)out;
 658     enc->tmplen = outlen + ivl;
 659     enc->tmpoff = 0;
 660
 661     if(enc->ivlen > 0) {
 662         enc->ivlen = 0;
 663     }
 664
 665     free(in);
 666
 667     return aes_read(buf, s, n, enc);
 668 }
 669
 670 int aes_encrypter_reset(AESEncrypter  *enc, curl_off_t offset, int origin) {
 671     if(origin != SEEK_SET || offset != 0 || !enc->seek) {
 672         return CURL_SEEKFUNC_CANTSEEK;
 673     }
 674
 675     enc->ivlen = 16;
 676     if(enc->seek(enc->stream, 0, SEEK_SET) != 0) {
 677         return CURL_SEEKFUNC_FAIL;
 678     }
 679     return CURL_SEEKFUNC_OK;
 680 }
 681
 682 void aes_encrypter_close(AESEncrypter *enc) {
 683     if(enc->tmp) {
 684         free(enc->tmp);
 685     }
 686     if(enc->iv) {
 687         free(enc->iv);
 688     }
 689     // TODO: cleanup cryptor
 690     free(enc);
 691 }
 692
 693 char* aes_encrypt(const char *in, size_t len, DavKey *key) {
 694     unsigned char iv[16];
 695     if(dav_rand_bytes(iv, 16)) {
 696         return NULL;
 697     }
 698
 699     CCCryptorRef cryptor;
 700     CCCryptorStatus status;
 701     if(key->type == DAV_KEY_AES128) {
 702         status = CCCryptorCreate(kCCEncrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding, key->data, key->length, iv, &cryptor);
 703     } else if(key->type == DAV_KEY_AES256) {
 704         status = CCCryptorCreate(kCCEncrypt, kCCAlgorithmAES, kCCOptionPKCS7Padding, key->data, key->length, iv, &cryptor);
 705     } else {
 706         return NULL;
 707     }
 708
 709     if(status != kCCSuccess) {
 710         return NULL;
 711     }
 712
 713     int buflen = len + 64;
 714     char *buf = calloc(1, buflen);
 715     memcpy(buf, iv, 16);
 716
 717     int pos = 16;
 718     size_t avail = buflen - 16;
 719     size_t moved;
 720     char *out = buf + 16;
 721
 722     status = CCCryptorUpdate(cryptor, in,
 723          len, out, avail,
 724          &moved);
 725     if(status != kCCSuccess) {
 726         free(buf);
 727         return NULL;
 728     }
 729
 730     pos += moved;
 731     avail -= moved;
 732     out += moved;
 733
 734     status = CCCryptorFinal(cryptor, out, avail, &moved);
 735     if(status != kCCSuccess) {
 736         free(buf);
 737         return NULL;
 738     }
 739
 740     pos += moved;
 741
 742     char *b64enc = util_base64encode(buf, pos);
 743     free(buf);
 744
 745     return b64enc;
 746 }
 747
 748 char* aes_decrypt(const char *in, size_t *len, DavKey *key) {
 749     int inlen;
 750     unsigned char *buf = (unsigned char*)util_base64decode_len(in, &inlen);
 751
 752     CCCryptorRef cryptor;
 753     CCCryptorStatus status;
 754     if(key->type == DAV_KEY_AES128) {
 755         status = CCCryptorCreate(kCCDecrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding, key->data, key->length, buf, &cryptor);
 756     } else if(key->type == DAV_KEY_AES256) {
 757         status = CCCryptorCreate(kCCDecrypt, kCCAlgorithmAES, kCCOptionPKCS7Padding, key->data, key->length, buf, &cryptor);
 758     } else {
 759         free(buf);
 760         return NULL;
 761     }
 762
 763     if(status != kCCSuccess) {
 764         free(buf);
 765         return NULL;
 766     }
 767
 768     char *out = malloc(inlen + 1);
 769     size_t outavail = inlen;
 770     size_t outlen = 0;
 771
 772     unsigned char *inbuf = buf + 16;
 773     inlen -= 16;
 774
 775     size_t moved = 0;
 776     status = CCCryptorUpdate(cryptor, inbuf, inlen, out, outavail, &moved);
 777     if(status != kCCSuccess) {
 778         free(buf);
 779         free(out);
 780         // TODO cryptor
 781         return NULL;
 782     }
 783
 784     outlen += moved;
 785     outavail -= moved;
 786
 787     status = CCCryptorFinal(cryptor, out + outlen, outavail, &moved);
 788     if(status != kCCSuccess) {
 789         free(buf);
 790         free(out);
 791         // TODO cryptor
 792         return NULL;
 793     }
 794
 795     outlen += moved;
 796     out[outlen] = 0;
 797
 798     *len = outlen;
 799     return out;
 800 }
 801
 802 void dav_get_hash(DAV_SHA_CTX *sha256, unsigned char *buf) {
 803     CC_SHA256_Final(buf, sha256);
 804 }
 805
 806 char* dav_create_hash(const char *data, size_t len) {
 807     unsigned char hash[DAV_SHA256_DIGEST_LENGTH];
 808     CC_SHA256((const unsigned char*)data, len, hash);
 809     return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
 810 }
 811
 812 DAV_SHA_CTX* dav_hash_init(void) {
 813     DAV_SHA_CTX *ctx = malloc(sizeof(DAV_SHA_CTX));
 814     CC_SHA256_Init(ctx);
 815     return ctx;
 816 }
 817
 818 void dav_hash_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
 819     CC_SHA256_Update(ctx, data, len);
 820 }
 821
 822 void dav_hash_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
 823     CC_SHA256_Final(buf, ctx);
 824     free(ctx);
 825 }
 826
 827 DavKey* dav_pw2key(const char *password, const unsigned char *salt, int saltlen, int pwfunc, int enc) {
 828     if(!password) {
 829         return NULL;
 830     }
 831     size_t len = strlen(password);
 832     if(len == 0) {
 833         return NULL;
 834     }
 835
 836     // setup key data and length
 837     unsigned char keydata[32];
 838     int keylen = 32;
 839     switch(enc) {
 840         case DAV_KEY_AES128: keylen = 16; break;
 841         case DAV_KEY_AES256: keylen = 32; break;
 842         default: return NULL;
 843     }
 844
 845     // generate key
 846     switch(pwfunc) {
 847         case DAV_PWFUNC_PBKDF2_SHA256: {
 848             int result = CCKeyDerivationPBKDF(
 849                     kCCPBKDF2,
 850                     password,
 851                     len,
 852                     salt,
 853                     saltlen,
 854                     kCCPRFHmacAlgSHA256,
 855                     DAV_CRYPTO_ITERATION_COUNT,
 856                     keydata,
 857                     keylen);
 858             if(result) {
 859                 return NULL;
 860             }
 861             break;
 862         }
 863         case DAV_PWFUNC_PBKDF2_SHA512: {
 864             int result = CCKeyDerivationPBKDF(
 865                     kCCPBKDF2,
 866                     password,
 867                     len,
 868                     salt,
 869                     saltlen,
 870                     kCCPRFHmacAlgSHA512,
 871                     DAV_CRYPTO_ITERATION_COUNT,
 872                     keydata,
 873                     keylen);
 874             if(result) {
 875                 return NULL;
 876             }
 877             break;
 878         }
 879         default: return NULL;
 880     }
 881
 882     // create DavKey with generated data
 883     DavKey *key = malloc(sizeof(DavKey));
 884     key->data = malloc(keylen);
 885     key->length = keylen;
 886     key->name = NULL;
 887     key->type = enc;
 888     memcpy(key->data, keydata, keylen);
 889     return key;
 890 }
 891
 892 #endif
 893
 894 /* -------------------- Windows Crypto Functions -------------------- */
 895 #ifdef DAV_CRYPTO_CNG
 896
 897 static void cng_cleanup(BCRYPT_ALG_HANDLE hAesAlg, BCRYPT_KEY_HANDLE hKey, BCRYPT_HASH_HANDLE hHash, void *pbObject) {
 898     if(hAesAlg) {
 899         BCryptCloseAlgorithmProvider(hAesAlg,0);
 900     }
 901     if(hKey) {
 902         BCryptDestroyKey(hKey);
 903     }
 904     if(hHash) {
 905         BCryptDestroyHash(hHash);
 906     }
 907     if(pbObject) {
 908         free(pbObject);
 909     }
 910 }
 911
 912 static int cng_init_key(BCRYPT_ALG_HANDLE *alg, BCRYPT_KEY_HANDLE *key, void **keyobj, DavKey *aesKey) {
 913     BCRYPT_ALG_HANDLE hAesAlg = NULL;
 914     BCRYPT_KEY_HANDLE hKey    = NULL;
 915
 916     void *pbKeyObject     = NULL;
 917     ULONG keyObjectLength = 0;
 918
 919     ULONG result = 0;
 920
 921     // check DavKey and get AES key length
 922     if(!aesKey) {
 923         return 1;
 924     }
 925
 926     ULONG aesKeyLength = 0;
 927     if(aesKey->type == DAV_KEY_AES128) {
 928         aesKeyLength = 16;
 929     } else if(aesKey->type == DAV_KEY_AES256) {
 930         aesKeyLength = 32;
 931     }
 932     if(aesKeyLength > aesKey->length || !aesKey->data) {
 933         // invalid DavKey
 934         return 1;
 935     }
 936
 937     // initialize BCrypt stuff
 938     if(BCryptOpenAlgorithmProvider(&hAesAlg, BCRYPT_AES_ALGORITHM, NULL, 0)) {
 939         fprintf(stderr, "Error: BCryptOpenAlgorithmProvider failed\n");
 940         return 1;
 941     }
 942
 943     if(BCryptGetProperty(hAesAlg, BCRYPT_OBJECT_LENGTH, (PUCHAR)&keyObjectLength, sizeof(DWORD), &result, 0)) {
 944         fprintf(stderr, "Error: BCrypt: Cannot get BCRYPT_OBJECT_LENGTH\n");
 945         cng_cleanup(hAesAlg, hKey, NULL, pbKeyObject);
 946         return 1;
 947     }
 948
 949     if(BCryptSetProperty(hAesAlg, BCRYPT_CHAINING_MODE, (PBYTE)BCRYPT_CHAIN_MODE_CBC, sizeof(BCRYPT_CHAIN_MODE_CBC), 0)) {
 950         fprintf(stderr, "Error: BCrypt: Cannot set CBC mode\n");
 951         cng_cleanup(hAesAlg, hKey, NULL, pbKeyObject);
 952         return 1;
 953     }
 954
 955     pbKeyObject = calloc(1, keyObjectLength);
 956     if(!pbKeyObject) {
 957         cng_cleanup(hAesAlg, hKey, NULL, pbKeyObject);
 958         return 1;
 959     }
 960
 961     // init key
 962     if(BCryptGenerateSymmetricKey(hAesAlg, &hKey, pbKeyObject, keyObjectLength, aesKey->data, aesKeyLength, 0)) {
 963         fprintf(stderr, "Error: BCrypt: Cannot set key\n");
 964         cng_cleanup(hAesAlg, hKey, NULL, pbKeyObject);
 965         return 1;
 966     }
 967
 968     *alg = hAesAlg;
 969     *key = hKey;
 970     *keyobj = pbKeyObject;
 971
 972     return 0;
 973 }
 974
 975 static int cng_hash_init(WinBCryptSHACTX *ctx) {
 976     if(BCryptOpenAlgorithmProvider(&ctx->hAlg, BCRYPT_SHA256_ALGORITHM, NULL, 0)) {
 977         fprintf(stderr, "Error: BCryptOpenAlgorithmProvider failed\n");
 978         return 1;
 979     }
 980
 981     ULONG hashObjectLen;
 982     ULONG result;
 983     if(BCryptGetProperty(ctx->hAlg, BCRYPT_OBJECT_LENGTH, (PBYTE)&hashObjectLen, sizeof(DWORD), &result, 0)) {
 984         cng_cleanup(ctx->hAlg, NULL, NULL, NULL);
 985         return 1;
 986     }
 987
 988     ctx->pbHashObject = calloc(1, hashObjectLen);
 989
 990     if(BCryptCreateHash(ctx->hAlg, &ctx->hHash, ctx->pbHashObject, hashObjectLen, NULL, 0, 0)) {
 991         cng_cleanup(ctx->hAlg, NULL, ctx->hHash, ctx->pbHashObject);
 992         return 1;
 993     }
 994
 995     return 0;
 996 }
 997
 998
 999 int dav_rand_bytes(unsigned char *buf, size_t len) {
1000     if(BCryptGenRandom(NULL, (unsigned char*)buf, (ULONG)len, BCRYPT_USE_SYSTEM_PREFERRED_RNG)) {
1001         return 1;
1002     }
1003     return 0;
1004 }
1005
1006 AESDecrypter* aes_decrypter_new(DavKey *key, void *stream, dav_write_func write_func) {
1007     AESDecrypter *dec = calloc(1, sizeof(AESDecrypter));
1008     if(!dec) {
1009         return NULL;
1010     }
1011     if(cng_hash_init(&dec->sha256)) {
1012         free(dec);
1013         return NULL;
1014     }
1015
1016     dec->stream = stream;
1017     dec->write = write_func;
1018     dec->key = key;
1019     dec->init = 0;
1020     dec->ivpos = 0;
1021
1022     return dec;
1023 }
1024
1025 static void aes_decrypter_init(AESDecrypter *dec) {
1026     if(cng_init_key(&dec->ctx.hAlg, &dec->ctx.hKey, &dec->ctx.pbKeyObject, dec->key)) {
1027         fprintf(stderr, "Error: cng_init_key failed\n");
1028         exit(-1);
1029     }
1030     // copy iv
1031     memcpy(dec->ctx.pbIV, dec->ivtmp, 16);
1032 }
1033
1034 size_t aes_write(const void *buf, size_t s, size_t n, AESDecrypter *dec) {
1035     int len = s*n;
1036     if(!dec->init) {
1037         dec->init = 1;
1038
1039         size_t n = 16 - dec->ivpos;
1040         size_t cp = n > len ? len : n;
1041         memcpy(dec->ivtmp + dec->ivpos, buf, cp);
1042         dec->ivpos += cp;
1043         if(dec->ivpos >= 16) {
1044             aes_decrypter_init(dec);
1045         }
1046         if(len == cp) {
1047             return len;
1048         } else {
1049             buf = (char*)buf + cp;
1050             len -= cp;
1051         }
1052     }
1053
1054     // the cipher text must be a multiply of 16
1055     // remaining bytes are stored in ctx.buf and must be added to cibuf
1056     // the next time
1057     size_t cbufalloc = len + 64;
1058     ULONG clen = 0;
1059     char *cbuf = malloc(cbufalloc);
1060
1061     // add previous remaining bytes
1062     if(dec->ctx.buflen > 0) {
1063         memcpy(cbuf, dec->ctx.buf, dec->ctx.buflen);
1064         clen = dec->ctx.buflen;
1065     }
1066     // add current bytes
1067     memcpy(cbuf + clen, buf, len);
1068     clen += len;
1069
1070     // check if the message fits the blocksize
1071     int remaining = clen % 16;
1072     if(remaining == 0) {
1073         // decrypt last block next time, or in aes_decrypter_shutdown
1074         // this makes sure, that shutdown always decrypts the last block
1075         // with BCRYPT_BLOCK_PADDING flag
1076         remaining = 16;
1077     }
1078
1079     // add remaining bytes to ctx.buf for the next aes_write run
1080     clen -= remaining;
1081     memcpy(dec->ctx.buf, cbuf + clen, remaining);
1082     dec->ctx.buflen = remaining;
1083
1084     // ready to decrypt the message
1085     ULONG outlen = clen + 32;
1086     unsigned char *out = malloc(outlen);
1087
1088     // decrypt
1089     if(clen > 0) {
1090         ULONG enc_len = 0;
1091         ULONG status = BCryptDecrypt(dec->ctx.hKey, cbuf, clen, NULL, dec->ctx.pbIV, 16, out, outlen, &enc_len, 0);
1092         if(status > 0) {
1093             fprintf(stderr, "Error: BCryptDecrypt failed: 0x%X\n", status);
1094             free(out);
1095             free(cbuf);
1096             return 0;
1097         }
1098         outlen = enc_len;
1099     }
1100
1101     // write decrypted data to the output stream and update the hash
1102     dec->write(out, 1, outlen, dec->stream);
1103     BCryptHashData(dec->sha256.hHash, out, outlen, 0);
1104
1105     free(out);
1106     free(cbuf);
1107
1108     return (s*n) / s;
1109 }
1110
1111 void aes_decrypter_shutdown(AESDecrypter *dec) {
1112     if(dec->init && dec->ctx.buflen > 0) {
1113         ULONG outlen = 64;
1114         char out[64];
1115         if(BCryptDecrypt(dec->ctx.hKey, dec->ctx.buf, dec->ctx.buflen, NULL, dec->ctx.pbIV, 16, out, outlen, &outlen, BCRYPT_BLOCK_PADDING)) {
1116             fprintf(stderr, "Error: BCryptDecrypt failed\n");
1117             return;
1118         }
1119         dec->write(out, 1, outlen, dec->stream);
1120         BCryptHashData(dec->sha256.hHash, out, outlen, 0);
1121     }
1122 }
1123
1124 void aes_decrypter_close(AESDecrypter *dec) {
1125     cng_cleanup(dec->ctx.hAlg, dec->ctx.hKey, NULL, dec->ctx.pbKeyObject);
1126     cng_cleanup(dec->sha256.hAlg, NULL, dec->sha256.hHash, dec->sha256.pbHashObject);
1127     free(dec);
1128 }
1129
1130 AESEncrypter* aes_encrypter_new(DavKey *key, void *stream, dav_read_func read_func, dav_seek_func seek_func) {
1131     unsigned char *iv = malloc(16);
1132     if(dav_rand_bytes(iv, 16)) {
1133         free(iv);
1134         return NULL;
1135     }
1136
1137     AESEncrypter *enc = calloc(1, sizeof(AESEncrypter));
1138     if(cng_hash_init(&enc->sha256)) {
1139         free(iv);
1140         free(enc);
1141         return NULL;
1142     }
1143
1144     enc->stream = stream;
1145     enc->read = read_func;
1146     enc->seek = seek_func;
1147     enc->tmp = NULL;
1148     enc->tmplen = 0;
1149     enc->tmpoff = 0;
1150     enc->end = 0;
1151     enc->iv = iv;
1152     enc->ivlen = 0;
1153
1154     if(cng_init_key(&enc->ctx.hAlg, &enc->ctx.hKey, &enc->ctx.pbKeyObject, key)) {
1155         fprintf(stderr, "Error: cng_init_key failed\n");
1156         exit(-1);
1157     }
1158
1159     enc->ctx.buflen = 0;
1160     memcpy(enc->ctx.pbIV, iv, 16);
1161
1162     return enc;
1163 }
1164
1165 size_t aes_read(void *buf, size_t s, size_t n, AESEncrypter *enc) {
1166     size_t len = s*n;
1167     size_t nread = 0;
1168
1169     if(enc->tmp) {
1170         // the temp buffer contains bytes that are already encrypted, but
1171         // the last aes_read had not enough read buffer space
1172
1173         // in case we have a tmp buf, we just return this
1174         size_t tmp_diff = enc->tmplen - enc->tmpoff;
1175         size_t cp_len = tmp_diff > len ? len : tmp_diff;
1176         memcpy(buf, enc->tmp + enc->tmpoff, cp_len);
1177         enc->tmpoff += cp_len;
1178         if(enc->tmpoff >= enc->tmplen) {
1179             free(enc->tmp);
1180             enc->tmp = NULL;
1181             enc->tmplen = 0;
1182             enc->tmpoff = 0;
1183         }
1184         return cp_len / s;
1185     }
1186
1187     if(enc->ivlen < 16) {
1188         size_t copy_iv_len = 16 - enc->ivlen;
1189         copy_iv_len = len > copy_iv_len ? copy_iv_len : len;
1190
1191         memcpy(buf, enc->iv, copy_iv_len);
1192         buf += copy_iv_len;
1193         len -= copy_iv_len;
1194         nread = copy_iv_len;
1195
1196         enc->ivlen += copy_iv_len;
1197
1198         if(len == 0) {
1199             return copy_iv_len / s;
1200         }
1201     }
1202
1203     if(enc->end) {
1204         return 0;
1205     }
1206
1207     size_t remaining = len % 16;
1208     len -= remaining;
1209
1210     if(len > 256) {
1211         len -= 16; // optimization for avoiding tmp buffer usage
1212     }
1213
1214     size_t inalloc = len;
1215     ULONG  inlen = 0;
1216     unsigned char *in = malloc(inalloc);
1217
1218     // fill the input buffer
1219     while(inlen < inalloc) {
1220         size_t r = enc->read(in + inlen, 1, inalloc - inlen, enc->stream);
1221         if(r == 0) {
1222             enc->end = 1;
1223             break;
1224         }
1225         inlen += r;
1226     }
1227
1228     if(inlen == 0) {
1229         return nread / s;
1230     }
1231
1232     // hash read data
1233     BCryptHashData(enc->sha256.hHash, in, inlen, 0);
1234
1235     // create output buffer
1236     ULONG outalloc = inlen + 16;
1237     ULONG outlen = 0;
1238     char *out = malloc(outalloc);
1239
1240     // encrypt
1241     int flags = 0;
1242     if(inlen % 16 != 0) {
1243         enc->end = 1;
1244     }
1245     if(enc->end) {
1246         flags = BCRYPT_BLOCK_PADDING;
1247     }
1248     if(BCryptEncrypt(enc->ctx.hKey, in, inlen, NULL, enc->ctx.pbIV, 16, out, outalloc, &outlen, flags)) {
1249         fprintf(stderr, "Error: BCryptEncrypt failed\n");
1250     }
1251
1252     // check if the output fits in buf, if not, save the remaining bytes in tmp
1253     if(outlen > len) {
1254         size_t tmplen = outlen - len;
1255         char *tmp = malloc(tmplen);
1256         memcpy(tmp, out+len, tmplen);
1257
1258         enc->tmp = tmp;
1259         enc->tmplen = tmplen;
1260         enc->tmpoff = 0;
1261
1262         outlen = len;
1263     }
1264
1265     // fill read buffer and return
1266     memcpy(buf, out, outlen);
1267     nread += outlen;
1268
1269     free(in);
1270     free(out);
1271
1272     return nread / s;
1273 }
1274
1275 void aes_encrypter_close(AESEncrypter *enc) {
1276     enc->end = 1;
1277 }
1278
1279 int aes_encrypter_reset(AESEncrypter  *enc, curl_off_t offset, int origin) {
1280     if(origin != SEEK_SET || offset != 0 || !enc->seek) {
1281         return CURL_SEEKFUNC_CANTSEEK;
1282     }
1283
1284     enc->ivlen = 0;
1285     memcpy(enc->ctx.pbIV, enc->iv, 16);
1286     if(enc->seek(enc->stream, 0, SEEK_SET) != 0) {
1287         return CURL_SEEKFUNC_FAIL;
1288     }
1289     return CURL_SEEKFUNC_OK;
1290 }
1291
1292 char* aes_encrypt(const char *in, size_t len, DavKey *key) {
1293     // create random IV
1294     char iv[16];
1295     if(dav_rand_bytes(iv, 16)) {
1296         return NULL;
1297     }
1298
1299     // initialize bcrypt stuff
1300     BCRYPT_ALG_HANDLE hAlg = NULL;
1301     BCRYPT_KEY_HANDLE hKey = NULL;
1302     void *pbKeyObject = NULL;
1303     if(cng_init_key(&hAlg, &hKey, &pbKeyObject, key)) {
1304         return NULL;
1305     }
1306
1307     // create output buffer
1308     ULONG outlen = len + 128;
1309     char *out = malloc(outlen);
1310
1311     // the output must start with the IV
1312     memcpy(out, iv, 16);
1313     char *encbuf = out + 16;
1314     ULONG enclen = outlen - 16;
1315     ULONG encoutlen = 0;
1316
1317     // encrypt
1318     if(BCryptEncrypt(hKey, (PUCHAR)in, len, NULL, (PUCHAR)iv, 16, encbuf, enclen, &encoutlen, BCRYPT_BLOCK_PADDING)) {
1319         fprintf(stderr, "Error: BCryptEncrypt failed\n");
1320         cng_cleanup(hAlg, hKey, NULL, pbKeyObject);
1321         free(out);
1322         return NULL;
1323     }
1324
1325     outlen = encoutlen + 16; // length of encrypted data + 16 bytes IV
1326
1327     // base64 encode
1328     char *outstr = util_base64encode(out, outlen);
1329
1330     cng_cleanup(hAlg, hKey, NULL, pbKeyObject);
1331     free(out);
1332
1333     return outstr;
1334 }
1335
1336 char* aes_decrypt(const char *in, size_t *len, DavKey *key) {
1337     BCRYPT_ALG_HANDLE hAlg = NULL;
1338     BCRYPT_KEY_HANDLE hKey = NULL;
1339     void *pbKeyObject = NULL;
1340     if(cng_init_key(&hAlg, &hKey, &pbKeyObject, key)) {
1341         return NULL;
1342     }
1343
1344     int inlen;
1345     unsigned char *buf = (unsigned char*)util_base64decode_len(in, &inlen);
1346     if(inlen < 16 || !buf) {
1347         cng_cleanup(hAlg, hKey, NULL, pbKeyObject);
1348         if(buf) {
1349             free(buf);
1350         }
1351         return NULL;
1352     }
1353
1354     // encrypted data starts with IV
1355     char iv[16];
1356     memcpy(iv, buf, 16);
1357
1358     // decrypt data
1359     char *data = buf + 16; // encrypted data starts after IV
1360     size_t datalen = inlen - 16;
1361
1362     // create output buffer
1363     ULONG outlen = inlen;
1364     char *out = malloc(outlen + 1);
1365
1366     // decrypt
1367     if(BCryptDecrypt(hKey, data, datalen, NULL, iv, 16, out, outlen, &outlen, BCRYPT_BLOCK_PADDING)) {
1368         cng_cleanup(hAlg, hKey, NULL, pbKeyObject);
1369         free(out);
1370         free(buf);
1371         return NULL;
1372     }
1373
1374     // decrypt finished, return
1375     out[outlen] = 0;
1376     *len = (size_t)outlen;
1377     return out;
1378 }
1379
1380 void dav_get_hash(DAV_SHA_CTX *sha256, unsigned char *buf) {
1381     BCryptFinishHash(sha256->hHash, buf, DAV_SHA256_DIGEST_LENGTH, 0);
1382 }
1383
1384
1385 char* dav_create_hash(const char *data, size_t len) {
1386     unsigned char hash[DAV_SHA256_DIGEST_LENGTH];
1387     DAV_SHA_CTX *ctx = dav_hash_init();
1388     if(ctx) {
1389         dav_hash_update(ctx, data, len);
1390         dav_hash_final(ctx, hash);
1391     }
1392     return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
1393 }
1394
1395 DAV_SHA_CTX* dav_hash_init(void) {
1396     DAV_SHA_CTX *ctx = malloc(sizeof(DAV_SHA_CTX));
1397     if(!ctx) {
1398         return NULL;
1399     }
1400     if(cng_hash_init(ctx)) {
1401         free(ctx);
1402         return NULL;
1403     }
1404     return ctx;
1405 }
1406
1407 void dav_hash_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
1408     BCryptHashData(ctx->hHash, (PUCHAR)data, len, 0);
1409 }
1410
1411 void dav_hash_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
1412     BCryptFinishHash(ctx->hHash, (PUCHAR)buf, DAV_SHA256_DIGEST_LENGTH, 0);
1413
1414     // cleanup
1415     cng_cleanup(ctx->hAlg, NULL, ctx->hHash, ctx->pbHashObject);
1416     free(ctx);
1417 }
1418
1419 DavKey* dav_pw2key(const char *password, const unsigned char *salt, int saltlen, int pwfunc, int enc) {
1420     if(!password) {
1421         return NULL;
1422     }
1423     size_t len = strlen(password);
1424     if(len == 0) {
1425         return NULL;
1426     }
1427
1428     // setup key data and length
1429     unsigned char keydata[128];
1430     int keylen = 32;
1431     switch(enc) {
1432         case DAV_KEY_AES128: keylen = 16; break;
1433         case DAV_KEY_AES256: keylen = 32; break;
1434         default: return NULL;
1435     }
1436
1437     LPCWSTR algid;
1438     switch(pwfunc) {
1439         case DAV_PWFUNC_PBKDF2_SHA256: algid = BCRYPT_SHA256_ALGORITHM; break;
1440         case DAV_PWFUNC_PBKDF2_SHA512: algid = BCRYPT_SHA512_ALGORITHM; break;
1441         default: return NULL;
1442     }
1443
1444     // open algorithm provider
1445     BCRYPT_ALG_HANDLE hAlg;
1446     ULONG status = BCryptOpenAlgorithmProvider(&hAlg, algid, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG);
1447     if(status > 0) {
1448         fprintf(stderr, "Error: dav_pw2key: BCryptOpenAlgorithmProvider failed: 0x%X\n", (unsigned int)status);
1449         return NULL;
1450     }
1451
1452     // derive key
1453     status =  BCryptDeriveKeyPBKDF2(
1454             hAlg,
1455             (PUCHAR)password,
1456             len,
1457             (PUCHAR)salt,
1458             saltlen,
1459             DAV_CRYPTO_ITERATION_COUNT,
1460             keydata,
1461             128,
1462             0);
1463
1464     BCryptCloseAlgorithmProvider(hAlg,0);
1465
1466     if(status) {
1467         fprintf(stderr, "Error: dav_pw2key: BCryptDeriveKeyPBKDF2 failed: 0x%X\n", (unsigned int)status);
1468         return NULL;
1469     }
1470
1471     // create DavKey with generated data
1472     DavKey *key = malloc(sizeof(DavKey));
1473     key->data = malloc(keylen);
1474     key->length = keylen;
1475     key->name = NULL;
1476     key->type = enc;
1477     memcpy(key->data, keydata, keylen);
1478     return key;
1479 }
1480 #endif
1481
1482
1483
1484 UcxBuffer* aes_encrypt_buffer(UcxBuffer *in, DavKey *key) {
1485     UcxBuffer *encbuf = ucx_buffer_new(
1486             NULL,
1487             in->size+16,
1488             UCX_BUFFER_AUTOEXTEND);
1489
1490     AESEncrypter *enc = aes_encrypter_new(
1491             key,
1492             in,
1493             (dav_read_func)ucx_buffer_read,
1494             NULL);
1495     if(!enc) {
1496         ucx_buffer_free(encbuf);
1497         return NULL;
1498     }
1499
1500     char buf[1024];
1501     size_t r;
1502     while((r = aes_read(buf, 1, 1024, enc)) > 0) {
1503         ucx_buffer_write(buf, 1, r, encbuf);
1504     }
1505     aes_encrypter_close(enc);
1506
1507     encbuf->pos = 0;
1508     return encbuf;
1509 }
1510
1511 UcxBuffer* aes_decrypt_buffer(UcxBuffer *in, DavKey *key) {
1512     UcxBuffer *decbuf = ucx_buffer_new(
1513             NULL,
1514             in->size,
1515             UCX_BUFFER_AUTOEXTEND);
1516     AESDecrypter *dec = aes_decrypter_new(
1517             key,
1518             decbuf,
1519             (dav_write_func)ucx_buffer_write);
1520
1521     aes_write(in->space, 1, in->size, dec);
1522     aes_decrypter_shutdown(dec);
1523     aes_decrypter_close(dec);
1524     decbuf->pos = 0;
1525     return decbuf;
1526 }