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

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