git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/crypto.c

   1 /*
   2  * crypto.c Encryption support functions
   3  *
   4  * Author: Landon Fuller <landonf@opendarwin.org>
   5  *
   6  * Version $Id$
   7  *
   8  * Copyright (C) 2005 Kern Sibbald
   9  *
  10  * This file was contributed to the Bacula project by Landon Fuller.
  11  *
  12  * Landon Fuller has been granted a perpetual, worldwide, non-exclusive,
  13  * no-charge, royalty-free, irrevocable copyright license to reproduce,
  14  * prepare derivative works of, publicly display, publicly perform,
  15  * sublicense, and distribute the original work contributed by Landon Fuller
  16  * to the Bacula project in source or object form.
  17  *
  18  * If you wish to license these contributions under an alternate open source
  19  * license please contact Landon Fuller <landonf@opendarwin.org>.
  20  */
  21 /*
  22    Copyright (C) 2005-2006 Kern Sibbald
  23
  24    This program is free software; you can redistribute it and/or
  25    modify it under the terms of the GNU General Public License
  26    version 2 as amended with additional clauses defined in the
  27    file LICENSE in the main source directory.
  28
  29    This program is distributed in the hope that it will be useful,
  30    but WITHOUT ANY WARRANTY; without even the implied warranty of
  31    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  32    the file LICENSE for additional details.
  33
  34  */
  35
  36
  37 #include "bacula.h"
  38 #include <assert.h>
  39
  40 /*
  41  * Bacula ASN.1 Syntax
  42  *
  43  * OID Allocation:
  44  * Prefix: iso.org.dod.internet.private.enterprise.threerings.external.bacula (1.3.6.1.4.1.22054.500.2)
  45  * Organization: Bacula Project
  46  * Contact Name: Kern Sibbald
  47  * Contact E-mail: kern@sibbald.com
  48  *
  49  * Top Level Allocations - 500.2
  50  * 1 - Published Allocations
  51  *   1.1 - Bacula Encryption
  52  *
  53  * Bacula Encryption - 500.2.1.1
  54  * 1 - ASN.1 Modules
  55  *    1.1 - BaculaCrypto
  56  * 2 - ASN.1 Object Identifiers
  57  *    2.1 - SignatureData
  58  *    2.2 - SignerInfo
  59  *    2.3 - CryptoData
  60  *    2.4 - RecipientInfo
  61  *
  62  * BaculaCrypto { iso(1) identified-organization(3) usdod(6)
  63  *                internet(1) private(4) enterprises(1) three-rings(22054)
  64  *                external(500) bacula(2) published(1) bacula-encryption(1)
  65  *                asn1-modules(1) bacula-crypto(1) }
  66  *
  67  * DEFINITIONS AUTOMATIC TAGS ::=
  68  * BEGIN
  69  *
  70  * SignatureData ::= SEQUENCE {
  71  *    version         Version DEFAULT v0,
  72  *    signerInfo      SignerInfo }
  73  *
  74  * CryptoData ::= SEQUENCE {
  75  *    version                     Version DEFAULT v0,
  76  *    contentEncryptionAlgorithm  ContentEncryptionAlgorithmIdentifier,
  77  *    iv                          InitializationVector,
  78  *    recipientInfo               RecipientInfo
  79  * }
  80  *
  81  * SignerInfo ::= SET OF SignerInfo
  82  * RecipientInfo ::= SET OF RecipientInfo
  83  *
  84  * Version ::= INTEGER { v0(0) }
  85  *
  86  * SignerInfo ::= SEQUENCE {
  87  *    version                 Version,
  88  *    subjectKeyIdentifier    SubjectKeyIdentifier,
  89  *    digestAlgorithm         DigestAlgorithmIdentifier,
  90  *    signatureAlgorithm      SignatureAlgorithmIdentifier,
  91  *    signature               SignatureValue }
  92  *
  93  * RecipientInfo ::= SEQUENCE {
  94  *    version                 Version
  95  *    subjectKeyIdentifier    SubjectKeyIdentifier
  96  *    keyEncryptionAlgorithm  KeyEncryptionAlgorithmIdentifier
  97  *    encryptedKey            EncryptedKey
  98  * }
  99  *
 100  * SubjectKeyIdentifier ::= OCTET STRING
 101  *
 102  * DigestAlgorithmIdentifier ::= AlgorithmIdentifier
 103  *
 104  * SignatureAlgorithmIdentifier ::= AlgorithmIdentifier
 105  *
 106  * KeyEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
 107  *
 108  * ContentEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
 109  *
 110  * InitializationVector ::= OCTET STRING
 111  *
 112  * SignatureValue ::= OCTET STRING
 113  *
 114  * EncryptedKey ::= OCTET STRING
 115  *
 116  * AlgorithmIdentifier ::= OBJECT IDENTIFIER
 117  *
 118  * END
 119  */
 120
 121 #ifdef HAVE_CRYPTO /* Is encryption enabled? */
 122 #ifdef HAVE_OPENSSL /* How about OpenSSL? */
 123
 124 /* Are we initialized? */
 125 static int crypto_initialized = false;
 126
 127 /* ASN.1 Declarations */
 128 #define BACULA_ASN1_VERSION 0
 129
 130 typedef struct {
 131    ASN1_INTEGER *version;
 132    ASN1_OCTET_STRING *subjectKeyIdentifier;
 133    ASN1_OBJECT *digestAlgorithm;
 134    ASN1_OBJECT *signatureAlgorithm;
 135    ASN1_OCTET_STRING *signature;
 136 } SignerInfo;
 137
 138 typedef struct {
 139    ASN1_INTEGER *version;
 140    ASN1_OCTET_STRING *subjectKeyIdentifier;
 141    ASN1_OBJECT *keyEncryptionAlgorithm;
 142    ASN1_OCTET_STRING *encryptedKey;
 143 } RecipientInfo;
 144
 145 ASN1_SEQUENCE(SignerInfo) = {
 146    ASN1_SIMPLE(SignerInfo, version, ASN1_INTEGER),
 147    ASN1_SIMPLE(SignerInfo, subjectKeyIdentifier, ASN1_OCTET_STRING),
 148    ASN1_SIMPLE(SignerInfo, digestAlgorithm, ASN1_OBJECT),
 149    ASN1_SIMPLE(SignerInfo, signatureAlgorithm, ASN1_OBJECT),
 150    ASN1_SIMPLE(SignerInfo, signature, ASN1_OCTET_STRING)
 151 } ASN1_SEQUENCE_END(SignerInfo);
 152
 153 ASN1_SEQUENCE(RecipientInfo) = {
 154    ASN1_SIMPLE(RecipientInfo, version, ASN1_INTEGER),
 155    ASN1_SIMPLE(RecipientInfo, subjectKeyIdentifier, ASN1_OCTET_STRING),
 156    ASN1_SIMPLE(RecipientInfo, keyEncryptionAlgorithm, ASN1_OBJECT),
 157    ASN1_SIMPLE(RecipientInfo, encryptedKey, ASN1_OCTET_STRING),
 158 } ASN1_SEQUENCE_END(RecipientInfo);
 159
 160 typedef struct {
 161    ASN1_INTEGER *version;
 162    STACK_OF(SignerInfo) *signerInfo;
 163 } SignatureData;
 164
 165 typedef struct {
 166    ASN1_INTEGER *version;
 167    ASN1_OBJECT *contentEncryptionAlgorithm;
 168    ASN1_OCTET_STRING *iv;
 169    STACK_OF(RecipientInfo) *recipientInfo;
 170 } CryptoData;
 171
 172 ASN1_SEQUENCE(SignatureData) = {
 173    ASN1_SIMPLE(SignatureData, version, ASN1_INTEGER),
 174    ASN1_SET_OF(SignatureData, signerInfo, SignerInfo),
 175 } ASN1_SEQUENCE_END(SignatureData);
 176
 177 ASN1_SEQUENCE(CryptoData) = {
 178    ASN1_SIMPLE(CryptoData, version, ASN1_INTEGER),
 179    ASN1_SIMPLE(CryptoData, contentEncryptionAlgorithm, ASN1_OBJECT),
 180    ASN1_SIMPLE(CryptoData, iv, ASN1_OCTET_STRING),
 181    ASN1_SET_OF(CryptoData, recipientInfo, RecipientInfo)
 182 } ASN1_SEQUENCE_END(CryptoData);
 183
 184 IMPLEMENT_ASN1_FUNCTIONS(SignerInfo)
 185 IMPLEMENT_ASN1_FUNCTIONS(RecipientInfo)
 186 IMPLEMENT_ASN1_FUNCTIONS(SignatureData)
 187 IMPLEMENT_ASN1_FUNCTIONS(CryptoData)
 188 IMPLEMENT_STACK_OF(SignerInfo)
 189 IMPLEMENT_STACK_OF(RecipientInfo)
 190
 191 /*
 192  * SignerInfo and RecipientInfo stack macros, generated by OpenSSL's util/mkstack.pl.
 193  */
 194 #define sk_SignerInfo_new(st) SKM_sk_new(SignerInfo, (st))
 195 #define sk_SignerInfo_new_null() SKM_sk_new_null(SignerInfo)
 196 #define sk_SignerInfo_free(st) SKM_sk_free(SignerInfo, (st))
 197 #define sk_SignerInfo_num(st) SKM_sk_num(SignerInfo, (st))
 198 #define sk_SignerInfo_value(st, i) SKM_sk_value(SignerInfo, (st), (i))
 199 #define sk_SignerInfo_set(st, i, val) SKM_sk_set(SignerInfo, (st), (i), (val))
 200 #define sk_SignerInfo_zero(st) SKM_sk_zero(SignerInfo, (st))
 201 #define sk_SignerInfo_push(st, val) SKM_sk_push(SignerInfo, (st), (val))
 202 #define sk_SignerInfo_unshift(st, val) SKM_sk_unshift(SignerInfo, (st), (val))
 203 #define sk_SignerInfo_find(st, val) SKM_sk_find(SignerInfo, (st), (val))
 204 #define sk_SignerInfo_delete(st, i) SKM_sk_delete(SignerInfo, (st), (i))
 205 #define sk_SignerInfo_delete_ptr(st, ptr) SKM_sk_delete_ptr(SignerInfo, (st), (ptr))
 206 #define sk_SignerInfo_insert(st, val, i) SKM_sk_insert(SignerInfo, (st), (val), (i))
 207 #define sk_SignerInfo_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SignerInfo, (st), (cmp))
 208 #define sk_SignerInfo_dup(st) SKM_sk_dup(SignerInfo, st)
 209 #define sk_SignerInfo_pop_free(st, free_func) SKM_sk_pop_free(SignerInfo, (st), (free_func))
 210 #define sk_SignerInfo_shift(st) SKM_sk_shift(SignerInfo, (st))
 211 #define sk_SignerInfo_pop(st) SKM_sk_pop(SignerInfo, (st))
 212 #define sk_SignerInfo_sort(st) SKM_sk_sort(SignerInfo, (st))
 213 #define sk_SignerInfo_is_sorted(st) SKM_sk_is_sorted(SignerInfo, (st))
 214
 215 #define d2i_ASN1_SET_OF_SignerInfo(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \
 216         SKM_ASN1_SET_OF_d2i(SignerInfo, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class))
 217 #define i2d_ASN1_SET_OF_SignerInfo(st, pp, i2d_func, ex_tag, ex_class, is_set) \
 218         SKM_ASN1_SET_OF_i2d(SignerInfo, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set))
 219 #define ASN1_seq_pack_SignerInfo(st, i2d_func, buf, len) \
 220         SKM_ASN1_seq_pack(SignerInfo, (st), (i2d_func), (buf), (len))
 221 #define ASN1_seq_unpack_SignerInfo(buf, len, d2i_func, free_func) \
 222         SKM_ASN1_seq_unpack(SignerInfo, (buf), (len), (d2i_func), (free_func))
 223
 224 #define sk_RecipientInfo_new(st) SKM_sk_new(RecipientInfo, (st))
 225 #define sk_RecipientInfo_new_null() SKM_sk_new_null(RecipientInfo)
 226 #define sk_RecipientInfo_free(st) SKM_sk_free(RecipientInfo, (st))
 227 #define sk_RecipientInfo_num(st) SKM_sk_num(RecipientInfo, (st))
 228 #define sk_RecipientInfo_value(st, i) SKM_sk_value(RecipientInfo, (st), (i))
 229 #define sk_RecipientInfo_set(st, i, val) SKM_sk_set(RecipientInfo, (st), (i), (val))
 230 #define sk_RecipientInfo_zero(st) SKM_sk_zero(RecipientInfo, (st))
 231 #define sk_RecipientInfo_push(st, val) SKM_sk_push(RecipientInfo, (st), (val))
 232 #define sk_RecipientInfo_unshift(st, val) SKM_sk_unshift(RecipientInfo, (st), (val))
 233 #define sk_RecipientInfo_find(st, val) SKM_sk_find(RecipientInfo, (st), (val))
 234 #define sk_RecipientInfo_delete(st, i) SKM_sk_delete(RecipientInfo, (st), (i))
 235 #define sk_RecipientInfo_delete_ptr(st, ptr) SKM_sk_delete_ptr(RecipientInfo, (st), (ptr))
 236 #define sk_RecipientInfo_insert(st, val, i) SKM_sk_insert(RecipientInfo, (st), (val), (i))
 237 #define sk_RecipientInfo_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(RecipientInfo, (st), (cmp))
 238 #define sk_RecipientInfo_dup(st) SKM_sk_dup(RecipientInfo, st)
 239 #define sk_RecipientInfo_pop_free(st, free_func) SKM_sk_pop_free(RecipientInfo, (st), (free_func))
 240 #define sk_RecipientInfo_shift(st) SKM_sk_shift(RecipientInfo, (st))
 241 #define sk_RecipientInfo_pop(st) SKM_sk_pop(RecipientInfo, (st))
 242 #define sk_RecipientInfo_sort(st) SKM_sk_sort(RecipientInfo, (st))
 243 #define sk_RecipientInfo_is_sorted(st) SKM_sk_is_sorted(RecipientInfo, (st))
 244
 245 #define d2i_ASN1_SET_OF_RecipientInfo(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \
 246         SKM_ASN1_SET_OF_d2i(RecipientInfo, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class))
 247 #define i2d_ASN1_SET_OF_RecipientInfo(st, pp, i2d_func, ex_tag, ex_class, is_set) \
 248         SKM_ASN1_SET_OF_i2d(RecipientInfo, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set))
 249 #define ASN1_seq_pack_RecipientInfo(st, i2d_func, buf, len) \
 250         SKM_ASN1_seq_pack(RecipientInfo, (st), (i2d_func), (buf), (len))
 251 #define ASN1_seq_unpack_RecipientInfo(buf, len, d2i_func, free_func) \
 252         SKM_ASN1_seq_unpack(RecipientInfo, (buf), (len), (d2i_func), (free_func))
 253 /* End of util/mkstack.pl block */
 254
 255 /* X509 Public/Private Key Pair Structure */
 256 struct X509_Keypair {
 257    ASN1_OCTET_STRING *keyid;
 258    EVP_PKEY *pubkey;
 259    EVP_PKEY *privkey;
 260 };
 261
 262 /* Message Digest Structure */
 263 struct Digest {
 264    crypto_digest_t type;
 265    EVP_MD_CTX ctx;
 266 };
 267
 268 /* Message Signature Structure */
 269 struct Signature {
 270    SignatureData *sigData;
 271 };
 272
 273 /* Encryption Session Data */
 274 struct Crypto_Session {
 275    CryptoData *cryptoData;                        /* ASN.1 Structure */
 276    unsigned char *session_key;                    /* Private symmetric session key */
 277    size_t session_key_len;                        /* Symmetric session key length */
 278 };
 279
 280 /* Symmetric Cipher Context */
 281 struct Cipher_Context {
 282    EVP_CIPHER_CTX ctx;
 283 };
 284
 285 /* PEM Password Dispatch Context */
 286 typedef struct PEM_CB_Context {
 287    CRYPTO_PEM_PASSWD_CB *pem_callback;
 288    const void *pem_userdata;
 289 } PEM_CB_CONTEXT;
 290
 291 /*
 292  * Extract subjectKeyIdentifier from x509 certificate.
 293  * Returns: On success, an ASN1_OCTET_STRING that must be freed via M_ASN1_OCTET_STRING_free().
 294  *          NULL on failure.
 295  */
 296 static ASN1_OCTET_STRING *openssl_cert_keyid(X509 *cert){
 297    X509_EXTENSION *ext;
 298    X509V3_EXT_METHOD *method;
 299    ASN1_OCTET_STRING *keyid;
 300    int i;
 301 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
 302    const unsigned char *ext_value_data;
 303 #else
 304    unsigned char *ext_value_data;
 305 #endif
 306
 307
 308    /* Find the index to the subjectKeyIdentifier extension */
 309    i = X509_get_ext_by_NID(cert, NID_subject_key_identifier, -1);
 310    if (i < 0) {
 311       /* Not found */
 312       return NULL;
 313    }
 314
 315    /* Grab the extension */
 316    ext = X509_get_ext(cert, i);
 317
 318    /* Get x509 extension method structure */
 319    if (!(method = X509V3_EXT_get(ext))) {
 320       return NULL;
 321    }
 322
 323    ext_value_data = ext->value->data;
 324
 325 #if (OPENSSL_VERSION_NUMBER > 0x00907000L)
 326    if (method->it) {
 327       /* New style ASN1 */
 328
 329       /* Decode ASN1 item in data */
 330       keyid = (ASN1_OCTET_STRING *) ASN1_item_d2i(NULL, &ext_value_data, ext->value->length,
 331                                                   ASN1_ITEM_ptr(method->it));
 332    } else {
 333       /* Old style ASN1 */
 334
 335       /* Decode ASN1 item in data */
 336       keyid = (ASN1_OCTET_STRING *) method->d2i(NULL, &ext_value_data, ext->value->length);
 337    }
 338
 339 #else
 340    keyid = (ASN1_OCTET_STRING *) method->d2i(NULL, &ext_value_data, ext->value->length);
 341 #endif
 342
 343    return keyid;
 344 }
 345
 346 /*
 347  * Create a new keypair object.
 348  *  Returns: A pointer to a X509 KEYPAIR object on success.
 349  *           NULL on failure.
 350  */
 351 X509_KEYPAIR *crypto_keypair_new (void) {
 352    X509_KEYPAIR *keypair;
 353
 354    /* Allocate our keypair structure */
 355    keypair = (X509_KEYPAIR *) malloc(sizeof(X509_KEYPAIR));
 356    if (!keypair) {
 357       return NULL;
 358    }
 359
 360    /* Initialize our keypair structure */
 361    keypair->keyid = NULL;
 362    keypair->pubkey = NULL;
 363    keypair->privkey = NULL;
 364
 365    return keypair;
 366 }
 367
 368 /*
 369  * Create a copy of a keypair object. The underlying
 370  * EVP objects are not duplicated, as no EVP_PKEY_dup()
 371  * API is available. Instead, the reference count is
 372  * incremented.
 373  */
 374 X509_KEYPAIR *crypto_keypair_dup (X509_KEYPAIR *keypair)
 375 {
 376    X509_KEYPAIR *newpair;
 377
 378    newpair = crypto_keypair_new();
 379
 380    if (!newpair) {
 381       /* Allocation failed */
 382       return NULL;
 383    }
 384
 385    /* Increment the public key ref count */
 386    if (keypair->pubkey) {
 387       CRYPTO_add(&(keypair->pubkey->references), 1, CRYPTO_LOCK_EVP_PKEY);
 388       newpair->pubkey = keypair->pubkey;
 389    }
 390
 391    /* Increment the private key ref count */
 392    if (keypair->privkey) {
 393       CRYPTO_add(&(keypair->privkey->references), 1, CRYPTO_LOCK_EVP_PKEY);
 394       newpair->privkey = keypair->privkey;
 395    }
 396
 397    /* Duplicate the keyid */
 398    if (keypair->keyid) {
 399       newpair->keyid = M_ASN1_OCTET_STRING_dup(keypair->keyid);
 400       if (!newpair->keyid) {
 401          /* Allocation failed */
 402          crypto_keypair_free(newpair);
 403          return NULL;
 404       }
 405    }
 406
 407    return newpair;
 408 }
 409
 410
 411 /*
 412  * Load a public key from a PEM-encoded x509 certificate.
 413  *  Returns: true on success
 414  *           false on failure
 415  */
 416 int crypto_keypair_load_cert (X509_KEYPAIR *keypair, const char *file)
 417 {
 418    BIO *bio;
 419    X509 *cert;
 420
 421    /* Open the file */
 422    if (!(bio = BIO_new_file(file, "r"))) {
 423       openssl_post_errors(M_ERROR, _("Unable to open certificate file"));
 424       return false;
 425    }
 426
 427    cert = PEM_read_bio_X509(bio, NULL, NULL, NULL);
 428    BIO_free(bio);
 429    if (!cert) {
 430       openssl_post_errors(M_ERROR, _("Unable to read certificate from file"));
 431       return false;
 432    }
 433
 434    /* Extract the public key */
 435    if (!(keypair->pubkey = X509_get_pubkey(cert))) {
 436       openssl_post_errors(M_ERROR, _("Unable to extract public key from certificate"));
 437       goto err;
 438    }
 439
 440    /* Extract the subjectKeyIdentifier extension field */
 441    if ((keypair->keyid = openssl_cert_keyid(cert)) == NULL) {
 442       Emsg0(M_ERROR, 0, _("Provided certificate does not include the required subjectKeyIdentifier extension."));
 443       goto err;
 444    }
 445
 446    /* Validate the public key type (only RSA is supported) */
 447    if (EVP_PKEY_type(keypair->pubkey->type) != EVP_PKEY_RSA) {
 448        Emsg1(M_ERROR, 0, _("Unsupported key type provided: %d\n"), EVP_PKEY_type(keypair->pubkey->type));
 449        goto err;
 450    }
 451
 452    X509_free(cert);
 453    return true;
 454
 455 err:
 456    X509_free(cert);
 457    if (keypair->pubkey) {
 458       EVP_PKEY_free(keypair->pubkey);
 459    }
 460    return false;
 461 }
 462
 463 /* Dispatch user PEM encryption callbacks */
 464 static int crypto_pem_callback_dispatch (char *buf, int size, int rwflag, void *userdata)
 465 {
 466    PEM_CB_CONTEXT *ctx = (PEM_CB_CONTEXT *) userdata;
 467    return (ctx->pem_callback(buf, size, ctx->pem_userdata));
 468 }
 469
 470 /*
 471  * Check a PEM-encoded file
 472  * for the existence of a private key.
 473  * Returns: true if a private key is found
 474  *          false otherwise
 475  */
 476 bool crypto_keypair_has_key (const char *file) {
 477    BIO *bio;
 478    char *name = NULL;
 479    char *header = NULL;
 480    unsigned char *data = NULL;
 481    bool retval = false;
 482    long len;
 483
 484    if (!(bio = BIO_new_file(file, "r"))) {
 485       openssl_post_errors(M_ERROR, _("Unable to open private key file"));
 486       return false;
 487    }
 488
 489    while (PEM_read_bio(bio, &name, &header, &data, &len)) {
 490       /* We don't care what the data is, just that it's there */
 491       OPENSSL_free(header);
 492       OPENSSL_free(data);
 493
 494       /*
 495        * PEM Header Found, check for a private key
 496        * Due to OpenSSL limitations, we must specifically
 497        * list supported PEM private key encodings.
 498        */
 499       if (strcmp(name, PEM_STRING_RSA) == 0
 500             || strcmp(name, PEM_STRING_DSA) == 0
 501             || strcmp(name, PEM_STRING_PKCS8) == 0
 502             || strcmp(name, PEM_STRING_PKCS8INF) == 0) {
 503          retval = true;
 504          OPENSSL_free(name);
 505          break;
 506       } else {
 507          OPENSSL_free(name);
 508       }
 509    }
 510
 511    /* Free our bio */
 512    BIO_free(bio);
 513
 514    /* Post PEM-decoding error messages, if any */
 515    openssl_post_errors(M_ERROR, _("Unable to read private key from file"));
 516    return retval;
 517 }
 518
 519 /*
 520  * Load a PEM-encoded private key.
 521  *  Returns: true on success
 522  *           false on failure
 523  */
 524 int crypto_keypair_load_key (X509_KEYPAIR *keypair, const char *file,
 525                              CRYPTO_PEM_PASSWD_CB *pem_callback,
 526                              const void *pem_userdata)
 527 {
 528    BIO *bio;
 529    PEM_CB_CONTEXT ctx;
 530
 531    /* Open the file */
 532    if (!(bio = BIO_new_file(file, "r"))) {
 533       openssl_post_errors(M_ERROR, _("Unable to open private key file"));
 534       return false;
 535    }
 536
 537    /* Set up PEM encryption callback */
 538    if (pem_callback) {
 539       ctx.pem_callback = pem_callback;
 540       ctx.pem_userdata = pem_userdata;
 541    } else {
 542       ctx.pem_callback = crypto_default_pem_callback;
 543       ctx.pem_userdata = NULL;
 544    }
 545
 546    keypair->privkey = PEM_read_bio_PrivateKey(bio, NULL, crypto_pem_callback_dispatch, &ctx);
 547    BIO_free(bio);
 548    if (!keypair->privkey) {
 549       openssl_post_errors(M_ERROR, _("Unable to read private key from file"));
 550       return false;
 551    }
 552
 553    return true;
 554 }
 555
 556 /*
 557  * Free memory associated with a keypair object.
 558  */
 559 void crypto_keypair_free (X509_KEYPAIR *keypair)
 560 {
 561    if (keypair->pubkey) {
 562       EVP_PKEY_free(keypair->pubkey);
 563    }
 564    if (keypair->privkey) {
 565       EVP_PKEY_free(keypair->privkey);
 566    }
 567    if (keypair->keyid) {
 568       M_ASN1_OCTET_STRING_free(keypair->keyid);
 569    }
 570    free(keypair);
 571 }
 572
 573 /*
 574  * Create a new message digest context of the specified type
 575  *  Returns: A pointer to a DIGEST object on success.
 576  *           NULL on failure.
 577  */
 578 DIGEST *crypto_digest_new (crypto_digest_t type)
 579 {
 580    DIGEST *digest;
 581    const EVP_MD *md = NULL; /* Quell invalid uninitialized warnings */
 582
 583    digest = (DIGEST *)malloc(sizeof(DIGEST));
 584    digest->type = type;
 585
 586    /* Initialize the OpenSSL message digest context */
 587    EVP_MD_CTX_init(&digest->ctx);
 588
 589    /* Determine the correct OpenSSL message digest type */
 590    switch (type) {
 591    case CRYPTO_DIGEST_MD5:
 592       md = EVP_md5();
 593       break;
 594    case CRYPTO_DIGEST_SHA1:
 595       md = EVP_sha1();
 596       break;
 597 #ifdef HAVE_SHA2
 598    case CRYPTO_DIGEST_SHA256:
 599       md = EVP_sha256();
 600       break;
 601    case CRYPTO_DIGEST_SHA512:
 602       md = EVP_sha512();
 603       break;
 604 #endif
 605    default:
 606       Emsg1(M_ERROR, 0, _("Unsupported digest type: %d\n"), type);
 607       goto err;
 608    }
 609
 610    /* Initialize the backing OpenSSL context */
 611    if (EVP_DigestInit_ex(&digest->ctx, md, NULL) == 0) {
 612       goto err;
 613    }
 614
 615    return digest;
 616
 617 err:
 618    /* This should not happen, but never say never ... */
 619    openssl_post_errors(M_ERROR, _("OpenSSL digest initialization failed"));
 620    crypto_digest_free(digest);
 621    return NULL;
 622 }
 623
 624 /*
 625  * Hash length bytes of data into the provided digest context.
 626  * Returns: true on success
 627  *          false on failure
 628  */
 629 bool crypto_digest_update(DIGEST *digest, const uint8_t *data, uint32_t length)
 630 {
 631    if (EVP_DigestUpdate(&digest->ctx, data, length) == 0) {
 632       return true;
 633    } else {
 634       return false;
 635    }
 636 }
 637
 638 /*
 639  * Finalize the data in digest, storing the result in dest and the result size
 640  * in length. The result size can be determined with crypto_digest_size().
 641  *
 642  * Returns: true on success
 643  *          false on failure
 644  */
 645 bool crypto_digest_finalize (DIGEST *digest, uint8_t *dest, uint32_t *length) {
 646    if (!EVP_DigestFinal(&digest->ctx, dest, (unsigned int *)length)) {
 647       return false;
 648    } else {
 649       return true;
 650    }
 651 }
 652
 653 /*
 654  * Free memory associated with a digest object.
 655  */
 656 void crypto_digest_free (DIGEST *digest)
 657 {
 658   EVP_MD_CTX_cleanup(&digest->ctx);
 659   free (digest);
 660 }
 661
 662 /*
 663  * Create a new message signature context.
 664  *  Returns: A pointer to a SIGNATURE object on success.
 665  *           NULL on failure.
 666  */
 667 SIGNATURE *crypto_sign_new (void)
 668 {
 669    SIGNATURE *sig;
 670
 671    sig = (SIGNATURE *) malloc(sizeof(SIGNATURE));
 672    if (!sig) {
 673       return NULL;
 674    }
 675
 676    sig->sigData = SignatureData_new();
 677
 678    if (!sig->sigData) {
 679       /* Allocation failed in OpenSSL */
 680       free(sig);
 681       return NULL;
 682    }
 683
 684    /* Set the ASN.1 structure version number */
 685    ASN1_INTEGER_set(sig->sigData->version, BACULA_ASN1_VERSION);
 686
 687    return sig;
 688 }
 689
 690 /*
 691  * For a given public key, find the associated SignatureInfo record
 692  * and create a digest context for signature validation
 693  * Returns: CRYPTO_ERROR_NONE on success, with the newly allocated DIGEST in digest.
 694  *          A crypto_error_t value on failure.
 695  */
 696 crypto_error_t crypto_sign_get_digest(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST **digest)
 697 {
 698    STACK_OF(SignerInfo) *signers;
 699    SignerInfo *si;
 700    int i;
 701
 702    signers = sig->sigData->signerInfo;
 703
 704    for (i = 0; i < sk_SignerInfo_num(signers); i++) {
 705       si = sk_SignerInfo_value(signers, i);
 706       if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, si->subjectKeyIdentifier) == 0) {
 707          /* Get the digest algorithm and allocate a digest context */
 708          switch (OBJ_obj2nid(si->digestAlgorithm)) {
 709          case NID_md5:
 710             *digest = crypto_digest_new(CRYPTO_DIGEST_MD5);
 711             break;
 712          case NID_sha1:
 713             *digest = crypto_digest_new(CRYPTO_DIGEST_SHA1);
 714             break;
 715 #ifdef HAVE_SHA2
 716          case NID_sha256:
 717             *digest = crypto_digest_new(CRYPTO_DIGEST_SHA256);
 718             break;
 719          case NID_sha512:
 720             *digest = crypto_digest_new(CRYPTO_DIGEST_SHA512);
 721             break;
 722 #endif
 723          default:
 724             *digest = NULL;
 725             return CRYPTO_ERROR_INVALID_DIGEST;
 726          }
 727
 728          /* Shouldn't happen */
 729          if (*digest == NULL) {
 730             return CRYPTO_ERROR_INVALID_DIGEST;
 731          } else {
 732             return CRYPTO_ERROR_NONE;
 733          }
 734       }
 735    }
 736
 737    return CRYPTO_ERROR_NOSIGNER;
 738 }
 739
 740 /*
 741  * For a given signature, public key, and digest, verify the SIGNATURE.
 742  * Returns: CRYPTO_ERROR_NONE on success.
 743  *          A crypto_error_t value on failure.
 744  */
 745 crypto_error_t crypto_sign_verify(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest)
 746 {
 747    STACK_OF(SignerInfo) *signers;
 748    SignerInfo *si;
 749    int ok, i;
 750    unsigned int sigLen;
 751 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
 752    const unsigned char *sigData;
 753 #else
 754    unsigned char *sigData;
 755 #endif
 756
 757    signers = sig->sigData->signerInfo;
 758
 759    /* Find the signer */
 760    for (i = 0; i < sk_SignerInfo_num(signers); i++) {
 761       si = sk_SignerInfo_value(signers, i);
 762       if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, si->subjectKeyIdentifier) == 0) {
 763          /* Extract the signature data */
 764          sigLen = M_ASN1_STRING_length(si->signature);
 765          sigData = M_ASN1_STRING_data(si->signature);
 766
 767          ok = EVP_VerifyFinal(&digest->ctx, sigData, sigLen, keypair->pubkey);
 768          if (ok >= 1) {
 769             return CRYPTO_ERROR_NONE;
 770          } else if (ok == 0) {
 771             return CRYPTO_ERROR_BAD_SIGNATURE;
 772          } else if (ok < 0) {
 773             /* Shouldn't happen */
 774             openssl_post_errors(M_ERROR, _("OpenSSL error occured"));
 775             return CRYPTO_ERROR_INTERNAL;
 776          }
 777       }
 778    }
 779
 780    /* Signer wasn't found. */
 781    return CRYPTO_ERROR_NOSIGNER;
 782 }
 783
 784
 785 /*
 786  * Add a new signer
 787  *  Returns: true on success
 788  *           false on failure
 789  */
 790 int crypto_sign_add_signer(SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair)
 791 {
 792    SignerInfo *si = NULL;
 793    unsigned char *buf = NULL;
 794    unsigned int len;
 795
 796    si = SignerInfo_new();
 797
 798    if (!si) {
 799       /* Allocation failed in OpenSSL */
 800       return false;
 801    }
 802
 803    /* Set the ASN.1 structure version number */
 804    ASN1_INTEGER_set(si->version, BACULA_ASN1_VERSION);
 805
 806    /* Set the digest algorithm identifier */
 807    switch (digest->type) {
 808    case CRYPTO_DIGEST_MD5:
 809       si->digestAlgorithm = OBJ_nid2obj(NID_md5);
 810       break;
 811    case CRYPTO_DIGEST_SHA1:
 812       si->digestAlgorithm = OBJ_nid2obj(NID_sha1);
 813       break;
 814 #ifdef HAVE_SHA2
 815    case CRYPTO_DIGEST_SHA256:
 816       si->digestAlgorithm = OBJ_nid2obj(NID_sha256);
 817       break;
 818    case CRYPTO_DIGEST_SHA512:
 819       si->digestAlgorithm = OBJ_nid2obj(NID_sha512);
 820       break;
 821 #endif
 822    default:
 823       /* This should never happen */
 824       goto err;
 825    }
 826
 827    /* Drop the string allocated by OpenSSL, and add our subjectKeyIdentifier */
 828    M_ASN1_OCTET_STRING_free(si->subjectKeyIdentifier);
 829    si->subjectKeyIdentifier = M_ASN1_OCTET_STRING_dup(keypair->keyid);
 830
 831    /* Set our signature algorithm. We currently require RSA */
 832    assert(EVP_PKEY_type(keypair->pubkey->type) == EVP_PKEY_RSA);
 833    /* This is slightly evil. Reach into the MD structure and grab the key type */
 834    si->signatureAlgorithm = OBJ_nid2obj(digest->ctx.digest->pkey_type);
 835
 836    /* Finalize/Sign our Digest */
 837    len = EVP_PKEY_size(keypair->privkey);
 838    buf = (unsigned char *) malloc(len);
 839    if (!EVP_SignFinal(&digest->ctx, buf, &len, keypair->privkey)) {
 840       openssl_post_errors(M_ERROR, _("Signature creation failed"));
 841       goto err;
 842    }
 843
 844    /* Add the signature to the SignerInfo structure */
 845    if (!M_ASN1_OCTET_STRING_set(si->signature, buf, len)) {
 846       /* Allocation failed in OpenSSL */
 847       goto err;
 848    }
 849
 850    /* No longer needed */
 851    free(buf);
 852
 853    /* Push the new SignerInfo structure onto the stack */
 854    sk_SignerInfo_push(sig->sigData->signerInfo, si);
 855
 856    return true;
 857
 858 err:
 859    if (si) {
 860       SignerInfo_free(si);
 861    }
 862    if (buf) {
 863       free(buf);
 864    }
 865
 866    return false;
 867 }
 868
 869 /*
 870  * Encodes the SignatureData structure. The length argument is used to specify the
 871  * size of dest. A length of 0 will cause no data to be written to dest, and the
 872  * required length to be written to length. The caller can then allocate sufficient
 873  * space for the output.
 874  *
 875  * Returns: true on success, stores the encoded data in dest, and the size in length.
 876  *          false on failure.
 877  */
 878 int crypto_sign_encode(SIGNATURE *sig, uint8_t *dest, uint32_t *length)
 879 {
 880    if (*length == 0) {
 881       *length = i2d_SignatureData(sig->sigData, NULL);
 882       return true;
 883    }
 884
 885    *length = i2d_SignatureData(sig->sigData, (unsigned char **)&dest);
 886    return true;
 887 }
 888
 889 /*
 890  * Decodes the SignatureData structure. The length argument is used to specify the
 891  * size of sigData.
 892  *
 893  * Returns: SIGNATURE instance on success.
 894  *          NULL on failure.
 895
 896  */
 897
 898 SIGNATURE *crypto_sign_decode(const uint8_t *sigData, uint32_t length)
 899 {
 900    SIGNATURE *sig;
 901 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
 902    const unsigned char *p = (const unsigned char *) sigData;
 903 #else
 904    unsigned char *p = (unsigned char *)sigData;
 905 #endif
 906
 907    sig = (SIGNATURE *)malloc(sizeof(SIGNATURE));
 908    if (!sig) {
 909       return NULL;
 910    }
 911
 912    /* d2i_SignatureData modifies the supplied pointer */
 913    sig->sigData  = d2i_SignatureData(NULL, &p, length);
 914
 915    if (!sig->sigData) {
 916       /* Allocation / Decoding failed in OpenSSL */
 917       openssl_post_errors(M_ERROR, _("Signature decoding failed"));
 918       free(sig);
 919       return NULL;
 920    }
 921
 922    return sig;
 923 }
 924
 925 /*
 926  * Free memory associated with a signature object.
 927  */
 928 void crypto_sign_free(SIGNATURE *sig)
 929 {
 930    SignatureData_free(sig->sigData);
 931    free (sig);
 932 }
 933
 934 /*
 935  * Create a new encryption session.
 936  *  Returns: A pointer to a CRYPTO_SESSION object on success.
 937  *           NULL on failure.
 938  */
 939 CRYPTO_SESSION *crypto_session_new (crypto_cipher_t cipher, alist *pubkeys)
 940 {
 941    CRYPTO_SESSION *cs;
 942    X509_KEYPAIR *keypair;
 943    const EVP_CIPHER *ec;
 944    unsigned char *iv;
 945    int iv_len;
 946
 947    /* Allocate our session description structures */
 948    cs = (CRYPTO_SESSION *) malloc(sizeof(CRYPTO_SESSION));
 949    if (!cs) {
 950       return NULL;
 951    }
 952
 953    /* Initialize required fields */
 954    cs->session_key = NULL;
 955
 956    /* Allocate a CryptoData structure */
 957    cs->cryptoData = CryptoData_new();
 958
 959    if (!cs->cryptoData) {
 960       /* Allocation failed in OpenSSL */
 961       free(cs);
 962       return NULL;
 963    }
 964
 965    /* Set the ASN.1 structure version number */
 966    ASN1_INTEGER_set(cs->cryptoData->version, BACULA_ASN1_VERSION);
 967
 968    /*
 969     * Acquire a cipher instance and set the ASN.1 cipher NID
 970     */
 971    switch (cipher) {
 972    case CRYPTO_CIPHER_AES_128_CBC:
 973       /* AES 128 bit CBC */
 974       cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_128_cbc);
 975       ec = EVP_aes_128_cbc();
 976       break;
 977    case CRYPTO_CIPHER_AES_192_CBC:
 978       /* AES 192 bit CBC */
 979       cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_192_cbc);
 980       ec = EVP_aes_192_cbc();
 981       break;
 982    case CRYPTO_CIPHER_AES_256_CBC:
 983       /* AES 256 bit CBC */
 984       cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_256_cbc);
 985       ec = EVP_aes_256_cbc();
 986       break;
 987    case CRYPTO_CIPHER_BLOWFISH_CBC:
 988       /* Blowfish CBC */
 989       cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_bf_cbc);
 990       ec = EVP_bf_cbc();
 991       break;
 992    default:
 993       Emsg0(M_ERROR, 0, _("Unsupported cipher type specified\n"));
 994       crypto_session_free(cs);
 995       return NULL;
 996    }
 997
 998    /* Generate a symmetric session key */
 999    cs->session_key_len = EVP_CIPHER_key_length(ec);
1000    cs->session_key = (unsigned char *) malloc(cs->session_key_len);
1001    if (RAND_bytes(cs->session_key, cs->session_key_len) <= 0) {
1002       /* OpenSSL failure */
1003       crypto_session_free(cs);
1004       return NULL;
1005    }
1006
1007    /* Generate an IV if possible */
1008    if ((iv_len = EVP_CIPHER_iv_length(ec))) {
1009       iv = (unsigned char *) malloc(iv_len);
1010       if (!iv) {
1011          /* Malloc failure */
1012          crypto_session_free(cs);
1013          return NULL;
1014       }
1015
1016       /* Generate random IV */
1017       if (RAND_bytes(iv, iv_len) <= 0) {
1018          /* OpenSSL failure */
1019          crypto_session_free(cs);
1020          free(iv);
1021          return NULL;
1022       }
1023
1024       /* Store it in our ASN.1 structure */
1025       if (!M_ASN1_OCTET_STRING_set(cs->cryptoData->iv, iv, iv_len)) {
1026          /* Allocation failed in OpenSSL */
1027          crypto_session_free(cs);
1028          free(iv);
1029          return NULL;
1030       }
1031       free(iv);
1032    }
1033
1034    /*
1035     * Create RecipientInfo structures for supplied
1036     * public keys.
1037     */
1038    foreach_alist(keypair, pubkeys) {
1039       RecipientInfo *ri;
1040       unsigned char *ekey;
1041       int ekey_len;
1042
1043       ri = RecipientInfo_new();
1044       if (!ri) {
1045          /* Allocation failed in OpenSSL */
1046          crypto_session_free(cs);
1047          return NULL;
1048       }
1049
1050       /* Set the ASN.1 structure version number */
1051       ASN1_INTEGER_set(ri->version, BACULA_ASN1_VERSION);
1052
1053       /* Drop the string allocated by OpenSSL, and add our subjectKeyIdentifier */
1054       M_ASN1_OCTET_STRING_free(ri->subjectKeyIdentifier);
1055       ri->subjectKeyIdentifier = M_ASN1_OCTET_STRING_dup(keypair->keyid);
1056
1057       /* Set our key encryption algorithm. We currently require RSA */
1058       assert(keypair->pubkey && EVP_PKEY_type(keypair->pubkey->type) == EVP_PKEY_RSA);
1059       ri->keyEncryptionAlgorithm = OBJ_nid2obj(NID_rsaEncryption);
1060
1061       /* Encrypt the session key */
1062       ekey = (unsigned char *) malloc(EVP_PKEY_size(keypair->pubkey));
1063       if (!ekey) {
1064          RecipientInfo_free(ri);
1065          crypto_session_free(cs);
1066          return NULL;
1067       }
1068
1069       if ((ekey_len = EVP_PKEY_encrypt(ekey, cs->session_key, cs->session_key_len, keypair->pubkey)) <= 0) {
1070          /* OpenSSL failure */
1071          RecipientInfo_free(ri);
1072          crypto_session_free(cs);
1073          free(ekey);
1074          return NULL;
1075       }
1076
1077       /* Store it in our ASN.1 structure */
1078       if (!M_ASN1_OCTET_STRING_set(ri->encryptedKey, ekey, ekey_len)) {
1079          /* Allocation failed in OpenSSL */
1080          RecipientInfo_free(ri);
1081          crypto_session_free(cs);
1082          free(ekey);
1083          return NULL;
1084       }
1085
1086       /* Free the encrypted key buffer */
1087       free(ekey);
1088
1089       /* Push the new RecipientInfo structure onto the stack */
1090       sk_RecipientInfo_push(cs->cryptoData->recipientInfo, ri);
1091    }
1092
1093    return cs;
1094 }
1095
1096 /*
1097  * Encodes the CryptoData structure. The length argument is used to specify the
1098  * size of dest. A length of 0 will cause no data to be written to dest, and the
1099  * required length to be written to length. The caller can then allocate sufficient
1100  * space for the output.
1101  *
1102  * Returns: true on success, stores the encoded data in dest, and the size in length.
1103  *          false on failure.
1104  */
1105 bool crypto_session_encode(CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length)
1106 {
1107    if (*length == 0) {
1108       *length = i2d_CryptoData(cs->cryptoData, NULL);
1109       return true;
1110    }
1111
1112    *length = i2d_CryptoData(cs->cryptoData, &dest);
1113    return true;
1114 }
1115
1116 /*
1117  * Decodes the CryptoData structure. The length argument is
1118  * used to specify the size of data.
1119  *
1120  * Returns: CRYPTO_SESSION instance on success.
1121  *          NULL on failure.
1122  * Returns: CRYPTO_ERROR_NONE and a pointer to a newly allocated CRYPTO_SESSION structure in *session on success.
1123  *          A crypto_error_t value on failure.
1124  */
1125 crypto_error_t crypto_session_decode(const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session)
1126 {
1127    CRYPTO_SESSION *cs;
1128    X509_KEYPAIR *keypair;
1129    STACK_OF(RecipientInfo) *recipients;
1130    crypto_error_t retval = CRYPTO_ERROR_NONE;
1131 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
1132    const unsigned char *p = (const unsigned char *)data;
1133 #else
1134    unsigned char *p = (unsigned char *)data;
1135 #endif
1136
1137    cs = (CRYPTO_SESSION *) malloc(sizeof(CRYPTO_SESSION));
1138    if (!cs) {
1139       return CRYPTO_ERROR_INTERNAL;
1140    }
1141
1142    /* Initialize required fields */
1143    cs->session_key = NULL;
1144
1145    /* d2i_CryptoData modifies the supplied pointer */
1146    cs->cryptoData = d2i_CryptoData(NULL, &p, length);
1147
1148    if (!cs->cryptoData) {
1149       /* Allocation / Decoding failed in OpenSSL */
1150       openssl_post_errors(M_ERROR, _("CryptoData decoding failed"));
1151       retval = CRYPTO_ERROR_INTERNAL;
1152       goto err;
1153    }
1154
1155    recipients = cs->cryptoData->recipientInfo;
1156
1157    /*
1158     * Find a matching RecipientInfo structure for a supplied
1159     * public key
1160     */
1161    foreach_alist(keypair, keypairs) {
1162       RecipientInfo *ri;
1163       int i;
1164
1165       /* Private key available? */
1166       if (keypair->privkey == NULL) {
1167          continue;
1168       }
1169
1170       for (i = 0; i < sk_RecipientInfo_num(recipients); i++) {
1171          ri = sk_RecipientInfo_value(recipients, i);
1172
1173          /* Match against the subjectKeyIdentifier */
1174          if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, ri->subjectKeyIdentifier) == 0) {
1175             /* Match found, extract symmetric encryption session data */
1176
1177             /* RSA is required. */
1178             assert(EVP_PKEY_type(keypair->privkey->type) == EVP_PKEY_RSA);
1179
1180             /* If we recieve a RecipientInfo structure that does not use
1181              * RSA, return an error */
1182             if (OBJ_obj2nid(ri->keyEncryptionAlgorithm) != NID_rsaEncryption) {
1183                retval = CRYPTO_ERROR_INVALID_CRYPTO;
1184                goto err;
1185             }
1186
1187             /* Decrypt the session key */
1188             /* Allocate sufficient space for the largest possible decrypted data */
1189             cs->session_key = (unsigned char *) malloc(EVP_PKEY_size(keypair->privkey));
1190             cs->session_key_len = EVP_PKEY_decrypt(cs->session_key, M_ASN1_STRING_data(ri->encryptedKey),
1191                                   M_ASN1_STRING_length(ri->encryptedKey), keypair->privkey);
1192
1193             if (cs->session_key_len <= 0) {
1194                openssl_post_errors(M_ERROR, _("Failure decrypting the session key"));
1195                retval = CRYPTO_ERROR_DECRYPTION;
1196                goto err;
1197             }
1198
1199             /* Session key successfully extracted, return the CRYPTO_SESSION structure */
1200             *session = cs;
1201             return CRYPTO_ERROR_NONE;
1202          }
1203       }
1204    }
1205
1206    /* No matching recipient found */
1207    return CRYPTO_ERROR_NORECIPIENT;
1208
1209 err:
1210    crypto_session_free(cs);
1211    return retval;
1212 }
1213
1214 /*
1215  * Free memory associated with a crypto session object.
1216  */
1217 void crypto_session_free (CRYPTO_SESSION *cs)
1218 {
1219    if (cs->cryptoData) {
1220       CryptoData_free(cs->cryptoData);
1221    }
1222    if (cs->session_key){
1223       free(cs->session_key);
1224    }
1225    free(cs);
1226 }
1227
1228 /*
1229  * Create a new crypto cipher context with the specified session object
1230  *  Returns: A pointer to a CIPHER_CONTEXT object on success. The cipher block size is returned in blocksize.
1231  *           NULL on failure.
1232  */
1233 CIPHER_CONTEXT *crypto_cipher_new (CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize)
1234 {
1235    CIPHER_CONTEXT *cipher_ctx;
1236    const EVP_CIPHER *ec;
1237
1238    cipher_ctx = (CIPHER_CONTEXT *) malloc(sizeof(CIPHER_CONTEXT));
1239    if (!cipher_ctx) {
1240       return NULL;
1241    }
1242
1243    /*
1244     * Acquire a cipher instance for the given ASN.1 cipher NID
1245     */
1246    if ((ec = EVP_get_cipherbyobj(cs->cryptoData->contentEncryptionAlgorithm)) == NULL) {
1247       Emsg1(M_ERROR, 0, _("Unsupported contentEncryptionAlgorithm: %d\n"), OBJ_obj2nid(cs->cryptoData->contentEncryptionAlgorithm));
1248       free(cipher_ctx);
1249       return NULL;
1250    }
1251
1252    /* Initialize the OpenSSL cipher context */
1253    EVP_CIPHER_CTX_init(&cipher_ctx->ctx);
1254    if (encrypt) {
1255       /* Initialize for encryption */
1256       if (!EVP_CipherInit_ex(&cipher_ctx->ctx, ec, NULL, NULL, NULL, 1)) {
1257          openssl_post_errors(M_ERROR, _("OpenSSL cipher context initialization failed"));
1258          goto err;
1259       }
1260    } else {
1261       /* Initialize for decryption */
1262       if (!EVP_CipherInit_ex(&cipher_ctx->ctx, ec, NULL, NULL, NULL, 0)) {
1263          openssl_post_errors(M_ERROR, _("OpenSSL cipher context initialization failed"));
1264          goto err;
1265       }
1266    }
1267
1268    /* Set the key size */
1269    if (!EVP_CIPHER_CTX_set_key_length(&cipher_ctx->ctx, cs->session_key_len)) {
1270       openssl_post_errors(M_ERROR, _("Encryption session provided an invalid symmetric key"));
1271       goto err;
1272    }
1273
1274    /* Validate the IV length */
1275    if (EVP_CIPHER_iv_length(ec) != M_ASN1_STRING_length(cs->cryptoData->iv)) {
1276       openssl_post_errors(M_ERROR, _("Encryption session provided an invalid IV"));
1277       goto err;
1278    }
1279
1280    /* Add the key and IV to the cipher context */
1281    if (!EVP_CipherInit_ex(&cipher_ctx->ctx, NULL, NULL, cs->session_key, M_ASN1_STRING_data(cs->cryptoData->iv), -1)) {
1282       openssl_post_errors(M_ERROR, _("OpenSSL cipher context key/IV initialization failed"));
1283       goto err;
1284    }
1285
1286    *blocksize = EVP_CIPHER_CTX_block_size(&cipher_ctx->ctx);
1287    return cipher_ctx;
1288
1289 err:
1290    crypto_cipher_free(cipher_ctx);
1291    return NULL;
1292 }
1293
1294
1295 /*
1296  * Encrypt/Decrypt length bytes of data using the provided cipher context
1297  * Returns: true on success, number of bytes output in written
1298  *          false on failure
1299  */
1300 bool crypto_cipher_update(CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written)
1301 {
1302    if (!EVP_CipherUpdate(&cipher_ctx->ctx, (unsigned char *)dest, (int *)written, (const unsigned char *)data, length)) {
1303       /* This really shouldn't fail */
1304       return false;
1305    } else {
1306       return true;
1307    }
1308 }
1309
1310 /*
1311  * Finalize the cipher context, writing any remaining data and necessary padding
1312  * to dest, and the size in written.
1313  * The result size will either be one block of data or zero.
1314  *
1315  * Returns: true on success
1316  *          false on failure
1317  */
1318 bool crypto_cipher_finalize (CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written)
1319 {
1320    if (!EVP_CipherFinal_ex(&cipher_ctx->ctx, (unsigned char *)dest, (int *) written)) {
1321       /* This really shouldn't fail */
1322       return false;
1323    } else {
1324       return true;
1325    }
1326 }
1327
1328
1329 /*
1330  * Free memory associated with a cipher context.
1331  */
1332 void crypto_cipher_free (CIPHER_CONTEXT *cipher_ctx)
1333 {
1334    EVP_CIPHER_CTX_cleanup(&cipher_ctx->ctx);
1335    free (cipher_ctx);
1336 }
1337
1338
1339 /*
1340  * Perform global initialization of OpenSSL
1341  * This function is not thread safe.
1342  *  Returns: 0 on success
1343  *           errno on failure
1344  */
1345 int init_crypto (void)
1346 {
1347    int stat;
1348
1349    if ((stat = openssl_init_threads()) != 0) {
1350       Emsg1(M_ABORT, 0, _("Unable to init OpenSSL threading: ERR=%s\n"), strerror(stat));
1351    }
1352
1353    /* Load libssl and libcrypto human-readable error strings */
1354    SSL_load_error_strings();
1355
1356    /* Initialize OpenSSL SSL  library */
1357    SSL_library_init();
1358
1359    /* Register OpenSSL ciphers and digests */
1360    OpenSSL_add_all_algorithms();
1361
1362    if (!openssl_seed_prng()) {
1363       Emsg0(M_ERROR_TERM, 0, _("Failed to seed OpenSSL PRNG\n"));
1364    }
1365
1366    crypto_initialized = true;
1367
1368    return stat;
1369 }
1370
1371 /*
1372  * Perform global cleanup of OpenSSL
1373  * All cryptographic operations must be completed before calling this function.
1374  * This function is not thread safe.
1375  *  Returns: 0 on success
1376  *           errno on failure
1377  */
1378 int cleanup_crypto (void)
1379 {
1380    /*
1381     * Ensure that we've actually been initialized; Doing this here decreases the
1382     * complexity of client's termination/cleanup code.
1383     */
1384    if (!crypto_initialized) {
1385       return 0;
1386    }
1387
1388    if (!openssl_save_prng()) {
1389       Emsg0(M_ERROR, 0, _("Failed to save OpenSSL PRNG\n"));
1390    }
1391
1392    openssl_cleanup_threads();
1393
1394    /* Free libssl and libcrypto error strings */
1395    ERR_free_strings();
1396
1397    /* Free all ciphers and digests */
1398    EVP_cleanup();
1399
1400    /* Free memory used by PRNG */
1401    RAND_cleanup();
1402
1403    crypto_initialized = false;
1404
1405    return 0;
1406 }
1407
1408
1409 #else /* HAVE_OPENSSL */
1410 # error No encryption library available
1411 #endif /* HAVE_OPENSSL */
1412
1413 #else /* HAVE_CRYPTO */
1414
1415 /*
1416  * Cryptography Support Disabled
1417  */
1418
1419 /* Message Digest Structure */
1420 struct Digest {
1421    crypto_digest_t type;
1422    union {
1423       SHA1Context sha1;
1424       MD5Context md5;
1425    };
1426 };
1427
1428 /* Dummy Signature Structure */
1429 struct Signature {
1430 };
1431
1432 DIGEST *crypto_digest_new (crypto_digest_t type)
1433 {
1434    DIGEST *digest;
1435
1436    digest = (DIGEST *)malloc(sizeof(DIGEST));
1437    digest->type = type;
1438
1439    switch (type) {
1440    case CRYPTO_DIGEST_MD5:
1441       MD5Init(&digest->md5);
1442       break;
1443    case CRYPTO_DIGEST_SHA1:
1444       SHA1Init(&digest->sha1);
1445       break;
1446    default:
1447       Emsg0(M_ERROR, 0, _("Unsupported digest type specified\n"));
1448       free(digest);
1449       return NULL;
1450    }
1451
1452    return (digest);
1453 }
1454
1455 bool crypto_digest_update(DIGEST *digest, const uint8_t *data, uint32_t length)
1456 {
1457    switch (digest->type) {
1458    case CRYPTO_DIGEST_MD5:
1459       /* Doesn't return anything ... */
1460       MD5Update(&digest->md5, (unsigned char *) data, length);
1461       return true;
1462    case CRYPTO_DIGEST_SHA1:
1463       int ret;
1464       if ((ret = SHA1Update(&digest->sha1, (const u_int8_t *) data, length)) == shaSuccess) {
1465          return true;
1466       } else {
1467          Emsg1(M_ERROR, 0, _("SHA1Update() returned an error: %d\n"), ret);
1468          return false;
1469       }
1470       break;
1471    default:
1472       return false;
1473    }
1474 }
1475
1476 bool crypto_digest_finalize(DIGEST *digest, uint8_t *dest, uint32_t *length)
1477 {
1478    switch (digest->type) {
1479    case CRYPTO_DIGEST_MD5:
1480       /* Guard against programmer error by either the API client or
1481        * an out-of-sync CRYPTO_DIGEST_MAX_SIZE */
1482       assert(*length >= CRYPTO_DIGEST_MD5_SIZE);
1483       *length = CRYPTO_DIGEST_MD5_SIZE;
1484       /* Doesn't return anything ... */
1485       MD5Final((unsigned char *)dest, &digest->md5);
1486       return true;
1487    case CRYPTO_DIGEST_SHA1:
1488       /* Guard against programmer error by either the API client or
1489        * an out-of-sync CRYPTO_DIGEST_MAX_SIZE */
1490       assert(*length >= CRYPTO_DIGEST_SHA1_SIZE);
1491       *length = CRYPTO_DIGEST_SHA1_SIZE;
1492       if (SHA1Final(&digest->sha1, (u_int8_t *) dest) == shaSuccess) {
1493          return true;
1494       } else {
1495          return false;
1496       }
1497       break;
1498    default:
1499       return false;
1500    }
1501
1502    return false;
1503 }
1504
1505 void crypto_digest_free(DIGEST *digest)
1506 {
1507    free (digest);
1508 }
1509
1510 /* Dummy routines */
1511 int init_crypto (void) { return 0; }
1512 int cleanup_crypto (void) { return 0; }
1513
1514 SIGNATURE *crypto_sign_new (void) { return NULL; }
1515
1516 crypto_error_t crypto_sign_get_digest (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST **digest) { return CRYPTO_ERROR_INTERNAL; }
1517 crypto_error_t crypto_sign_verify (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest) { return CRYPTO_ERROR_INTERNAL; }
1518
1519 int crypto_sign_add_signer (SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair) { return false; }
1520 int crypto_sign_encode (SIGNATURE *sig, uint8_t *dest, uint32_t *length) { return false; }
1521
1522 SIGNATURE *crypto_sign_decode (const uint8_t *sigData, uint32_t length) { return NULL; }
1523 void crypto_sign_free (SIGNATURE *sig) { }
1524
1525
1526 X509_KEYPAIR *crypto_keypair_new (void) { return NULL; }
1527 X509_KEYPAIR *crypto_keypair_dup (X509_KEYPAIR *keypair) { return NULL; }
1528 int crypto_keypair_load_cert (X509_KEYPAIR *keypair, const char *file) { return false; }
1529 bool crypto_keypair_has_key (const char *file) { return false; }
1530 int crypto_keypair_load_key (X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata) { return false; }
1531 void crypto_keypair_free (X509_KEYPAIR *keypair) { }
1532
1533 CRYPTO_SESSION *crypto_session_new (crypto_cipher_t cipher, alist *pubkeys) { return NULL; }
1534 void crypto_session_free (CRYPTO_SESSION *cs) { }
1535 bool crypto_session_encode (CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length) { return false; }
1536 crypto_error_t crypto_session_decode(const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session) { return CRYPTO_ERROR_INTERNAL; }
1537
1538 CIPHER_CONTEXT *crypto_cipher_new (CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize) { return NULL; }
1539 bool crypto_cipher_update (CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written) { return false; }
1540 bool crypto_cipher_finalize (CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written) { return false; }
1541 void crypto_cipher_free (CIPHER_CONTEXT *cipher_ctx) { }
1542
1543 #endif /* HAVE_CRYPTO */
1544
1545 /* Shared Code */
1546
1547 /*
1548  * Default PEM encryption passphrase callback.
1549  * Returns an empty password.
1550  */
1551 int crypto_default_pem_callback(char *buf, int size, const void *userdata)
1552 {
1553    bstrncpy(buf, "", size);
1554    return (strlen(buf));
1555 }
1556
1557 /*
1558  * Returns the ASCII name of the digest type.
1559  * Returns: ASCII name of digest type.
1560  */
1561 const char *crypto_digest_name (DIGEST *digest) {
1562    switch (digest->type) {
1563    case CRYPTO_DIGEST_MD5:
1564       return "MD5";
1565    case CRYPTO_DIGEST_SHA1:
1566       return "SHA1";
1567    case CRYPTO_DIGEST_SHA256:
1568       return "SHA256";
1569    case CRYPTO_DIGEST_SHA512:
1570       return "SHA512";
1571    case CRYPTO_DIGEST_NONE:
1572       return "None";
1573    default:
1574       return "Invalid Digest Type";
1575    }
1576
1577 }
1578
1579 /*
1580  * Given a stream type, returns the associated
1581  * crypto_digest_t value.
1582  */
1583 crypto_digest_t crypto_digest_stream_type (int stream) {
1584    switch (stream) {
1585    case STREAM_MD5_DIGEST:
1586       return CRYPTO_DIGEST_MD5;
1587    case STREAM_SHA1_DIGEST:
1588       return CRYPTO_DIGEST_SHA1;
1589    case STREAM_SHA256_DIGEST:
1590       return CRYPTO_DIGEST_SHA256;
1591    case STREAM_SHA512_DIGEST:
1592       return CRYPTO_DIGEST_SHA512;
1593    default:
1594       return CRYPTO_DIGEST_NONE;
1595    }
1596 }
1597
1598 /*
1599  *  * Given a crypto_error_t value, return the associated
1600  *   * error string
1601  *    */
1602 const char *crypto_strerror(crypto_error_t error) {
1603    switch (error) {
1604    case CRYPTO_ERROR_NONE:
1605       return "No error";
1606    case CRYPTO_ERROR_NOSIGNER:
1607       return "Signer not found";
1608    case CRYPTO_ERROR_NORECIPIENT:
1609       return "Recipient not found";
1610    case CRYPTO_ERROR_INVALID_DIGEST:
1611       return "Unsupported digest algorithm";
1612    case CRYPTO_ERROR_INVALID_CRYPTO:
1613       return "Unsupported encryption algorithm";
1614    case CRYPTO_ERROR_BAD_SIGNATURE:
1615       return "Signature is invalid";
1616    case CRYPTO_ERROR_DECRYPTION:
1617       return "Decryption error";
1618    case CRYPTO_ERROR_INTERNAL:
1619       /* This shouldn't happen */
1620       return "Internal error";
1621    default:
1622       return "Unknown error";
1623    }
1624 }