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 plus additions
  11    that are listed 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    X509_KEYPAIR *keypair;
 367
 368    /* Allocate our keypair structure */
 369    keypair = (X509_KEYPAIR *) malloc(sizeof(X509_KEYPAIR));
 370    if (!keypair) {
 371       return NULL;
 372    }
 373
 374    /* Initialize our keypair structure */
 375    keypair->keyid = NULL;
 376    keypair->pubkey = NULL;
 377    keypair->privkey = NULL;
 378
 379    return keypair;
 380 }
 381
 382 /*
 383  * Create a copy of a keypair object. The underlying
 384  * EVP objects are not duplicated, as no EVP_PKEY_dup()
 385  * API is available. Instead, the reference count is
 386  * incremented.
 387  */
 388 X509_KEYPAIR *crypto_keypair_dup(X509_KEYPAIR *keypair)
 389 {
 390    X509_KEYPAIR *newpair;
 391
 392    newpair = crypto_keypair_new();
 393
 394    if (!newpair) {
 395       /* Allocation failed */
 396       return NULL;
 397    }
 398
 399    /* Increment the public key ref count */
 400    if (keypair->pubkey) {
 401       CRYPTO_add(&(keypair->pubkey->references), 1, CRYPTO_LOCK_EVP_PKEY);
 402       newpair->pubkey = keypair->pubkey;
 403    }
 404
 405    /* Increment the private key ref count */
 406    if (keypair->privkey) {
 407       CRYPTO_add(&(keypair->privkey->references), 1, CRYPTO_LOCK_EVP_PKEY);
 408       newpair->privkey = keypair->privkey;
 409    }
 410
 411    /* Duplicate the keyid */
 412    if (keypair->keyid) {
 413       newpair->keyid = M_ASN1_OCTET_STRING_dup(keypair->keyid);
 414       if (!newpair->keyid) {
 415          /* Allocation failed */
 416          crypto_keypair_free(newpair);
 417          return NULL;
 418       }
 419    }
 420
 421    return newpair;
 422 }
 423
 424
 425 /*
 426  * Load a public key from a PEM-encoded x509 certificate.
 427  *  Returns: true on success
 428  *           false on failure
 429  */
 430 int crypto_keypair_load_cert(X509_KEYPAIR *keypair, const char *file)
 431 {
 432    BIO *bio;
 433    X509 *cert;
 434
 435    /* Open the file */
 436    if (!(bio = BIO_new_file(file, "r"))) {
 437       openssl_post_errors(M_ERROR, _("Unable to open certificate file"));
 438       return false;
 439    }
 440
 441    cert = PEM_read_bio_X509(bio, NULL, NULL, NULL);
 442    BIO_free(bio);
 443    if (!cert) {
 444       openssl_post_errors(M_ERROR, _("Unable to read certificate from file"));
 445       return false;
 446    }
 447
 448    /* Extract the public key */
 449    if (!(keypair->pubkey = X509_get_pubkey(cert))) {
 450       openssl_post_errors(M_ERROR, _("Unable to extract public key from certificate"));
 451       goto err;
 452    }
 453
 454    /* Extract the subjectKeyIdentifier extension field */
 455    if ((keypair->keyid = openssl_cert_keyid(cert)) == NULL) {
 456       Emsg0(M_ERROR, 0, _("Provided certificate does not include the required subjectKeyIdentifier extension."));
 457       goto err;
 458    }
 459
 460    /* Validate the public key type (only RSA is supported) */
 461    if (EVP_PKEY_type(keypair->pubkey->type) != EVP_PKEY_RSA) {
 462        Emsg1(M_ERROR, 0, _("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
 601    /* Initialize the OpenSSL message digest context */
 602    EVP_MD_CTX_init(&digest->ctx);
 603
 604    /* Determine the correct OpenSSL message digest type */
 605    switch (type) {
 606    case CRYPTO_DIGEST_MD5:
 607       md = EVP_md5();
 608       break;
 609    case CRYPTO_DIGEST_SHA1:
 610       md = EVP_sha1();
 611       break;
 612 #ifdef HAVE_SHA2
 613    case CRYPTO_DIGEST_SHA256:
 614       md = EVP_sha256();
 615       break;
 616    case CRYPTO_DIGEST_SHA512:
 617       md = EVP_sha512();
 618       break;
 619 #endif
 620    default:
 621       Jmsg1(jcr, M_ERROR, 0, _("Unsupported digest type: %d\n"), type);
 622       goto err;
 623    }
 624
 625    /* Initialize the backing OpenSSL context */
 626    if (EVP_DigestInit_ex(&digest->ctx, md, NULL) == 0) {
 627       goto err;
 628    }
 629
 630    return digest;
 631
 632 err:
 633    /* This should not happen, but never say never ... */
 634    openssl_post_errors(jcr, M_ERROR, _("OpenSSL digest initialization failed"));
 635    crypto_digest_free(digest);
 636    return NULL;
 637 }
 638
 639 /*
 640  * Hash length bytes of data into the provided digest context.
 641  * Returns: true on success
 642  *          false on failure
 643  */
 644 bool crypto_digest_update(DIGEST *digest, const uint8_t *data, uint32_t length)
 645 {
 646    if (EVP_DigestUpdate(&digest->ctx, data, length) == 0) {
 647       openssl_post_errors(digest->jcr, M_ERROR, _("OpenSSL digest update failed"));
 648       return false;
 649    } else {
 650       return true;
 651    }
 652 }
 653
 654 /*
 655  * Finalize the data in digest, storing the result in dest and the result size
 656  * in length. The result size can be determined with crypto_digest_size().
 657  *
 658  * Returns: true on success
 659  *          false on failure
 660  */
 661 bool crypto_digest_finalize(DIGEST *digest, uint8_t *dest, uint32_t *length)
 662 {
 663    if (!EVP_DigestFinal(&digest->ctx, dest, (unsigned int *)length)) {
 664       openssl_post_errors(digest->jcr, M_ERROR, _("OpenSSL digest finalize failed"));
 665       return false;
 666    } else {
 667       return true;
 668    }
 669 }
 670
 671 /*
 672  * Free memory associated with a digest object.
 673  */
 674 void crypto_digest_free(DIGEST *digest)
 675 {
 676   EVP_MD_CTX_cleanup(&digest->ctx);
 677   free(digest);
 678 }
 679
 680 /*
 681  * Create a new message signature context.
 682  *  Returns: A pointer to a SIGNATURE object on success.
 683  *           NULL on failure.
 684  */
 685 SIGNATURE *crypto_sign_new(JCR *jcr)
 686 {
 687    SIGNATURE *sig;
 688
 689    sig = (SIGNATURE *)malloc(sizeof(SIGNATURE));
 690    if (!sig) {
 691       return NULL;
 692    }
 693
 694    sig->sigData = SignatureData_new();
 695    sig->jcr = jcr;
 696
 697    if (!sig->sigData) {
 698       /* Allocation failed in OpenSSL */
 699       free(sig);
 700       return NULL;
 701    }
 702
 703    /* Set the ASN.1 structure version number */
 704    ASN1_INTEGER_set(sig->sigData->version, BACULA_ASN1_VERSION);
 705
 706    return sig;
 707 }
 708
 709 /*
 710  * For a given public key, find the associated SignatureInfo record
 711  * and create a digest context for signature validation
 712  * Returns: CRYPTO_ERROR_NONE on success, with the newly allocated DIGEST in digest.
 713  *          A crypto_error_t value on failure.
 714  */
 715 crypto_error_t crypto_sign_get_digest(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST **digest)
 716 {
 717    STACK_OF(SignerInfo) *signers;
 718    SignerInfo *si;
 719    int i;
 720
 721    signers = sig->sigData->signerInfo;
 722
 723    for (i = 0; i < sk_SignerInfo_num(signers); i++) {
 724       si = sk_SignerInfo_value(signers, i);
 725       if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, si->subjectKeyIdentifier) == 0) {
 726          /* Get the digest algorithm and allocate a digest context */
 727          switch (OBJ_obj2nid(si->digestAlgorithm)) {
 728          case NID_md5:
 729             *digest = crypto_digest_new(sig->jcr, CRYPTO_DIGEST_MD5);
 730             break;
 731          case NID_sha1:
 732             *digest = crypto_digest_new(sig->jcr, CRYPTO_DIGEST_SHA1);
 733             break;
 734 #ifdef HAVE_SHA2
 735          case NID_sha256:
 736             *digest = crypto_digest_new(sig->jcr, CRYPTO_DIGEST_SHA256);
 737             break;
 738          case NID_sha512:
 739             *digest = crypto_digest_new(sig->jcr, CRYPTO_DIGEST_SHA512);
 740             break;
 741 #endif
 742          default:
 743             *digest = NULL;
 744             return CRYPTO_ERROR_INVALID_DIGEST;
 745          }
 746
 747          /* Shouldn't happen */
 748          if (*digest == NULL) {
 749             openssl_post_errors(sig->jcr, M_ERROR, _("OpenSSL digest_new failed"));
 750             return CRYPTO_ERROR_INVALID_DIGEST;
 751          } else {
 752             return CRYPTO_ERROR_NONE;
 753          }
 754       } else {
 755          openssl_post_errors(sig->jcr, M_ERROR, _("OpenSSL sign get digest failed"));
 756       }
 757
 758    }
 759
 760    return CRYPTO_ERROR_NOSIGNER;
 761 }
 762
 763 /*
 764  * For a given signature, public key, and digest, verify the SIGNATURE.
 765  * Returns: CRYPTO_ERROR_NONE on success.
 766  *          A crypto_error_t value on failure.
 767  */
 768 crypto_error_t crypto_sign_verify(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest)
 769 {
 770    STACK_OF(SignerInfo) *signers;
 771    SignerInfo *si;
 772    int ok, i;
 773    unsigned int sigLen;
 774 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
 775    const unsigned char *sigData;
 776 #else
 777    unsigned char *sigData;
 778 #endif
 779
 780    signers = sig->sigData->signerInfo;
 781
 782    /* Find the signer */
 783    for (i = 0; i < sk_SignerInfo_num(signers); i++) {
 784       si = sk_SignerInfo_value(signers, i);
 785       if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, si->subjectKeyIdentifier) == 0) {
 786          /* Extract the signature data */
 787          sigLen = M_ASN1_STRING_length(si->signature);
 788          sigData = M_ASN1_STRING_data(si->signature);
 789
 790          ok = EVP_VerifyFinal(&digest->ctx, sigData, sigLen, keypair->pubkey);
 791          if (ok >= 1) {
 792             return CRYPTO_ERROR_NONE;
 793          } else if (ok == 0) {
 794             openssl_post_errors(sig->jcr, M_ERROR, _("OpenSSL digest Verify final failed"));
 795             return CRYPTO_ERROR_BAD_SIGNATURE;
 796          } else if (ok < 0) {
 797             /* Shouldn't happen */
 798             openssl_post_errors(sig->jcr, M_ERROR, _("OpenSSL digest Verify final failed"));
 799             return CRYPTO_ERROR_INTERNAL;
 800          }
 801       }
 802    }
 803    Jmsg(sig->jcr, M_ERROR, 0, _("No signers found for crypto verify.\n"));
 804    /* Signer wasn't found. */
 805    return CRYPTO_ERROR_NOSIGNER;
 806 }
 807
 808
 809 /*
 810  * Add a new signer
 811  *  Returns: true on success
 812  *           false on failure
 813  */
 814 int crypto_sign_add_signer(SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair)
 815 {
 816    SignerInfo *si = NULL;
 817    unsigned char *buf = NULL;
 818    unsigned int len;
 819
 820    si = SignerInfo_new();
 821
 822    if (!si) {
 823       /* Allocation failed in OpenSSL */
 824       return false;
 825    }
 826
 827    /* Set the ASN.1 structure version number */
 828    ASN1_INTEGER_set(si->version, BACULA_ASN1_VERSION);
 829
 830    /* Set the digest algorithm identifier */
 831    switch (digest->type) {
 832    case CRYPTO_DIGEST_MD5:
 833       si->digestAlgorithm = OBJ_nid2obj(NID_md5);
 834       break;
 835    case CRYPTO_DIGEST_SHA1:
 836       si->digestAlgorithm = OBJ_nid2obj(NID_sha1);
 837       break;
 838 #ifdef HAVE_SHA2
 839    case CRYPTO_DIGEST_SHA256:
 840       si->digestAlgorithm = OBJ_nid2obj(NID_sha256);
 841       break;
 842    case CRYPTO_DIGEST_SHA512:
 843       si->digestAlgorithm = OBJ_nid2obj(NID_sha512);
 844       break;
 845 #endif
 846    default:
 847       /* This should never happen */
 848       goto err;
 849    }
 850
 851    /* Drop the string allocated by OpenSSL, and add our subjectKeyIdentifier */
 852    M_ASN1_OCTET_STRING_free(si->subjectKeyIdentifier);
 853    si->subjectKeyIdentifier = M_ASN1_OCTET_STRING_dup(keypair->keyid);
 854
 855    /* Set our signature algorithm. We currently require RSA */
 856    assert(EVP_PKEY_type(keypair->pubkey->type) == EVP_PKEY_RSA);
 857    /* This is slightly evil. Reach into the MD structure and grab the key type */
 858    si->signatureAlgorithm = OBJ_nid2obj(digest->ctx.digest->pkey_type);
 859
 860    /* Finalize/Sign our Digest */
 861    len = EVP_PKEY_size(keypair->privkey);
 862    buf = (unsigned char *) malloc(len);
 863    if (!EVP_SignFinal(&digest->ctx, buf, &len, keypair->privkey)) {
 864       openssl_post_errors(M_ERROR, _("Signature creation failed"));
 865       goto err;
 866    }
 867
 868    /* Add the signature to the SignerInfo structure */
 869    if (!M_ASN1_OCTET_STRING_set(si->signature, buf, len)) {
 870       /* Allocation failed in OpenSSL */
 871       goto err;
 872    }
 873
 874    /* No longer needed */
 875    free(buf);
 876
 877    /* Push the new SignerInfo structure onto the stack */
 878    sk_SignerInfo_push(sig->sigData->signerInfo, si);
 879
 880    return true;
 881
 882 err:
 883    if (si) {
 884       SignerInfo_free(si);
 885    }
 886    if (buf) {
 887       free(buf);
 888    }
 889
 890    return false;
 891 }
 892
 893 /*
 894  * Encodes the SignatureData structure. The length argument is used to specify the
 895  * size of dest. A length of 0 will cause no data to be written to dest, and the
 896  * required length to be written to length. The caller can then allocate sufficient
 897  * space for the output.
 898  *
 899  * Returns: true on success, stores the encoded data in dest, and the size in length.
 900  *          false on failure.
 901  */
 902 int crypto_sign_encode(SIGNATURE *sig, uint8_t *dest, uint32_t *length)
 903 {
 904    if (*length == 0) {
 905       *length = i2d_SignatureData(sig->sigData, NULL);
 906       return true;
 907    }
 908
 909    *length = i2d_SignatureData(sig->sigData, (unsigned char **)&dest);
 910    return true;
 911 }
 912
 913 /*
 914  * Decodes the SignatureData structure. The length argument is used to specify the
 915  * size of sigData.
 916  *
 917  * Returns: SIGNATURE instance on success.
 918  *          NULL on failure.
 919
 920  */
 921
 922 SIGNATURE *crypto_sign_decode(const uint8_t *sigData, uint32_t length)
 923 {
 924    SIGNATURE *sig;
 925 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
 926    const unsigned char *p = (const unsigned char *) sigData;
 927 #else
 928    unsigned char *p = (unsigned char *)sigData;
 929 #endif
 930
 931    sig = (SIGNATURE *)malloc(sizeof(SIGNATURE));
 932    if (!sig) {
 933       return NULL;
 934    }
 935
 936    /* d2i_SignatureData modifies the supplied pointer */
 937    sig->sigData  = d2i_SignatureData(NULL, &p, length);
 938
 939    if (!sig->sigData) {
 940       /* Allocation / Decoding failed in OpenSSL */
 941       openssl_post_errors(M_ERROR, _("Signature decoding failed"));
 942       free(sig);
 943       return NULL;
 944    }
 945
 946    return sig;
 947 }
 948
 949 /*
 950  * Free memory associated with a signature object.
 951  */
 952 void crypto_sign_free(SIGNATURE *sig)
 953 {
 954    SignatureData_free(sig->sigData);
 955    free (sig);
 956 }
 957
 958 /*
 959  * Create a new encryption session.
 960  *  Returns: A pointer to a CRYPTO_SESSION object on success.
 961  *           NULL on failure.
 962  */
 963 CRYPTO_SESSION *crypto_session_new (crypto_cipher_t cipher, alist *pubkeys)
 964 {
 965    CRYPTO_SESSION *cs;
 966    X509_KEYPAIR *keypair;
 967    const EVP_CIPHER *ec;
 968    unsigned char *iv;
 969    int iv_len;
 970
 971    /* Allocate our session description structures */
 972    cs = (CRYPTO_SESSION *) malloc(sizeof(CRYPTO_SESSION));
 973    if (!cs) {
 974       return NULL;
 975    }
 976
 977    /* Initialize required fields */
 978    cs->session_key = NULL;
 979
 980    /* Allocate a CryptoData structure */
 981    cs->cryptoData = CryptoData_new();
 982
 983    if (!cs->cryptoData) {
 984       /* Allocation failed in OpenSSL */
 985       free(cs);
 986       return NULL;
 987    }
 988
 989    /* Set the ASN.1 structure version number */
 990    ASN1_INTEGER_set(cs->cryptoData->version, BACULA_ASN1_VERSION);
 991
 992    /*
 993     * Acquire a cipher instance and set the ASN.1 cipher NID
 994     */
 995    switch (cipher) {
 996    case CRYPTO_CIPHER_AES_128_CBC:
 997       /* AES 128 bit CBC */
 998       cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_128_cbc);
 999       ec = EVP_aes_128_cbc();
1000       break;
1001    case CRYPTO_CIPHER_AES_192_CBC:
1002       /* AES 192 bit CBC */
1003       cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_192_cbc);
1004       ec = EVP_aes_192_cbc();
1005       break;
1006    case CRYPTO_CIPHER_AES_256_CBC:
1007       /* AES 256 bit CBC */
1008       cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_256_cbc);
1009       ec = EVP_aes_256_cbc();
1010       break;
1011    case CRYPTO_CIPHER_BLOWFISH_CBC:
1012       /* Blowfish CBC */
1013       cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_bf_cbc);
1014       ec = EVP_bf_cbc();
1015       break;
1016    default:
1017       Emsg0(M_ERROR, 0, _("Unsupported cipher type specified\n"));
1018       crypto_session_free(cs);
1019       return NULL;
1020    }
1021
1022    /* Generate a symmetric session key */
1023    cs->session_key_len = EVP_CIPHER_key_length(ec);
1024    cs->session_key = (unsigned char *) malloc(cs->session_key_len);
1025    if (RAND_bytes(cs->session_key, cs->session_key_len) <= 0) {
1026       /* OpenSSL failure */
1027       crypto_session_free(cs);
1028       return NULL;
1029    }
1030
1031    /* Generate an IV if possible */
1032    if ((iv_len = EVP_CIPHER_iv_length(ec))) {
1033       iv = (unsigned char *) malloc(iv_len);
1034       if (!iv) {
1035          /* Malloc failure */
1036          crypto_session_free(cs);
1037          return NULL;
1038       }
1039
1040       /* Generate random IV */
1041       if (RAND_bytes(iv, iv_len) <= 0) {
1042          /* OpenSSL failure */
1043          crypto_session_free(cs);
1044          free(iv);
1045          return NULL;
1046       }
1047
1048       /* Store it in our ASN.1 structure */
1049       if (!M_ASN1_OCTET_STRING_set(cs->cryptoData->iv, iv, iv_len)) {
1050          /* Allocation failed in OpenSSL */
1051          crypto_session_free(cs);
1052          free(iv);
1053          return NULL;
1054       }
1055       free(iv);
1056    }
1057
1058    /*
1059     * Create RecipientInfo structures for supplied
1060     * public keys.
1061     */
1062    foreach_alist(keypair, pubkeys) {
1063       RecipientInfo *ri;
1064       unsigned char *ekey;
1065       int ekey_len;
1066
1067       ri = RecipientInfo_new();
1068       if (!ri) {
1069          /* Allocation failed in OpenSSL */
1070          crypto_session_free(cs);
1071          return NULL;
1072       }
1073
1074       /* Set the ASN.1 structure version number */
1075       ASN1_INTEGER_set(ri->version, BACULA_ASN1_VERSION);
1076
1077       /* Drop the string allocated by OpenSSL, and add our subjectKeyIdentifier */
1078       M_ASN1_OCTET_STRING_free(ri->subjectKeyIdentifier);
1079       ri->subjectKeyIdentifier = M_ASN1_OCTET_STRING_dup(keypair->keyid);
1080
1081       /* Set our key encryption algorithm. We currently require RSA */
1082       assert(keypair->pubkey && EVP_PKEY_type(keypair->pubkey->type) == EVP_PKEY_RSA);
1083       ri->keyEncryptionAlgorithm = OBJ_nid2obj(NID_rsaEncryption);
1084
1085       /* Encrypt the session key */
1086       ekey = (unsigned char *) malloc(EVP_PKEY_size(keypair->pubkey));
1087       if (!ekey) {
1088          RecipientInfo_free(ri);
1089          crypto_session_free(cs);
1090          return NULL;
1091       }
1092
1093       if ((ekey_len = EVP_PKEY_encrypt(ekey, cs->session_key, cs->session_key_len, keypair->pubkey)) <= 0) {
1094          /* OpenSSL failure */
1095          RecipientInfo_free(ri);
1096          crypto_session_free(cs);
1097          free(ekey);
1098          return NULL;
1099       }
1100
1101       /* Store it in our ASN.1 structure */
1102       if (!M_ASN1_OCTET_STRING_set(ri->encryptedKey, ekey, ekey_len)) {
1103          /* Allocation failed in OpenSSL */
1104          RecipientInfo_free(ri);
1105          crypto_session_free(cs);
1106          free(ekey);
1107          return NULL;
1108       }
1109
1110       /* Free the encrypted key buffer */
1111       free(ekey);
1112
1113       /* Push the new RecipientInfo structure onto the stack */
1114       sk_RecipientInfo_push(cs->cryptoData->recipientInfo, ri);
1115    }
1116
1117    return cs;
1118 }
1119
1120 /*
1121  * Encodes the CryptoData structure. The length argument is used to specify the
1122  * size of dest. A length of 0 will cause no data to be written to dest, and the
1123  * required length to be written to length. The caller can then allocate sufficient
1124  * space for the output.
1125  *
1126  * Returns: true on success, stores the encoded data in dest, and the size in length.
1127  *          false on failure.
1128  */
1129 bool crypto_session_encode(CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length)
1130 {
1131    if (*length == 0) {
1132       *length = i2d_CryptoData(cs->cryptoData, NULL);
1133       return true;
1134    }
1135
1136    *length = i2d_CryptoData(cs->cryptoData, &dest);
1137    return true;
1138 }
1139
1140 /*
1141  * Decodes the CryptoData structure. The length argument is
1142  * used to specify the size of data.
1143  *
1144  * Returns: CRYPTO_SESSION instance on success.
1145  *          NULL on failure.
1146  * Returns: CRYPTO_ERROR_NONE and a pointer to a newly allocated CRYPTO_SESSION structure in *session on success.
1147  *          A crypto_error_t value on failure.
1148  */
1149 crypto_error_t crypto_session_decode(const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session)
1150 {
1151    CRYPTO_SESSION *cs;
1152    X509_KEYPAIR *keypair;
1153    STACK_OF(RecipientInfo) *recipients;
1154    crypto_error_t retval = CRYPTO_ERROR_NONE;
1155 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
1156    const unsigned char *p = (const unsigned char *)data;
1157 #else
1158    unsigned char *p = (unsigned char *)data;
1159 #endif
1160
1161    /* bacula-fd.conf doesn't contains any key */
1162    if (!keypairs) {
1163       return CRYPTO_ERROR_NORECIPIENT;
1164    }
1165
1166    cs = (CRYPTO_SESSION *) malloc(sizeof(CRYPTO_SESSION));
1167    if (!cs) {
1168       return CRYPTO_ERROR_INTERNAL;
1169    }
1170
1171    /* Initialize required fields */
1172    cs->session_key = NULL;
1173
1174    /* d2i_CryptoData modifies the supplied pointer */
1175    cs->cryptoData = d2i_CryptoData(NULL, &p, length);
1176
1177    if (!cs->cryptoData) {
1178       /* Allocation / Decoding failed in OpenSSL */
1179       openssl_post_errors(M_ERROR, _("CryptoData decoding failed"));
1180       retval = CRYPTO_ERROR_INTERNAL;
1181       goto err;
1182    }
1183
1184    recipients = cs->cryptoData->recipientInfo;
1185
1186    /*
1187     * Find a matching RecipientInfo structure for a supplied
1188     * public key
1189     */
1190    foreach_alist(keypair, keypairs) {
1191       RecipientInfo *ri;
1192       int i;
1193
1194       /* Private key available? */
1195       if (keypair->privkey == NULL) {
1196          continue;
1197       }
1198
1199       for (i = 0; i < sk_RecipientInfo_num(recipients); i++) {
1200          ri = sk_RecipientInfo_value(recipients, i);
1201
1202          /* Match against the subjectKeyIdentifier */
1203          if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, ri->subjectKeyIdentifier) == 0) {
1204             /* Match found, extract symmetric encryption session data */
1205
1206             /* RSA is required. */
1207             assert(EVP_PKEY_type(keypair->privkey->type) == EVP_PKEY_RSA);
1208
1209             /* If we recieve a RecipientInfo structure that does not use
1210              * RSA, return an error */
1211             if (OBJ_obj2nid(ri->keyEncryptionAlgorithm) != NID_rsaEncryption) {
1212                retval = CRYPTO_ERROR_INVALID_CRYPTO;
1213                goto err;
1214             }
1215
1216             /* Decrypt the session key */
1217             /* Allocate sufficient space for the largest possible decrypted data */
1218             cs->session_key = (unsigned char *) malloc(EVP_PKEY_size(keypair->privkey));
1219             cs->session_key_len = EVP_PKEY_decrypt(cs->session_key, M_ASN1_STRING_data(ri->encryptedKey),
1220                                   M_ASN1_STRING_length(ri->encryptedKey), keypair->privkey);
1221
1222             if (cs->session_key_len <= 0) {
1223                openssl_post_errors(M_ERROR, _("Failure decrypting the session key"));
1224                retval = CRYPTO_ERROR_DECRYPTION;
1225                goto err;
1226             }
1227
1228             /* Session key successfully extracted, return the CRYPTO_SESSION structure */
1229             *session = cs;
1230             return CRYPTO_ERROR_NONE;
1231          }
1232       }
1233    }
1234
1235    /* No matching recipient found */
1236    return CRYPTO_ERROR_NORECIPIENT;
1237
1238 err:
1239    crypto_session_free(cs);
1240    return retval;
1241 }
1242
1243 /*
1244  * Free memory associated with a crypto session object.
1245  */
1246 void crypto_session_free (CRYPTO_SESSION *cs)
1247 {
1248    if (cs->cryptoData) {
1249       CryptoData_free(cs->cryptoData);
1250    }
1251    if (cs->session_key){
1252       free(cs->session_key);
1253    }
1254    free(cs);
1255 }
1256
1257 /*
1258  * Create a new crypto cipher context with the specified session object
1259  *  Returns: A pointer to a CIPHER_CONTEXT object on success. The cipher block size is returned in blocksize.
1260  *           NULL on failure.
1261  */
1262 CIPHER_CONTEXT *crypto_cipher_new(CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize)
1263 {
1264    CIPHER_CONTEXT *cipher_ctx;
1265    const EVP_CIPHER *ec;
1266
1267    cipher_ctx = (CIPHER_CONTEXT *) malloc(sizeof(CIPHER_CONTEXT));
1268    if (!cipher_ctx) {
1269       return NULL;
1270    }
1271
1272    /*
1273     * Acquire a cipher instance for the given ASN.1 cipher NID
1274     */
1275    if ((ec = EVP_get_cipherbyobj(cs->cryptoData->contentEncryptionAlgorithm)) == NULL) {
1276       Emsg1(M_ERROR, 0, _("Unsupported contentEncryptionAlgorithm: %d\n"), OBJ_obj2nid(cs->cryptoData->contentEncryptionAlgorithm));
1277       free(cipher_ctx);
1278       return NULL;
1279    }
1280
1281    /* Initialize the OpenSSL cipher context */
1282    EVP_CIPHER_CTX_init(&cipher_ctx->ctx);
1283    if (encrypt) {
1284       /* Initialize for encryption */
1285       if (!EVP_CipherInit_ex(&cipher_ctx->ctx, ec, NULL, NULL, NULL, 1)) {
1286          openssl_post_errors(M_ERROR, _("OpenSSL cipher context initialization failed"));
1287          goto err;
1288       }
1289    } else {
1290       /* Initialize for decryption */
1291       if (!EVP_CipherInit_ex(&cipher_ctx->ctx, ec, NULL, NULL, NULL, 0)) {
1292          openssl_post_errors(M_ERROR, _("OpenSSL cipher context initialization failed"));
1293          goto err;
1294       }
1295    }
1296
1297    /* Set the key size */
1298    if (!EVP_CIPHER_CTX_set_key_length(&cipher_ctx->ctx, cs->session_key_len)) {
1299       openssl_post_errors(M_ERROR, _("Encryption session provided an invalid symmetric key"));
1300       goto err;
1301    }
1302
1303    /* Validate the IV length */
1304    if (EVP_CIPHER_iv_length(ec) != M_ASN1_STRING_length(cs->cryptoData->iv)) {
1305       openssl_post_errors(M_ERROR, _("Encryption session provided an invalid IV"));
1306       goto err;
1307    }
1308
1309    /* Add the key and IV to the cipher context */
1310    if (!EVP_CipherInit_ex(&cipher_ctx->ctx, NULL, NULL, cs->session_key, M_ASN1_STRING_data(cs->cryptoData->iv), -1)) {
1311       openssl_post_errors(M_ERROR, _("OpenSSL cipher context key/IV initialization failed"));
1312       goto err;
1313    }
1314
1315    *blocksize = EVP_CIPHER_CTX_block_size(&cipher_ctx->ctx);
1316    return cipher_ctx;
1317
1318 err:
1319    crypto_cipher_free(cipher_ctx);
1320    return NULL;
1321 }
1322
1323
1324 /*
1325  * Encrypt/Decrypt length bytes of data using the provided cipher context
1326  * Returns: true on success, number of bytes output in written
1327  *          false on failure
1328  */
1329 bool crypto_cipher_update(CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written)
1330 {
1331    if (!EVP_CipherUpdate(&cipher_ctx->ctx, (unsigned char *)dest, (int *)written, (const unsigned char *)data, length)) {
1332       /* This really shouldn't fail */
1333       return false;
1334    } else {
1335       return true;
1336    }
1337 }
1338
1339 /*
1340  * Finalize the cipher context, writing any remaining data and necessary padding
1341  * to dest, and the size in written.
1342  * The result size will either be one block of data or zero.
1343  *
1344  * Returns: true on success
1345  *          false on failure
1346  */
1347 bool crypto_cipher_finalize (CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written)
1348 {
1349    if (!EVP_CipherFinal_ex(&cipher_ctx->ctx, (unsigned char *)dest, (int *) written)) {
1350       /* This really shouldn't fail */
1351       return false;
1352    } else {
1353       return true;
1354    }
1355 }
1356
1357
1358 /*
1359  * Free memory associated with a cipher context.
1360  */
1361 void crypto_cipher_free (CIPHER_CONTEXT *cipher_ctx)
1362 {
1363    EVP_CIPHER_CTX_cleanup(&cipher_ctx->ctx);
1364    free (cipher_ctx);
1365 }
1366
1367
1368 /*
1369  * Perform global initialization of OpenSSL
1370  * This function is not thread safe.
1371  *  Returns: 0 on success
1372  *           errno on failure
1373  */
1374 int init_crypto (void)
1375 {
1376    int stat;
1377
1378    if ((stat = openssl_init_threads()) != 0) {
1379       Emsg1(M_ABORT, 0, _("Unable to init OpenSSL threading: ERR=%s\n"), strerror(stat));
1380    }
1381
1382    /* Load libssl and libcrypto human-readable error strings */
1383    SSL_load_error_strings();
1384
1385    /* Initialize OpenSSL SSL  library */
1386    SSL_library_init();
1387
1388    /* Register OpenSSL ciphers and digests */
1389    OpenSSL_add_all_algorithms();
1390
1391    if (!openssl_seed_prng()) {
1392       Emsg0(M_ERROR_TERM, 0, _("Failed to seed OpenSSL PRNG\n"));
1393    }
1394
1395    crypto_initialized = true;
1396
1397    return stat;
1398 }
1399
1400 /*
1401  * Perform global cleanup of OpenSSL
1402  * All cryptographic operations must be completed before calling this function.
1403  * This function is not thread safe.
1404  *  Returns: 0 on success
1405  *           errno on failure
1406  */
1407 int cleanup_crypto (void)
1408 {
1409    /*
1410     * Ensure that we've actually been initialized; Doing this here decreases the
1411     * complexity of client's termination/cleanup code.
1412     */
1413    if (!crypto_initialized) {
1414       return 0;
1415    }
1416
1417    if (!openssl_save_prng()) {
1418       Emsg0(M_ERROR, 0, _("Failed to save OpenSSL PRNG\n"));
1419    }
1420
1421    openssl_cleanup_threads();
1422
1423    /* Free libssl and libcrypto error strings */
1424    ERR_free_strings();
1425
1426    /* Free all ciphers and digests */
1427    EVP_cleanup();
1428
1429    /* Free memory used by PRNG */
1430    RAND_cleanup();
1431
1432    crypto_initialized = false;
1433
1434    return 0;
1435 }
1436
1437
1438 #else /* HAVE_OPENSSL */
1439 # error No encryption library available
1440 #endif /* HAVE_OPENSSL */
1441
1442 #else /* HAVE_CRYPTO */
1443
1444 /*
1445  * Cryptography Support Disabled
1446  */
1447
1448 /* Message Digest Structure */
1449 struct Digest {
1450    crypto_digest_t type;
1451    union {
1452       SHA1Context sha1;
1453       MD5Context md5;
1454    };
1455 };
1456
1457 /* Dummy Signature Structure */
1458 struct Signature {
1459 };
1460
1461 DIGEST *crypto_digest_new(JCR *jcr, crypto_digest_t type)
1462 {
1463    DIGEST *digest;
1464
1465    digest = (DIGEST *)malloc(sizeof(DIGEST));
1466    digest->type = type;
1467    digest->jcr = jcr;
1468
1469    switch (type) {
1470    case CRYPTO_DIGEST_MD5:
1471       MD5Init(&digest->md5);
1472       break;
1473    case CRYPTO_DIGEST_SHA1:
1474       SHA1Init(&digest->sha1);
1475       break;
1476    default:
1477       Jmsg1(jcr, M_ERROR, 0, _("Unsupported digest type=%d specified\n"), type);
1478       free(digest);
1479       return NULL;
1480    }
1481
1482    return (digest);
1483 }
1484
1485 bool crypto_digest_update(DIGEST *digest, const uint8_t *data, uint32_t length)
1486 {
1487    switch (digest->type) {
1488    case CRYPTO_DIGEST_MD5:
1489       /* Doesn't return anything ... */
1490       MD5Update(&digest->md5, (unsigned char *) data, length);
1491       return true;
1492    case CRYPTO_DIGEST_SHA1:
1493       int ret;
1494       if ((ret = SHA1Update(&digest->sha1, (const u_int8_t *) data, length)) == shaSuccess) {
1495          return true;
1496       } else {
1497          Emsg1(M_ERROR, 0, _("SHA1Update() returned an error: %d\n"), ret);
1498          return false;
1499       }
1500       break;
1501    default:
1502       return false;
1503    }
1504 }
1505
1506 bool crypto_digest_finalize(DIGEST *digest, uint8_t *dest, uint32_t *length)
1507 {
1508    switch (digest->type) {
1509    case CRYPTO_DIGEST_MD5:
1510       /* Guard against programmer error by either the API client or
1511        * an out-of-sync CRYPTO_DIGEST_MAX_SIZE */
1512       assert(*length >= CRYPTO_DIGEST_MD5_SIZE);
1513       *length = CRYPTO_DIGEST_MD5_SIZE;
1514       /* Doesn't return anything ... */
1515       MD5Final((unsigned char *)dest, &digest->md5);
1516       return true;
1517    case CRYPTO_DIGEST_SHA1:
1518       /* Guard against programmer error by either the API client or
1519        * an out-of-sync CRYPTO_DIGEST_MAX_SIZE */
1520       assert(*length >= CRYPTO_DIGEST_SHA1_SIZE);
1521       *length = CRYPTO_DIGEST_SHA1_SIZE;
1522       if (SHA1Final(&digest->sha1, (u_int8_t *) dest) == shaSuccess) {
1523          return true;
1524       } else {
1525          return false;
1526       }
1527       break;
1528    default:
1529       return false;
1530    }
1531
1532    return false;
1533 }
1534
1535 void crypto_digest_free(DIGEST *digest)
1536 {
1537    free(digest);
1538 }
1539
1540 /* Dummy routines */
1541 int init_crypto (void) { return 0; }
1542 int cleanup_crypto (void) { return 0; }
1543
1544 SIGNATURE *crypto_sign_new(JCR *jcr) { return NULL; }
1545
1546 crypto_error_t crypto_sign_get_digest (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST **digest) { return CRYPTO_ERROR_INTERNAL; }
1547 crypto_error_t crypto_sign_verify (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest) { return CRYPTO_ERROR_INTERNAL; }
1548
1549 int crypto_sign_add_signer (SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair) { return false; }
1550 int crypto_sign_encode (SIGNATURE *sig, uint8_t *dest, uint32_t *length) { return false; }
1551
1552 SIGNATURE *crypto_sign_decode (const uint8_t *sigData, uint32_t length) { return NULL; }
1553 void crypto_sign_free (SIGNATURE *sig) { }
1554
1555
1556 X509_KEYPAIR *crypto_keypair_new(void) { return NULL; }
1557 X509_KEYPAIR *crypto_keypair_dup (X509_KEYPAIR *keypair) { return NULL; }
1558 int crypto_keypair_load_cert (X509_KEYPAIR *keypair, const char *file) { return false; }
1559 bool crypto_keypair_has_key (const char *file) { return false; }
1560 int crypto_keypair_load_key (X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata) { return false; }
1561 void crypto_keypair_free (X509_KEYPAIR *keypair) { }
1562
1563 CRYPTO_SESSION *crypto_session_new (crypto_cipher_t cipher, alist *pubkeys) { return NULL; }
1564 void crypto_session_free (CRYPTO_SESSION *cs) { }
1565 bool crypto_session_encode (CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length) { return false; }
1566 crypto_error_t crypto_session_decode(const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session) { return CRYPTO_ERROR_INTERNAL; }
1567
1568 CIPHER_CONTEXT *crypto_cipher_new (CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize) { return NULL; }
1569 bool crypto_cipher_update (CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written) { return false; }
1570 bool crypto_cipher_finalize (CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written) { return false; }
1571 void crypto_cipher_free (CIPHER_CONTEXT *cipher_ctx) { }
1572
1573 #endif /* HAVE_CRYPTO */
1574
1575 /* Shared Code */
1576
1577 /*
1578  * Default PEM encryption passphrase callback.
1579  * Returns an empty password.
1580  */
1581 int crypto_default_pem_callback(char *buf, int size, const void *userdata)
1582 {
1583    bstrncpy(buf, "", size);
1584    return (strlen(buf));
1585 }
1586
1587 /*
1588  * Returns the ASCII name of the digest type.
1589  * Returns: ASCII name of digest type.
1590  */
1591 const char *crypto_digest_name (DIGEST *digest) {
1592    switch (digest->type) {
1593    case CRYPTO_DIGEST_MD5:
1594       return "MD5";
1595    case CRYPTO_DIGEST_SHA1:
1596       return "SHA1";
1597    case CRYPTO_DIGEST_SHA256:
1598       return "SHA256";
1599    case CRYPTO_DIGEST_SHA512:
1600       return "SHA512";
1601    case CRYPTO_DIGEST_NONE:
1602       return "None";
1603    default:
1604       return "Invalid Digest Type";
1605    }
1606
1607 }
1608
1609 /*
1610  * Given a stream type, returns the associated
1611  * crypto_digest_t value.
1612  */
1613 crypto_digest_t crypto_digest_stream_type (int stream) {
1614    switch (stream) {
1615    case STREAM_MD5_DIGEST:
1616       return CRYPTO_DIGEST_MD5;
1617    case STREAM_SHA1_DIGEST:
1618       return CRYPTO_DIGEST_SHA1;
1619    case STREAM_SHA256_DIGEST:
1620       return CRYPTO_DIGEST_SHA256;
1621    case STREAM_SHA512_DIGEST:
1622       return CRYPTO_DIGEST_SHA512;
1623    default:
1624       return CRYPTO_DIGEST_NONE;
1625    }
1626 }
1627
1628 /*
1629  *  * Given a crypto_error_t value, return the associated
1630  *   * error string
1631  *    */
1632 const char *crypto_strerror(crypto_error_t error) {
1633    switch (error) {
1634    case CRYPTO_ERROR_NONE:
1635       return _("No error");
1636    case CRYPTO_ERROR_NOSIGNER:
1637       return _("Signer not found");
1638    case CRYPTO_ERROR_NORECIPIENT:
1639       return _("Recipient not found");
1640    case CRYPTO_ERROR_INVALID_DIGEST:
1641       return _("Unsupported digest algorithm");
1642    case CRYPTO_ERROR_INVALID_CRYPTO:
1643       return _("Unsupported encryption algorithm");
1644    case CRYPTO_ERROR_BAD_SIGNATURE:
1645       return _("Signature is invalid");
1646    case CRYPTO_ERROR_DECRYPTION:
1647       return _("Decryption error");
1648    case CRYPTO_ERROR_INTERNAL:
1649       /* This shouldn't happen */
1650       return _("Internal error");
1651    default:
1652       return _("Unknown error");
1653    }
1654 }